web/Obj/brisk.phh

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