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.15.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>: primo passo per rendere più robusto il sistema di notifica.',
 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>: new users subscription system, refactored sidebanner system.',
 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', 300);
 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
1871     else if (strncmp($msg, "/alarm ", 7) == 0) {
1872       if (strncmp($msg, "/alarm to ", 10) == 0) {
1873         $sp_pos = strpos($msg, " ", 10);
1874         $target = substr($msg, 10, $sp_pos - 10);
1875         $alarm_check = "/alarm to ".$target." ".$G_alarm_passwd." ";
1876       }
1877       else {
1878         $target = "";
1879         $alarm_check = "/alarm ".$G_alarm_passwd." ";
1880       }
1881       do {
1882         if (strncmp($msg, $alarm_check, strlen($alarm_check)) != 0) {
1883           /* MLANG: "<br>La password digitata non &egrave; corretta.<br><br>" */
1884           $msg = $mlang_brisk['alarpass'][$G_lang];
1885           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 100);
1886
1887           break;
1888         }
1889
1890         /* MLANG: "Alarm <b>%s</b> inviato a <b>%s</b>." */
1891         $prestr = sprintf($mlang_brisk['alarret'][$G_lang], xcape(substr($msg, strlen($alarm_check))),
1892                            ($target == "" ? $mlang_brisk['tit_all'][$G_lang] : xcape($target)) );
1893         $to_user = nickserv_msg($dt, $prestr);
1894
1895         $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
1896                        $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
1897         /* MLANG: "chiudi" */
1898         $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
1899       } while (0);
1900     } // /alarm chat command
1901     else if (strncmp($msg, "/listen ", 8) == 0) {
1902       $arg = substr($msg, 8);
1903
1904       if (strcasecmp($arg, "isolation") == 0) {
1905         $flags_old = 0;
1906         if ($user->stat == 'room' && $user->subst == 'sitdown' &&
1907             $user->table >= TABLES_AUTH_N) {
1908           $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
1909
1910         }
1911         else {
1912           $user->flags &= ~USER_FLAG_MAP_AUTH;
1913           $user->flags |= USER_FLAG_ISOLAUTH;
1914           $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
1915         }
1916       }
1917       else if (strcasecmp($arg, "auth") == 0) {
1918         $flags_old = $user->flags;
1919         $user->flags &= ~USER_FLAG_MAP_AUTH;
1920         $user->flags |= USER_FLAG_LISTAUTH;
1921         $to_user = 'list_set(\'auth\', true, \''.$mlang_brisk['tit_onauth'][$G_lang].'\'); ';
1922       }
1923       else {
1924         $flags_old = $user->flags;
1925         $user->flags &= ~USER_FLAG_MAP_AUTH;
1926         $to_user = 'list_set(\'all\', true, \'\'); ';
1927
1928       }
1929       // if from isolation redraw standup area
1930       if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
1931         $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
1932
1933       }
1934     }
1935     else if (strcmp($msg, "/authreq") == 0) {
1936         if ($user->is_cert()) {
1937             $to_user = sprintf('authbox(300,200);');
1938         }
1939         else {
1940             /* 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." */
1941             $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
1942         }
1943     }
1944     else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
1945         if ($user->is_auth()) {
1946         $to_user = sprintf('mesgtoadmbox(500,300);');
1947       }
1948       else {
1949         /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
1950         $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
1951       }
1952     }
1953     else if (strncmp($msg, "/nick ", 6) == 0) {
1954       log_main("chatt_send BEGIN");
1955
1956       do {
1957         if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
1958           $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
1959           break;
1960         }
1961
1962         $msg = "COMMAND ".$msg;
1963         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1964           $user_cur = $this->user[$i];
1965
1966           if ($user_cur->is_active() == FALSE)
1967             continue;
1968           if (strcasecmp($user_cur->name,$name_new) == 0)
1969             break;
1970           }
1971         if ($i <  MAX_PLAYERS) {
1972           $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
1973           $to_user = nickserv_msg($dt, $prestr);
1974           break;
1975         }
1976
1977         /* 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>" */
1978         if ($user->is_auth()) {
1979           if (strcasecmp($user->name,$name_new) != 0) {
1980              if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
1981                 ($user->subst == 'standup' ||
1982                  ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
1983                  )
1984                 ) {
1985               $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
1986               for ($i = 0 ; $i < TABLES_N ; $i++) {
1987                 $to_user .= $this->table[$i]->act_content($user);
1988               }
1989             }
1990             else {
1991               $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
1992               break;
1993             }
1994           }
1995         }
1996         $user->name = $name_new; // OK - nick changed
1997         /* se nome gia' in uso, segnala cosa potrebbe capitare */
1998         if ( ! $user->is_auth() ) {
1999             if (($bdb = BriskDB::create()) != FALSE) {
2000                 $bdb->users_load();
2001                 /* 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>" */
2002                 if ($bdb->login_exists($name_new)) {
2003                     $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
2004                     $to_user .= nickserv_msg($dt, $prestr);
2005                 }
2006             }
2007         }
2008
2009         log_main("chatt_send start set");
2010
2011         $update_room = TRUE;
2012       } while (0);
2013     } // nick chat command
2014     else if (strncmp($msg, "/guar ", 6) == 0 || $msg == "/guar") {
2015         $guar_user = substr($msg, 6);
2016
2017         $this->guarantee_show($user, $guar_user, $dt);
2018     }
2019     else if (strncmp($msg, "/st ", 4) == 0) {
2020       log_main("chatt_send BEGIN");
2021
2022       do {
2023         $st_str = substr($msg, 4);
2024
2025         if (strcasecmp($st_str, "normale") == 0) {
2026           $st = USER_FLAG_S_NORM;
2027         }
2028         else if (strcasecmp($st_str, "pausa") == 0) {
2029           $st = USER_FLAG_S_PAU;
2030         }
2031         else if (strcasecmp($st_str, "fuori") == 0) {
2032           $st = USER_FLAG_S_OUT;
2033         }
2034         else if (strcasecmp($st_str, "cane") == 0) {
2035           $st = USER_FLAG_S_DOG;
2036         }
2037         else if (strcasecmp($st_str, "cibo") == 0) {
2038           $st = USER_FLAG_S_EAT;
2039         }
2040         else if (strcasecmp($st_str, "lavoro") == 0) {
2041           $st = USER_FLAG_S_WRK;
2042         }
2043         else if (strcasecmp($st_str, "sigaretta") == 0) {
2044           $st = USER_FLAG_S_SMK;
2045         }
2046         else if (strcasecmp($st_str, "presente") == 0) {
2047           $st = USER_FLAG_S_EYE;
2048         }
2049         else if (strcasecmp($st_str, "coniglio") == 0) {
2050           $st = USER_FLAG_S_RABB;
2051         }
2052         else if (strcasecmp($st_str, "calcio") == 0) {
2053           $st = USER_FLAG_S_SOCC;
2054         }
2055         else if (strcasecmp($st_str, "pupo") == 0) {
2056           $st = USER_FLAG_S_BABY;
2057         }
2058         else if (strcasecmp($st_str, "pulizie") == 0) {
2059           $st = USER_FLAG_S_MOP;
2060         }
2061         else if (strcasecmp($st_str, "babbo") == 0) {
2062           $st = USER_FLAG_S_BABBO;
2063         }
2064         else if (strcasecmp($st_str, "renna") == 0) {
2065           $st = USER_FLAG_S_RENNA;
2066         }
2067         else if (strcasecmp($st_str, "pupazzo") == 0) {
2068           $st = USER_FLAG_S_PUPAZ;
2069         }
2070         else if (strcasecmp($st_str, "vischio") == 0) {
2071           $st = USER_FLAG_S_VISCH;
2072         }
2073         else {
2074           /* MLANG: "Questo stato non esiste." */
2075           $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
2076           break;
2077         }
2078
2079         log_main("chatt_send start set");
2080         if (($user->flags & USER_FLAG_S_ALL) != $st) {
2081           $update_room = TRUE;
2082           $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
2083         }
2084       } while (0);
2085     } // nick chat command
2086
2087     else { // normal chat line
2088       $is_normchat = TRUE;
2089       if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
2090         $only_you = TRUE;
2091         $user->chat_dlt = $user->chat_dlt * 2;
2092         if ($user->chat_dlt > 120)
2093           $user->chat_dlt = 120;
2094       }
2095       else if ($user->chat_lst == $msg)
2096         $only_you = TRUE;
2097       else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2098         $user->chat_ban = $curtime;
2099         $user->chat_dlt = 5;
2100         $only_you = TRUE;
2101       }
2102       else {
2103         $user->chat_ban = 0;
2104         $user->chat_dlt = 0;
2105       }
2106
2107       if ($only_you) {
2108         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2109       }
2110       else {
2111         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2112         // temporary silentiation for troll (will became array check)
2113         // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2114         $to_room = $to_user;
2115       }
2116
2117       log_legal($curtime, $user->ip, $user,
2118                 ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2119
2120       $user->chat_lst = "$msg";
2121       $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2122       $user->chat_cur++;
2123     }
2124
2125     if ($to_all) {
2126       $to_room = $to_all;
2127       $to_tabl = $to_all;
2128     }
2129
2130     //
2131     //  Output to clients
2132     //
2133
2134     if ($to_user != FALSE) {
2135       $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2136       $user->comm[$user->step % COMM_N] .= $to_user;
2137       $user->step_inc();
2138     }
2139
2140     if ($to_room != FALSE) {
2141       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2142         $user_cur = $this->user[$i];
2143         if ($target != "" && $user_cur->name != $target)
2144           continue;
2145         if ($user_cur->is_active() == FALSE // is not active user
2146             || $user_cur->stat == 'table'   // or stat is 'table'
2147             || $user->idx_get() == $i)      // or the $user idx is equal to current var
2148           continue;
2149
2150         if ($is_normchat == TRUE) {
2151           // use MAP_AUTH to check if auth or isolation
2152           if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2153               if ( ! $user->is_auth() ) {
2154                   continue;
2155               }
2156           }
2157         }
2158         /*
2159         else if ($is_ticker) {
2160           if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2161             if ($user->table >= TABLES_AUTH_N)
2162               continue;
2163           }
2164         }
2165         */
2166         $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2167         $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2168         $user_cur->step_inc();
2169       }
2170     }
2171
2172     if ($to_tabl) {
2173         // FIXME BRISK4: include for each kind of table
2174         require_once("${G_base}briskin5/Obj/briskin5.phh");
2175         // Before all align times with table timeout
2176         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2177             if (isset($this->match[$table_idx])) {
2178                 $bin5 = $this->match[$table_idx];
2179
2180                 $bin5_table = $bin5->table[0];
2181                 for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2182                     // stat must be "table" by definition
2183                     $bin5_user = $bin5->user[$i];
2184
2185                     if ($target != "" && $bin5_user->name != $target)
2186                         continue;
2187                     log_main("writa: ".$user_mesg);
2188                     $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2189                     $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2190                     $bin5_user->step_inc();
2191                 }
2192             } // if (isset($this->match
2193         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2194     } // if ($to_tabl == true ...
2195
2196     if ($update_room) {
2197       if ($user->stat == 'room' && $user->subst == 'standup') {
2198         $this->standup_update($user);
2199       }
2200       else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2201         log_main("chatt_send pre table update");
2202         $this->table_update($user);
2203         log_main("chatt_send post table update");
2204       }
2205     } // if ($update_room ...
2206
2207     return;
2208   } // function chatt_send( ...
2209
2210   function get_user($sess, &$idx)
2211   {
2212       GLOBAL $PHP_SELF;
2213
2214       if (validate_sess($sess)) {
2215           for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2216               if ($this->user[$i]->is_empty())
2217                   continue;
2218               if (strcmp($sess, $this->user[$i]->sess) == 0) {
2219                   // find it
2220                   $idx = $i;
2221                   $ret = $this->user[$i];
2222                   return ($ret);
2223               }
2224           }
2225           log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2226           // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2227           // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2228       }
2229       else {
2230           log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2231       }
2232
2233       return (FALSE);
2234   }
2235
2236   /*
2237    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2238    *
2239    * RETURN VALUE:
2240    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2241    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2242    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2243    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2244    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2245    *   if ($idx == -$idx && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2246    */
2247
2248   function add_user(&$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2249   {
2250     GLOBAL $G_base;
2251
2252     $idx = 0;
2253
2254     $authenticate = FALSE;
2255     $user_type    = 0;
2256     $login_exists = FALSE;
2257     $ghost = -1;
2258     $ghost_auth = FALSE;
2259     $idx = -1;
2260     $idfree = -1;
2261     $code = FALSE;
2262
2263     if (($name_new = validate_name($name)) == FALSE) {
2264       $idx = -2;
2265       return (FALSE);
2266     }
2267
2268     log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2269     if (validate_sess($sess) == FALSE)
2270       $sess = "";
2271
2272     /* if pass != FALSE verify the login with pass */
2273     log_auth("XXX", "auth1");
2274
2275     if (($bdb = BriskDB::create()) != FALSE) {
2276         $bdb->users_load();
2277         if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2278             log_auth("XXX", "auth2");
2279             $authenticate = $bdb->login_verify($name_new, $pass, $code);
2280             log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2281
2282             if ($authenticate != FALSE) {
2283                 $user_type = $authenticate->type_get();
2284             }
2285             else {
2286                 $idx = -3;
2287                 return (FALSE);
2288             }
2289         }
2290         else {
2291             $login_exists =  $bdb->login_exists($name_new);
2292         }
2293     }
2294     else {
2295         // if db is down, send a warning and verify only current users
2296         // no actions at this moment
2297     }
2298     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2299         /* free user ? */
2300         if ($this->user[$i]->is_empty()) {
2301             if ($idfree == -1) {
2302                 $idfree = $i;
2303             }
2304             continue;
2305         }
2306         if (strcmp($sess, $this->user[$i]->sess) == 0) {
2307             if ($idx == -1) {
2308                 $idx = $i;
2309             }
2310         }
2311         if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2312             if ($authenticate != FALSE) {
2313                 $ghost = $i;
2314                 $ghost_auth = $this->user[$i]->is_auth();
2315             }
2316             else {
2317                 $idx = $i;
2318                 break;
2319             }
2320         }
2321     }
2322     if ($idx == -1)
2323       $idx = $idfree;
2324
2325     log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2326
2327     /* there is another user logged with your account and you and him have authenticated => new user
2328        get the session of the old user */
2329     if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2330       /* swap session */
2331
2332       $ghost_user = $this->user[$ghost];
2333       $curtime = time();
2334       $this->ghost_sess->push($curtime, $ghost_user->sess, GHOST_SESS_REAS_ANOT);
2335       $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2336       $ghost_user->step_inc();
2337       if ($sess == "") {
2338         $sess = uniqid("");
2339         $ghost_user->sess = $sess;
2340       }
2341       else {
2342         $ghost_user->sess = $sess;
2343       }
2344
2345       // If user at the table we need to update the table data too
2346       $table_idx = $ghost_user->table;
2347       if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2348           require_once("${G_base}briskin5/Obj/briskin5.phh");
2349           if (isset($this->match[$table_idx])) {
2350               $bin5 = $this->match[$table_idx];
2351
2352               if ($bin5->the_end != TRUE) {
2353                   $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2354                   $bin5->user[$ghost_user->table_pos]->step_inc();
2355                   $bin5->user[$ghost_user->table_pos]->sess = $sess;
2356               }
2357           }
2358       }
2359
2360       $idx = $ghost;
2361       if (defined('CURL_DE_SAC_VERS')) {
2362           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2363       }
2364       return ($this->user[$ghost]);
2365     }
2366     else if ($idx != -1 && $i == MAX_PLAYERS) {
2367       /* SUCCESS */
2368       $curtime = time();
2369       if ($sess == "") {
2370         $sess = uniqid("");
2371         $this->user[$idx]->sess = $sess;
2372       }
2373       else {
2374         $this->user[$idx]->sess = $sess;
2375       }
2376       $this->user[$idx]->name = $name_new; // OK - add new user
2377       $this->user[$idx]->stat_set("room");
2378       $this->user[$idx]->step_set(0);
2379       while (array_pop($this->user[$idx]->comm) != NULL);
2380       $this->user[$idx]->subst = "standup";
2381       $this->user[$idx]->lacc =   $curtime;
2382       $this->user[$idx]->laccwr = $curtime;
2383       $this->user[$idx]->bantime = 0;
2384       $this->user[$idx]->ip = $ip;
2385
2386       $this->user[$idx]->rec = $authenticate;
2387       $this->user[$idx]->flags = $user_type;
2388       $this->user[$idx]->flags |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2389       $this->user[$idx]->flags |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2390       log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags));
2391
2392       if ($authenticate != FALSE) {
2393           $this->user[$idx]->code = $authenticate->code_get();
2394           if (0 == 1) {
2395               // all this part is included in the db server
2396               $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2397
2398               if (isset($cookie['CO_list'])) {
2399                   fprintf(STDERR, "QQ: %s CO_list: [%s]\n", __FUNCTION__, $cookie['CO_list']);
2400                   if (strcmp($cookie['CO_list'], "auth") == 0) {
2401                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2402                       $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2403                   }
2404                   if (strcmp($cookie['CO_list'], "isolation") == 0) {
2405                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2406                       $this->user[$idx]->flags |= USER_FLAG_ISOLAUTH;
2407                   }
2408                   else {
2409                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2410                   }
2411               }
2412           }
2413           else {
2414               fprintf(STDERR, "QQ: CO_list not set flags: %x\n", __FUNCTION__, $this->user[$idx]->flags);
2415           }
2416       }
2417       fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2418       if ($ghost > -1) {
2419         log_main("ghost: rename!");
2420         $ghost_user = $this->user[$ghost];
2421
2422         if ($ghost_auth == FALSE) {
2423           for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2424             $ghostname = 'ghost'.$sfx;
2425             for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2426               if (strcmp("", $this->user[$i]->sess) == 0)
2427                 continue;
2428
2429               if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2430                 $ghostname = '';
2431                 break;
2432               }
2433             }
2434             if ($ghostname != '')
2435               break;
2436           }
2437
2438           $ghost_user->name = $ghostname;
2439
2440           if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2441             $this->standup_update($ghost_user);
2442           }
2443           else {
2444             log_main("chatt_send pre table update");
2445             $this->table_update($ghost_user);
2446           log_main("chatt_send post table update");
2447           }
2448         } // if ($ghost_auth == FALSE
2449         else {
2450           // FIXME: cacciare il vecchio utente room && table (if needed)
2451           $ghost_user->the_end = TRUE;
2452           $ghost_user->lacc = 0;
2453           $this->garbage_manager(TRUE);
2454         }
2455       } //  if ($ghost > -1) {
2456
2457       $real_idx = $idx;
2458       if ($login_exists)
2459         $idx = -($idx + 1);
2460       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));
2461
2462       $ret = $this->user[$real_idx];
2463       if (defined('CURL_DE_SAC_VERS')) {
2464           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2465       }
2466       return ($ret);
2467     }
2468
2469     return (FALSE);
2470   }
2471
2472   function standup_update($user)
2473   {
2474     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2475       $user_cur = $this->user[$i];
2476       if ($user_cur->is_active() == FALSE)
2477         continue;
2478
2479       log_main("STANDUP START: ".$user_cur->stat);
2480
2481       if ($user_cur->stat == 'room') {
2482         $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2483         if ($user->idx_get() == $i) {
2484           $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2485         }
2486         log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2487
2488         $user_cur->step_inc();
2489       }
2490     }
2491   }
2492
2493   function dump_data()
2494   {
2495       $brisk_ser = serialize($this);
2496       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2497       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2498           return (TRUE);
2499       }
2500
2501       return (FALSE);
2502   }
2503
2504   function standup_content($user)
2505   {
2506     $ret = "";
2507
2508     if ($user->stat != 'room')
2509       return;
2510
2511     $content = ' j_stand_cont( [ ';
2512
2513     $user_cur_id = $user->idx_get();
2514     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2515         if ($this->user[$i]->is_active() == FALSE // is not active user
2516             || $this->user[$i]->stat != "room"    // or the stat isn't 'room'
2517             || $this->user[$i]->name == "")       // or the name is empty, happens when user is reset (TODO: check it)
2518         continue;
2519
2520       $flags = $this->user[$i]->flags;
2521
2522       // sql record exists AND last donate > 2013-01-01
2523       if ($this->user[$i]->is_supp_custom()) {
2524           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2525       }
2526       else {
2527           $supp_comp_s = '';
2528       }
2529
2530       if ($this->user[$i]->subst == "standup") {
2531           if ($user_cur_id == $i) {
2532               $flags |= 1;
2533           }
2534
2535           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2536                               xcape($this->user[$i]->name), $supp_comp_s);
2537           $ct++;
2538       }
2539     }
2540     $content .= ' ]);';
2541
2542     return ($content);
2543   }
2544
2545   function table_content($user, $table_idx)
2546   {
2547     $content = "";
2548     $ret = "";
2549     // TODO
2550     //
2551     //   Si possono usare i dati nella classe table
2552     //
2553
2554     $sess = $user->sess;
2555     $table = $this->table[$table_idx];
2556
2557     if ($user->stat != 'room')
2558       return;
2559
2560     $user_cur_id = $user->idx_get();
2561     $content = "[ ";
2562     for ($i = 0 ; $i < $table->player_n ; $i++) {
2563         $user_cur = $this->user[$table->player[$i]];
2564
2565         $flags = $user_cur->flags;
2566
2567         if ($user_cur_id == $table->player[$i])
2568             $flags |= 1;
2569
2570         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2571         if ($user_cur->is_supp_custom())
2572             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2573         else
2574             $supp_comp_s = '';
2575
2576         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2577                             xcape($user_cur->name), $supp_comp_s);
2578     }
2579
2580     $content .= ' ]';
2581
2582     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2583
2584     return ($ret);
2585   }
2586
2587   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2588   {
2589       GLOBAL $G_ban_list, $G_black_list;
2590
2591       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2592       $remote_addr = addrtoipv4($addr);
2593
2594           fprintf(STDERR, "\n\n\n PRE_BLACK_CHECK \n\n\n");
2595       if ($this->black_check($remote_addr)) {
2596           // TODO: waiting async 5 sec before close
2597           fprintf(STDERR, "\n\n\n BLACK_CHECK \n\n\n");
2598           return (FALSE);
2599       }
2600
2601       $enc = get_encoding($header);
2602       if (isset($header['User-Agent'])) {
2603           if (strstr($header['User-Agent'], "MSIE")) {
2604               $transp_type = "htmlfile";
2605           }
2606           else {
2607               $transp_type = "xhr";
2608           }
2609       }
2610       else {
2611           $transp_type = "iframe";
2612       }
2613       force_no_cache($header_out);
2614
2615       switch ($path) {
2616       case "":
2617       case "index.php":
2618           ob_start();
2619           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2620           $content = ob_get_contents();
2621           ob_end_clean();
2622
2623           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2624           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2625           return TRUE;
2626
2627           break;
2628       case "index_wr.php":
2629           //
2630           // Enhance required: in the POST case, after the header you must get content
2631           //                   from the socket, waiting if necessary
2632           //
2633
2634           ob_start();
2635           index_wr_main($this, $addr, $get, $post, $cookie);
2636           $content = ob_get_contents();
2637           ob_end_clean();
2638
2639           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2640           return TRUE;
2641
2642           break;
2643       case "index_rd.php":
2644           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2645               $transp = "iframe";
2646           if ($transp == 'websocket')
2647               $enc = 'plain';
2648
2649           do {
2650               if (!isset($cookie['sess'])
2651                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2652
2653                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2654
2655                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2656                   return TRUE;
2657
2658                   break;
2659               }
2660               $this->sess_cur_set($user->sess);
2661               // close a previous opened index_read_ifra socket, if exists
2662               if (($prev = $user->rd_socket_get()) != NULL) {
2663                   $s_a_p->socks_unset($user->rd_socket_get());
2664                   fclose($user->rd_socket_get());
2665                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2666                   $user->rd_socket_set(NULL);
2667               }
2668
2669               $content = "";
2670               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2671               $response = headers_render($header_out, -1).$user->chunked_content($content);
2672               $response_l = mb_strlen($response, "ASCII");
2673
2674               $wret = @fwrite($new_socket, $response, $response_l);
2675               if ($wret < $response_l) {
2676                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2677                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2678               }
2679               else {
2680                   $user->rd_cache_set("");
2681               }
2682               fflush($new_socket);
2683
2684
2685               $s_a_p->socks_set($new_socket, $user, NULL);
2686               $user->rd_socket_set($new_socket);
2687               printf(" - qui ci siamo - ");
2688               return TRUE;
2689           } while (FALSE);
2690
2691           return FALSE;
2692           break;
2693       case 'test.php':
2694           if (!(BRISK_DEBUG & DBG_ENGI))
2695               return (FALSE);
2696           fprintf(STDERR, "TEST.PHP running\n");
2697           if (isset($post['data'])) {
2698               $content = $post['data'];
2699           }
2700           else {
2701               $content = "NO DATA AVAILABLE";
2702           }
2703           $header_out['Content-Type'] = 'text/plain';
2704           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2705           return TRUE;
2706           break;
2707       default:
2708           /* FAR TODO: move all into an array of registered sub-apps */
2709           $subs = "briskin5/";
2710           $subs_l = strlen($subs);
2711           if (!strncmp($path, $subs, $subs_l)) {
2712               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2713               return ($ret);
2714           }
2715           break;
2716       }
2717
2718       return (FALSE);
2719   }
2720
2721   function match_add($idx, $match)
2722   {
2723       $this->match[$idx] = $match;
2724   }
2725
2726   function match_del($idx)
2727   {
2728       unset($this->match[$idx]);
2729   }
2730
2731   function match_get($idx, $token)
2732   {
2733       if (isset($this->match[$idx])) {
2734           if (   $token == NULL
2735               || $token == $this->match[$idx]->table_token) {
2736               return ($this->match[$idx]);
2737           }
2738       }
2739       return NULL;
2740   }
2741   function sess_cur_set($sess)
2742   {
2743       static::$sess_cur = $sess;
2744   }
2745
2746   static function sess_cur_get()
2747   {
2748       return(static::$sess_cur);
2749   }
2750 } // end class Brisk
2751
2752 function make_seed()
2753 {
2754   list($usec, $sec) = explode(' ', microtime());
2755   return (float) $sec + ((float) $usec * 100000);
2756 }
2757
2758 function btrace_line($ar)
2759 {
2760     GLOBAL $G_btrace_pref_sub;
2761
2762     $ret = "";
2763     for ($i = 0 ; $i < count($ar) ; $i++) {
2764         $with_class = isset($ar[$i]['class']);
2765         $with_file  = isset($ar[$i]['file']);
2766         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2767                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2768                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2769                         ($with_file ? $ar[$i]['line'] : ""));
2770     }
2771
2772     return ($ret);
2773 }
2774
2775 function trace_ftok($id, $add)
2776 {
2777     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2778     $tok=@ftok($id, $add);
2779
2780     log_shme($tok.": ".$id." + ".$add);
2781
2782     return ($tok);
2783 }
2784
2785 function log_mop($step, $log)
2786 {
2787     GLOBAL $PHP_SELF;
2788
2789     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2790         return;
2791
2792     $sess = Brisk::sess_cur_get();
2793     if (isset($sess) == FALSE)
2794         $ssess = "XXXX";
2795     else
2796         $ssess = $sess;
2797
2798     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2799         return;
2800
2801     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2802         $btrace = btrace_line(debug_backtrace());
2803     else
2804         $btrace = "";
2805     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2806         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2807         fclose($fp);
2808     }
2809 }
2810
2811 function log_step($log)
2812 {
2813     GLOBAL $PHP_SELF;
2814
2815     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2816         return;
2817
2818     $sess = Brisk::sess_cur_get();
2819     if (isset($sess) == FALSE)
2820         $ssess = "XXXX";
2821     else
2822         $ssess = $sess;
2823
2824     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2825         return;
2826
2827     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2828         $btrace = btrace_line(debug_backtrace());
2829     else
2830         $btrace = "";
2831     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
2832         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2833         fclose($fp);
2834     }
2835 }
2836
2837
2838
2839 function log_cds($log)
2840 {
2841     GLOBAL $PHP_SELF;
2842
2843     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
2844         return;
2845
2846     $sess = Brisk::sess_cur_get();
2847     if (isset($sess) == FALSE)
2848         $ssess = "XXXX";
2849     else
2850         $ssess = $sess;
2851
2852     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
2853         return;
2854
2855     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2856         $btrace = btrace_line(debug_backtrace());
2857     else
2858         $btrace = "";
2859     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
2860         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2861         fclose($fp);
2862     }
2863 }
2864
2865
2866 function log_only2($log)
2867 {
2868     GLOBAL $PHP_SELF;
2869
2870     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
2871         return;
2872
2873     $sess = Brisk::sess_cur_get();
2874     if (isset($sess) == FALSE)
2875         $ssess = "XXXX";
2876     else
2877         $ssess = $sess;
2878
2879     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
2880         return;
2881
2882     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2883         $btrace = btrace_line(debug_backtrace());
2884     else
2885         $btrace = "";
2886     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2887         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2888         fclose($fp);
2889     }
2890 }
2891
2892 function log_crit($log)
2893 {
2894     GLOBAL $PHP_SELF;
2895
2896     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
2897         return;
2898
2899     $sess = Brisk::sess_cur_get();
2900     if (isset($sess) == FALSE)
2901         $ssess = "XXXX";
2902     else
2903         $ssess = $sess;
2904
2905     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
2906         return;
2907
2908     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2909         $btrace = btrace_line(debug_backtrace());
2910     else
2911         $btrace = "";
2912     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2913         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2914         fclose($fp);
2915     }
2916 }
2917
2918 function log_only($log)
2919 {
2920     GLOBAL $PHP_SELF;
2921
2922     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
2923         return;
2924
2925     $sess = Brisk::sess_cur_get();
2926     if (isset($sess) == FALSE)
2927         $ssess = "XXXX";
2928     else
2929         $ssess = $sess;
2930
2931     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
2932         return;
2933
2934     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2935         $btrace = btrace_line(debug_backtrace());
2936     else
2937         $btrace = "";
2938     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2939         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2940         fclose($fp);
2941     }
2942 }
2943
2944 function log_main($log)
2945 {
2946     GLOBAL $PHP_SELF;
2947
2948     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
2949         return;
2950
2951     $sess = Brisk::sess_cur_get();
2952     if (isset($sess) == FALSE)
2953         $ssess = "XXXX";
2954     else
2955         $ssess = $sess;
2956
2957     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
2958         return;
2959
2960     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2961         $btrace = btrace_line(debug_backtrace());
2962     else
2963         $btrace = "";
2964     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2965         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2966         fclose($fp);
2967     }
2968 }
2969
2970 function log_rd($log)
2971 {
2972     GLOBAL $PHP_SELF;
2973
2974     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
2975         return;
2976
2977     $sess = Brisk::sess_cur_get();
2978     if (isset($sess) == FALSE)
2979         $ssess = "XXXX";
2980     else
2981         $ssess = $sess;
2982
2983     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
2984         return;
2985
2986     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2987         $btrace = btrace_line(debug_backtrace());
2988     else
2989         $btrace = "";
2990     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2991         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2992         fclose($fp);
2993     }
2994 }
2995
2996 function log_rd2($log)
2997 {
2998     GLOBAL $PHP_SELF;
2999
3000     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
3001         return;
3002
3003     $sess = Brisk::sess_cur_get();
3004     if (isset($sess) == FALSE)
3005         $ssess = "XXXX";
3006     else
3007         $ssess = $sess;
3008
3009     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
3010         return;
3011
3012     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3013         $btrace = btrace_line(debug_backtrace());
3014     else
3015         $btrace = "";
3016
3017     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3018         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3019         fclose($fp);
3020     }
3021 }
3022
3023 function log_send($log)
3024 {
3025     GLOBAL $PHP_SELF;
3026
3027     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3028         return;
3029
3030     $sess = Brisk::sess_cur_get();
3031     if (isset($sess) == FALSE)
3032         $ssess = "XXXX";
3033     else
3034         $ssess = $sess;
3035
3036     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3037         return;
3038
3039     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3040         $btrace = btrace_line(debug_backtrace());
3041     else
3042         $btrace = "";
3043     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3044         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3045         fclose($fp);
3046     }
3047 }
3048
3049 function log_lock($log)
3050 {
3051     GLOBAL $PHP_SELF;
3052
3053     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3054         return;
3055
3056     $sess = Brisk::sess_cur_get();
3057     if (isset($sess) == FALSE)
3058         $ssess = "XXXX";
3059     else
3060         $ssess = $sess;
3061
3062     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3063         return;
3064
3065     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3066         $btrace = btrace_line(debug_backtrace());
3067     else
3068         $btrace = "";
3069     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3070         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3071         fclose($fp);
3072     }
3073 }
3074
3075 function log_wr($log)
3076 {
3077     GLOBAL $PHP_SELF;
3078
3079     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3080         return;
3081
3082     $sess = Brisk::sess_cur_get();
3083     if (isset($sess) == FALSE)
3084         $ssess = "XXXX";
3085     else
3086         $ssess = $sess;
3087
3088     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3089         return;
3090
3091     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3092         $btrace = btrace_line(debug_backtrace());
3093     else
3094         $btrace = "";
3095     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3096         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3097         fclose($fp);
3098     }
3099 }
3100
3101 function log_load($log)
3102 {
3103     GLOBAL $PHP_SELF;
3104
3105     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3106         return;
3107
3108     $sess = Brisk::sess_cur_get();
3109     if (isset($sess) == FALSE)
3110         $ssess = "XXXX";
3111     else
3112         $ssess = $sess;
3113
3114     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3115         return;
3116
3117     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3118         $btrace = btrace_line(debug_backtrace());
3119     else
3120         $btrace = "";
3121     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3122         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3123         fclose($fp);
3124     }
3125 }
3126
3127 function log_auth($sess, $log)
3128 {
3129     GLOBAL $PHP_SELF;
3130
3131     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3132         return;
3133
3134     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3135         return;
3136
3137     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3138         $btrace = btrace_line(debug_backtrace());
3139     else
3140         $btrace = "";
3141     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3142         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3143         fclose($fp);
3144     }
3145 }
3146
3147 function log_shme($log)
3148 {
3149     GLOBAL $PHP_SELF;
3150
3151     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3152         return;
3153
3154     $sess = Brisk::sess_cur_get();
3155     if (isset($sess) == FALSE)
3156         $ssess = "XXXX";
3157     else
3158         $ssess = $sess;
3159
3160     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3161         return;
3162
3163     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3164         $btrace = btrace_line(debug_backtrace());
3165     else
3166         $btrace = "";
3167     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3168         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3169         fclose($fp);
3170     }
3171 }
3172
3173
3174
3175 // function log_legal($curtime, $sess, $name, $where, $mesg)
3176 function log_legal($curtime, $addr, $user, $where, $mesg)
3177 {
3178
3179   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3180     /* Unix time | session | nickname | IP | where was | mesg */
3181     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
3182                         ($user->is_auth() ? 'A' : 'N'),
3183                         $user->name, $addr, $where , $mesg));
3184     fclose($fp);
3185   }
3186 }
3187
3188 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3189 {
3190   $ret = "";
3191
3192   if ($isstanding) {
3193     if ($sitted < PLAYERS_N) {
3194       if ($allowed)
3195         $act = 'sit';
3196       else
3197         $act = 'reserved';
3198     }
3199   }
3200   else {
3201     if ($table == $cur_table)
3202       $act = 'wake';
3203     else
3204       $act = 'none';
3205   }
3206
3207   if ($act != '')
3208     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3209
3210   return ($ret);
3211 }
3212
3213 function show_notify($text, $tout, $butt, $w, $h)
3214 {
3215   log_main("SHOW_NOTIFY: ".$text);
3216   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3217 }
3218
3219 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3220 {
3221   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3222   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);
3223 }
3224
3225 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3226 {
3227   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3228
3229   $butts = "";
3230   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3231       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3232   }
3233
3234   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3235                  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);
3236 }
3237
3238
3239 function root_welcome($user)
3240 {
3241   GLOBAL $root_wellarr, $G_lang;
3242   $ret = "";
3243
3244   $curtime = time();
3245   $dt = date("H:i ", $curtime);
3246
3247   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3248       $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3249
3250   return ($ret);
3251 }
3252
3253
3254
3255 function validate_sess($sess)
3256 {
3257   if (strlen($sess) == SESS_LEN)
3258     return (TRUE);
3259   else
3260     return (FALSE);
3261 }
3262
3263 function validate_name($name)
3264 {
3265     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3266
3267   for ($i = 0 ; $i < strlen($name_new) ; $i++) {
3268     $c = $name_new[$i];
3269     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3270       return ($name_new);
3271   }
3272
3273   return (FALSE);
3274 }
3275
3276 function playsound($filename)
3277 {
3278   return (sprintf('playsound("flasou", "%s");', $filename));
3279 }
3280
3281 function secstoword($secs)
3282 {
3283   GLOBAL $G_lang;
3284
3285   $ret = "";
3286
3287   $mins = floor($secs / 60);
3288   $secs = $secs % 60;
3289   if ($G_lang == 'en') {
3290     if ($mins > 0)
3291       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3292
3293     if ($secs > 0)
3294       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3295   }
3296   else {
3297     if ($mins > 0)
3298       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3299
3300     if ($secs > 0)
3301       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3302   }
3303   return ($ret);
3304 }
3305
3306 function sharedmem_sz($tok)
3307 {
3308   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3309     log_main("shmop_open failed");
3310     return (-1);
3311   }
3312   $shm_sz = shmop_size($shm_id);
3313   shmop_close($shm_id);
3314
3315   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3316   return ($shm_sz);
3317 }
3318
3319 class Warrant {
3320     static $delta_t;
3321
3322   static function lock_data($is_exclusive)
3323   {
3324       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3325           self::$delta_t = microtime(TRUE);
3326           log_lock("LOCK   warrant      [".self::$delta_t."]");
3327
3328           return ($res);
3329       }
3330
3331       return (FALSE);
3332   }
3333
3334   static function unlock_data($res)
3335   {
3336     GLOBAL $sess;
3337
3338     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3339
3340     file_unlock($res);
3341   }
3342 }
3343
3344 class Poll {
3345     static $delta_t;
3346
3347   static function lock_data($is_exclusive)
3348   {
3349       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3350           self::$delta_t = microtime(TRUE);
3351           log_lock("LOCK   poll         [".self::$delta_t."]");
3352
3353           return ($res);
3354       }
3355
3356       return (FALSE);
3357   }
3358
3359   static function unlock_data($res)
3360   {
3361     GLOBAL $sess;
3362
3363     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3364
3365     file_unlock($res);
3366   }
3367 }
3368
3369 function carousel_top()
3370 {
3371     $what = rand(1,2);
3372     if ($what == 1) {
3373         $rn = rand(1, 3);
3374         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));
3375         }
3376     else {
3377         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>'));
3378     }
3379 }
3380
3381
3382 ?>