web/Obj/brisk.phh

   1 <?php
   2 /*
   3  *  brisk - brisk.phh
   4  *
   5  *  Copyright (C) 2006-2015 Matteo Nastasi
   6  *                          mailto: nastasi@alternativeoutput.it
   7  *                                  matteo.nastasi@milug.org
   8  *                          web: http://www.alternativeoutput.it
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABLILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details. You should have received a
  19  * copy of the GNU General Public License along with this program; if
  20  * not, write to the Free Software Foundation, Inc, 59 Temple Place -
  21  * Suite 330, Boston, MA 02111-1307, USA.
  22  *
  23  */
  24
  25
  26 define('BRISK_CONF', "brisk.conf.pho");
  27 define('FTOK_PATH', "/var/lib/brisk");
  28 define('LEGAL_PATH', "/tmp/legal_brisk");
  29 define('PROXY_PATH', "/var/lib/brisk_proxy");
  30 define('TABLES_N', 36);
  31 define('TABLES_APPR_N', 12);
  32 define('TABLES_AUTH_N', 8);
  33 define('TABLES_CERT_N', 4);
  34 define('PLAYERS_N', 3);
  35 define('MAX_POINTS', 5);
  36 define('MAX_PLAYERS', (20 + (PLAYERS_N * TABLES_N)));
  37 define('SHM_DIMS_MIN', (50000 + 10000 * TABLES_N + 15000 * MAX_PLAYERS));
  38 define('SHM_DIMS_MAX', SHM_DIMS_MIN + 1048576);
  39 define('SHM_DIMS_DLT', 65536);
  40
  41 define('SHM_DIMS_U_MIN', 4096);
  42 define('SHM_DIMS_U_MAX', 65536);
  43 define('SHM_DIMS_U_DLT', 4096);
  44
  45 define('COMM_N', 18);
  46 define('COMM_GEN_N', 50);
  47
  48 define('CHAT_N', 3);
  49 define('CHAT_ILL_TIME', 6);
  50 define('CHAT_ENABLED', TRUE);
  51
  52 define('SESS_LEN', 13);
  53 define('STREAM_TIMEOUT', 60);
  54 /* FIXME: move to sac-a-push .phh */
  55 /* TIME_RD define the server-side timeout, after half of it a ping request
  56    is sent to client, after this time the client is log out */
  57 define('EXPIRE_TIME_RD', 180);
  58 define('EXPIRE_TIME_SMAMMA', 360);
  59 define('EXPIRE_TIME_WAG', 10);
  60 define('WAKEUP_TIME', 12);
  61 // BAN_TIME da allineare anche in commons.js
  62 define('BAN_TIME', 900);
  63 define('GARBAGE_TIMEOUT', 5);
  64 define('NICKSERV', "BriskServ");
  65
  66 define('LOCK_SHARE_MAX', 10000);
  67
  68 define('DBG_ONL2', 0x000001);
  69 define('DBG_ONLY', 0x000002);
  70 define('DBG_MAIN', 0x000004);
  71 define('DBG_READ', 0x000008);
  72 define('DBG_REA2', 0x000010);
  73 define('DBG_SEND', 0x000020);
  74 define('DBG_LOCK', 0x000040);
  75 define('DBG_WRIT', 0x000080);
  76 define('DBG_LOAD', 0x000100);
  77 define('DBG_AUTH', 0x000200);
  78 define('DBG_CRIT', 0x000400);
  79 define('DBG_LMOP', 0x000800);
  80 define('DBG_TRAC', 0x001000);
  81 define('DBG_SHME', 0x002000);
  82 define('DBG_ENGI', 0x004000);
  83 define('DBG_CDS',  0x008000);
  84 define('DBG_STEP', 0x010000);
  85 // NOTE: BRISK DEBUG must be a numerical constant, not the result of operations on symbols
  86 define('BRISK_DEBUG', 0x0800);
  87
  88 define('BRISK_SINGLE_DEBUG',0);
  89 define('BRISK_SINGLE_SESS', "");
  90 define('DEBUGGING', "no-debugging");
  91
  92 define('BSK_BUSTING', "dev");
  93
  94 require_once("$DOCUMENT_ROOT/Etc/".BRISK_CONF);
  95 require_once("${G_base}Obj/ipclass.phh");
  96
  97 $mlang_brisk = array( 'btn_backstand'=> array( 'it' => 'torna in piedi',
  98                                                'en' => 'back standing' ),
  99                       'btn_close' => array( 'it' => 'chiudi',
 100                                             'en' => 'close'),
 101
 102                       'tit_all' => array( 'it' => 'tutti',
 103                                           'en' => 'all' ),
 104
 105                       'tabtout_a'=> array( 'it' => '<br>Sei stato inattivo per ',
 106                                            'en' => '<br>You are being idle for ' ),
 107                       'tabtout_b'=> array( 'it' => ' minuti. <br><br>Quindi ritorni tra i <b>Giocatori in piedi</b>.',
 108                                            'en' => ' minutes. <br><br>Then you return with the <b>standing players</b>.'),
 109                       'tickmust' => array( 'it' => '<br>Per attivare il messaggio di segnalazione del tavolo occorre essere seduti.<br><br>',
 110                                            'en' => '<br>To activate the signalling message of the table it\'s necessary to be sitting<br><br>'),
 111                       'tickjust' => array( 'it' => '<br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br> ',
 112                                            'en' => 'EN<br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br> '),
 113                       'tickwait' => array( 'it' => '<br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>',
 114                                            'en' => 'EN<br>The signalling message of the table<br>will be deactivated for %d second%s.<br><br>'),
 115                       'alarpass' => array( 'it' => '<br>La password digitata non &egrave; corretta.<br><br>',
 116                                            'en' => '<br>The entered password is not correct.<br><br>'),
 117                       'alarret'  => array( 'it' => 'Alarm \\"<b>%s</b>\\" inviato a <b>%s</b>.',
 118                                            'en' => 'Alarm \\"<b>%s</b>\\" sent to <b>%s</b>.'),
 119                       'authmust' => array( 'it' => '<b>Per autenticare qualcuno devi a tua volta essere autenticato e certificato.</b>',
 120                                            'en' => '<b>To authenticate someone you have to be authenticated and certified.</b>'), // on your turn
 121                       'mesgmust' => array( 'it' => '<b>Per inviare un messaggio devi essere autenticato.</b>',
 122                                            'en' => '<b>To send a message you have to be authenticated.</b>'),
 123                       'nickmust' => array( 'it' => 'Il nickname deve contenere almeno una lettera dell\'alfabeto o una cifra.',
 124                                            'en' => 'The nickname have to contain at least one letter or one number.'),
 125                       'nickdupl' => array( 'it' => 'Nickname <b>%s</b> gi&agrave; in uso.',
 126                                            'en' => 'The nickname <b>%s</b> is already in use.'),
 127                       'authchan' => array( 'it' => '<b>Non puoi cambiare nick a un tavolo per soli autenticati o se sei in modalità isolata.</b>',
 128                                            'en' => '<b>You can\'t change your nickname into a table for only authenticated or if you are in isolation mode.</b>'),
 129                       'nickjust' => array( 'it' => 'Il nickname <b>\'%s\'</b> &egrave; gi&agrave; registrato, <b>se il suo proprietario si autentificher&agrave; verrai rinominato d\'ufficio come ghost<i>N</i>.</b>',
 130                                            'en' => 'The nickname <b>\'%s\'</b> is already registered, <b>if its proprietary will authenticate you will named again officially ghost<i>N</i>.</b>'), // FIXME: him ???
 131                       'statunkn' => array( 'it' => 'Questo stato non esiste.',
 132                                            'en' => 'This state don\'t exists.'),
 133                       'tabincon' => array( 'it' => '<br>I dati del tavolo n&deg; %d sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>',
 134                                            'en' => 'EN <br>I dati del tavolo n&deg; %d sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>'),
 135                       'listmust' => array( 'it' => '<b>Per andare in isolamento non bisogna essere seduti a tavoli non riservati.</b>',
 136                                            'en' => '<b>To go to isolation you must don\'t stay on not reserved tables</b>'),
 137
 138                       'tit_onisol'=>array( 'it' => '(autenticati)',
 139                                            'en' => '(authenticated)'),
 140                       'db_failed' =>array('it'  => '<br>Il collegamento al database è fallito.<br>Temporaneamente tutte le autenticazioni verranno sospese, accederai a Brisk come un utente normale.<br><br>Ci scusiamo per il disagio.',
 141                                           'en'  => 'Connection to the database failed<br>All authentications are suspended temporarly, you login as normal user.<br>We are about the limitation'),
 142
 143                       'tos_old'  => array( 'it' => '<b>%s</b> ha sottoscritto dei Termini del Servizio antecedenti a quelli necessari per poter richiedere questa funzionalità.',
 144                                            'en' => 'EN <b>%s</b> ha sottoscritto dei Termini del Servizio antecedenti a quelli necessarig per poter richiedere questa funzionalità.'),
 145                       'inf_self' => array( 'it' => 'Non puoi informarti su te stesso.',
 146                                            'en' => 'EN Non puoi informarti su te stesso.'),
 147                       'inf_nfd'  => array( 'it' => 'Non è stato trovato un garante per <b>%s</b>.',
 148                                            'en' => 'EN Non è stato trovato un garante per <b>%s</b>.'),
 149                       'inf_err'  => array( 'it' => 'Error %d. Utilizzo: <b>/info <i>&lt;login&gt;</i></b>.',
 150                                            'en' => 'Error %d. Usage: <b>/info <i>&lt;login&gt;</i></b>.')
 151 );
 152
 153 $G_lng = langtolng($G_lang);
 154
 155 $G_all_points = array( 11,10,4,3,2, 0,0,0,0,0 );
 156 $G_brisk_version = "5.9.0";
 157
 158 /* MLANG: ALL THE INFO STRINGS IN brisk.phh */
 159 $root_wellarr = array( 'it' => array ( 'Brisk (Ver. '.$G_brisk_version.'), <b>NOVITA\'</b>: dati dai client via web-socket.',
 160                                        'Se vuoi iscriverti alla <a target="_blank" href="mailto:ml-briscola+subscribe@milug.org">Mailing List</a>, cliccala!' ),
 161                        'en' => array ( 'EN Brisk (Ver. '.$G_brisk_version.'), <b>NOVITA\'</b>: puoi creare la tua rete di amicizie con /info,',
 162                                        'vedere cosa pensano i tuoi amici degli altri utenti e tavoli riservati per registrati e apprendisti.',
 163                                        'Se vuoi iscriverti alla <a target="_blank" href="mailto:ml-briscola+subscribe@milug.org">Mailing List</a>, cliccala!' ) );
 164
 165 $G_room_help = array( 'it' => '
 166 <div style=\\"text-align: left; padding: 8px;\\">
 167 <b>Descrizione</b><br>
 168 Questa è un\'implementazione della briscola in cinque, cos&igrave; come &egrave; spiegata su
 169 <a target=\\"_blank\\" href=\\"http://it.wikipedia.org/wiki/Briscola#Gioco_a_5\\">Wikipedia</a>; in breve &egrave; la variante con l\'asta prima sulla carta e poi sui punti.<br><br>
 170 <b>Configurazione del browser.</b><br>
 171 Occorre abilitare i cookies.<br>
 172 <br>
 173 <b>Uso del sito</b><br>
 174 Potete sedervi a un tavolo o rimanere in piedi.<br>
 175 Se al vostro tavolo si raggiungono i 5 giocatori inizia automaticamente la partita.<br>
 176 <br>
 177 <b>Partita</b><br>
 178 All\'inizio vengono distribuite le carte e parte l\'asta; per partecipare all\'asta, quando sar&agrave; il vostro turno, potrete scegliere se andare avanti o passare cliccando sulle icone corrispondenti. Se si arriva ai punti, scrivete nella textbox il vostro rilancio e cliccate PUNTI.<br><br>
 179 Chi vince l\'asta dovr&agrave; decidere il seme della carta scelta e inizier&agrave; la mano.<br>
 180 Per giocare le carte dovrete trascinarle nel quadrato al centro del vostro schermo.<br><br>
 181 Il vostro turno &egrave; sempre segnalato da una cornice verde lampeggiante intorno al quadrato al centro del vostro schermo.<br><br>
 182 Durante la partita, se vorrete ricaricare la pagina, usate l\'apposito bottone \\"reload\\" in basso a destra.<br>
 183 Dopo che &egrave; iniziata una partita per uscirne dovete chiedere agli altri giocatori di sbloccarla cliccando sul lucchetto. Se non si segue questa prassi, una volta usciti, non vi potrete sedere a nessun tavolo per '.floor(BAN_TIME/60).' minuti.
 184 <dl>
 185 <dt><b>Comandi della chat</b>
 186 <!-- <dd><b>/nick <i>&lt;nuovo_nickname&gt;</i></b> - cambio di nickname -->
 187 <dd><b>/tav <i>&lt;frase di invito&gt;</i></b> - invito per gli altri giocatori al tavolo dove si &egrave; seduti
 188 <dd><b>/st <i>&lt;stato&gt;</i></b> - cambia l\'icona associata al tuo user; <i>stato</i> pu&ograve; valere: \\"normale\\", \\"fuori\\", \\"pausa\\", \\"cibo\\", \\"cane\\", \\"lavoro\\", \\"presente\\" oppure \\"sigaretta\\"
 189 <dd><b>/cont <i>&lt;id partita&gt;</i></b> - quando si è a un tavolo per garantiti, permette di proseguire una partita giocata in precedenza con gli stessi giocatori
 190 <dd><b>/info <i>&lt;login&gt;</i></b> - mostra lo stato corrente dell\'utente passato come argomento e in che relazione siete
 191 <dd><b>/authreq</b> - se si &egrave; autenticati permette di garantire per un utente fidato
 192 <dd><b>/mesgtoadm</b> - se si &egrave; autenticati permette di lasciare un messaggio all\'amministratore del sito
 193 <!-- <dd><b>/listen &lt;all or auth&gt;</b> - se si &egrave; autenticati permette leggere solo i messaggi degli altri autenticati (auth) o di tutti (all) -->
 194 </dl>
 195 </div>
 196 ',
 197
 198 'en' => '
 199 <div style=\\"text-align: left; padding: 8px;\\">
 200 <b>EN Descrizione</b><br>
 201 EN Questa è un\'implementazione della briscola in cinque, cos&igrave; come &egrave; spiegata su
 202 <a target=\\"_blank\\" href=\\"http://it.wikipedia.org/wiki/Briscola#Gioco_a_5\\">Wikipedia</a>; in breve &egrave; la variante con l\'asta prima sulla carta e poi sui punti.<br><br>
 203 <b>Configurazione del browser.</b><br>
 204 Occorre abilitare i cookies.<br>
 205 <br>
 206 <b>Uso del sito</b><br>
 207 Potete sedervi a un tavolo o rimanere in piedi.<br>
 208 Se al vostro tavolo si raggiungono i 5 giocatori inizia automaticamente la partita.<br>
 209 <br>
 210 <b>Partita</b><br>
 211 All\'inizio vengono distribuite le carte e parte l\'asta; per partecipare all\'asta, quando sar&agrave; il vostro turno, potrete scegliere se andare avanti o passare cliccando sulle icone corrispondenti. Se si arriva ai punti, scrivete nella textbox il vostro rilancio e cliccate PUNTI.<br><br>
 212 Chi vince l\'asta dovr&agrave; decidere il seme della carta scelta e inizier&agrave; la mano.<br>
 213 Per giocare le carte dovrete trascinarle nel quadrato al centro del vostro schermo.<br><br>
 214 Il vostro turno &egrave; sempre segnalato da una cornice verde lampeggiante intorno al quadrato al centro del vostro schermo.<br><br>
 215 Durante la partita, se vorrete ricaricare la pagina, usate l\'apposito bottone \\"reload\\" in basso a destra.<br>
 216 Dopo che &egrave; iniziata una partita per uscirne dovete chiedere agli altri giocatori di sbloccarla cliccando sul lucchetto. Se non si segue questa prassi, una volta usciti, non vi potrete sedere a nessun tavolo per '.floor(BAN_TIME/60).' minuti.
 217 <dl>
 218 <dt><b>Comandi della chat</b>
 219 <dd><b>/nick <i>&lt;nuovo_nickname&gt;</i></b> - cambio di nickname
 220 <dd><b>/tav <i>&lt;frase di invito&gt;</i></b> - invito per gli altri giocatori al tavolo dove si &egrave; seduti
 221 <dd><b>/st <i>&lt;stato&gt;</i></b> - cambia l\'icona associata al tuo user; <i>stato</i> pu&ograve; valere: \\"normale\\", \\"fuori\\", \\"pausa\\", \\"cibo\\", \\"cane\\", \\"lavoro\\", \\"presente\\" oppure \\"sigaretta\\"
 222 <dd><b>/cont <i>&lt;id partita&gt;</i></b> - quando si è a un tavolo per garantiti, permette di proseguire una partita giocata in precedenza con gli stessi giocatori
 223 <dd><b>/info <i>&lt;login&gt;</i></b> - mostra lo stato corrente dell\'utente passato come argomento e in che relazione siete
 224 <dd><b>/authreq</b> - se si &egrave; autenticati permette di garantire per un utente fidato
 225 <dd><b>/mesgtoadm</b> - se si &egrave; autenticati permette di lasciare un messaggio all\'amministratore del sito
 226 <!-- <dd><b>/listen &lt;all or auth&gt;</b> - se si &egrave; autenticati permette leggere solo i messaggi degli altri autenticati (auth) o di tutti (all) -->
 227 </dl>
 228 </div>
 229 ');
 230
 231 //
 232 $G_room_passwdhowto = array( 'it' => '<br><h2>Come registrarsi su Brisk</h2>
 233 <div style=\\"text-align: left; padding: 8px;\\">
 234 Attualmente ci sono due metodi per ottenere una password sul sito:<br><br>
 235 <dir>
 236 <li><b>Facendosi garantire da un utente di Brisk che sia certificato.</b><br><br>
 237 <li><b>Auto-garantendosi utilizzando uno dei seguenti sistemi di identificazione digitale:</b><br><br>
 238 <dir>
 239 <li>Carta Regionale dei Servizi della Lombardia (la tessera sanitaria)
 240 <li>Carta Regionale dei Servizi del Friuli Venezia Giulia (la tessera sanitaria)
 241 <li>Smart card di InfoCamere
 242 </dir>
 243 <br>
 244 <b>Per auto-garantisi occorre possedere:</b><br><br>
 245 <dir>
 246 <li>il codice PIN della propria carta
 247 <li>il lettore di smart-card per collegare la carta al PC (acquistabile di solito presso le edicole)
 248 </dir>
 249 <br>
 250 <b>Per effettuare la registrazione collegarsi al sito:</b> <a class=\\"flat\\"  target=\\"_blank\\" href=\\"https://brisk.mine.nu\\">https://brisk.mine.nu</a>
 251 <br>
 252 Se sei in possesso di una carta che permette l\'identificazione via internet che non è nell\'elenco qui sopra
 253 <a class=\\"flat\\" href=\\"mailto:authadmbrisk@alternativeoutput.it\\">fai una segnalazione</a>.<br><br>
 254 Le regole per ottenere la certificazione sono in via di definizione, l\' unica accettata è la conoscenza
 255 diretta dell\' utente da parte dell\' amministratore.
 256
 257 </dir>
 258 </div>
 259 ',
 260                              'en' => '<br><h2>EN Come registrarsi su Brisk</h2>
 261 <div style=\\"text-align: left; padding: 8px;\\">
 262 EN Attualmente ci sono due metodi per ottenere una password sul sito:<br><br>
 263 <dir>
 264 <li><b>Facendosi garantire da un utente di Brisk che gi&agrave; possidede una password</b><br><br>
 265 <li><b>Auto-garantendosi utilizzando uno dei seguenti sistemi di identificazione digitale:</b><br><br>
 266 <dir>
 267 <li>Carta Regionale dei Servizi della Lombardia (la tessera sanitaria)
 268 <li>Carta Regionale dei Servizi del Friuli Venezia Giulia (la tessera sanitaria)
 269 </dir>
 270 <br>
 271 <b>Per auto-garantisi occorre possedere:</b><br><br>
 272 <dir>
 273 <li>il codice PIN della propria carta
 274 <li>il lettore di smart-card per collegare la carta al PC (acquistabile di solito presso le edicole)
 275 </dir>
 276 <br>
 277 <b>Per effettuare la registrazione collegarsi al sito:</b> <a class=\\"flat\\"  target=\\"_blank\\" href=\\"https://brisk.mine.nu\\">https://brisk.mine.nu</a>
 278 <br>
 279 Se sei in possesso di una carta che permette l\'identificazione via internet che non è nell\'elenco qui sopra
 280 <a class=\\"flat\\" href=\\"mailto:authadmbrisk@alternativeoutput.it\\">fai una segnalazione</a>.<br><br>
 281 Le regole per ottenere la certificazione sono in via di definizione, l\' unica accettata è la conoscenza
 282 diretta dell\' utente da parte dell\' amministratore.
 283
 284
 285 </dir>
 286 </div>
 287 ' );
 288 /*
 289 <dd>Seguendo la procedura di auto-garanzia all\'url: <a href="https://brisk.mine.nu">https://brisk.mine.nu</a>
 290 ';
 291 */
 292
 293 $G_room_about = array( 'it' => '<br>
 294 <div id=\\"header\\" class=\\"header\\">
 295   <img class=\\"nobo\\" src=\\"img/brisk_logo64.png\\">
 296   briscola chiamata in salsa ajax
 297 </div>
 298 <br><b>version '.$G_brisk_version.'</b><br><br>
 299 Copyright 2006-2012 <a href=\\"mailto:brisk@alternativeoutput.it\\">Matteo Nastasi</a> (aka mop)<br><br>',
 300                       'en' => '<br>
 301 <div id=\\"header\\" class=\\"header\\">
 302   <img class=\\"nobo\\" src=\\"img/brisk_logo64.png\\">
 303   declaration briscola in ajax sauce <b>(Beta)</b>
 304 </div>
 305 <br><b>version '.$G_brisk_version.'</b><br><br>
 306 Copyright 2006-2012 <a href=\\"mailto:brisk@alternativeoutput.it\\">Matteo Nastasi</a> (aka mop)<br><br>');
 307
 308
 309 $G_PG_vow = array("a", "e", "i", "o", "u", "y");
 310 $G_PG_vow_n = 6;
 311 $G_PG_cons = array(
 312       "b", "bb", "bc", "bd", "bf", "bg", "bk", "bl", "bm", "bn", "bp",       "br", "bs", "bt", "bv", "bw",       "bz",
 313       "c", "cb", "cc", "cd", "cf", "cg", "ck", "cl", "cm", "cn", "cp", "cq", "cr", "cs", "ct", "cv", "cw", "cx", "cz",
 314       "d", "db", "dc", "dd", "df", "dg", "dk", "dl", "dm", "dn", "dp",       "dr", "ds", "dt", "dv", "dw", "dx", "dz",
 315       "f", "fb", "fc", "fd", "ff", "fg", "fk", "fl", "fm", "fn", "fp",       "fr", "fs", "ft", "fv", "fw", "fx", "fz",
 316       "g", "gb", "gc", "gd", "gf", "gg", "gk", "gl", "gm", "gn", "gp",       "gr", "gs", "gt", "gv", "gw", "gx", "gz",
 317       "j", "jb", "jc", "jd", "jf", "jg", "jk", "jl", "jm", "jn", "jp", "jq", "jr", "js", "jt", "jv", "jw", "jx", "jz",
 318       "k", "kb", "kc", "kd", "kf", "kg", "kk", "kl", "km", "kn", "kp",       "kr", "ks", "kt", "kv", "kw", "kx", "kz",
 319       "l", "lb", "lc", "ld", "lf", "lg", "lk", "ll", "lm", "ln", "lp",       "lr", "ls", "lt", "lv", "lw", "lx", "lz",
 320       "m", "mb", "mc", "md", "mf", "mg", "mk", "ml", "mm", "mn", "mp",       "mr", "ms", "mt", "mv", "mw", "mx", "mz",
 321       "n", "nb", "nc", "nd", "nf", "ng", "nk", "nl", "nm", "nn", "np",       "nr", "ns", "nt", "nv", "nw", "nx", "nz",
 322       "p", "pb", "pc", "pd", "pf", "pg", "pk", "pl", "pm", "pn", "pp",       "pr", "ps", "pt", "pv", "pw", "px", "pz",
 323       "q", "qb", "qc", "qd", "qf", "qg", "qk", "ql", "qm", "qn", "qp", "qq", "qr", "qs", "qt", "qv", "qw", "qx", "qz",
 324       "r", "rb", "rc", "rd", "rf", "rg", "rk", "rl", "rm", "rn", "rp",       "rr", "rs", "rt", "rv", "rw", "rx", "rz",
 325       "s", "sb", "sc", "sd", "sf", "sg", "sk", "sl", "sm", "sn", "sp", "sq", "sr", "ss", "st", "sv", "sw", "sx", "sz",
 326       "t", "tb", "tc", "td", "tf", "tg", "tk", "tl", "tm", "tn", "tp",       "tr", "ts", "tt", "tv", "tw", "tx", "tz",
 327       "v", "vb", "vc", "vd", "vf", "vg", "vk", "vl", "vm", "vn", "vp",       "vr", "vs", "vt", "vv", "vw", "vx", "vz",
 328       "w", "wb", "wc", "wd", "wf", "wg", "wk", "wl", "wm", "wn", "wp",       "wr", "ws", "wt", "wv", "ww", "wx", "wz",
 329       "x", "xb", "xc", "xd", "xf", "xg", "xk", "xl", "xm", "xn", "xp",       "xr", "xs", "xt", "xv", "xw", "xx", "xz",
 330       "z", "zb", "zc", "zd", "zf", "zg", "zk", "zl", "zm", "zn", "zp",       "zr", "zs", "zt", "zv", "zw", "zx", "zz",
 331                   );
 332 // $G_PG_cons_n = count($G_PG_cons);
 333 // printf("N CONS: %d\n", $G_PG_cons_n);
 334 $G_PG_cons_n = 345;
 335     /*     printf("%d %d\n", count($voc), count($cons)); */
 336     /* for ($i = 0 ; $i < 26 ; $i++) { */
 337     /*     if (array_search(chr(ord('a') + $i), $voc) !== FALSE || $i == 7) */
 338     /*         continue; */
 339     /*     printf('      "%s", ', chr(ord('a') + $i)); */
 340     /*     for ($e = 0 ; $e < 26 ; $e++) { */
 341     /*         if (array_search(chr(ord('a') + $e), $voc) !== FALSE || $e == 7) */
 342     /*             continue; */
 343     /*         printf('"%s%s", ', chr(ord('a') + $i), chr(ord('a') + $e)); */
 344     /*     } */
 345     /*     printf("\n"); */
 346     /* } */
 347
 348 function ip2int($s)
 349 {
 350     return (ip2long($s));
 351 }
 352
 353 function int2ip($i)
 354 {
 355     return (long2ip($i));
 356 }
 357
 358 function int2four($l)
 359 {
 360     if (PHP_INT_SIZE == 4)
 361         return ($l);
 362
 363     return ( ($l & 0x80000000 ? 0xffffffff00000000 : 0x00) | $l );
 364 }
 365
 366 function four2int($s)
 367 {
 368     return ($s & 0xffffffff);
 369 }
 370
 371 function ip2four($s)
 372 {
 373     return int2four( ip2int($s) );
 374 }
 375
 376 function four2ip($i)
 377 {
 378     return int2ip( four2int($i) );
 379 }
 380
 381 function nickserv_msg($dt, $msg) {
 382     return sprintf('chatt_sub("%s",[0x040003,"%s"],"%s");', $dt, NICKSERV, $msg);
 383 }
 384
 385 function passwd_gen($seed = NULL)
 386 {
 387     GLOBAL $G_PG_vow, $G_PG_vow_n, $G_PG_cons, $G_PG_cons_n;
 388
 389     $pw = "";
 390
 391     if ($seed != NULL)
 392         mt_srand($seed);
 393     else
 394         mt_srand();
 395
 396     for ($sil = 0 ; $sil < 7 ; $sil++) {
 397         if (($sil % 2) == 0) {
 398             // vowels
 399             for ($n = 0 ; $n < mt_rand(1,2) ; $n++) {
 400                 if ($n == 0) {
 401                     $old = mt_rand(0, $G_PG_vow_n-1);
 402                     $pw .= $G_PG_vow[$old];
 403                 }
 404                 else {
 405                     $new = mt_rand(0, $G_PG_vow_n-1);
 406                     if ($new == $old)
 407                         $new = ($new + mt_rand(0, $G_PG_vow_n-2)) % $G_PG_vow_n;
 408                     $pw .= $G_PG_vow[$new];
 409                 }
 410             }
 411         }
 412         else {
 413             // consonants
 414             $pw .= $G_PG_cons[mt_rand(0, $G_PG_cons_n-1)];
 415         }
 416     }
 417
 418     return $pw;
 419 }
 420
 421 function cmd_return($val, $desc)
 422 {
 423     return array('val' => $val, 'desc' => $desc);
 424 }
 425
 426 function cmd_serialize($attrs)
 427 {
 428     $ret = "";
 429
 430     $sep = "";
 431     foreach ($attrs as $key => $value) {
 432         $ret .= $sep . $key . '=' . urlencode($value);
 433         $sep = "&";
 434     }
 435     return $ret;
 436 }
 437
 438 function cmd_deserialize($cmd)
 439 {
 440     $ret = array();
 441     $a = explode('&', $cmd);
 442     $i = 0;
 443     while ($i < count($a)) {
 444         $b = split('=', $a[$i]);
 445         $ret[urldecode($b[0])] = urldecode($b[1]);
 446         $i++;
 447     }
 448
 449     return $ret;
 450 }
 451
 452 //  return values
 453 // -1 v1 < v2
 454 //  0 equal
 455 //  1 v1 > v2
 456 function versions_cmp($v1, $v2)
 457 {
 458     // printf("V1: [%s]\nV2: [%s]\n", $v1, $v2);
 459     if ($v1 == $v2)
 460         return 0;
 461
 462     $v1_ar = split('\.', $v1);
 463     $v2_ar = split('\.', $v2);
 464
 465     $v2_ct = count($v2_ar);
 466
 467     for ($i = 0 ; $i < count($v1_ar) ; $i++) {
 468         if (($v2_ct - 1) < $i) {
 469             break;
 470         }
 471         // printf("here [%s] [%s]\n", $v1_ar[$i], $v2_ar[$i]);
 472         if ($v1_ar[$i] != $v2_ar[$i]) {
 473             if (strval($v1_ar[$i]) < strval($v2_ar[$i]))
 474                 return -1;
 475             else
 476                 return  1;
 477         }
 478     }
 479     return 0;
 480 }
 481
 482 // return string with IPV4 address
 483 function addrtoipv4($addr)
 484 {
 485     $ipv4addr_arr = explode(':' , $addr);
 486     if (isset($ipv4addr_arr[3])) {
 487         $ipv4addr = $ipv4addr_arr[3];
 488     }
 489     else {
 490         $ipv4addr = $addr;
 491     }
 492     return $ipv4addr;
 493 }
 494
 495 function mop_flush()
 496 {
 497     for ($i = 0; $i < ob_get_level(); $i++)
 498         ob_end_flush();
 499     ob_implicit_flush(1);
 500     flush();
 501 }
 502
 503 function force_no_cache(&$header_out)
 504 {
 505     $header_out['Pragma'] = 'no-cache, must-revalidate';
 506     $header_out['Cache-Control'] = 'no-cache';
 507     $header_out['Expires'] = '-1';
 508 }
 509
 510 function file_lock($fname, $is_exclusive)
 511 {
 512     if (($res = @fopen($fname, "r+")) == FALSE) {
 513         return (FALSE);
 514     }
 515
 516     if (flock($res, ($is_exclusive ? LOCK_EX : LOCK_SH)) == FALSE) {
 517         fclose($res);
 518         return (FALSE);
 519     }
 520
 521     return ($res);
 522 }
 523
 524 function file_unlock($res)
 525 {
 526     if ($res != FALSE) {
 527         flock($res, LOCK_UN);
 528         fclose($res);
 529     }
 530 }
 531
 532 $escpush_from = array("\\", "\"");
 533 $escpush_to   = array("\\\\", "\\\"");
 534 function escpush($s)
 535 {
 536     GLOBAL $escpush_from, $escpush_to;
 537
 538     return str_replace($escpush_from, $escpush_to, $s);
 539 }
 540
 541 $escinp_from = array( "\""     );
 542 $escinp_to = array(   "&quot;" );
 543
 544 function escinput($s)
 545 {
 546     GLOBAL $escinp_from, $escinp_to;
 547
 548     return str_replace($escinp_from, $escinp_to, $s);
 549 }
 550
 551 function eschtml($s)
 552 {
 553     return htmlentities($s, ENT_COMPAT, "UTF-8");
 554 }
 555
 556 function esclfhtml($s)
 557 {
 558     return str_replace(" ", "&nbsp;", str_replace("\n", "<br>", htmlspecialchars($s)));
 559 }
 560
 561 function langtolng($lang)
 562 {
 563   GLOBAL $G_lang;
 564
 565   return ($G_lang == 'en' ? '-en' : '');
 566 }
 567
 568 function csplitter($in, $sep)
 569 {
 570     $st = 0;
 571     $id = 0;
 572     $out = array();
 573     $out[$id] = "";
 574     for ($i = 0 ; $i < strlen($in) ; $i++) {
 575         $ini = substr($in, $i, 1);
 576         if ($st == 0) {
 577             if ($ini == '\\')
 578                 $st = 1;
 579             else if ($ini == $sep) {
 580                 $id++;
 581                 $out[$id] = "";
 582             }
 583             else {
 584                 $out[$id] .= $ini;
 585             }
 586         }
 587         else if ($st == 1) {
 588             $out[$id] .= $ini;
 589             $st = 0;
 590         }
 591     }
 592
 593     return ($out);
 594 }
 595
 596 function xcape($s)
 597 {
 598     $from = array (   '\\',     '@',        '|' );
 599     $to   = array ( '\\\\', '&#64;', '&brvbar;' );
 600
 601     return (str_replace($from, $to, htmlentities($s,ENT_COMPAT,"UTF-8")));
 602 }
 603
 604 function xcapelt($s)
 605 {
 606     $from = array (   '\\',     '|',  "\t",  "\n");
 607     $to   = array ( '\\\\',   '\\|', "\\t", "\\n");
 608
 609     return (str_replace($from, $to, $s));
 610 }
 611
 612 function xcapemesg($s)
 613 {
 614     $from = array (  "\n");
 615     $to   = array ( "\\n");
 616
 617     return (str_replace($from, $to, $s));
 618 }
 619
 620
 621 class Vect {
 622     function Vect($a)
 623     {
 624         $this->el = $a;
 625     }
 626
 627     function getbyid($idx)
 628     {
 629         return ($this->el[$idx]);
 630     }
 631
 632     function setbyid($idx, $v)
 633     {
 634         $this->el[$idx] = $v;
 635     }
 636 }
 637
 638 define('TABLE_AUTH_TY_PUBL', 0);
 639 define('TABLE_AUTH_TY_APPR', 1);
 640 define('TABLE_AUTH_TY_AUTH', 2);
 641 define('TABLE_AUTH_TY_CERT', 3);
 642
 643
 644 class Table {
 645     var $idx;
 646     var $player;
 647     var $player_n;
 648
 649     var $auth_type;     // required authorization to sit down
 650
 651     var $wag_own;
 652     var $wag_com;
 653     var $wag_tout;
 654
 655     var $table_token;
 656     var $table_start;   // information field
 657
 658     var $wakeup_time;
 659
 660     function Table()
 661     {
 662     }
 663
 664     function create($idx)
 665     {
 666         if (($thiz = new Table()) == FALSE)
 667             return (FALSE);
 668
 669         $thiz->idx       =   $idx;
 670         $thiz->player    =   array();
 671         $thiz->player_n  =   0;
 672
 673         if ($idx < TABLES_CERT_N)
 674             $thiz->auth_type =   TABLE_AUTH_TY_CERT;
 675         else if ($idx < TABLES_AUTH_N)
 676             $thiz->auth_type =   TABLE_AUTH_TY_AUTH;
 677         else if ($idx < TABLES_APPR_N)
 678             $thiz->auth_type =   TABLE_AUTH_TY_APPR;
 679         else
 680             $thiz->auth_type =   TABLE_AUTH_TY_PUBL;
 681
 682         $thiz->wag_own   =  -1;
 683         $thiz->wag_com   =  "";
 684         $thiz->wag_tout   =  0;
 685
 686         $thiz->table_token  = "";
 687         $thiz->table_start  = 0;
 688
 689         $thiz->wakeup_time = 0;
 690
 691         return ($thiz);
 692     }
 693
 694     function copy($from)
 695     {
 696         $this->idx = $from->idx;
 697         $this->player = array();
 698         for ($i = 0 ; $i < $from->player_n ; $i++)
 699             $this->player[$i] = $from->player[$i];
 700         $this->player_n = $from->player_n;
 701
 702         log_main("PLAYER_N - parent::copy.".$this->player_n);
 703
 704         $this->auth_type =  $from->auth_type;
 705
 706         $this->wag_own   =  $from->wag_own;
 707         $this->wag_com   =  $from->wag_com;
 708         $this->wag_tout  =  $from->wag_tout;
 709
 710         $this->table_token  = $from->table_token;
 711         $this->table_start  = $from->table_start;
 712
 713         $this->wakeup_time = $from->wakeup_time;
 714     }
 715
 716     function myclone($from)
 717     {
 718         if (($thiz = new Table()) == FALSE)
 719             return (FALSE);
 720
 721         $this->copy($from);
 722
 723         return ($thiz);
 724     }
 725
 726     function spawn($from)
 727     {
 728         if (($thiz = new Table()) == FALSE)
 729             return (FALSE);
 730
 731         $thiz->idx = $from->idx;
 732         $thiz->player = array();
 733         for ($i = 0 ; $i < $from->player_n ; $i++)
 734             $thiz->player[$i] = $i;
 735         $thiz->player_n = $from->player_n;
 736
 737         $thiz->auth_type =  $from->auth_type;
 738
 739         $thiz->wag_own = $from->wag_own;
 740         $thiz->wag_com = $from->wag_com;
 741         $thiz->wag_tout  =  $from->wag_tout;
 742
 743         $thiz->table_token  = $from->table_token;
 744         $thiz->table_start  = $from->table_start;
 745
 746         $thiz->wakeup_time = $from->wakeup_time;
 747
 748         return ($thiz);
 749     }
 750
 751     function wag_set($user_idx, $mesg)
 752     {
 753         log_main("WAG_SET");
 754
 755         $this->wag_own  =  $user_idx;
 756         $this->wag_com  =  $mesg;
 757         $this->wag_tout =  0;
 758     }
 759
 760     function wag_reset($timeout)
 761     {
 762         log_main("WAG_RESET");
 763
 764         unset($this->wag_own);
 765         $this->wag_own  = -1;
 766         $this->wag_com  = "";
 767         $this->wag_tout = $timeout;
 768     }
 769
 770     function player_get($idx)
 771     {
 772         return ($this->player[$idx]);
 773     }
 774
 775     function player_set($idx, $player)
 776     {
 777         $this->player[$idx] = $player;
 778     }
 779
 780     function user_add($idx)
 781     {
 782         $this->player[$this->player_n] = $idx;
 783         $this->player_n++;
 784
 785         return ($this->player_n - 1);
 786     }
 787
 788     function user_rem($brisk, $user)
 789     {
 790         $tabpos = $user->table_pos;
 791
 792         /* verifico la consistenza dei dati */
 793         if ($brisk->user[$this->player[$tabpos]] == $user) {
 794
 795             /* aggiorna l'array dei giocatori al tavolo. */
 796             for ($i = $tabpos ; $i < $this->player_n-1 ; $i++) {
 797                 $this->player[$i] = $this->player[$i+1];
 798                 $user_cur = $brisk->user[$this->player[$i]];
 799                 $user_cur->table_pos = $i;
 800             }
 801             $this->player_n--;
 802         }
 803         else {
 804             log_main("INCONSISTENCY ON TABLE.");
 805         }
 806     }
 807
 808     // Table->act_content - return 'id' of type of output required for table button
 809     function act_content($user)
 810     {
 811         $ret = "";
 812         $isstanding = ($user->subst == 'standup');
 813         $sitted = $this->player_n;
 814         $table = $this->idx;
 815         $cur_table = $user->table;
 816         $allowed = TRUE;
 817
 818         if ($isstanding) {
 819             if ($sitted < PLAYERS_N) {
 820                 switch ($this->auth_type) {
 821                 case TABLE_AUTH_TY_CERT:
 822                     if ($user->is_cert() && !$user->is_appr())
 823                         $act = "sitcert";
 824                     else
 825                         $act = 'resercert';
 826                     break;
 827                 case TABLE_AUTH_TY_AUTH:
 828                     if ($user->is_auth() && !$user->is_appr())
 829                         $act = "sitreser";
 830                     else
 831                         $act = 'reserved';
 832                     break;
 833                 case TABLE_AUTH_TY_APPR:
 834                     if ($user->is_auth())
 835                         $act = "sitappr";
 836                     else
 837                         $act = 'reserved';
 838                     break;
 839                 default:
 840                     $act = 'sit';
 841                     break;
 842                 }
 843             }
 844             else {
 845                 $act = 'none';
 846             }
 847         }
 848         else {
 849             if ($table == $cur_table)
 850                 $act = 'wake';
 851             else
 852                 $act = 'none';
 853         }
 854
 855         if ($act != '')
 856             $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
 857
 858         return ($ret);
 859     }
 860 } // end class Table
 861
 862
 863 class Delay_Manager
 864 {
 865     var $delta;
 866     var $lastckeck;
 867     var $triglevel;
 868
 869     function Delay_Manager($triglevel)
 870     {
 871         $this->triglevel = $triglevel;
 872         $this->delta = array();
 873         $this->lastcheck = 0;
 874     }
 875
 876     function delta_get($curtime)
 877     {
 878         // clean too old delta items
 879         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 880             if ($this->delta[$i][0] < $curtime) {
 881                 array_splice($this->delta, $i, 1);
 882                 $i--;
 883             }
 884         }
 885
 886         // add new delta items if delay exceeded $this->triglevel sec
 887         if ($curtime > $this->lastcheck + $this->triglevel && $curtime < $this->lastcheck + 1200.0) {
 888             $delta = $curtime - $this->lastcheck - $this->triglevel;
 889             array_push($this->delta, array($curtime + $delta , $delta));
 890             // fprintf(STDERR, "DELTA: add new delta [%f] [%f] [%f]\n", $this->triglevel, $curtime + $delta, $delta);
 891         }
 892
 893         // extract the maximum valid delta
 894         $delta_max = 0.0;
 895         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 896             $delta_cur = $this->delta[$i][1];
 897             if ($delta_max < $delta_cur)
 898                 $delta_max = $delta_cur;
 899         }
 900
 901         // fprintf(STDERR, "DELTA: status %d, delta_max: %f\n", count($this->delta), $delta_max);
 902
 903         return ($delta_max);
 904     }
 905
 906     function lastcheck_set($curtime)
 907     {
 908         $this->lastcheck = $curtime;
 909     }
 910 }
 911
 912 class Client_prefs {
 913     var $listen;
 914     var $supp_comp;
 915
 916     function Client_prefs()
 917     {
 918     }
 919
 920     static function from_user($user)
 921     {
 922         $thiz = new Client_prefs();
 923         $thiz->user_load($user);
 924
 925         return ($thiz);
 926     }
 927
 928     static function from_json($json)
 929     {
 930         $thiz = new Client_prefs();
 931         if ($thiz->json_load($json) == FALSE) {
 932             unset($thiz);
 933             return (FALSE);
 934         }
 935
 936         return ($thiz);
 937     }
 938
 939     function user_load($user)
 940     {
 941         // fprintf(STDERR, "QQ %s: %x\n", __FUNCTION__, $user->flags);
 942         $this->listen = ($user->flags & USER_FLAG_MAP_AUTH) >> 2;
 943         if ($user->rec != FALSE) {
 944             $this->supp_comp = $user->rec->supp_comp_get();
 945         }
 946         else {
 947             $this->supp_comp = "000000000000";
 948         }
 949
 950         // fprintf(STDERR, "QQ %s: LISTEN: %d\n", __FUNCTION__, $this->listen);
 951     }
 952
 953     function json_load($json_s)
 954     {
 955         $ret = FALSE;
 956
 957         do {
 958             if (gettype($json_s) == "string") {
 959                 if (($json = json_decode($json_s)) == FALSE)
 960                     break;
 961             }
 962             else {
 963                 $json = $json_s;
 964             }
 965             if ($this->listen < 0 || $this->listen > 2)
 966                 break;
 967             $this->listen = $json->listen;
 968
 969             if (mb_strlen($json->supp_comp, "ASCII") != 12)
 970                 break;
 971
 972             for ($i = 0, $idx = 0 ; $i < 12 ; $i++) {
 973                 if (($json->supp_comp[$i] >= '0' && $json->supp_comp[$i] <= '9') ||
 974                     ($json->supp_comp[$i] >= 'a' && $json->supp_comp[$i] <= 'f'))
 975                     continue;
 976                 break;
 977             }
 978             if ($i < 12)
 979                 break;
 980             $this->supp_comp = $json->supp_comp;
 981             $ret = TRUE;
 982         } while (FALSE);
 983
 984         return ($ret);
 985     }
 986
 987     function store($user, $is_save)
 988     {
 989         // save into DB
 990         // fprintf(STDERR, "QQ %s::%s PRE: %x\n", __CLASS__, __FUNCTION__,
 991         //         $user->flags & (~USER_FLAG_S_ALL & ~USER_FLAG_AUTH));
 992         $user->flags_set(($this->listen << 2), USER_FLAG_MAP_AUTH);
 993         // fprintf(STDERR, "QQ %s::%s %x\n", __CLASS__, __FUNCTION__,
 994         //         $user->flags);
 995         if ($user->is_supp_custom()) {
 996             $user->rec->supp_comp_set($this->supp_comp);
 997         }
 998         if ($is_save)
 999             $user->prefs_store();
1000     }
1001 }
1002
1003 define('GHOST_SESS_TOUT', 1800);
1004 define('GHOST_SESS_REAS_LOUT', 1); // logout
1005 define('GHOST_SESS_REAS_ANOT', 2); // another user get session
1006 define('GHOST_SESS_REAS_TOUT', 3); // room timeout
1007 define('GHOST_SESS_REAS_TTOT', 4); // table timeout
1008 define('GHOST_SESS_REAS_ANON', 5); // anonymizer access
1009 define('GHOST_SESS_REAS_PROX', 6); // proxy access
1010
1011 class GhostSessEl
1012 {
1013     var $time;
1014     var $sess;
1015     var $reas;
1016
1017     function GhostSessEl($time, $sess, $reas)
1018     {
1019         $this->time = $time + GHOST_SESS_TOUT;
1020         $this->sess = $sess;
1021         $this->reas = $reas;
1022     }
1023 }
1024
1025 class GhostSess
1026 {
1027     var $gs;
1028
1029     function GhostSess()
1030     {
1031         $this->gs = array();
1032     }
1033
1034     // push or update for this session
1035     function push($time, $sess, $reas)
1036     {
1037         foreach($this->gs as $el) {
1038             if ($el->sess == "$sess") {
1039                 $el->reas = $reas;
1040                 $el->time = $time + GHOST_SESS_TOUT;
1041                 return TRUE;
1042             }
1043         }
1044
1045         $this->gs[] = new GhostSessEl($time, $sess, $reas);
1046         return TRUE;
1047     }
1048
1049     function pop($sess)
1050     {
1051         foreach($this->gs as $key => $el) {
1052             if ($el->sess == "$sess") {
1053                 $ret = $this->gs[$key];
1054                 unset($this->gs[$key]);
1055                 return ($ret);
1056             }
1057         }
1058         return FALSE;
1059     }
1060
1061     function garbage_manager($curtime)
1062     {
1063         foreach($this->gs as $key => $el) {
1064             if ($el->time < $curtime) {
1065                 unset($this->gs[$key]);
1066             }
1067         }
1068     }
1069 }
1070
1071 class Brisk
1072 {
1073     static $delta_t;
1074
1075     var $crystal_filename;
1076     var $user;
1077     var $table;
1078     var $match;
1079     var $comm; // commands for many people
1080     var $step; // current step of the comm array
1081     var $garbage_timeout;
1082     var $shm_sz;
1083
1084     var $ban_list;       // ban list (authized allowed)
1085     var $black_list;     // black list (anti-dos, noone allowed)
1086     var $cloud_smasher;  // list of cloud ip ranges to be rejected
1087     var $ghost_sess;
1088     var $delay_mgr;
1089
1090     var $cds;
1091
1092     public static $sess_cur;
1093
1094     function Brisk()
1095     {
1096         $this->cds = NULL;
1097     }
1098
1099     // constructor
1100     static function create($crystal_filename, $ban_list, $black_list, $cloud_smasher) {
1101         if (($brisk_ser = @file_get_contents($crystal_filename)) != FALSE) {
1102             if (($brisk = unserialize($brisk_ser)) != FALSE) {
1103                 fprintf(STDERR, "ROOM FROM FILE\n");
1104                 rename($crystal_filename, $crystal_filename.".old");
1105
1106                 $brisk->reload(TRUE, $ban_list, $black_list, $cloud_smasher);
1107
1108                 return($brisk);
1109             }
1110         }
1111
1112         fprintf(STDERR, "NEW ROOM\n");
1113         $thiz = new Brisk();
1114
1115         $thiz->crystal_filename = $crystal_filename;
1116         $thiz->user  = array();
1117         $thiz->table = array();
1118         $thiz->match = array();
1119
1120         $thiz->ban_list = IpClass::create();
1121         $thiz->black_list = IpClass::create();
1122         $thiz->cloud_smasher = IpClass::create();
1123         $thiz->ghost_sess = new GhostSess();
1124
1125         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1126             $thiz->user[$i] = User::create($thiz, $i, "", "");
1127         }
1128
1129         for ($i = 0 ; $i < TABLES_N ; $i++) {
1130             $thiz->table[$i] = Table::create($i);
1131         }
1132         $thiz->garbage_timeout = 0;
1133         $thiz->shm_sz = SHM_DIMS_MIN;
1134
1135         $thiz->delay_mgr = new Delay_Manager(1.5);
1136
1137         static::$sess_cur = FALSE;
1138
1139         $thiz->reload(TRUE, $ban_list, $black_list, $cloud_smasher);
1140
1141         return ($thiz);
1142     }
1143
1144     function reload($is_first, $ban_list, $black_list, $cloud_smasher)
1145     {
1146         fprintf(STDERR, "RELOAD STUFF (%d)(%d)(%d)\n",
1147                 count($ban_list), count($black_list), count($cloud_smasher));
1148
1149         if (defined('CURL_DE_SAC_VERS')) {
1150             if (brisk_cds_reload($this) == FALSE) {
1151                 exit(12);
1152             }
1153         }
1154         $this->ban_list->update($ban_list);
1155         $this->black_list->update($black_list);
1156         $this->cloud_smasher->update($cloud_smasher);
1157
1158         if (!$is_first) {
1159             $this->banned_kickoff();
1160             $this->garbage_manager(TRUE);
1161         }
1162     }
1163
1164     function banned_kickoff()
1165     {
1166         $is_ban = FALSE;
1167
1168         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1169             $table_cur = $this->table[$table_idx];
1170             // if the table is complete and exists we check users IP
1171
1172             if ($table_cur->player_n == PLAYERS_N) {
1173                 if (isset($this->match[$table_idx]) &&
1174                     $table_cur->table_token == $bin5->table_token) {
1175                     log_main("PLAYERS == N TABLE ".$table_idx);
1176
1177                     $bin5 = $this->match[$table_idx];
1178
1179                     $is_ban |= $bin5->banned_kickoff();
1180                 }
1181             }
1182         }
1183
1184         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1185             $user_cur = $this->user[$i];
1186
1187             if ($user_cur->is_active() == FALSE)
1188                 continue;
1189
1190             // check if the IP is blacklisted
1191             if ($this->black_check($user_cur->ip) ||
1192                 $this->cloud_check($user_cur->ip)) {
1193                 $user_cur->lacc = 0;
1194                 $is_ban = TRUE;
1195                 continue;
1196             }
1197
1198             // if authorized not check if banlisted
1199             if ($user_cur->is_auth()) {
1200                 continue;
1201             }
1202
1203             if ($this->ban_check($user_cur->ip)) {
1204                 $user_cur->lacc = 0;
1205                 $is_ban = TRUE;
1206             }
1207         }
1208
1209         return $is_ban;
1210     }
1211
1212     function ban_check($ip_str)
1213     {
1214         return ($this->ban_list->check($ip_str));
1215     }
1216
1217     function black_check($ip_str)
1218     {
1219         return ($this->black_list->check($ip_str));
1220     }
1221
1222     function cloud_check($ip_str)
1223     {
1224         return ($this->cloud_smasher->check($ip_str));
1225     }
1226
1227     function users_cleanup()
1228     {
1229         $curtime = time();
1230         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1231             $user_cur = $this->user[$i];
1232
1233             if ($user_cur->the_end
1234                 && (($user_cur->rd_toflush == FALSE
1235                      && $user_cur->rd_step == $user_cur->step)
1236                     || $user_cur->rd_endtime_is_expired($curtime))
1237                 ) {
1238                 $user_cur->reset(); // users_cleanup, OK
1239             }
1240         }
1241     }
1242
1243     function garbage_manager($force)
1244     {
1245         GLOBAL $G_lang, $mlang_brisk, $G_base;
1246
1247         $ismod = FALSE;
1248
1249         log_rd2("garbage_manager START");
1250
1251         /* Garbage collector degli utenti in timeout */
1252         $curtime = microtime(TRUE);
1253
1254         $delta = $this->delay_mgr->delta_get($curtime);
1255
1256         if (!$force && !($this->garbage_timeout < $curtime)) {
1257             $this->delay_mgr->lastcheck_set($curtime);
1258             return ($ismod);
1259         }
1260
1261         // Before all align times with table timeout
1262         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1263             $table_cur = $this->table[$table_idx];
1264             // if the table is complete and exists its shared mem we get the info about users lacc
1265
1266             if ($table_cur->player_n == PLAYERS_N) {
1267                 log_main("PLAYERS == N TABLE ".$table_idx);
1268
1269
1270                 $no_recovery = FALSE;
1271                 if (isset($this->match[$table_idx])) {
1272                     $bin5 = $this->match[$table_idx];
1273
1274                     if ($table_cur->table_token != $bin5->table_token) {
1275                         log_main("ERROR: not matching table_token. Brisk: ".$table_cur->table_token."  Table: ".$bin5->table_token);
1276                         log_main("ERROR: not matching table_start. Brisk: ".$table_cur->table_start."  Table: ".$bin5->table_start);
1277                         $no_recovery = TRUE;
1278                         $bin5 = FALSE;
1279                     }
1280
1281                     if ($bin5 != FALSE) {
1282                         //
1283                         //  SPAWN: JOIN
1284                         //
1285                         log_main("garbage_manager: bri loaded successfully.");
1286                         $bin5->garbage_manager(TRUE);
1287
1288                         $bin5_table = $bin5->table[0];
1289
1290                         // is the end of the table
1291
1292                         if ($bin5->the_end == TRUE) {
1293                             /*
1294                              *  DESTROY OF FINISHED TABLE && MOVE PLAYER TO ROOM AGAIN
1295                              */
1296                             log_main("garbage_manager: INSIDE THE END.");
1297
1298                             $plist = "$table_cur->table_token|$table_cur->idx|$table_cur->player_n";
1299                             for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1300                                 $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1301                             }
1302
1303                             for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1304                                 // stat must be "table" by definition
1305                                 $user_cur = $this->user[$table_cur->player[$i]];
1306                                 $bin5_user = $bin5->user[$i];
1307
1308                                 $user_cur->subst      = $bin5_user->subst;
1309                                 $user_cur->rd_step    = $bin5_user->rd_step;
1310                                 $user_cur->step       = $bin5_user->step;
1311                                 $user_cur->lacc       = $bin5_user->lacc;
1312                                 $user_cur->laccwr     = $bin5_user->lacc;
1313                                 $user_cur->bantime    = $bin5_user->bantime;
1314                                 $user_cur->the_end    = $bin5_user->the_end;
1315                                 if ($user_cur->the_end) {
1316                                     $this->ghost_sess->push($curtime, $user_cur->sess, GHOST_SESS_REAS_TTOT);
1317                                 }
1318                             }
1319
1320                             log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME", $plist);
1321
1322                             $this->room_join_wakeup($user_cur, FALSE, 0);
1323                             $table_cur->table_token = "";
1324                             $table_cur->wakeup_time = $curtime + WAKEUP_TIME;
1325
1326                             $this->match_del($table_idx);
1327                         }
1328                         else {
1329                             log_main("gm:: save_data");
1330
1331                             for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1332                                 $this->user[$table_cur->player[$i]]->lacc = $bin5->user[$i]->lacc;
1333                             }
1334                         }
1335                     } // if ($bin5 == FALSE
1336                     else if ($no_recovery == FALSE) {
1337                         log_crit("ERROR: table ".$table_idx." unrecoverable join");
1338
1339                         for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1340                             $user_cur = $this->user[$table_cur->player[$i]];
1341                             $user_cur->subst = "shutdowner";
1342                             $user_cur->step_inc();
1343
1344                             $ret = sprintf('stat = "%s"; subst = "%s";',  $user_cur->stat, $user_cur->subst);
1345                             $ret .= "gst.st = ".($user_cur->step+1)."; ";
1346                             // MLANG <br>I dati del tavolo n&deg; ".$user_cur->table." sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>
1347                             $prestr = sprintf($mlang_brisk['tabincon'][$G_lang], $user_cur->table);
1348                             $ret .= show_notify($prestr, 2000, $mlang_brisk['btn_close'][$G_lang], 400, 110);
1349                             $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1350                             $user_cur->step_inc();
1351                         }
1352
1353                         $plist = "$table_cur->table_token|$user_cur->table|$table_cur->player_n";
1354                         for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1355                             $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1356                         }
1357                         log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME(RECOVERY)", $plist);
1358
1359                         $this->room_join_wakeup($user_cur, TRUE, -2);
1360                         $table_cur->table_token = "";
1361                     }
1362                 }
1363             } //  if ($table_cur->player_n == PLAYERS_N) {
1364         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1365
1366         log_rd2("out new loop.");
1367
1368         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1369             $user_cur = $this->user[$i];
1370
1371             log_rd2("User: ".$user_cur->name."  stat: ".$user_cur->stat."  subst: ".$user_cur->subst);
1372
1373             if ($user_cur->is_active() == FALSE)
1374                 continue;
1375
1376             if ($user_cur->lacc + (($user_cur->ping_req ? 1.5 : 1.0) * EXPIRE_TIME_RD) < ($curtime - $delta)) {
1377                 // Auto logout dell'utente
1378                 log_rd2("AUTO LOGOUT.".($user_cur->lacc + EXPIRE_TIME_RD)." curtime - delta ".($curtime - $delta));
1379
1380                 $this->ghost_sess->push($curtime, $user_cur->sess, GHOST_SESS_REAS_TOUT);
1381                 $user_cur->the_end = TRUE;
1382
1383                 log_rd2("AUTO LOGOUT.");
1384                 if ($user_cur->stat == 'table' || $user_cur->stat == 'room') {
1385                     log_auth($user_cur->sess, "Autologout session.");
1386
1387                     if ($user_cur->subst == 'sitdown' || $user_cur->stat == 'table')
1388                         $this->room_wakeup($user_cur);
1389                     else if ($user_cur->subst == 'standup')
1390                         $this->room_outstandup($user_cur);
1391                     else
1392                         log_rd2("LOGOUT FROM WHAT ???");
1393                 }
1394             }
1395
1396             if ($user_cur->laccwr + EXPIRE_TIME_SMAMMA < ($curtime - $delta)) { // lo rimettiamo in piedi
1397                 if ($user_cur->stat == 'room' && $user_cur->subst == 'sitdown') {
1398                     $this->room_wakeup($user_cur);
1399                     $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ";
1400                     /* MLANG: <br>Sei stato inattivo per ".(EXPIRE_TIME_SMAMMA/60.0)." minuti. <br><br>Quindi ritorni tra i <b>Giocatori in piedi</b>.", "torna ai tavoli" */
1401                     $user_cur->comm[$user_cur->step % COMM_N] .=  show_notify($mlang_brisk['tabtout_a'][$G_lang].(EXPIRE_TIME_SMAMMA/60.0).$mlang_brisk['tabtout_b'][$G_lang], 0, $mlang_brisk['btn_backstand'][$G_lang], 400, 100);
1402                     $user_cur->step_inc();
1403                 }
1404             }
1405         }
1406         log_rd2("GARBAGE UPDATED!");
1407
1408         $this->garbage_timeout = $curtime + GARBAGE_TIMEOUT;
1409         $ismod = TRUE;
1410
1411         $this->ghost_sess->garbage_manager($curtime);
1412
1413         $this->delay_mgr->lastcheck_set($curtime);
1414         return ($ismod);
1415     }
1416
1417     function show_room($user_step, $user)
1418     {
1419         GLOBAL $G_lang, $mlang_brisk;
1420         log_main("show_room: username: ".$user->name);
1421
1422         $ret = sprintf('gst.st = %d; ',  $user_step);
1423
1424         $prefs = Client_prefs::from_user($user);
1425         $ret .= sprintf('prefs_load(\'%s\', false, false);', json_encode($prefs));
1426
1427         if(false) {
1428             if ($user->flags & USER_FLAG_ISOLAUTH) {
1429                 $ret .= 'list_set(\'isolation\', false, \''.$mlang_brisk['tit_onisol'][$G_lang].'\' ); ';
1430             }
1431             else {
1432                 $ret .= 'list_set(\'all\', false, \'\' ); ';
1433             }
1434         }
1435
1436         if ($user->subst == 'standup')
1437             $ret .= "tra.show(); ";
1438         else
1439             $ret .= "tra.hide(); ";
1440
1441         $ret .= sprintf('stat = "%s";',  $user->stat);
1442
1443         $ret .= root_welcome($user);
1444         if ($user->flags & USER_FLAG_DBFAILED) {
1445             $ret .= "gst.st = ".($user->step+1)."; ";
1446             $ret .= show_notify($mlang_brisk['db_failed'][$G_lang], 0, $mlang_brisk['btn_close'][$G_lang], 400, 140);
1447         }
1448
1449         $ret .= sprintf('subst = "%s";', $user->subst);
1450         $ret .= $user->myname_innerHTML();
1451
1452         for ($i = 0 ; $i < TABLES_N ; $i++) {
1453
1454             $ret .= $this->table_content($user, $i);
1455
1456             $ret .=  $this->table[$i]->act_content($user);
1457             if ($this->table[$i]->wag_own != -1)
1458                 $ret .= sprintf('tra.add(%d, "%s: %s"); ', $i,  $this->user[$this->table[$i]->wag_own]->name, $this->table[$i]->wag_com);
1459             else
1460                 $ret .= sprintf('tra.rem(%d); ', $i);
1461         }
1462         $ret .= $this->standup_content($user);
1463         $ret .= "setTimeout(preload_images, 0, g_preload_img_arr, g_imgct); ";
1464
1465         return ($ret);
1466     }
1467
1468     function room_wakeup($user)
1469     {
1470         $table_idx = $user->table;
1471         $table = $this->table[$table_idx];
1472
1473         log_main("WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1474
1475         $curtime = time();
1476
1477         $from_table = ($user->stat == "table");
1478         if ($from_table) {
1479             log_main("WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1480
1481             for ($i = 0 ; $i < $table->player_n ; $i++) {
1482                 $user_cur = $this->user[$table->player[$i]];
1483                 log_main("PREIMPOST: INLOOP name: ".$user_cur->name);
1484
1485                 if ($user->idx_get() != $table->player[$i]) {
1486                     $user_cur->stat_set("room");
1487                     $user_cur->subst = "sitdown";
1488                     $user_cur->laccwr = $curtime;
1489                 }
1490                 else if ($user->is_active()) {
1491                     $user_cur->stat_set("room");
1492                     $user_cur->subst = "standup";
1493                     $user_cur->laccwr = $curtime;
1494                     $user_cur->table = -1;
1495                 }
1496             }
1497         }
1498         else {
1499             $user->stat_set("room");
1500             $user->subst = "standup";
1501             $user->laccwr = $curtime;
1502         }
1503
1504         $remove_wagon = FALSE;
1505         if($table->wag_own == $user->idx_get()) {
1506             $table->wag_reset($curtime);
1507             $remove_wagon = TRUE;
1508         }
1509
1510         /* aggiorna l'array dei giocatori al tavolo. */
1511         $table->user_rem($this, $user);
1512
1513         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1514             $user_cur = $this->user[$i];
1515             if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1516                 continue;
1517
1518             // log_main("VALORI: name: ".$user_cur->name."from_table: ".$from_table."  tab: ".$user_cur->table." taix: ".$table_idx."  ucur: ".$user_cur."  us: ".$user);
1519
1520             $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1521             if ($from_table && ($user_cur->table == $table_idx || $user->idx_get() == $i)) {
1522                 $ret .= 'gst.st_loc++; xstm.stop(); window.onunload = null; window.onbeforeunload = null; document.location.assign("index.php");|';
1523                 // $ret .= 'gst.st_loc++; document.location.assign("index.php");|';
1524                 log_main("DOCUMENT.index.php: from table");
1525             }
1526             else if ($user_cur->stat == "room") {
1527                 log_main("DOCUMENT.index.php: from table");
1528
1529                 $ret .= $this->table_content($user_cur, $table_idx);
1530                 $ret .= $this->standup_content($user_cur);
1531
1532                 // $ret .= table_act_content(FALSE, 0, $table_idx, $user->table, FALSE);
1533                 $ret .= $table->act_content($user);
1534
1535                 if ($user->idx_get() == $i) {
1536                     // set the new status
1537                     $ret .=  'subst = "standup"; tra.show(); ';
1538                     // clean the action buttons in other tables
1539                     for ($e = 0 ; $e < TABLES_N ; $e++) {
1540                         if ($this->table[$e]->player_n < PLAYERS_N) {
1541                             $ret .= $this->table[$e]->act_content($user);
1542                         }
1543                     }
1544                 }
1545                 else {
1546                     $ret .= $table->act_content($user_cur);
1547                 }
1548             }
1549             log_wr("ROOM_WAKEUP: ".$ret);
1550             $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1551             $user_cur->step_inc();
1552         }
1553     }
1554
1555     function room_join_wakeup($user, $update_lacc = FALSE, $trans_delta)
1556     {
1557         $table_idx = $user->table;
1558         $table = $this->table[$table_idx];
1559
1560         log_main("JOIN_WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1561
1562         $curtime = time();
1563         $user_wup = array();
1564         $user_wup_n = 0;
1565         $user_tab = array();
1566         $user_tab_n = 0;
1567         log_main("JOIN WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1568
1569         for ($i = 0 ; $i < $table->player_n ; $i++) {
1570             $user_cur = $this->user[$table->player[$i]];
1571             log_main("PREIMPOST INLOOP name: ".$user_cur->name);
1572             if ($user_cur->is_empty()) {
1573                 continue;
1574             }
1575             if ($update_lacc == TRUE) {
1576                 $user_cur->laccwr = $curtime;
1577             }
1578             log_main("cur: ".$user_cur->name."  subst: ".$user_cur->subst);
1579             if ($user_cur->subst == "shutdowned") {
1580                 $user_cur->stat_set("room");
1581                 $user_cur->subst = "sitdown";
1582             }
1583             else if ($user_cur->subst == "shutdowner") {
1584                 $user_cur->stat_set("room");
1585                 $user_cur->subst = "standup";
1586                 $user_cur->table = -1;
1587                 $user_wup[$user_wup_n++] = $user_cur;
1588
1589                 $remove_wagon = FALSE;
1590                 if($table->wag_own == $table->player[$i]) {
1591                     $remove_wagon = TRUE;
1592                     $table->wag_reset($curtime);
1593                 }
1594             }
1595             $user_tab[$user_tab_n++] = $table->player[$i];
1596         }
1597
1598         for ($wup_idx = 0 ; $wup_idx < $user_wup_n  ; $wup_idx++)
1599             $table->user_rem($this, $user_wup[$wup_idx]);
1600
1601         /* aggiorna l'array dei giocatori al tavolo. */
1602
1603         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1604             log_main("START LOOP");
1605             $user_cur = $this->user[$i];
1606             if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') { // is not active user or the stat isn't 'room'
1607                 log_main("name: ".$user_cur->name."skip   subst: ".$user_cur->subst);
1608                 continue;
1609             }
1610
1611             log_main("___");
1612             log_main("VALORI name: ".$user_cur->name."  tab: ".$user_cur->table." taix: ".$table_idx);
1613
1614             $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1615             if ($user_cur->stat == "room") {
1616                 log_main("DOCUMENT.index.php from table");
1617
1618                 $ret .= $this->table_content($user_cur, $table_idx);
1619                 $ret .= $this->standup_content($user_cur);
1620
1621                 $ret .= $table->act_content($user_cur);
1622
1623
1624                 for ($tab_idx = 0 ; $tab_idx < $user_tab_n  ; $tab_idx++)
1625                     if ($user_tab[$tab_idx] == $i)
1626                         break;
1627
1628                 // for users that wakeup the room will be reconstructed by index_rd.php
1629                 if ($tab_idx < $user_tab_n) {
1630                     log_main("PRE show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1631
1632 //        ARRAY_POP DISABLED
1633 //           if ($trans_delta == 0)
1634 //             while (array_pop($user_cur->comm) != NULL);
1635
1636                     $user_cur->trans_step = $user_cur->step + 1 + $trans_delta;
1637                     $user_cur->comm[$user_cur->step % COMM_N] = "";
1638                     $user_cur->step_inc();
1639                     $user_cur->comm[$user_cur->step % COMM_N] = $this->show_room(($user_cur->step + 1), $user_cur);
1640                     $user_cur->step_inc();
1641                     log_main("POST show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1642
1643                     continue;
1644                 }
1645                 log_main("JOIN_WAKEUP wup_idx ".$wup_idx."  wup_n ".$user_wup_n);
1646
1647                 log_main("JOIN_WAKEUP more");
1648
1649                 $ret .= $table->act_content($user_cur);
1650
1651                 log_main("JOIN_WAKEUP end more");
1652             }
1653             log_wr("ROOM_JOIN_WAKEUP: ".$ret);
1654             $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1655             $user_cur->step_inc();
1656         }
1657     }
1658
1659   /*
1660     function info_show($user, $target, $dt)
1661
1662     if success return assoc. array with "ret" => 0 and other fields
1663     else return an assoc. array with "ret: != 0 and "mesg" with an error description
1664   */
1665   function info_show($user, $target, $dt)
1666   {
1667       GLOBAL $G_lang, $mlang_brisk, $G_base;
1668
1669       $mesg = "";
1670       $user_code = -1;
1671       $ret = 0;
1672
1673       do {
1674           if ($target == "") {
1675               $ret = 1;
1676               break;
1677           }
1678           if (($bdb = BriskDB::create()) == FALSE) {
1679               $ret = 2;
1680               break;
1681           }
1682           if ($target == $user->name) {
1683               $ret = 3;
1684               $mesg = sprintf($mlang_brisk['inf_self'][$G_lang]);
1685               break;
1686           }
1687           if (($user_item = $bdb->getitem_bylogin($target, $user_code)) == FALSE) {
1688               $ret = 4;
1689               break;
1690           }
1691           if (($guar_item = $bdb->getitem_bycode($user_item->guar_code_get())) != FALSE) {
1692               $guar_login = $guar_item->login_get();
1693           }
1694           else {
1695               $guar_login = "";
1696           }
1697           $user_tos_vers = $user_item->tos_vers_get();
1698
1699           $partyskill = $bdb->usersnet_partyskill($user->code, $user_item->code);
1700
1701           $widefriend = $bdb->usersnet_widefriend($user->code, $user_item->code);
1702           $widefriend['skill'] = $bdb->usersnet_wideskill($user->code, $user_item->code);
1703           $narrowfriend = $bdb->usersnet_narrowfriend($user->code, $user_item->code);
1704           $narrowfriend['skill'] = $bdb->usersnet_narrowskill($user->code, $user_item->code);
1705
1706           if (($usersnet_item = $bdb->usersnet_bycode($user->code, $user_item->code,
1707                                                       $widefriend, $narrowfriend)) == FALSE) {
1708               $usersnet_item = $bdb->usersnet_default($user->code, $user_item->code,
1709                                                       $widefriend, $narrowfriend);
1710           }
1711
1712           if (versions_cmp($user_tos_vers, "1.2") < 0) {
1713               $mesg = sprintf($mlang_brisk['tos_old'][$G_lang], xcape($target));
1714           }
1715           else if ($guar_login == "") {
1716               $mesg = sprintf($mlang_brisk['inf_nfd'][$G_lang], xcape($target));
1717           }
1718       } while (0);
1719
1720       if ($ret > 0 && $mesg == "") {
1721           $mesg = sprintf($mlang_brisk['inf_err'][$G_lang], $ret);
1722       }
1723
1724       if ($ret != 0) {
1725           $jret = json_encode(array("ret" => $ret, "mesg" => $mesg));
1726       }
1727       else {
1728           $jret = json_encode(array("ret" => 0,
1729                                     "mesg" => "",
1730                                     "login" => $target,
1731                                     // FIXME: state internationalization
1732                                     "state" =>
1733                                     ($user_item->type & USER_FLAG_TY_APPR ? "Apprendista" :
1734                                      ($user_item->type & USER_FLAG_TY_CERT ? "Certificato" :
1735                                       ($user_item->type & (USER_FLAG_TY_NORM | USER_FLAG_TY_SUPER) ?
1736                                        "Normale" : "Stato sconosciuto"))),
1737                                     "guar" => ($user_item->type & USER_FLAG_TY_APPR ?
1738                                                "" : $guar_login),
1739                                     "party" => $partyskill,
1740                                     "match" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->match_cnt) ,
1741                                     "game" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->game_cnt),
1742                                     "friend" => usersnet_friend_getlabel($usersnet_item->friend),
1743                                     "skill" => $usersnet_item->skill,
1744                                     "trust"  => $usersnet_item->trust,
1745                                     "widefriend" => $usersnet_item->widefriend,
1746                                     "narrowfriend" => $usersnet_item->narrowfriend
1747                                     ));
1748       }
1749
1750       return $jret;
1751   }
1752
1753   function info_save($user, $json_s)
1754   {
1755       GLOBAL $G_lang, $mlang_brisk, $G_base;
1756
1757       $mesg = "";
1758       $user_code = -1;
1759       $ret = 0;
1760       $subret = 0;
1761
1762       do {
1763           if (($json = json_decode($json_s)) == FALSE) {
1764               $ret = 1;
1765               break;
1766           }
1767
1768           if (($bdb = BriskDB::create()) == FALSE) {
1769               $ret = 2;
1770               break;
1771           }
1772
1773           if (($subret = $bdb->usersnet_save($user->code, $json)) != 0) {
1774               $ret = 4000 + $subret;
1775               break;
1776           }
1777       } while(0);
1778
1779       return ($ret);
1780   }
1781
1782   function room_outstandup($user)
1783   {
1784       $this->room_sitdown($user, -1);
1785   }
1786
1787   function table_update($user)
1788   {
1789       log_main("table_update: pre - USER: ".$user->name);
1790
1791       $table_idx = $user->table;
1792
1793       if ($table_idx > -1)
1794           $table = $this->table[$table_idx];
1795
1796       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1797           $ret = "";
1798           $user_cur = $this->user[$i];
1799           if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1800               continue;
1801
1802           $ret = "gst.st = ".($user_cur->step+1)."; ";
1803           if ($table_idx > -1)
1804               $ret .= $this->table_content($user_cur, $table_idx);
1805
1806           if ($user->idx_get() == $i) {
1807               $ret .= $user->myname_innerHTML();
1808           }
1809           $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1810           $user_cur->step_inc();
1811       }
1812
1813       log_main("table_update: post");
1814   }
1815
1816   function room_sitdown($user, $table_idx)
1817   {
1818       log_main("room_sitdown ".($user == FALSE ? "USER: FALSE" : "USER: ".$user->name));
1819
1820       $train_app = "";
1821
1822       if ($table_idx > -1 && $table_idx < TABLES_N) {
1823           $table = $this->table[$table_idx];
1824
1825           // wagon shutdown
1826           if ($table->wag_own != -1 && $table->player_n == PLAYERS_N) {
1827               for ($i = 0 ; $i < TABLES_N ; $i++) {
1828                   if ($table->wag_own == $table->player[$i]) {
1829                       $train_app = sprintf("tra.rem(%d); ", $table_idx);
1830                       $table->wag_reset(time());
1831                       break;
1832                   }
1833               }
1834           }
1835       }
1836
1837       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1838           $ret = "";
1839           $user_cur = $this->user[$i];
1840           if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1841               continue;
1842
1843           $ret = "gst.st = ".($user_cur->step+1)."; ".$train_app;
1844           if ($table_idx > -1)
1845               $ret .= $this->table_content($user_cur, $table_idx);
1846           $ret .= $this->standup_content($user_cur);
1847
1848           if ($user->idx_get() == $i) {
1849               $ret .=  'subst = "sitdown"; tra.hide(); ';
1850               // clean the action buttons in other tables
1851               for ($e = 0 ; $e < TABLES_N ; $e++) {
1852                   $ret .= $this->table[$e]->act_content($user_cur);
1853               }
1854           }
1855           else if ($table_idx > -1) {
1856               if ($table->player_n == PLAYERS_N) {
1857
1858                   $ret .= $table->act_content($user_cur);
1859               }
1860           }
1861           $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1862           $user_cur->step_inc();
1863       }
1864   }
1865
1866   function kickuser($user, $out_reas)
1867   {
1868       $curtime = time();
1869
1870       fprintf(STDERR, "MOP: GHOST_SESS: %d\n", $out_reas);
1871
1872       $this->ghost_sess->push($curtime, $user->sess, $out_reas);
1873
1874       fprintf(STDERR, "MOP: status out: %s %s %d\n", $user->stat, $user->subst, $user->idx);
1875       if ($user->stat == 'table' && $user->subst != 'sitdown') {
1876           $bin5 = &$this->match[$user->table];
1877           $user_bin5 = &$bin5->user[$user->table_pos];
1878           fprintf(STDERR, "MOP: status in: %s %s %d\n", $user_bin5->stat, $user_bin5->subst, $user_bin5->idx);
1879           $bin5->table_wakeup($user_bin5);
1880           $user->the_end = TRUE;
1881           $this->room_wakeup($user);
1882           return;
1883       }
1884
1885       if ($user->stat == 'table' || $user->stat == 'room') {
1886           $user->the_end = TRUE;
1887           if ($user->subst == 'sitdown' || $user->stat == 'table') {
1888               $this->room_wakeup($user);
1889           }
1890           else if ($user->subst == 'standup') {
1891               fprintf(STDERR, "MOP: KICK here [%s]\n", btrace_line(debug_backtrace()));
1892               $this->room_outstandup($user);
1893           }
1894           else {
1895               log_rd2("LOGOUT FROM WHAT ???");
1896           }
1897       }
1898   }
1899
1900   function kickuser_by_name($name, $out_reas)
1901   {
1902       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1903           $user_out = $this->user[$i];
1904           if (strcmp($user_out->name, $name) == 0) {
1905               return ($this->kickuser($user_out, $out_reas));
1906           }
1907       }
1908       return FALSE;
1909   }
1910
1911   function kickuser_by_sess($sess, $out_reas)
1912   {
1913       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1914           $user_out = $this->user[$i];
1915           if (strcmp($user_out->sess, $sess) == 0) {
1916               return ($this->kickuser($user_out, $out_reas));
1917           }
1918       }
1919       return FALSE;
1920   }
1921
1922   function kickuser_by_idx($idx, $out_reas)
1923   {
1924       $user_out = $this->user[$idx];
1925       return ($this->kickuser($user_out, $out_reas));
1926   }
1927
1928   function chatt_send($user, $mesg, $mlang_indwr = NULL)
1929   {
1930       GLOBAL $G_base, $G_alarm_passwd, $mlang_brisk, $G_lang;
1931       $only_you = FALSE;
1932
1933       // fprintf(STDERR, "WE ARE HERE: [%s]\n", $mesg);
1934
1935       // common settings
1936       $msg = mb_substr($mesg, 6, 128, "UTF-8");
1937       $curtime = time();
1938       $dt = date("H:i ", $curtime);
1939       $target = "";
1940
1941       //
1942       //  Compute actions
1943       //
1944
1945       $to_user     = FALSE;
1946       $to_all      = FALSE;
1947       $to_room     = FALSE;
1948       $to_tabl     = FALSE;
1949       $is_normchat = FALSE;
1950       /* for old isolation management $is_ticker   = FALSE; */
1951       $update_room = FALSE;
1952
1953       if (strcmp($msg,  "/tav") == 0 ||
1954       strncmp($msg, "/tav ", 5) == 0) {
1955           do {
1956               if ($user->stat != 'room' || $user->subst != 'sitdown') {
1957                   /* MLANG: "<br>Per attivare il messaggio di segnalazione del tavolo occorre essere seduti.<br><br>", "<br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br>", "<br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>" */
1958                   $msg = $mlang_brisk['tickmust'][$G_lang];
1959                   $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1960
1961                   break;
1962               }
1963
1964               $table = $this->table[$user->table];
1965
1966               if ($table->wag_own != -1) {
1967                   // MLANG <br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br>
1968                   $msg = $mlang_brisk['tickjust'][$G_lang];
1969                   $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1970
1971                   break;
1972               }
1973
1974               $dtime = $curtime - $table->wag_tout;
1975               if ($dtime  < EXPIRE_TIME_WAG) {
1976                   // MLANG - <br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>
1977                   $msg = sprintf($mlang_brisk['tickwait'][$G_lang],
1978                   EXPIRE_TIME_WAG - $dtime, (EXPIRE_TIME_WAG - $dtime == 1 ? ($G_lang == 'en' ? "" : "o") : ($G_lang == 'en' ? "s" : "i")));
1979                   $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang] , 400, 100);
1980
1981                   break;
1982               }
1983
1984               $msg = substr($msg, 5);
1985
1986               $table->wag_set($user->idx_get(), $msg);
1987               $to_user = sprintf('tra.add(%d, "%s");', $user->table, xcape(sprintf("%s: %s", $user->name, $msg)));
1988               $to_room = $to_user;
1989               /* for old isolation management $is_ticker = TRUE; */
1990           } while (0);
1991       } // /tav chat command
1992       // just for development use currently
1993       else if (FALSE && strncmp($msg, "/out ", 5) == 0) {
1994           fprintf(STDERR, "MOP OUT\n");
1995           $target = substr($msg, 5);
1996           $this->kickuser_by_name($target, GHOST_SESS_REAS_ANON);
1997       }
1998       else if (strncmp($msg, "/alarm ", 7) == 0) {
1999           if (strncmp($msg, "/alarm to ", 10) == 0) {
2000               $sp_pos = strpos($msg, " ", 10);
2001               $target = substr($msg, 10, $sp_pos - 10);
2002               $alarm_check = "/alarm to ".$target." ".$G_alarm_passwd." ";
2003           }
2004           else {
2005               $target = "";
2006               $alarm_check = "/alarm ".$G_alarm_passwd." ";
2007           }
2008           do {
2009               if (strncmp($msg, $alarm_check, strlen($alarm_check)) != 0) {
2010                   /* MLANG: "<br>La password digitata non &egrave; corretta.<br><br>" */
2011                   $msg = $mlang_brisk['alarpass'][$G_lang];
2012                   $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 100);
2013
2014                   break;
2015               }
2016
2017               /* MLANG: "Alarm <b>%s</b> inviato a <b>%s</b>." */
2018               $prestr = sprintf($mlang_brisk['alarret'][$G_lang], xcape(substr($msg, strlen($alarm_check))),
2019               ($target == "" ? $mlang_brisk['tit_all'][$G_lang] : xcape($target)) );
2020               $to_user = nickserv_msg($dt, $prestr);
2021
2022               $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
2023               $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
2024               /* MLANG: "chiudi" */
2025               $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
2026           } while (0);
2027       } // /alarm chat command
2028       else if (FALSE && strncmp($msg, "/listen ", 8) == 0) {
2029           $arg = substr($msg, 8);
2030
2031           if (strcasecmp($arg, "isolation") == 0) {
2032               $flags_old = 0;
2033               if ($user->stat == 'room' && $user->subst == 'sitdown' &&
2034               $user->table >= TABLES_AUTH_N) {
2035                   $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
2036
2037               }
2038               else {
2039                   $user->flags &= ~USER_FLAG_MAP_AUTH;
2040                   $user->flags |= USER_FLAG_ISOLAUTH;
2041                   $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
2042               }
2043           }
2044           else {
2045               $flags_old = $user->flags;
2046               $user->flags &= ~USER_FLAG_MAP_AUTH;
2047               $to_user = 'list_set(\'all\', true, \'\'); ';
2048
2049           }
2050           // if from isolation redraw standup area
2051           if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
2052               $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
2053
2054           }
2055       }
2056       else if (strcmp($msg, "/authreq") == 0) {
2057           if ($user->is_cert()) {
2058               $to_user = sprintf('authbox(300,200);');
2059           }
2060           else {
2061               /* MLANG: "<b>Per autenticare qualcuno devi a tua volta essere autenticato.</b>", "Il nickname deve contenere almeno una lettera dell\'alfabeto o una cifra.", "Nickname <b>%s</b> gi&agrave; in uso." */
2062               $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
2063           }
2064       }
2065       else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
2066           if ($user->is_auth()) {
2067               $to_user = sprintf('mesgtoadmbox(500,300);');
2068           }
2069           else {
2070               /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
2071               $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
2072           }
2073       }
2074       else if (FALSE && strncmp($msg, "/nick ", 6) == 0) {
2075           log_main("chatt_send BEGIN");
2076
2077           do {
2078               if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
2079                   $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
2080                   break;
2081               }
2082
2083               $msg = "COMMAND ".$msg;
2084               for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2085                   $user_cur = $this->user[$i];
2086
2087                   if ($user_cur->is_active() == FALSE)
2088                       continue;
2089                   if (strcasecmp($user_cur->name,$name_new) == 0)
2090                       break;
2091               }
2092               if ($i <  MAX_PLAYERS) {
2093                   $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
2094                   $to_user = nickserv_msg($dt, $prestr);
2095                   break;
2096               }
2097
2098               /* MLANG: "<b>Non puoi cambiare nick a un tavolo per soli autenticati.</b>", "Il nickname <b>\'%s\'</b> &egrave; gi&agrave; registrato, <b>se il suo proprietario si autentificher&agrave; verrai rinominato d\'ufficio come ghost<i>N</i>.</b>" */
2099               if ($user->is_auth()) {
2100                   if (strcasecmp($user->name,$name_new) != 0) {
2101                       if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
2102                       ($user->subst == 'standup' ||
2103                       ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
2104                       )
2105                       ) {
2106                           $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
2107                           for ($i = 0 ; $i < TABLES_N ; $i++) {
2108                               $to_user .= $this->table[$i]->act_content($user);
2109                           }
2110                       }
2111                       else {
2112                           $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
2113                           break;
2114                       }
2115                   }
2116               }
2117               $user->name = $name_new; // OK - nick changed
2118               /* se nome gia' in uso, segnala cosa potrebbe capitare */
2119               if ( ! $user->is_auth() ) {
2120                   if (($bdb = BriskDB::create()) != FALSE) {
2121                       $bdb->users_load();
2122                       /* MLANG: "Il nickname <b>\'%s\'</b> &egrave; gi&agrave; registrato, <b>se il suo proprietario si autentificher&agrave; verrai rinominato d\'ufficio come ghost<i>N</i>.</b>" */
2123                       if ($bdb->login_exists(strtolower($name_new))) {
2124                           $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
2125                           $to_user .= nickserv_msg($dt, $prestr);
2126                       }
2127                   }
2128               }
2129
2130               log_main("chatt_send start set");
2131
2132               $update_room = TRUE;
2133           } while (0);
2134       } // nick chat command
2135       else if (strncmp($msg, "/info ", 6) == 0) {
2136           do {
2137               if (! $user->is_auth()) {
2138                   if ($mlang_indwr) {
2139                       $to_user = nickserv_msg($dt, $mlang_indwr['info_auth'][$G_lang]);
2140                   }
2141                   else {
2142                       $to_user = nickserv_msg($dt, "error");
2143                   }
2144                   break;
2145               }
2146               $info_user = substr($msg, 6);
2147
2148               echo $this->info_show($user, urldecode($info_user), $dt);
2149           } while(0);
2150       }
2151       else if (strncmp($msg, "/st ", 4) == 0) {
2152           log_main("chatt_send BEGIN");
2153
2154           do {
2155               $st_str = substr($msg, 4);
2156
2157               if (strcasecmp($st_str, "normale") == 0) {
2158                   $st = USER_FLAG_S_NORM;
2159               }
2160               else if (strcasecmp($st_str, "pausa") == 0) {
2161                   $st = USER_FLAG_S_PAU;
2162               }
2163               else if (strcasecmp($st_str, "fuori") == 0) {
2164                   $st = USER_FLAG_S_OUT;
2165               }
2166               else if (strcasecmp($st_str, "cane") == 0) {
2167                   $st = USER_FLAG_S_DOG;
2168               }
2169               else if (strcasecmp($st_str, "cibo") == 0) {
2170                   $st = USER_FLAG_S_EAT;
2171               }
2172               else if (strcasecmp($st_str, "lavoro") == 0) {
2173                   $st = USER_FLAG_S_WRK;
2174               }
2175               else if (strcasecmp($st_str, "sigaretta") == 0) {
2176                   $st = USER_FLAG_S_SMK;
2177               }
2178               else if (strcasecmp($st_str, "presente") == 0) {
2179                   $st = USER_FLAG_S_EYE;
2180               }
2181               else if (strcasecmp($st_str, "coniglio") == 0) {
2182                   $st = USER_FLAG_S_RABB;
2183               }
2184               else if (strcasecmp($st_str, "calcio") == 0) {
2185                   $st = USER_FLAG_S_SOCC;
2186               }
2187               else if (strcasecmp($st_str, "pupo") == 0) {
2188                   $st = USER_FLAG_S_BABY;
2189               }
2190               else if (strcasecmp($st_str, "pulizie") == 0) {
2191                   $st = USER_FLAG_S_MOP;
2192               }
2193               else if (strcasecmp($st_str, "babbo") == 0) {
2194                   $st = USER_FLAG_S_BABBO;
2195               }
2196               else if (strcasecmp($st_str, "renna") == 0) {
2197                   $st = USER_FLAG_S_RENNA;
2198               }
2199               else if (strcasecmp($st_str, "pupazzo") == 0) {
2200                   $st = USER_FLAG_S_PUPAZ;
2201               }
2202               else if (strcasecmp($st_str, "vischio") == 0) {
2203                   $st = USER_FLAG_S_VISCH;
2204               }
2205               else {
2206                   /* MLANG: "Questo stato non esiste." */
2207                   $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
2208                   break;
2209               }
2210
2211               log_main("chatt_send start set");
2212               if (($user->flags & USER_FLAG_S_ALL) != $st) {
2213                   $update_room = TRUE;
2214                   $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
2215               }
2216           } while (0);
2217       } // nick chat command
2218
2219       else { // normal chat line
2220           $is_normchat = TRUE;
2221           if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
2222               $only_you = TRUE;
2223               $user->chat_dlt = $user->chat_dlt * 2;
2224               if ($user->chat_dlt > 120)
2225                   $user->chat_dlt = 120;
2226           }
2227           else if ($user->chat_lst == $msg)
2228               $only_you = TRUE;
2229           else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2230               $user->chat_ban = $curtime;
2231               $user->chat_dlt = 5;
2232               $only_you = TRUE;
2233           }
2234           else {
2235               $user->chat_ban = 0;
2236               $user->chat_dlt = 0;
2237           }
2238
2239           if ($only_you) {
2240               $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2241           }
2242           else {
2243               // TEMPORARY DISABLED UNTIL test user option will be available
2244               // if ( TRUE && (!$user->is_auth() || $user->is_appr()) ) {
2245               if (!$user->is_auth()) {
2246                   $to_user = nickserv_msg($dt, xcape("Visto l'elevato numero di molestatori che ultimamente hanno preso dimora su Brisk abbiamo deciso"));
2247                   $to_user .= nickserv_msg($dt, xcape("di disattivare temporaneamente la chat in room per i non registrati, non ce ne vogliate e buone feste."));
2248                   if (FALSE) {
2249                       $aug_head = array("Tanti", "Tantissimi", "Un enormità", "Un milione", "Un' esagerazione");
2250                       $aug_body = array("a tutti gli utenti", "a tutti gli uomini", "a tutte le donne", "a tutti gli utenti");
2251                       $aug_tail = array("di Brisk", "del sito", "della ciurma", "della comitiva", "del gruppo");
2252
2253                       $auguri = sprintf("%s auguri %s %s.",
2254                       $aug_head[mt_rand(0, count($aug_head)-1)],
2255                       $aug_body[mt_rand(0, count($aug_body)-1)],
2256                       $aug_tail[mt_rand(0, count($aug_tail)-1)]);
2257
2258                       $to_room = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name),
2259                       xcape($auguri));
2260                   }
2261               }
2262               else {
2263                   $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2264                   // temporary silentiation for troll (will became array check)
2265                   // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2266                   $to_room = $to_user;
2267               }
2268           }
2269
2270           log_legal($curtime, $user->ip, $user,
2271           ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2272
2273           $user->chat_lst = "$msg";
2274           $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2275           $user->chat_cur++;
2276       }
2277
2278       if ($to_all) {
2279           $to_room = $to_all;
2280           $to_tabl = $to_all;
2281       }
2282
2283       //
2284       //  Output to clients
2285       //
2286
2287       if ($to_user != FALSE) {
2288           $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2289           $user->comm[$user->step % COMM_N] .= $to_user;
2290           $user->step_inc();
2291       }
2292
2293       if ($to_room != FALSE) {
2294           for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2295               $user_cur = $this->user[$i];
2296               if ($target != "" && $user_cur->name != $target)
2297                   continue;
2298               if ($user_cur->is_active() == FALSE // is not active user
2299               || $user_cur->stat == 'table'   // or stat is 'table'
2300               || $user->idx_get() == $i)      // or the $user idx is equal to current var
2301                   continue;
2302
2303               if ($is_normchat == TRUE) {
2304                   // use MAP_AUTH to check if auth or isolation
2305                   if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2306                       if ( ! $user->is_auth() ) {
2307                           continue;
2308                       }
2309                   }
2310               }
2311               /*
2312                 else if ($is_ticker) {
2313                 if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2314                 if ($user->table >= TABLES_AUTH_N)
2315                 continue;
2316                 }
2317                 }
2318               */
2319               $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2320               $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2321               $user_cur->step_inc();
2322           }
2323       }
2324
2325       if ($to_tabl) {
2326           // FIXME BRISK4: include for each kind of table
2327           require_once("${G_base}briskin5/Obj/briskin5.phh");
2328           // Before all align times with table timeout
2329           for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2330               if (isset($this->match[$table_idx])) {
2331                   $bin5 = $this->match[$table_idx];
2332
2333                   $bin5_table = $bin5->table[0];
2334                   for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2335                       // stat must be "table" by definition
2336                       $bin5_user = $bin5->user[$i];
2337
2338                       if ($target != "" && $bin5_user->name != $target)
2339                           continue;
2340                       log_main("writa: ".$user_mesg);
2341                       $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2342                       $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2343                       $bin5_user->step_inc();
2344                   }
2345               } // if (isset($this->match
2346           } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2347       } // if ($to_tabl == true ...
2348
2349       if ($update_room) {
2350           if ($user->stat == 'room' && $user->subst == 'standup') {
2351               $this->standup_update($user);
2352           }
2353           else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2354               log_main("chatt_send pre table update");
2355               $this->table_update($user);
2356               log_main("chatt_send post table update");
2357           }
2358       } // if ($update_room ...
2359
2360       return;
2361   } // function chatt_send( ...
2362
2363   function get_user($sess, &$idx)
2364   {
2365       GLOBAL $PHP_SELF;
2366
2367       if (validate_sess($sess)) {
2368           for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2369               if ($this->user[$i]->is_empty())
2370                   continue;
2371               if (strcmp($sess, $this->user[$i]->sess) == 0) {
2372                   // find it
2373                   $idx = $i;
2374                   $ret = $this->user[$i];
2375                   return ($ret);
2376               }
2377           }
2378           log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2379           // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2380           // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2381       }
2382       else {
2383           log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2384       }
2385
2386       return (FALSE);
2387   }
2388
2389   /*
2390    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2391    *
2392    * RETURN VALUE:
2393    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2394    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2395    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2396    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2397    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2398    *   if ($idx == -($idx + 1) && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2399    */
2400
2401   function add_user(&$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2402   {
2403       GLOBAL $G_base;
2404
2405       $idx = 0;
2406
2407       $authenticate = FALSE;
2408       $user_type    = 0;
2409       $login_exists = FALSE;
2410       $ghost = -1;
2411       $ghost_auth = FALSE;
2412       $idx = -1;
2413       $idfree = -1;
2414       $code = FALSE;
2415
2416       if (($name_new = validate_name($name)) == FALSE) {
2417           $idx = -2;
2418           return (FALSE);
2419       }
2420
2421       log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2422       if (validate_sess($sess) == FALSE)
2423           $sess = "";
2424
2425       /* if pass != FALSE verify the login with pass */
2426       log_auth("XXX", "auth1");
2427
2428       if (($bdb = BriskDB::create()) != FALSE) {
2429           $bdb->users_load();
2430           if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2431               log_auth("XXX", "auth2");
2432               $authenticate = $bdb->login_verify($name_new, $pass, $code);
2433               log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2434
2435               if ($authenticate != FALSE) {
2436                   $user_type = $authenticate->type_get();
2437               }
2438               else {
2439                   $idx = -3;
2440                   return (FALSE);
2441               }
2442           }
2443           else {
2444               $login_exists =  $bdb->login_exists(strtolower($name_new));
2445 /*
2446   TO ENABLE USER-LOGIN ONLY
2447   -            $login_exists =  $bdb->login_exists(strtolower($name_new));
2448   +            // $login_exists =  $bdb->login_exists(strtolower($name_new));
2449   +            // Force access with login and password
2450   +            $idx = -3;
2451   +            return (FALSE);
2452 */
2453           }
2454       }
2455       else {
2456           // if db is down, send a warning and verify only current users
2457           // no actions at this moment
2458       }
2459       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2460           /* free user ? */
2461           if ($this->user[$i]->is_empty()) {
2462               if ($idfree == -1) {
2463                   $idfree = $i;
2464               }
2465               continue;
2466           }
2467           if (strcmp($sess, $this->user[$i]->sess) == 0) {
2468               if ($idx == -1) {
2469                   $idx = $i;
2470               }
2471           }
2472           if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2473               if ($authenticate != FALSE) {
2474                   $ghost = $i;
2475                   $ghost_auth = $this->user[$i]->is_auth();
2476               }
2477               else {
2478                   $idx = $i;
2479                   break;
2480               }
2481           }
2482       }
2483       if ($idx == -1)
2484           $idx = $idfree;
2485
2486       log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2487
2488       /* there is another user logged with your account and you and him have authenticated => new user
2489          get the session of the old user */
2490       if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2491           /* swap session */
2492
2493           $ghost_user = $this->user[$ghost];
2494           $curtime = time();
2495           $this->ghost_sess->push($curtime, $ghost_user->sess, GHOST_SESS_REAS_ANOT);
2496           $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2497           $ghost_user->step_inc();
2498           if ($sess == "") {
2499               $sess = uniqid("");
2500               $ghost_user->sess = $sess;
2501           }
2502           else {
2503               $ghost_user->sess = $sess;
2504           }
2505
2506           // If user at the table we need to update the table data too
2507           $table_idx = $ghost_user->table;
2508           if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2509               require_once("${G_base}briskin5/Obj/briskin5.phh");
2510               if (isset($this->match[$table_idx])) {
2511                   $bin5 = $this->match[$table_idx];
2512
2513                   if ($bin5->the_end != TRUE) {
2514                       $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2515                       $bin5->user[$ghost_user->table_pos]->step_inc();
2516                       $bin5->user[$ghost_user->table_pos]->sess = $sess;
2517                   }
2518               }
2519           }
2520
2521           $idx = $ghost;
2522           if (defined('CURL_DE_SAC_VERS')) {
2523               brisk_cds_execute($this, $ghost, $idx, $sess, $ip, $authenticate, $header);
2524           }
2525           return ($this->user[$ghost]);
2526       }
2527       else if ($idx != -1 && $i == MAX_PLAYERS) {
2528           /* SUCCESS */
2529           $curtime = time();
2530           if ($sess == "") {
2531               $sess = uniqid("");
2532               $this->user[$idx]->sess = $sess;
2533           }
2534           else {
2535               $this->user[$idx]->sess = $sess;
2536           }
2537           $this->user[$idx]->name = $name_new; // OK - add new user
2538           $this->user[$idx]->stat_set("room");
2539           $this->user[$idx]->step_set(0);
2540           while (array_pop($this->user[$idx]->comm) != NULL);
2541           $this->user[$idx]->subst = "standup";
2542           $this->user[$idx]->lacc =   $curtime;
2543           $this->user[$idx]->laccwr = $curtime;
2544           $this->user[$idx]->bantime = 0;
2545           $this->user[$idx]->ip = $ip;
2546
2547           $this->user[$idx]->rec = $authenticate;
2548           $this->user[$idx]->flags = $user_type;
2549           $this->user[$idx]->flags |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2550           $this->user[$idx]->flags |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2551           log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags));
2552
2553           if ($authenticate != FALSE) {
2554               $this->user[$idx]->code = $authenticate->code_get();
2555               if (0 == 1) {
2556                   // all this part is included in the db server
2557                   $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2558
2559                   if (isset($cookie['CO_list'])) {
2560                       // fprintf(STDERR, "QQ: %s CO_list: [%s]\n", __FUNCTION__, $cookie['CO_list']);
2561                       if (strcmp($cookie['CO_list'], "auth") == 0) {
2562                           $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2563                           $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2564                       }
2565                       if (strcmp($cookie['CO_list'], "isolation") == 0) {
2566                           $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2567                           $this->user[$idx]->flags |= USER_FLAG_ISOLAUTH;
2568                       }
2569                       else {
2570                           $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2571                       }
2572                   }
2573               }
2574               // else {
2575               //    fprintf(STDERR, "QQ: CO_list not set flags: %x\n", __FUNCTION__, $this->user[$idx]->flags);
2576               // }
2577           }
2578           // fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2579           if ($ghost > -1) {
2580               log_main("ghost: rename!");
2581               $ghost_user = $this->user[$ghost];
2582
2583               if ($ghost_auth == FALSE) {
2584                   for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2585                       $ghostname = 'ghost'.$sfx;
2586                       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2587                           if (strcmp("", $this->user[$i]->sess) == 0)
2588                               continue;
2589
2590                           if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2591                               $ghostname = '';
2592                               break;
2593                           }
2594                       }
2595                       if ($ghostname != '')
2596                           break;
2597                   }
2598
2599                   $ghost_user->name = $ghostname;
2600
2601                   if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2602                       $this->standup_update($ghost_user);
2603                   }
2604                   else {
2605                       log_main("chatt_send pre table update");
2606                       $this->table_update($ghost_user);
2607                       log_main("chatt_send post table update");
2608                   }
2609               } // if ($ghost_auth == FALSE
2610               else {
2611                   // FIXME: cacciare il vecchio utente room && table (if needed)
2612                   $ghost_user->the_end = TRUE;
2613                   $ghost_user->lacc = 0;
2614                   $this->garbage_manager(TRUE);
2615               }
2616           } //  if ($ghost > -1) {
2617
2618           $real_idx = $idx;
2619           if ($login_exists)
2620               $idx = -($idx + 1);
2621           log_main(sprintf("TROVATO LIBERO A [%d] sess [%s] name [%s] count [%d] name [%s] code [%s]", $idx, $sess, $name_new, count($this->user),$this->user[$real_idx]->name, $this->user[$real_idx]->code));
2622
2623           $ret = $this->user[$real_idx];
2624           if (defined('CURL_DE_SAC_VERS')) {
2625               brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2626           }
2627           return ($ret);
2628       }
2629
2630       return (FALSE);
2631   }
2632
2633   function standup_update($user)
2634   {
2635       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2636           $user_cur = $this->user[$i];
2637           if ($user_cur->is_active() == FALSE)
2638               continue;
2639
2640           log_main("STANDUP START: ".$user_cur->stat);
2641
2642           if ($user_cur->stat == 'room') {
2643               $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2644               if ($user->idx_get() == $i) {
2645                   $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2646               }
2647               log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2648
2649               $user_cur->step_inc();
2650           }
2651       }
2652   }
2653
2654   function dump_data()
2655   {
2656       $brisk_ser = serialize($this);
2657       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2658       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2659           return (TRUE);
2660       }
2661
2662       return (FALSE);
2663   }
2664
2665   function standup_content($user)
2666   {
2667       $ret = "";
2668
2669       if ($user->stat != 'room')
2670           return;
2671
2672       $content = ' j_stand_cont( [ ';
2673
2674       $user_cur_id = $user->idx_get();
2675       for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2676           if ($this->user[$i]->is_active() == FALSE // is not active user
2677           || $this->user[$i]->stat != "room"    // or the stat isn't 'room'
2678           || $this->user[$i]->name == "")       // or the name is empty, happens when user is reset (TODO: check it)
2679               continue;
2680
2681           $flags = $this->user[$i]->flags;
2682
2683           // sql record exists AND last donate > 2013-01-01
2684           if ($this->user[$i]->is_supp_custom()) {
2685               $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2686           }
2687           else {
2688               $supp_comp_s = '';
2689           }
2690
2691           if ($this->user[$i]->subst == "standup") {
2692               $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2693               xcape($this->user[$i]->name), $supp_comp_s);
2694               $ct++;
2695           }
2696       }
2697       $content .= ' ]);';
2698
2699       return ($content);
2700   }
2701
2702   function table_content($user, $table_idx)
2703   {
2704       $content = "";
2705       $ret = "";
2706       // TODO
2707       //
2708       //   Si possono usare i dati nella classe table
2709       //
2710
2711       $sess = $user->sess;
2712       $table = $this->table[$table_idx];
2713
2714       if ($user->stat != 'room')
2715           return;
2716
2717       $user_cur_id = $user->idx_get();
2718       $content = "[ ";
2719       for ($i = 0 ; $i < $table->player_n ; $i++) {
2720           $user_cur = $this->user[$table->player[$i]];
2721
2722           $flags = $user_cur->flags;
2723
2724           log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2725           if ($user_cur->is_supp_custom())
2726               $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2727           else
2728               $supp_comp_s = '';
2729
2730           $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2731           xcape($user_cur->name), $supp_comp_s);
2732       }
2733
2734       $content .= ' ]';
2735
2736       $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2737
2738       return ($ret);
2739   }
2740
2741   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2742   {
2743       GLOBAL $G_ban_list, $G_black_list, $G_cloud_smasher;
2744
2745       // printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2746
2747       // fprintf(STDERR, "\n\n\n PRE_BLACK [%s]\n\n\n", $addr);
2748       if ($this->black_check($addr)) {
2749           // TODO: waiting async 5 sec before close
2750           // fprintf(STDERR, "\n\n\n BLACK CHECK\n\n\n");
2751           return (FALSE);
2752       }
2753       if ($path != "" && $path != "index.php") {
2754           if ($this->cloud_check($addr)) {
2755               // TODO: waiting async 5 sec before close
2756               return (FALSE);
2757           }
2758       }
2759
2760       $enc = get_encoding($header);
2761       if (isset($header['User-Agent'])) {
2762           if (strstr($header['User-Agent'], "MSIE")) {
2763               $transp_type = "htmlfile";
2764           }
2765           else {
2766               $transp_type = "xhr";
2767           }
2768       }
2769       else {
2770           $transp_type = "iframe";
2771       }
2772       force_no_cache($header_out);
2773
2774       switch ($path) {
2775       case "":
2776       case "index.php":
2777           ob_start();
2778           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2779           $content = ob_get_contents();
2780           ob_end_clean();
2781
2782           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2783           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2784           return TRUE;
2785
2786           break;
2787       case "index_wr.php":
2788           //
2789           // Enhance required: in the POST case, after the header you must get content
2790           //                   from the socket, waiting if necessary
2791           //
2792
2793           ob_start();
2794           index_wr_main($this, $addr, $get, $post, $cookie);
2795           $content = ob_get_contents();
2796           ob_end_clean();
2797
2798           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2799           return TRUE;
2800
2801           break;
2802       case "index_rd.php":
2803       case "index_rd_wss.php":
2804           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2805               $transp = "iframe";
2806           if ($transp == 'websocket' || $transp == 'websocketsec')
2807               $enc = 'plain';
2808
2809           do {
2810               if (!isset($cookie['sess'])
2811                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2812
2813                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2814
2815                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2816                   return TRUE;
2817
2818                   break;
2819               }
2820               $this->sess_cur_set($user->sess);
2821               // close a previous opened index_read_ifra socket, if exists
2822               if (($prev = $user->rd_socket_get()) != NULL) {
2823                   $s_a_p->socks_unset($user->rd_socket_get());
2824                   fclose($user->rd_socket_get());
2825                   // printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2826                   $user->rd_socket_set(NULL);
2827               }
2828
2829               $content = "";
2830               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2831               $response = headers_render($header_out, -1).$user->chunked_content($content);
2832               $response_l = mb_strlen($response, "ASCII");
2833
2834               $wret = @fwrite($new_socket, $response, $response_l);
2835               if ($wret < $response_l) {
2836                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2837                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2838               }
2839               else {
2840                   $user->rd_cache_set("");
2841               }
2842               fflush($new_socket);
2843
2844
2845               $s_a_p->socks_set($new_socket, $user, NULL);
2846               $user->rd_socket_set($new_socket);
2847               // printf(" - qui ci siamo - ");
2848               return TRUE;
2849           } while (FALSE);
2850
2851           return FALSE;
2852           break;
2853       case 'test.php':
2854           if (!(BRISK_DEBUG & DBG_ENGI))
2855               return (FALSE);
2856           fprintf(STDERR, "TEST.PHP running\n");
2857           if (isset($post['data'])) {
2858               $content = $post['data'];
2859           }
2860           else {
2861               $content = "NO DATA AVAILABLE";
2862           }
2863           $header_out['Content-Type'] = 'text/plain';
2864           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2865           return TRUE;
2866           break;
2867       default:
2868           /* FAR TODO: move all into an array of registered sub-apps */
2869           $subs = "briskin5/";
2870           $subs_l = strlen($subs);
2871           if (!strncmp($path, $subs, $subs_l)) {
2872               $ret = Bin5::request_mgr($s_a_p, $header, $header_out, $new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2873               return ($ret);
2874           }
2875           break;
2876       }
2877
2878       return (FALSE);
2879   }
2880
2881   function match_add($idx, $match)
2882   {
2883       $this->match[$idx] = $match;
2884   }
2885
2886   function match_del($idx)
2887   {
2888       unset($this->match[$idx]);
2889   }
2890
2891   function match_get($idx, $token)
2892   {
2893       if (isset($this->match[$idx])) {
2894           if (   $token == NULL
2895               || $token == $this->match[$idx]->table_token) {
2896               return ($this->match[$idx]);
2897           }
2898       }
2899       return NULL;
2900   }
2901   function sess_cur_set($sess)
2902   {
2903       static::$sess_cur = $sess;
2904   }
2905
2906   static function sess_cur_get()
2907   {
2908       return(static::$sess_cur);
2909   }
2910 } // end class Brisk
2911
2912 function make_seed()
2913 {
2914     list($usec, $sec) = explode(' ', microtime());
2915     return (float) $sec + ((float) $usec * 100000);
2916 }
2917
2918 function btrace_line($ar)
2919 {
2920     GLOBAL $G_btrace_pref_sub;
2921
2922     $ret = "";
2923     for ($i = 0 ; $i < count($ar) ; $i++) {
2924         $with_class = isset($ar[$i]['class']);
2925         $with_file  = isset($ar[$i]['file']);
2926         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2927                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2928                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2929                         ($with_file ? $ar[$i]['line'] : ""));
2930     }
2931
2932     return ($ret);
2933 }
2934
2935 function trace_ftok($id, $add)
2936 {
2937     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2938     $tok=@ftok($id, $add);
2939
2940     log_shme($tok.": ".$id." + ".$add);
2941
2942     return ($tok);
2943 }
2944
2945 function log_mop($step, $log)
2946 {
2947     GLOBAL $PHP_SELF;
2948
2949     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2950         return;
2951
2952     $sess = Brisk::sess_cur_get();
2953     if (isset($sess) == FALSE)
2954         $ssess = "XXXX";
2955     else
2956         $ssess = $sess;
2957
2958     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2959         return;
2960
2961     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2962         $btrace = btrace_line(debug_backtrace());
2963     else
2964         $btrace = "";
2965     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2966         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2967         fclose($fp);
2968     }
2969 }
2970
2971 function log_step($log)
2972 {
2973     GLOBAL $PHP_SELF;
2974
2975     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2976         return;
2977
2978     $sess = Brisk::sess_cur_get();
2979     if (isset($sess) == FALSE)
2980         $ssess = "XXXX";
2981     else
2982         $ssess = $sess;
2983
2984     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2985         return;
2986
2987     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2988         $btrace = btrace_line(debug_backtrace());
2989     else
2990         $btrace = "";
2991     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
2992         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2993         fclose($fp);
2994     }
2995 }
2996
2997
2998
2999 function log_cds($log)
3000 {
3001     GLOBAL $PHP_SELF;
3002
3003     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
3004         return;
3005
3006     $sess = Brisk::sess_cur_get();
3007     if (isset($sess) == FALSE)
3008         $ssess = "XXXX";
3009     else
3010         $ssess = $sess;
3011
3012     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
3013         return;
3014
3015     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3016         $btrace = btrace_line(debug_backtrace());
3017     else
3018         $btrace = "";
3019     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
3020         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3021         fclose($fp);
3022     }
3023 }
3024
3025
3026 function log_only2($log)
3027 {
3028     GLOBAL $PHP_SELF;
3029
3030     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
3031         return;
3032
3033     $sess = Brisk::sess_cur_get();
3034     if (isset($sess) == FALSE)
3035         $ssess = "XXXX";
3036     else
3037         $ssess = $sess;
3038
3039     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
3040         return;
3041
3042     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3043         $btrace = btrace_line(debug_backtrace());
3044     else
3045         $btrace = "";
3046     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3047         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3048         fclose($fp);
3049     }
3050 }
3051
3052 function log_crit($log)
3053 {
3054     GLOBAL $PHP_SELF;
3055
3056     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
3057         return;
3058
3059     $sess = Brisk::sess_cur_get();
3060     if (isset($sess) == FALSE)
3061         $ssess = "XXXX";
3062     else
3063         $ssess = $sess;
3064
3065     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
3066         return;
3067
3068     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3069         $btrace = btrace_line(debug_backtrace());
3070     else
3071         $btrace = "";
3072     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3073         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3074         fclose($fp);
3075     }
3076 }
3077
3078 function log_only($log)
3079 {
3080     GLOBAL $PHP_SELF;
3081
3082     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
3083         return;
3084
3085     $sess = Brisk::sess_cur_get();
3086     if (isset($sess) == FALSE)
3087         $ssess = "XXXX";
3088     else
3089         $ssess = $sess;
3090
3091     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
3092         return;
3093
3094     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3095         $btrace = btrace_line(debug_backtrace());
3096     else
3097         $btrace = "";
3098     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3099         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3100         fclose($fp);
3101     }
3102 }
3103
3104 function log_main($log)
3105 {
3106     GLOBAL $PHP_SELF;
3107
3108     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
3109         return;
3110
3111     $sess = Brisk::sess_cur_get();
3112     if (isset($sess) == FALSE)
3113         $ssess = "XXXX";
3114     else
3115         $ssess = $sess;
3116
3117     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
3118         return;
3119
3120     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3121         $btrace = btrace_line(debug_backtrace());
3122     else
3123         $btrace = "";
3124     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3125         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3126         fclose($fp);
3127     }
3128 }
3129
3130 function log_rd($log)
3131 {
3132     GLOBAL $PHP_SELF;
3133
3134     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
3135         return;
3136
3137     $sess = Brisk::sess_cur_get();
3138     if (isset($sess) == FALSE)
3139         $ssess = "XXXX";
3140     else
3141         $ssess = $sess;
3142
3143     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
3144         return;
3145
3146     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3147         $btrace = btrace_line(debug_backtrace());
3148     else
3149         $btrace = "";
3150     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3151         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3152         fclose($fp);
3153     }
3154 }
3155
3156 function log_rd2($log)
3157 {
3158     GLOBAL $PHP_SELF;
3159
3160     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
3161         return;
3162
3163     $sess = Brisk::sess_cur_get();
3164     if (isset($sess) == FALSE)
3165         $ssess = "XXXX";
3166     else
3167         $ssess = $sess;
3168
3169     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
3170         return;
3171
3172     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3173         $btrace = btrace_line(debug_backtrace());
3174     else
3175         $btrace = "";
3176
3177     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3178         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3179         fclose($fp);
3180     }
3181 }
3182
3183 function log_send($log)
3184 {
3185     GLOBAL $PHP_SELF;
3186
3187     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3188         return;
3189
3190     $sess = Brisk::sess_cur_get();
3191     if (isset($sess) == FALSE)
3192         $ssess = "XXXX";
3193     else
3194         $ssess = $sess;
3195
3196     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3197         return;
3198
3199     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3200         $btrace = btrace_line(debug_backtrace());
3201     else
3202         $btrace = "";
3203     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3204         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3205         fclose($fp);
3206     }
3207 }
3208
3209 function log_lock($log)
3210 {
3211     GLOBAL $PHP_SELF;
3212
3213     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3214         return;
3215
3216     $sess = Brisk::sess_cur_get();
3217     if (isset($sess) == FALSE)
3218         $ssess = "XXXX";
3219     else
3220         $ssess = $sess;
3221
3222     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3223         return;
3224
3225     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3226         $btrace = btrace_line(debug_backtrace());
3227     else
3228         $btrace = "";
3229     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3230         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3231         fclose($fp);
3232     }
3233 }
3234
3235 function log_wr($log)
3236 {
3237     GLOBAL $PHP_SELF;
3238
3239     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3240         return;
3241
3242     $sess = Brisk::sess_cur_get();
3243     if (isset($sess) == FALSE)
3244         $ssess = "XXXX";
3245     else
3246         $ssess = $sess;
3247
3248     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3249         return;
3250
3251     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3252         $btrace = btrace_line(debug_backtrace());
3253     else
3254         $btrace = "";
3255     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3256         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3257         fclose($fp);
3258     }
3259 }
3260
3261 function log_load($log)
3262 {
3263     GLOBAL $PHP_SELF;
3264
3265     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3266         return;
3267
3268     $sess = Brisk::sess_cur_get();
3269     if (isset($sess) == FALSE)
3270         $ssess = "XXXX";
3271     else
3272         $ssess = $sess;
3273
3274     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3275         return;
3276
3277     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3278         $btrace = btrace_line(debug_backtrace());
3279     else
3280         $btrace = "";
3281     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3282         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3283         fclose($fp);
3284     }
3285 }
3286
3287 function log_auth($sess, $log)
3288 {
3289     GLOBAL $PHP_SELF;
3290
3291     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3292         return;
3293
3294     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3295         return;
3296
3297     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3298         $btrace = btrace_line(debug_backtrace());
3299     else
3300         $btrace = "";
3301     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3302         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3303         fclose($fp);
3304     }
3305 }
3306
3307 function log_shme($log)
3308 {
3309     GLOBAL $PHP_SELF;
3310
3311     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3312         return;
3313
3314     $sess = Brisk::sess_cur_get();
3315     if (isset($sess) == FALSE)
3316         $ssess = "XXXX";
3317     else
3318         $ssess = $sess;
3319
3320     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3321         return;
3322
3323     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3324         $btrace = btrace_line(debug_backtrace());
3325     else
3326         $btrace = "";
3327     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3328         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3329         fclose($fp);
3330     }
3331 }
3332
3333
3334
3335 // function log_legal($curtime, $sess, $name, $where, $mesg)
3336 function log_legal($curtime, $addr, $user, $where, $mesg)
3337 {
3338     if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3339         /* Unix time | session | nickname | IP | where was | mesg */
3340         fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, ($user ? $user->sess : "NOSESS"),
3341         ($user ? ($user->is_auth() ? 'A' : 'N') : "U"),
3342         ($user ? $user->name : "NO-USER"), $addr, $where , $mesg));
3343         fclose($fp);
3344     }
3345 }
3346
3347 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3348 {
3349     $ret = "";
3350
3351     if ($isstanding) {
3352         if ($sitted < PLAYERS_N) {
3353             if ($allowed)
3354                 $act = 'sit';
3355             else
3356                 $act = 'reserved';
3357         }
3358     }
3359     else {
3360         if ($table == $cur_table)
3361             $act = 'wake';
3362         else
3363             $act = 'none';
3364     }
3365
3366     if ($act != '')
3367         $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3368
3369     return ($ret);
3370 }
3371
3372 function show_notify($text, $tout, $butt, $w, $h)
3373 {
3374     log_main("SHOW_NOTIFY: ".$text);
3375     return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3376 }
3377
3378 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3379 {
3380     log_main("SHOW_NOTIFY OPAQUE: ".$text);
3381     return sprintf('var noti = new notify_ex(gst,"%s",%d,"%s",%d,%d, %s, %d);', $text, $tout, $butt, $w, $h, ($is_opaque ? "true" : "false"), $block_time);
3382 }
3383
3384 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3385 {
3386     log_main("SHOW_NOTIFY OPAQUE: ".$text);
3387
3388     $butts = "";
3389     for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3390         $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3391     }
3392
3393     return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3394     escpush($text), $tout, $butts, ($confirm_func == NULL ? "null" : $confirm_func), (($confirm_func == NULL|| $confirm_func_args == NULL) ? "[]" : $confirm_func_args), $w, $h, ($is_opaque ? "true" : "false"), $block_time);
3395 }
3396
3397
3398 function root_welcome($user)
3399 {
3400     GLOBAL $root_wellarr, $G_lang;
3401     $ret = "";
3402
3403     $curtime = time();
3404     $dt = date("H:i ", $curtime);
3405
3406     for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3407         $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3408
3409     return ($ret);
3410 }
3411
3412
3413
3414 function validate_sess($sess)
3415 {
3416     if (strlen($sess) == SESS_LEN)
3417         return (TRUE);
3418     else
3419         return (FALSE);
3420 }
3421
3422 function validate_name($name)
3423 {
3424     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3425
3426     for ($i = 0 ; $i < mb_strlen($name_new) ; $i++) {
3427         $c = $name_new[$i];
3428         if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3429             return ($name_new);
3430     }
3431
3432     return (FALSE);
3433 }
3434
3435 function playsound($name)
3436 {
3437     return (sprintf('g_jukebox.play("%s");', $name));
3438 }
3439
3440 function secstoword($secs)
3441 {
3442     GLOBAL $G_lang;
3443
3444     $ret = "";
3445
3446     $mins = floor($secs / 60);
3447     $secs = $secs % 60;
3448     if ($G_lang == 'en') {
3449         if ($mins > 0)
3450             $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3451
3452         if ($secs > 0)
3453             $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3454     }
3455     else {
3456         if ($mins > 0)
3457             $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3458
3459         if ($secs > 0)
3460             $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3461     }
3462     return ($ret);
3463 }
3464
3465 function sharedmem_sz($tok)
3466 {
3467     if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3468         log_main("shmop_open failed");
3469         return (-1);
3470     }
3471     $shm_sz = shmop_size($shm_id);
3472     shmop_close($shm_id);
3473
3474     // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3475     return ($shm_sz);
3476 }
3477
3478 class Warrant {
3479     static $delta_t;
3480
3481     static function lock_data($is_exclusive)
3482     {
3483         if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3484             self::$delta_t = microtime(TRUE);
3485             log_lock("LOCK   warrant      [".self::$delta_t."]");
3486
3487             return ($res);
3488         }
3489
3490         return (FALSE);
3491     }
3492
3493     static function unlock_data($res)
3494     {
3495         GLOBAL $sess;
3496
3497         log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3498
3499         file_unlock($res);
3500     }
3501 }
3502
3503 class Poll {
3504     static $delta_t;
3505
3506     static function lock_data($is_exclusive)
3507     {
3508         if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3509             self::$delta_t = microtime(TRUE);
3510             log_lock("LOCK   poll         [".self::$delta_t."]");
3511
3512             return ($res);
3513         }
3514
3515         return (FALSE);
3516     }
3517
3518     static function unlock_data($res)
3519     {
3520         GLOBAL $sess;
3521
3522         log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3523
3524         file_unlock($res);
3525     }
3526 }
3527
3528 function carousel_top()
3529 {
3530     $what = rand(1,2);
3531     if ($what == 1) {
3532         $rn = rand(1, 3);
3533         return (sprintf('<a target="_blank" href="http://shop.alternativeoutput.it"><img class="nobo" style="display: inline; border: 1px solid #808080;" alt="il negozio virtuale di Brisk" title="il negozio virtuale di Brisk" src="img/briskshop%d.gif"></a>', $rn));
3534         }
3535     else {
3536         return (sprintf('<a target="_blank" href="http://www.alternativeoutput.it/briskblog"><img class="nobo" alt="il nuovo blog di Brisk" title="il nuovo blog di Brisk" style="display: inline; border: 1px solid #808080;" src="img/briskblog_bannersmall.png"></a>'));
3537     }
3538 }
3539
3540 function login_consistency($name)
3541 {
3542     $old_c = '';
3543     if (($len = mb_strlen($name)) > 12) {
3544         return FALSE;
3545     }
3546
3547     for ($i = 0 ; $i < mb_strlen($name) ; $i++) {
3548         $c = mb_substr($name, $i, 1);
3549         if (mb_ereg_match ("[a-zA-Z0-9]", $c)) {
3550             if ($old_c != $c) {
3551                 $old_c = $c;
3552                 $old_ct = 1;
3553             }
3554             else {
3555                 $old_ct++;
3556                 if ($old_ct > 2) {
3557                     return (FALSE);
3558                 }
3559             }
3560         }
3561         else {
3562             return (FALSE);
3563         }
3564     }
3565     return (TRUE);
3566 }
3567 ?>