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_ANOT', 1);
 988 class GhostSessEl
 989 {
 990     var $time;
 991     var $sess;
 992     var $reas;
 993
 994     function GhostSessEl($time, $sess, $reas)
 995     {
 996         $this->time = $time + GHOST_SESS_TOUT;
 997         $this->sess = $sess;
 998         $this->reas = $reas;
 999     }
1000 }
1001
1002 class GhostSess
1003 {
1004     var $gs;
1005
1006     function GhostSess()
1007     {
1008         $this->gs = array();
1009     }
1010
1011     // push or update for this session
1012     function push($time, $sess, $reas)
1013     {
1014         foreach($this->gs as $el) {
1015             if ($el->sess == "$sess") {
1016                 $el->reas = $reas;
1017                 $el->time = $time + GHOST_SESS_TOUT;
1018                 return TRUE;
1019             }
1020         }
1021
1022         $this->gs[] = new GhostSessEl($time, $sess, $reas);
1023         return TRUE;
1024     }
1025
1026     function pop($sess)
1027     {
1028         foreach($this->gs as $key => $el) {
1029             if ($el->sess == "$sess") {
1030                 $ret = $this->gs[$key];
1031                 unset($this->gs[$key]);
1032                 return ($ret);
1033             }
1034         }
1035         return FALSE;
1036     }
1037
1038     function garbage_manager($curtime)
1039     {
1040         foreach($this->gs as $key => $el) {
1041             if ($el->time < $curtime) {
1042                 unset($this->gs[$key]);
1043             }
1044         }
1045     }
1046 }
1047
1048 class Brisk
1049 {
1050     static $delta_t;
1051
1052     var $crystal_filename;
1053     var $user;
1054     var $table;
1055     var $match;
1056     var $comm; // commands for many people
1057     var $step; // current step of the comm array
1058     var $garbage_timeout;
1059     var $shm_sz;
1060
1061     var $ban_list;  // ban list (authized allowed)
1062     var $black_list;  // black list (anti-dos, noone allowed)
1063     var $ghost_sess;
1064     var $delay_mgr;
1065
1066     var $cds;
1067
1068     public static $sess_cur;
1069
1070     function Brisk()
1071     {
1072         $this->cds = NULL;
1073     }
1074
1075     // constructor
1076     static function create($crystal_filename, $ban_list, $black_list) {
1077         if (($brisk_ser = @file_get_contents($crystal_filename)) != FALSE) {
1078             if (($brisk = unserialize($brisk_ser)) != FALSE) {
1079                 fprintf(STDERR, "ROOM FROM FILE\n");
1080                 rename($crystal_filename, $crystal_filename.".old");
1081
1082                 $brisk->reload(TRUE, $ban_list, $black_list);
1083
1084                 return($brisk);
1085             }
1086         }
1087
1088         fprintf(STDERR, "NEW ROOM\n");
1089         $thiz = new Brisk();
1090
1091         $thiz->crystal_filename = $crystal_filename;
1092         $thiz->user  = array();
1093         $thiz->table = array();
1094         $thiz->match = array();
1095
1096         $thiz->ban_list = NULL;
1097         $thiz->black_list = NULL;
1098         $thiz->ghost_sess = new GhostSess();
1099
1100         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1101             $thiz->user[$i] = User::create($thiz, $i, "", "");
1102         }
1103
1104         for ($i = 0 ; $i < TABLES_N ; $i++) {
1105             $thiz->table[$i] = Table::create($i);
1106         }
1107         $thiz->garbage_timeout = 0;
1108         $thiz->shm_sz = SHM_DIMS_MIN;
1109
1110         $thiz->delay_mgr = new Delay_Manager(1.5);
1111
1112         static::$sess_cur = FALSE;
1113
1114         $thiz->reload(TRUE, $ban_list, $black_list);
1115
1116         return ($thiz);
1117     }
1118
1119     function ipclass_update($ip_out_s, $ip_in)
1120     {
1121         fprintf(STDERR, "N_IN: %d\n", count($ip_in));
1122
1123         $ip_out = &$this->$ip_out_s;
1124
1125         // if already set clean the ban_list property
1126         if ($ip_out) {
1127             $ct = count($ip_out);
1128             for ($i = 0 ; $i < $ct ; $i++) {
1129                 unset($ip_out[$i]);
1130             }
1131             unset($ip_out);
1132         }
1133
1134         $ip_out = array();
1135         for ($i = 0 ; $i < count($ip_in) ; $i++) {
1136             $ip_out[$i] = new IPClass($ip_in[$i]);
1137         }
1138     }
1139
1140     function reload($is_first, $ban_list, $black_list)
1141     {
1142         fprintf(STDERR, "RELOAD STUFF (%d)(%d)\n", count($ban_list), count($black_list));
1143
1144         if (defined('CURL_DE_SAC_VERS')) {
1145             if (brisk_cds_reload($this) == FALSE) {
1146                 exit(12);
1147             }
1148         }
1149         $this->ipclass_update("ban_list", $ban_list);
1150         $this->ipclass_update("black_list", $black_list);
1151
1152         if (!$is_first) {
1153             $this->banned_kickoff();
1154             $this->garbage_manager(TRUE);
1155         }
1156     }
1157
1158     function banned_kickoff()
1159     {
1160         $is_ban = FALSE;
1161
1162         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1163             $table_cur = $this->table[$table_idx];
1164             // if the table is complete and exists we check users IP
1165
1166             if ($table_cur->player_n == PLAYERS_N) {
1167                 if (isset($this->match[$table_idx]) &&
1168                     $table_cur->table_token == $bin5->table_token) {
1169                     log_main("PLAYERS == N TABLE ".$table_idx);
1170
1171                     $bin5 = $this->match[$table_idx];
1172
1173                     $is_ban |= $bin5->banned_kickoff();
1174                 }
1175             }
1176         }
1177
1178         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1179             $user_cur = $this->user[$i];
1180
1181             if ($user_cur->sess == "")
1182                 continue;
1183
1184             // check if the IP is blacklisted
1185             if ($this->black_check($user_cur->ip)) {
1186                 $user_cur->lacc = 0;
1187                 $is_ban = TRUE;
1188                 continue;
1189             }
1190
1191             // if authorized not check if banlisted
1192             if ($user_cur->is_auth()) {
1193                 continue;
1194             }
1195
1196             if ($this->ban_check($user_cur->ip)) {
1197                 $user_cur->lacc = 0;
1198                 $is_ban = TRUE;
1199             }
1200         }
1201
1202         return $is_ban;
1203     }
1204
1205     function ban_check($ip_str)
1206     {
1207         $ip = ip2long($ip_str);
1208         fprintf(STDERR, "Brisk::ban_check %d\n", count($this->ban_list));
1209         for ($i = 0 ; $i < count($this->ban_list) ; $i++) {
1210             fprintf(STDERR, "ban_list[%d] = %x (%x)\n", $i,
1211                     $this->ban_list[$i]->addr, $this->ban_list[$i]->mask);
1212             if ($this->ban_list[$i]->match($ip)) {
1213                 fprintf(STDERR, "\n\nMATCHA!\n\n");
1214                 return(TRUE);
1215             }
1216         }
1217         return (FALSE);
1218     }
1219
1220     function black_check($ip_str)
1221     {
1222         $ip = ip2long($ip_str);
1223         fprintf(STDERR, "Brisk::black_check %d\n", count($this->black_list));
1224         for ($i = 0 ; $i < count($this->black_list) ; $i++) {
1225             fprintf(STDERR, "black_list[%d] = %x (%x)\n", $i,
1226                    $this->black_list[$i]->addr, $this->black_list[$i]->mask);
1227             if ($this->black_list[$i]->match($ip)) {
1228                 fprintf(STDERR, "\n\nMATCHA!\n\n");
1229                 return(TRUE);
1230             }
1231         }
1232         return (FALSE);
1233     }
1234
1235   function garbage_manager($force)
1236   {
1237     GLOBAL $G_lang, $mlang_brisk, $G_base;
1238
1239     $ismod = FALSE;
1240
1241     log_rd2("garbage_manager START");
1242
1243     /* Garbage collector degli utenti in timeout */
1244     $curtime = microtime(TRUE);
1245
1246     $delta = $this->delay_mgr->delta_get($curtime);
1247
1248     if (!$force && !($this->garbage_timeout < $curtime)) {
1249         $this->delay_mgr->lastcheck_set($curtime);
1250         return ($ismod);
1251     }
1252
1253     // Before all align times with table timeout
1254     for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1255         $table_cur = $this->table[$table_idx];
1256         // if the table is complete and exists its shared mem we get the info about users lacc
1257
1258         if ($table_cur->player_n == PLAYERS_N) {
1259             log_main("PLAYERS == N TABLE ".$table_idx);
1260
1261
1262             $no_recovery = FALSE;
1263             if (isset($this->match[$table_idx])) {
1264                 $bin5 = $this->match[$table_idx];
1265
1266                 if ($table_cur->table_token != $bin5->table_token) {
1267                     log_main("ERROR: not matching table_token. Brisk: ".$table_cur->table_token."  Table: ".$bin5->table_token);
1268                     log_main("ERROR: not matching table_start. Brisk: ".$table_cur->table_start."  Table: ".$bin5->table_start);
1269                     $no_recovery = TRUE;
1270                     $bin5 = FALSE;
1271                 }
1272
1273                 if ($bin5 != FALSE) {
1274                     //
1275                     //  SPAWN: JOIN
1276                     //
1277                     log_main("garbage_manager: bri loaded successfully.");
1278                     $bin5->garbage_manager(TRUE);
1279
1280                     $bin5_table = $bin5->table[0];
1281
1282                     // is the end of the table
1283
1284                     if ($bin5->the_end == TRUE) {
1285                         /*
1286                          *  DESTROY OF FINISHED TABLE && MOVE PLAYER TO ROOM AGAIN
1287                          */
1288                         log_main("garbage_manager: INSIDE THE END.");
1289
1290                         $plist = "$table_cur->table_token|$table_cur->idx|$table_cur->player_n";
1291                         for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1292                             $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1293                         }
1294
1295                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1296                             // stat must be "table" by definition
1297                             $user_cur = $this->user[$table_cur->player[$i]];
1298                             $bin5_user = $bin5->user[$i];
1299
1300                             $user_cur->subst      = $bin5_user->subst;
1301                             $user_cur->step       = $bin5_user->step;
1302                             $user_cur->lacc       = $bin5_user->lacc;
1303                             $user_cur->laccwr     = $bin5_user->lacc;
1304                             $user_cur->bantime    = $bin5_user->bantime;
1305                         }
1306
1307                         log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME", $plist);
1308
1309                         $this->room_join_wakeup($user_cur, FALSE, 0);
1310                         $table_cur->table_token = "";
1311                         $table_cur->wakeup_time = $curtime + WAKEUP_TIME;
1312
1313                         $this->match_del($table_idx);
1314                     }
1315                     else {
1316                         log_main("gm:: save_data");
1317
1318                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1319                             $this->user[$table_cur->player[$i]]->lacc = $bin5->user[$i]->lacc;
1320                         }
1321                     }
1322                 } // if ($bin5 == FALSE
1323                 else if ($no_recovery == FALSE) {
1324                     log_crit("ERROR: table ".$table_idx." unrecoverable join");
1325
1326                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1327                         $user_cur = $this->user[$table_cur->player[$i]];
1328                         $user_cur->subst = "shutdowner";
1329                         $user_cur->step_inc();
1330
1331                         $ret = sprintf('stat = "%s"; subst = "%s";',  $user_cur->stat, $user_cur->subst);
1332                         $ret .= "gst.st = ".($user_cur->step+1)."; ";
1333                         // MLANG <br>I dati del tavolo n&deg; ".$user_cur->table." sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>
1334                         $prestr = sprintf($mlang_brisk['tabincon'][$G_lang], $user_cur->table);
1335                         $ret .= show_notify($prestr, 2000, $mlang_brisk['btn_close'][$G_lang], 400, 110);
1336                         $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1337                         $user_cur->step_inc();
1338                     }
1339
1340                     $plist = "$table_cur->table_token|$user_cur->table|$table_cur->player_n";
1341                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1342                         $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1343                     }
1344                     log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME(RECOVERY)", $plist);
1345
1346                     $this->room_join_wakeup($user_cur, TRUE, -2);
1347                     $table_cur->table_token = "";
1348                 }
1349             }
1350         } //  if ($table_cur->player_n == PLAYERS_N) {
1351     } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1352
1353     log_rd2("out new loop.");
1354
1355     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1356         $user_cur = $this->user[$i];
1357
1358         log_rd2("User: ".$user_cur->name."  stat: ".$user_cur->stat."  subst: ".$user_cur->subst);
1359
1360         if ($user_cur->sess == "")
1361             continue;
1362
1363         if ($user_cur->lacc + EXPIRE_TIME_RD < ($curtime - $delta)) {
1364             // Auto logout dell'utente
1365             log_rd2("AUTO LOGOUT.".($user_cur->lacc + EXPIRE_TIME_RD)." curtime - delta ".($curtime - $delta));
1366
1367             if ($user_cur->stat == 'table' || $user_cur->stat == 'room') {
1368                 log_auth($user_cur->sess, "Autologout session.");
1369
1370                 $user_cur->reset();
1371
1372                 log_rd2("AUTO LOGOUT.");
1373                 if ($user_cur->subst == 'sitdown' || $user_cur->stat == 'table')
1374                     $this->room_wakeup($user_cur);
1375                 else if ($user_cur->subst == 'standup')
1376                     $this->room_outstandup($user_cur);
1377                 else
1378                     log_rd2("LOGOUT FROM WHAT ???");
1379             }
1380         }
1381
1382         if ($user_cur->laccwr + EXPIRE_TIME_SMAMMA < ($curtime - $delta)) { // lo rimettiamo in piedi
1383             if ($user_cur->stat == 'room' && $user_cur->subst == 'sitdown') {
1384                 $this->room_wakeup($user_cur);
1385                 $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ";
1386                 /* 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" */
1387                 $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);
1388                 $user_cur->step_inc();
1389             }
1390         }
1391     }
1392     log_rd2("GARBAGE UPDATED!");
1393
1394     $this->garbage_timeout = $curtime + GARBAGE_TIMEOUT;
1395     $ismod = TRUE;
1396
1397     $this->ghost_sess->garbage_manager($curtime);
1398
1399     $this->delay_mgr->lastcheck_set($curtime);
1400     return ($ismod);
1401   }
1402
1403   function show_room($user_step, $user)
1404   {
1405     GLOBAL $G_lang, $mlang_brisk;
1406     log_main("show_room: username: ".$user->name);
1407
1408     $ret = sprintf('gst.st = %d; ',  $user_step);
1409
1410     $prefs = Client_prefs::from_user($user);
1411     $ret .= sprintf('prefs_load(\'%s\', false, false);', json_encode($prefs));
1412
1413     if(false) {
1414         if ($user->flags & USER_FLAG_ISOLAUTH) {
1415             $ret .= 'list_set(\'isolation\', false, \''.$mlang_brisk['tit_onisol'][$G_lang].'\' ); ';
1416         }
1417         else if ($user->flags & USER_FLAG_LISTAUTH) {
1418             $ret .= 'list_set(\'auth\', false, \''.$mlang_brisk['tit_onauth'][$G_lang].'\' ); ';
1419         }
1420         else {
1421             $ret .= 'list_set(\'all\', false, \'\' ); ';
1422         }
1423     }
1424
1425     if ($user->subst == 'standup')
1426       $ret .= "tra.show(); ";
1427     else
1428       $ret .= "tra.hide(); ";
1429
1430     $ret .= sprintf('stat = "%s";',  $user->stat);
1431
1432     $ret .= root_welcome($user);
1433     if ($user->flags & USER_FLAG_DBFAILED) {
1434         $ret .= "gst.st = ".($user->step+1)."; ";
1435         $ret .= show_notify($mlang_brisk['db_failed'][$G_lang], 0, $mlang_brisk['btn_close'][$G_lang], 400, 140);
1436     }
1437
1438     $ret .= sprintf('subst = "%s";', $user->subst);
1439     $ret .= $user->myname_innerHTML();
1440
1441     for ($i = 0 ; $i < TABLES_N ; $i++) {
1442
1443       $ret .= $this->table_content($user, $i);
1444
1445       $ret .=  $this->table[$i]->act_content($user);
1446       if ($this->table[$i]->wag_own != -1)
1447         $ret .= sprintf('tra.add(%d, "%s: %s"); ', $i,  $this->user[$this->table[$i]->wag_own]->name, $this->table[$i]->wag_com);
1448       else
1449         $ret .= sprintf('tra.rem(%d); ', $i);
1450     }
1451     $ret .= $this->standup_content($user);
1452     $ret .= "setTimeout(preload_images, 0, g_preload_img_arr, g_imgct); ";
1453
1454     return ($ret);
1455   }
1456
1457
1458   function room_wakeup($user)
1459   {
1460     $table_idx = $user->table;
1461     $table = $this->table[$table_idx];
1462
1463     log_main("WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1464
1465     $curtime = time();
1466
1467     $from_table = ($user->stat == "table");
1468     if ($from_table) {
1469       log_main("WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1470
1471       for ($i = 0 ; $i < $table->player_n ; $i++) {
1472         $user_cur = $this->user[$table->player[$i]];
1473         log_main("PREIMPOST: INLOOP name: ".$user_cur->name);
1474
1475         if ($user->idx_get() != $table->player[$i]) {
1476           $user_cur->stat_set("room");
1477           $user_cur->subst = "sitdown";
1478           $user_cur->laccwr = $curtime;
1479         }
1480         else if ($user->sess != "") {
1481           $user_cur->stat_set("room");
1482           $user_cur->subst = "standup";
1483           $user_cur->laccwr = $curtime;
1484           $user_cur->table = -1;
1485         }
1486       }
1487     }
1488     else {
1489       $user->stat_set("room");
1490       $user->subst = "standup";
1491       $user->laccwr = $curtime;
1492     }
1493
1494     $remove_wagon = FALSE;
1495     if($table->wag_own == $user->idx_get()) {
1496       $table->wag_reset($curtime);
1497       $remove_wagon = TRUE;
1498     }
1499
1500
1501     /* aggiorna l'array dei giocatori al tavolo. */
1502     $table->user_rem($this, $user);
1503
1504     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1505       $user_cur = $this->user[$i];
1506       if ($user_cur->sess == '' || $user_cur->stat != 'room')
1507         continue;
1508
1509       // log_main("VALORI: name: ".$user_cur->name."from_table: ".$from_table."  tab: ".$user_cur->table." taix: ".$table_idx."  ucur: ".$user_cur."  us: ".$user);
1510
1511       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1512       if ($from_table && ($user_cur->table == $table_idx || $user->idx_get() == $i)) {
1513         $ret .= 'gst.st_loc++; xstm.stop(); window.onunload = null; window.onbeforeunload = null; document.location.assign("index.php");|';
1514         // $ret .= 'gst.st_loc++; document.location.assign("index.php");|';
1515         log_main("DOCUMENT.index.php: from table");
1516       }
1517       else if ($user_cur->stat == "room") {
1518         log_main("DOCUMENT.index.php: from table");
1519
1520         $ret .= $this->table_content($user_cur, $table_idx);
1521         $ret .= $this->standup_content($user_cur);
1522
1523         // $ret .= table_act_content(FALSE, 0, $table_idx, $user->table, FALSE);
1524         $ret .= $table->act_content($user);
1525
1526         if ($user->idx_get() == $i) {
1527           // set the new status
1528           $ret .=  'subst = "standup"; tra.show(); ';
1529           // clean the action buttons in other tables
1530           for ($e = 0 ; $e < TABLES_N ; $e++) {
1531             if ($this->table[$e]->player_n < PLAYERS_N) {
1532               $ret .= $this->table[$e]->act_content($user);
1533             }
1534           }
1535         }
1536         else {
1537           $ret .= $table->act_content($user_cur);
1538         }
1539       }
1540       log_wr("ROOM_WAKEUP: ".$ret);
1541       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1542       $user_cur->step_inc();
1543     }
1544   }
1545
1546   function room_join_wakeup($user, $update_lacc = FALSE, $trans_delta)
1547   {
1548     $table_idx = $user->table;
1549     $table = $this->table[$table_idx];
1550
1551     log_main("JOIN_WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1552
1553     $curtime = time();
1554     $user_wup = array();
1555     $user_wup_n = 0;
1556     $user_tab = array();
1557     $user_tab_n = 0;
1558     log_main("JOIN WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1559
1560     for ($i = 0 ; $i < $table->player_n ; $i++) {
1561       $user_cur = $this->user[$table->player[$i]];
1562       log_main("PREIMPOST INLOOP name: ".$user_cur->name);
1563       if ($user_cur->sess != "") {
1564         if ($update_lacc == TRUE) {
1565           $user_cur->laccwr = $curtime;
1566         }
1567         log_main("cur: ".$user_cur->name."  subst: ".$user_cur->subst);
1568         if ($user_cur->subst == "shutdowned") {
1569           $user_cur->stat_set("room");
1570           $user_cur->subst = "sitdown";
1571         }
1572         else if ($user_cur->subst == "shutdowner") {
1573           $user_cur->stat_set("room");
1574           $user_cur->subst = "standup";
1575           $user_cur->table = -1;
1576           $user_wup[$user_wup_n++] = $user_cur;
1577
1578           $remove_wagon = FALSE;
1579           if($table->wag_own == $table->player[$i]) {
1580             $remove_wagon = TRUE;
1581             $table->wag_reset($curtime);
1582           }
1583         }
1584         $user_tab[$user_tab_n++] = $table->player[$i];
1585       }
1586     }
1587
1588     for ($wup_idx = 0 ; $wup_idx < $user_wup_n  ; $wup_idx++)
1589       $table->user_rem($this, $user_wup[$wup_idx]);
1590
1591     /* aggiorna l'array dei giocatori al tavolo. */
1592
1593     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1594       log_main("START LOOP");
1595       $user_cur = $this->user[$i];
1596       if ($user_cur->sess == '' || $user_cur->stat != 'room') {
1597         log_main("name: ".$user_cur->name."skip   subst: ".$user_cur->subst);
1598         continue;
1599       }
1600
1601       log_main("___");
1602       log_main("VALORI name: ".$user_cur->name."  tab: ".$user_cur->table." taix: ".$table_idx);
1603
1604       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1605       if ($user_cur->stat == "room") {
1606         log_main("DOCUMENT.index.php from table");
1607
1608         $ret .= $this->table_content($user_cur, $table_idx);
1609         $ret .= $this->standup_content($user_cur);
1610
1611         $ret .= $table->act_content($user_cur);
1612
1613
1614         for ($tab_idx = 0 ; $tab_idx < $user_tab_n  ; $tab_idx++)
1615             if ($user_tab[$tab_idx] == $i)
1616                 break;
1617
1618         // for users that wakeup the room will be reconstructed by index_rd.php
1619         if ($tab_idx < $user_tab_n) {
1620           log_main("PRE show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1621
1622 //        ARRAY_POP DISABLED
1623 //           if ($trans_delta == 0)
1624 //             while (array_pop($user_cur->comm) != NULL);
1625
1626           $user_cur->trans_step = $user_cur->step + 1 + $trans_delta;
1627           $user_cur->comm[$user_cur->step % COMM_N] = "";
1628           $user_cur->step_inc();
1629           $user_cur->comm[$user_cur->step % COMM_N] = $this->show_room(($user_cur->step + 1), $user_cur);
1630           $user_cur->step_inc();
1631           log_main("POST show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1632
1633           continue;
1634         }
1635         log_main("JOIN_WAKEUP wup_idx ".$wup_idx."  wup_n ".$user_wup_n);
1636
1637         log_main("JOIN_WAKEUP more");
1638
1639         $ret .= $table->act_content($user_cur);
1640
1641         log_main("JOIN_WAKEUP end more");
1642       }
1643       log_wr("ROOM_JOIN_WAKEUP: ".$ret);
1644       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1645       $user_cur->step_inc();
1646     }
1647   }
1648
1649   function guarantee_show($user, $user_login, $dt)
1650   {
1651       GLOBAL $G_lang, $mlang_brisk, $G_base;
1652
1653       $user_code = -1;
1654       $ret = 0;
1655
1656       do {
1657           if ($user_login == "") {
1658               $ret = 1;
1659               break;
1660           }
1661           if (($bdb = BriskDB::create()) == FALSE) {
1662               $ret = 2;
1663               break;
1664           }
1665           if (($user_item = $bdb->getitem_bylogin($user_login, $user_code)) == FALSE) {
1666               $ret = 3;
1667               break;
1668           }
1669           if (($guar_item = $bdb->getitem_bycode($user_item->guar_code_get())) != FALSE) {
1670               $guar_login = $guar_item->login_get();
1671           }
1672           else {
1673               $guar_login = "";
1674           }
1675           $user_tos_vers = $user_item->tos_vers_get();
1676
1677           if (versions_cmp($user_tos_vers, "1.2") < 0) {
1678               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['tos_old'][$G_lang], xcape($user_login)));
1679           }
1680           else if ($guar_login == "") {
1681               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_nfd'][$G_lang], xcape($user_login)));
1682           }
1683           else if ($guar_login == $user_login) {
1684               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_self'][$G_lang], xcape($user_login)));
1685           }
1686           else {
1687               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_info'][$G_lang],
1688                                                 xcape($user_login), xcape($guar_login)));
1689           }
1690       } while (0);
1691
1692       if ($ret > 0) {
1693           $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_err'][$G_lang], $ret));
1694       }
1695
1696       $user->comm[$user->step % COMM_N] = "gst.st = ".($user->step+1)."; ".$mesg;
1697       $user->step_inc();
1698
1699       return TRUE;
1700   }
1701
1702   function room_outstandup($user)
1703   {
1704     $this->room_sitdown($user, -1);
1705   }
1706
1707   function table_update($user)
1708   {
1709     log_main("table_update: pre - USER: ".$user->name);
1710
1711     $table_idx = $user->table;
1712
1713     if ($table_idx > -1)
1714       $table = $this->table[$table_idx];
1715
1716     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1717       $ret = "";
1718       $user_cur = $this->user[$i];
1719       if ($user_cur->sess == '' || $user_cur->stat != 'room')
1720       continue;
1721
1722       $ret = "gst.st = ".($user_cur->step+1)."; ";
1723       if ($table_idx > -1)
1724         $ret .= $this->table_content($user_cur, $table_idx);
1725
1726       if ($user->idx_get() == $i) {
1727           $ret .= $user->myname_innerHTML();
1728       }
1729       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1730       $user_cur->step_inc();
1731     }
1732
1733     log_main("table_update: post");
1734   }
1735
1736   function room_sitdown($user, $table_idx)
1737   {
1738       log_main("room_sitdown ".($user == FALSE ? "USER: FALSE" : "USER: ".$user->name));
1739
1740       $train_app = "";
1741
1742       if ($table_idx > -1 && $table_idx < TABLES_N) {
1743           $table = $this->table[$table_idx];
1744
1745           // wagon shutdown
1746           if ($table->wag_own != -1 && $table->player_n == PLAYERS_N) {
1747               for ($i = 0 ; $i < TABLES_N ; $i++) {
1748                   if ($table->wag_own == $table->player[$i]) {
1749                       $train_app = sprintf("tra.rem(%d); ", $table_idx);
1750                       $table->wag_reset(time());
1751                       break;
1752                   }
1753               }
1754           }
1755       }
1756
1757       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1758           $ret = "";
1759           $user_cur = $this->user[$i];
1760           if ($user_cur->sess == '' || $user_cur->stat != 'room')
1761               continue;
1762
1763           $ret = "gst.st = ".($user_cur->step+1)."; ".$train_app;
1764           if ($table_idx > -1)
1765               $ret .= $this->table_content($user_cur, $table_idx);
1766           $ret .= $this->standup_content($user_cur);
1767
1768           if ($user->idx_get() == $i) {
1769               $ret .=  'subst = "sitdown"; tra.hide(); ';
1770               // clean the action buttons in other tables
1771               for ($e = 0 ; $e < TABLES_N ; $e++) {
1772                   $ret .= $this->table[$e]->act_content($user_cur);
1773               }
1774           }
1775           else if ($table_idx > -1) {
1776               if ($table->player_n == PLAYERS_N) {
1777
1778                   $ret .= $table->act_content($user_cur);
1779               }
1780           }
1781           $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1782           $user_cur->step_inc();
1783       }
1784   }
1785
1786   function chatt_send($user, $mesg)
1787   {
1788     GLOBAL $G_base, $G_alarm_passwd, $mlang_brisk, $G_lang;
1789     $only_you = FALSE;
1790
1791     // common settings
1792     $msg = mb_substr($mesg, 6, 128, "UTF-8");
1793     $curtime = time();
1794     $dt = date("H:i ", $curtime);
1795     $target = "";
1796
1797     //
1798     //  Compute actions
1799     //
1800
1801     $to_user     = FALSE;
1802     $to_all      = FALSE;
1803     $to_room     = FALSE;
1804     $to_tabl     = FALSE;
1805     $is_normchat = FALSE;
1806     /* for old isolation management $is_ticker   = FALSE; */
1807     $update_room = FALSE;
1808
1809     if (strcmp($msg,  "/tav") == 0 ||
1810         strncmp($msg, "/tav ", 5) == 0) {
1811       do {
1812         if ($user->stat != 'room' || $user->subst != 'sitdown') {
1813           /* 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>" */
1814           $msg = $mlang_brisk['tickmust'][$G_lang];
1815           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1816
1817           break;
1818         }
1819
1820         $table = $this->table[$user->table];
1821
1822         if ($table->wag_own != -1) {
1823           // MLANG <br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br>
1824           $msg = $mlang_brisk['tickjust'][$G_lang];
1825           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1826
1827           break;
1828         }
1829
1830         $dtime = $curtime - $table->wag_tout;
1831         if ($dtime  < EXPIRE_TIME_WAG) {
1832           // MLANG - <br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>
1833           $msg = sprintf($mlang_brisk['tickwait'][$G_lang],
1834                          EXPIRE_TIME_WAG - $dtime, (EXPIRE_TIME_WAG - $dtime == 1 ? ($G_lang == 'en' ? "" : "o") : ($G_lang == 'en' ? "s" : "i")));
1835           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang] , 400, 100);
1836
1837           break;
1838         }
1839
1840         $msg = substr($msg, 5);
1841
1842         $table->wag_set($user->idx_get(), $msg);
1843         $to_user = sprintf('tra.add(%d, "%s");', $user->table, xcape(sprintf("%s: %s", $user->name, $msg)));
1844         $to_room = $to_user;
1845         /* for old isolation management $is_ticker = TRUE; */
1846       } while (0);
1847     } // /tav chat command
1848
1849     else if (strncmp($msg, "/alarm ", 7) == 0) {
1850       if (strncmp($msg, "/alarm to ", 10) == 0) {
1851         $sp_pos = strpos($msg, " ", 10);
1852         $target = substr($msg, 10, $sp_pos - 10);
1853         $alarm_check = "/alarm to ".$target." ".$G_alarm_passwd." ";
1854       }
1855       else {
1856         $target = "";
1857         $alarm_check = "/alarm ".$G_alarm_passwd." ";
1858       }
1859       do {
1860         if (strncmp($msg, $alarm_check, strlen($alarm_check)) != 0) {
1861           /* MLANG: "<br>La password digitata non &egrave; corretta.<br><br>" */
1862           $msg = $mlang_brisk['alarpass'][$G_lang];
1863           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 100);
1864
1865           break;
1866         }
1867
1868         /* MLANG: "Alarm <b>%s</b> inviato a <b>%s</b>." */
1869         $prestr = sprintf($mlang_brisk['alarret'][$G_lang], xcape(substr($msg, strlen($alarm_check))),
1870                            ($target == "" ? $mlang_brisk['tit_all'][$G_lang] : xcape($target)) );
1871         $to_user = nickserv_msg($dt, $prestr);
1872
1873         $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
1874                        $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
1875         /* MLANG: "chiudi" */
1876         $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
1877       } while (0);
1878     } // /alarm chat command
1879     else if (strncmp($msg, "/listen ", 8) == 0) {
1880       $arg = substr($msg, 8);
1881
1882       if (strcasecmp($arg, "isolation") == 0) {
1883         $flags_old = 0;
1884         if ($user->stat == 'room' && $user->subst == 'sitdown' &&
1885             $user->table >= TABLES_AUTH_N) {
1886           $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
1887
1888         }
1889         else {
1890           $user->flags &= ~USER_FLAG_MAP_AUTH;
1891           $user->flags |= USER_FLAG_ISOLAUTH;
1892           $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
1893         }
1894       }
1895       else if (strcasecmp($arg, "auth") == 0) {
1896         $flags_old = $user->flags;
1897         $user->flags &= ~USER_FLAG_MAP_AUTH;
1898         $user->flags |= USER_FLAG_LISTAUTH;
1899         $to_user = 'list_set(\'auth\', true, \''.$mlang_brisk['tit_onauth'][$G_lang].'\'); ';
1900       }
1901       else {
1902         $flags_old = $user->flags;
1903         $user->flags &= ~USER_FLAG_MAP_AUTH;
1904         $to_user = 'list_set(\'all\', true, \'\'); ';
1905
1906       }
1907       // if from isolation redraw standup area
1908       if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
1909         $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
1910
1911       }
1912     }
1913     else if (strcmp($msg, "/authreq") == 0) {
1914         if ($user->is_cert()) {
1915             $to_user = sprintf('authbox(300,200);');
1916         }
1917         else {
1918             /* 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." */
1919             $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
1920         }
1921     }
1922     else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
1923         if ($user->is_auth()) {
1924         $to_user = sprintf('mesgtoadmbox(500,300);');
1925       }
1926       else {
1927         /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
1928         $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
1929       }
1930     }
1931     else if (strncmp($msg, "/nick ", 6) == 0) {
1932       log_main("chatt_send BEGIN");
1933
1934       do {
1935         if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
1936           $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
1937           break;
1938         }
1939
1940         $msg = "COMMAND ".$msg;
1941         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1942           $user_cur = $this->user[$i];
1943
1944           if ($user_cur->sess == '')
1945             continue;
1946           if (strcasecmp($user_cur->name,$name_new) == 0)
1947             break;
1948           }
1949         if ($i <  MAX_PLAYERS) {
1950           $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
1951           $to_user = nickserv_msg($dt, $prestr);
1952           break;
1953         }
1954
1955         /* 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>" */
1956         if ($user->is_auth()) {
1957           if (strcasecmp($user->name,$name_new) != 0) {
1958              if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
1959                 ($user->subst == 'standup' ||
1960                  ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
1961                  )
1962                 ) {
1963               $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
1964               for ($i = 0 ; $i < TABLES_N ; $i++) {
1965                 $to_user .= $this->table[$i]->act_content($user);
1966               }
1967             }
1968             else {
1969               $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
1970               break;
1971             }
1972           }
1973         }
1974         $user->name = $name_new; // OK - nick changed
1975         /* se nome gia' in uso, segnala cosa potrebbe capitare */
1976         if ( ! $user->is_auth() ) {
1977             if (($bdb = BriskDB::create()) != FALSE) {
1978                 $bdb->users_load();
1979                 /* 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>" */
1980                 if ($bdb->login_exists($name_new)) {
1981                     $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
1982                     $to_user .= nickserv_msg($dt, $prestr);
1983                 }
1984             }
1985         }
1986
1987         log_main("chatt_send start set");
1988
1989         $update_room = TRUE;
1990       } while (0);
1991     } // nick chat command
1992     else if (strncmp($msg, "/guar ", 6) == 0 || $msg == "/guar") {
1993         $guar_user = substr($msg, 6);
1994
1995         $this->guarantee_show($user, $guar_user, $dt);
1996     }
1997     else if (strncmp($msg, "/st ", 4) == 0) {
1998       log_main("chatt_send BEGIN");
1999
2000       do {
2001         $st_str = substr($msg, 4);
2002
2003         if (strcasecmp($st_str, "normale") == 0) {
2004           $st = USER_FLAG_S_NORM;
2005         }
2006         else if (strcasecmp($st_str, "pausa") == 0) {
2007           $st = USER_FLAG_S_PAU;
2008         }
2009         else if (strcasecmp($st_str, "fuori") == 0) {
2010           $st = USER_FLAG_S_OUT;
2011         }
2012         else if (strcasecmp($st_str, "cane") == 0) {
2013           $st = USER_FLAG_S_DOG;
2014         }
2015         else if (strcasecmp($st_str, "cibo") == 0) {
2016           $st = USER_FLAG_S_EAT;
2017         }
2018         else if (strcasecmp($st_str, "lavoro") == 0) {
2019           $st = USER_FLAG_S_WRK;
2020         }
2021         else if (strcasecmp($st_str, "sigaretta") == 0) {
2022           $st = USER_FLAG_S_SMK;
2023         }
2024         else if (strcasecmp($st_str, "presente") == 0) {
2025           $st = USER_FLAG_S_EYE;
2026         }
2027         else if (strcasecmp($st_str, "coniglio") == 0) {
2028           $st = USER_FLAG_S_RABB;
2029         }
2030         else if (strcasecmp($st_str, "calcio") == 0) {
2031           $st = USER_FLAG_S_SOCC;
2032         }
2033         else if (strcasecmp($st_str, "pupo") == 0) {
2034           $st = USER_FLAG_S_BABY;
2035         }
2036         else if (strcasecmp($st_str, "pulizie") == 0) {
2037           $st = USER_FLAG_S_MOP;
2038         }
2039         else if (strcasecmp($st_str, "babbo") == 0) {
2040           $st = USER_FLAG_S_BABBO;
2041         }
2042         else if (strcasecmp($st_str, "renna") == 0) {
2043           $st = USER_FLAG_S_RENNA;
2044         }
2045         else if (strcasecmp($st_str, "pupazzo") == 0) {
2046           $st = USER_FLAG_S_PUPAZ;
2047         }
2048         else if (strcasecmp($st_str, "vischio") == 0) {
2049           $st = USER_FLAG_S_VISCH;
2050         }
2051         else {
2052           /* MLANG: "Questo stato non esiste." */
2053           $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
2054           break;
2055         }
2056
2057         log_main("chatt_send start set");
2058         if (($user->flags & USER_FLAG_S_ALL) != $st) {
2059           $update_room = TRUE;
2060           $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
2061         }
2062       } while (0);
2063     } // nick chat command
2064
2065     else { // normal chat line
2066       $is_normchat = TRUE;
2067       if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
2068         $only_you = TRUE;
2069         $user->chat_dlt = $user->chat_dlt * 2;
2070         if ($user->chat_dlt > 120)
2071           $user->chat_dlt = 120;
2072       }
2073       else if ($user->chat_lst == $msg)
2074         $only_you = TRUE;
2075       else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2076         $user->chat_ban = $curtime;
2077         $user->chat_dlt = 5;
2078         $only_you = TRUE;
2079       }
2080       else {
2081         $user->chat_ban = 0;
2082         $user->chat_dlt = 0;
2083       }
2084
2085       if ($only_you) {
2086         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2087       }
2088       else {
2089         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2090         // temporary silentiation for troll (will became array check)
2091         // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2092         $to_room = $to_user;
2093       }
2094
2095       log_legal($curtime, $user->ip, $user,
2096                 ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2097
2098       $user->chat_lst = "$msg";
2099       $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2100       $user->chat_cur++;
2101     }
2102
2103     if ($to_all) {
2104       $to_room = $to_all;
2105       $to_tabl = $to_all;
2106     }
2107
2108     //
2109     //  Output to clients
2110     //
2111
2112     if ($to_user != FALSE) {
2113       $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2114       $user->comm[$user->step % COMM_N] .= $to_user;
2115       $user->step_inc();
2116     }
2117
2118     if ($to_room != FALSE) {
2119       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2120         $user_cur = $this->user[$i];
2121         if ($target != "" && $user_cur->name != $target)
2122           continue;
2123         if ($user_cur->sess == '' || $user_cur->stat == 'table' || $user->idx_get() == $i)
2124           continue;
2125
2126         if ($is_normchat == TRUE) {
2127           // use MAP_AUTH to check if auth or isolation
2128           if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2129               if ( ! $user->is_auth() ) {
2130                   continue;
2131               }
2132           }
2133         }
2134         /*
2135         else if ($is_ticker) {
2136           if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2137             if ($user->table >= TABLES_AUTH_N)
2138               continue;
2139           }
2140         }
2141         */
2142         $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2143         $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2144         $user_cur->step_inc();
2145       }
2146     }
2147
2148     if ($to_tabl) {
2149         // FIXME BRISK4: include for each kind of table
2150         require_once("${G_base}briskin5/Obj/briskin5.phh");
2151         // Before all align times with table timeout
2152         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2153             if (isset($this->match[$table_idx])) {
2154                 $bin5 = $this->match[$table_idx];
2155
2156                 $bin5_table = $bin5->table[0];
2157                 for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2158                     // stat must be "table" by definition
2159                     $bin5_user = $bin5->user[$i];
2160
2161                     if ($target != "" && $bin5_user->name != $target)
2162                         continue;
2163                     log_main("writa: ".$user_mesg);
2164                     $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2165                     $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2166                     $bin5_user->step_inc();
2167                 }
2168             } // if (isset($this->match
2169         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2170     } // if ($to_tabl == true ...
2171
2172     if ($update_room) {
2173       if ($user->stat == 'room' && $user->subst == 'standup') {
2174         $this->standup_update($user);
2175       }
2176       else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2177         log_main("chatt_send pre table update");
2178         $this->table_update($user);
2179         log_main("chatt_send post table update");
2180       }
2181     } // if ($update_room ...
2182
2183     return;
2184   } // function chatt_send( ...
2185
2186   function get_user($sess, &$idx)
2187   {
2188     GLOBAL $PHP_SELF;
2189
2190     if (validate_sess($sess)) {
2191       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2192         if (strcmp($sess, $this->user[$i]->sess) == 0) {
2193           // find it
2194           $idx = $i;
2195           $ret = $this->user[$i];
2196           return ($ret);
2197         }
2198       }
2199       log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2200       // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2201       // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2202     }
2203     else {
2204       log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2205     }
2206
2207     return (FALSE);
2208   }
2209
2210   /*
2211    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2212    *
2213    * RETURN VALUE:
2214    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2215    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2216    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2217    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2218    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2219    *   if ($idx == -$idx && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2220    */
2221
2222   function add_user(&$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2223   {
2224     GLOBAL $G_base;
2225
2226     $idx = 0;
2227
2228     $authenticate = FALSE;
2229     $user_type    = 0;
2230     $login_exists = FALSE;
2231     $ghost = -1;
2232     $ghost_auth = FALSE;
2233     $idx = -1;
2234     $idfree = -1;
2235     $code = FALSE;
2236
2237     if (($name_new = validate_name($name)) == FALSE) {
2238       $idx = -2;
2239       return (FALSE);
2240     }
2241
2242     log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2243     if (validate_sess($sess) == FALSE)
2244       $sess = "";
2245
2246     /* if pass != FALSE verify the login with pass */
2247     log_auth("XXX", "auth1");
2248
2249     if (($bdb = BriskDB::create()) != FALSE) {
2250         $bdb->users_load();
2251         if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2252             log_auth("XXX", "auth2");
2253             $authenticate = $bdb->login_verify($name_new, $pass, $code);
2254             log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2255
2256             if ($authenticate != FALSE) {
2257                 $user_type = $authenticate->type_get();
2258             }
2259             else {
2260                 $idx = -3;
2261                 return (FALSE);
2262             }
2263         }
2264         else {
2265             $login_exists =  $bdb->login_exists($name_new);
2266         }
2267     }
2268     else {
2269         // if db is down, send a warning and verify only current users
2270         // no actions at this moment
2271     }
2272     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2273       /* free user ? */
2274       if (strcmp($sess, $this->user[$i]->sess) == 0) {
2275         if ($idx == -1)
2276           $idx = $i;
2277       }
2278       if ($idfree == -1 && strcmp($this->user[$i]->sess, "") == 0) {
2279         $idfree = $i;
2280         continue; // NOTE: CHECK IT !!
2281       }
2282       if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2283           if ($authenticate != FALSE) {
2284               $ghost = $i;
2285               $ghost_auth = $this->user[$i]->is_auth();
2286           }
2287           else {
2288               $idx = $i;
2289               break;
2290           }
2291       }
2292     }
2293     if ($idx == -1)
2294       $idx = $idfree;
2295
2296     log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2297
2298     /* there is another user logged with your account and you and him have authenticated => new user
2299        get the session of the old user */
2300     if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2301       /* swap session */
2302
2303       $ghost_user = $this->user[$ghost];
2304       $curtime = time();
2305       $this->ghost_sess->push($curtime, $ghost_user->sess, GHOST_SESS_REAS_ANOT);
2306       $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2307       $ghost_user->step_inc();
2308       if ($sess == "") {
2309         $sess = uniqid("");
2310         $ghost_user->sess = $sess;
2311       }
2312       else {
2313         $ghost_user->sess = $sess;
2314       }
2315
2316       // If user at the table we need to update the table data too
2317       $table_idx = $ghost_user->table;
2318       if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2319           require_once("${G_base}briskin5/Obj/briskin5.phh");
2320           if (isset($this->match[$table_idx])) {
2321               $bin5 = $this->match[$table_idx];
2322
2323               if ($bin5->the_end != TRUE) {
2324                   $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2325                   $bin5->user[$ghost_user->table_pos]->step_inc();
2326                   $bin5->user[$ghost_user->table_pos]->sess = $sess;
2327               }
2328           }
2329       }
2330
2331       $idx = $ghost;
2332       if (defined('CURL_DE_SAC_VERS')) {
2333           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2334       }
2335       return ($this->user[$ghost]);
2336     }
2337     else if ($idx != -1 && $i == MAX_PLAYERS) {
2338       /* SUCCESS */
2339       $curtime = time();
2340       if ($sess == "") {
2341         $sess = uniqid("");
2342         $this->user[$idx]->sess = $sess;
2343       }
2344       else {
2345         $this->user[$idx]->sess = $sess;
2346       }
2347       $this->user[$idx]->name = $name_new; // OK - add new user
2348       $this->user[$idx]->stat_set("room");
2349       $this->user[$idx]->step_set(0);
2350       while (array_pop($this->user[$idx]->comm) != NULL);
2351       $this->user[$idx]->subst = "standup";
2352       $this->user[$idx]->lacc =   $curtime;
2353       $this->user[$idx]->laccwr = $curtime;
2354       $this->user[$idx]->bantime = 0;
2355       $this->user[$idx]->ip = $ip;
2356
2357       $this->user[$idx]->rec = $authenticate;
2358       $this->user[$idx]->flags = $user_type;
2359       $this->user[$idx]->flags |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2360       $this->user[$idx]->flags |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2361       log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags));
2362
2363       if ($authenticate != FALSE) {
2364           $this->user[$idx]->code = $authenticate->code_get();
2365           if (0 == 1) {
2366               // all this part is included in the db server
2367               $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2368
2369               if (isset($cookie['CO_list'])) {
2370                   fprintf(STDERR, "QQ: %s CO_list: [%s]\n", __FUNCTION__, $cookie['CO_list']);
2371                   if (strcmp($cookie['CO_list'], "auth") == 0) {
2372                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2373                       $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2374                   }
2375                   if (strcmp($cookie['CO_list'], "isolation") == 0) {
2376                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2377                       $this->user[$idx]->flags |= USER_FLAG_ISOLAUTH;
2378                   }
2379                   else {
2380                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2381                   }
2382               }
2383           }
2384           else {
2385               fprintf(STDERR, "QQ: CO_list not set flags: %x\n", __FUNCTION__, $this->user[$idx]->flags);
2386           }
2387       }
2388       fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2389       if ($ghost > -1) {
2390         log_main("ghost: rename!");
2391         $ghost_user = $this->user[$ghost];
2392
2393         if ($ghost_auth == FALSE) {
2394           for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2395             $ghostname = 'ghost'.$sfx;
2396             for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2397               if (strcmp("", $this->user[$i]->sess) == 0)
2398                 continue;
2399
2400               if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2401                 $ghostname = '';
2402                 break;
2403               }
2404             }
2405             if ($ghostname != '')
2406               break;
2407           }
2408
2409           $ghost_user->name = $ghostname;
2410
2411           if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2412             $this->standup_update($ghost_user);
2413           }
2414           else {
2415             log_main("chatt_send pre table update");
2416             $this->table_update($ghost_user);
2417           log_main("chatt_send post table update");
2418           }
2419         } // if ($ghost_auth == FALSE
2420         else {
2421           // FIXME: cacciare il vecchio utente room && table (if needed)
2422           $ghost_user->the_end = TRUE;
2423           $ghost_user->lacc = 0;
2424           $this->garbage_manager(TRUE);
2425         }
2426       } //  if ($ghost > -1) {
2427
2428       $real_idx = $idx;
2429       if ($login_exists)
2430         $idx = -($idx + 1);
2431       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));
2432
2433       $ret = $this->user[$real_idx];
2434       if (defined('CURL_DE_SAC_VERS')) {
2435           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2436       }
2437       return ($ret);
2438     }
2439
2440     return (FALSE);
2441   }
2442
2443   function standup_update($user)
2444   {
2445     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2446       $user_cur = $this->user[$i];
2447       if ($user_cur->sess == '')
2448         continue;
2449
2450       log_main("STANDUP START: ".$user_cur->stat);
2451
2452       if ($user_cur->stat == 'room') {
2453         $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2454         if ($user->idx_get() == $i) {
2455           $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2456         }
2457         log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2458
2459         $user_cur->step_inc();
2460       }
2461     }
2462   }
2463
2464   function dump_data()
2465   {
2466       $brisk_ser = serialize($this);
2467       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2468       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2469           return (TRUE);
2470       }
2471
2472       return (FALSE);
2473   }
2474
2475   function standup_content($user)
2476   {
2477     $ret = "";
2478     $content = "";
2479
2480     if ($user->stat != 'room')
2481       return;
2482
2483     for ($i = 0 , $ct = 0 ; $ct < 4 && $i < MAX_PLAYERS ; $i++) {
2484       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2485         continue;
2486       $ct++;
2487     }
2488
2489     // $content .= sprintf('<table cols=\\"%d\\" class=\\"table_standup\\">', $ct);
2490
2491     $content = ' j_stand_cont( [ ';
2492
2493     $user_cur_id = $user->idx_get();
2494     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2495       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2496         continue;
2497
2498       $flags = $this->user[$i]->flags;
2499
2500       // sql record exists AND last donate > 2013-01-01
2501       if ($this->user[$i]->is_supp_custom()) {
2502           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2503       }
2504       else {
2505           $supp_comp_s = '';
2506       }
2507
2508       if ($this->user[$i]->subst == "standup") {
2509           if ($user_cur_id == $i) {
2510               $flags |= 1;
2511           }
2512
2513           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2514                               xcape($this->user[$i]->name), $supp_comp_s);
2515           $ct++;
2516       }
2517     }
2518     $content .= ' ]);';
2519
2520     return ($content);
2521   }
2522
2523   function table_content($user, $table_idx)
2524   {
2525     $content = "";
2526     $ret = "";
2527     // TODO
2528     //
2529     //   Si possono usare i dati nella classe table
2530     //
2531
2532     $sess = $user->sess;
2533     $table = $this->table[$table_idx];
2534
2535     if ($user->stat != 'room')
2536       return;
2537
2538     $user_cur_id = $user->idx_get();
2539     $content = "[ ";
2540     for ($i = 0 ; $i < $table->player_n ; $i++) {
2541         $user_cur = $this->user[$table->player[$i]];
2542
2543         $flags = $user_cur->flags;
2544
2545         if ($user_cur_id == $table->player[$i])
2546             $flags |= 1;
2547
2548         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2549         if ($user_cur->is_supp_custom())
2550             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2551         else
2552             $supp_comp_s = '';
2553
2554         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2555                             xcape($user_cur->name), $supp_comp_s);
2556     }
2557
2558     $content .= ' ]';
2559
2560     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2561
2562     return ($ret);
2563   }
2564
2565   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2566   {
2567       GLOBAL $G_ban_list, $G_black_list;
2568
2569       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2570       $remote_addr = addrtoipv4($addr);
2571
2572           fprintf(STDERR, "\n\n\n PRE_BLACK_CHECK \n\n\n");
2573       if ($this->black_check($remote_addr)) {
2574           // TODO: waiting async 5 sec before close
2575           fprintf(STDERR, "\n\n\n BLACK_CHECK \n\n\n");
2576           return (FALSE);
2577       }
2578
2579       $enc = get_encoding($header);
2580       if (isset($header['User-Agent'])) {
2581           if (strstr($header['User-Agent'], "MSIE")) {
2582               $transp_type = "htmlfile";
2583           }
2584           else {
2585               $transp_type = "xhr";
2586           }
2587       }
2588       else {
2589           $transp_type = "iframe";
2590       }
2591       force_no_cache($header_out);
2592
2593       switch ($path) {
2594       case "":
2595       case "index.php":
2596           ob_start();
2597           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2598           $content = ob_get_contents();
2599           ob_end_clean();
2600
2601           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2602           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2603           return TRUE;
2604
2605           break;
2606       case "index_wr.php":
2607           //
2608           // Enhance required: in the POST case, after the header you must get content
2609           //                   from the socket, waiting if necessary
2610           //
2611
2612           ob_start();
2613           index_wr_main($this, $addr, $get, $post, $cookie);
2614           $content = ob_get_contents();
2615           ob_end_clean();
2616
2617           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2618           return TRUE;
2619
2620           break;
2621       case "index_rd.php":
2622           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2623               $transp = "iframe";
2624           if ($transp == 'websocket')
2625               $enc = 'plain';
2626
2627           do {
2628               if (!isset($cookie['sess'])
2629                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2630
2631                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2632
2633                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2634                   return TRUE;
2635
2636                   break;
2637               }
2638               $this->sess_cur_set($user->sess);
2639               // close a previous opened index_read_ifra socket, if exists
2640               if (($prev = $user->rd_socket_get()) != NULL) {
2641                   $s_a_p->socks_unset($user->rd_socket_get());
2642                   fclose($user->rd_socket_get());
2643                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2644                   $user->rd_socket_set(NULL);
2645               }
2646
2647               $content = "";
2648               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2649               $response = headers_render($header_out, -1).$user->chunked_content($content);
2650               $response_l = mb_strlen($response, "ASCII");
2651
2652               $wret = @fwrite($new_socket, $response, $response_l);
2653               if ($wret < $response_l) {
2654                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2655                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2656               }
2657               else {
2658                   $user->rd_cache_set("");
2659               }
2660               fflush($new_socket);
2661
2662
2663               $s_a_p->socks_set($new_socket, $user, NULL);
2664               $user->rd_socket_set($new_socket);
2665               printf(" - qui ci siamo - ");
2666               return TRUE;
2667           } while (FALSE);
2668
2669           return FALSE;
2670           break;
2671       case 'test.php':
2672           if (!(BRISK_DEBUG & DBG_ENGI))
2673               return (FALSE);
2674           fprintf(STDERR, "TEST.PHP running\n");
2675           if (isset($post['data'])) {
2676               $content = $post['data'];
2677           }
2678           else {
2679               $content = "NO DATA AVAILABLE";
2680           }
2681           $header_out['Content-Type'] = 'text/plain';
2682           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2683           return TRUE;
2684           break;
2685       default:
2686           /* FAR TODO: move all into an array of registered sub-apps */
2687           $subs = "briskin5/";
2688           $subs_l = strlen($subs);
2689           if (!strncmp($path, $subs, $subs_l)) {
2690               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2691               return ($ret);
2692           }
2693           break;
2694       }
2695
2696       return (FALSE);
2697   }
2698
2699   function match_add($idx, $match)
2700   {
2701       $this->match[$idx] = $match;
2702   }
2703
2704   function match_del($idx)
2705   {
2706       unset($this->match[$idx]);
2707   }
2708
2709   function match_get($idx, $token)
2710   {
2711       if (isset($this->match[$idx])) {
2712           if (   $token == NULL
2713               || $token == $this->match[$idx]->table_token) {
2714               return ($this->match[$idx]);
2715           }
2716       }
2717       return NULL;
2718   }
2719   function sess_cur_set($sess)
2720   {
2721       static::$sess_cur = $sess;
2722   }
2723
2724   static function sess_cur_get()
2725   {
2726       return(static::$sess_cur);
2727   }
2728 } // end class Brisk
2729
2730 function make_seed()
2731 {
2732   list($usec, $sec) = explode(' ', microtime());
2733   return (float) $sec + ((float) $usec * 100000);
2734 }
2735
2736 function btrace_line($ar)
2737 {
2738     GLOBAL $G_btrace_pref_sub;
2739
2740     $ret = "";
2741     for ($i = 0 ; $i < count($ar) ; $i++) {
2742         $with_class = isset($ar[$i]['class']);
2743         $with_file  = isset($ar[$i]['file']);
2744         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2745                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2746                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2747                         ($with_file ? $ar[$i]['line'] : ""));
2748     }
2749
2750     return ($ret);
2751 }
2752
2753 function trace_ftok($id, $add)
2754 {
2755     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2756     $tok=@ftok($id, $add);
2757
2758     log_shme($tok.": ".$id." + ".$add);
2759
2760     return ($tok);
2761 }
2762
2763 function log_mop($step, $log)
2764 {
2765     GLOBAL $PHP_SELF;
2766
2767     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2768         return;
2769
2770     $sess = Brisk::sess_cur_get();
2771     if (isset($sess) == FALSE)
2772         $ssess = "XXXX";
2773     else
2774         $ssess = $sess;
2775
2776     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2777         return;
2778
2779     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2780         $btrace = btrace_line(debug_backtrace());
2781     else
2782         $btrace = "";
2783     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2784         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2785         fclose($fp);
2786     }
2787 }
2788
2789 function log_step($log)
2790 {
2791     GLOBAL $PHP_SELF;
2792
2793     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2794         return;
2795
2796     $sess = Brisk::sess_cur_get();
2797     if (isset($sess) == FALSE)
2798         $ssess = "XXXX";
2799     else
2800         $ssess = $sess;
2801
2802     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2803         return;
2804
2805     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2806         $btrace = btrace_line(debug_backtrace());
2807     else
2808         $btrace = "";
2809     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
2810         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2811         fclose($fp);
2812     }
2813 }
2814
2815
2816
2817 function log_cds($log)
2818 {
2819     GLOBAL $PHP_SELF;
2820
2821     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
2822         return;
2823
2824     $sess = Brisk::sess_cur_get();
2825     if (isset($sess) == FALSE)
2826         $ssess = "XXXX";
2827     else
2828         $ssess = $sess;
2829
2830     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
2831         return;
2832
2833     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2834         $btrace = btrace_line(debug_backtrace());
2835     else
2836         $btrace = "";
2837     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
2838         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2839         fclose($fp);
2840     }
2841 }
2842
2843
2844 function log_only2($log)
2845 {
2846     GLOBAL $PHP_SELF;
2847
2848     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
2849         return;
2850
2851     $sess = Brisk::sess_cur_get();
2852     if (isset($sess) == FALSE)
2853         $ssess = "XXXX";
2854     else
2855         $ssess = $sess;
2856
2857     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
2858         return;
2859
2860     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2861         $btrace = btrace_line(debug_backtrace());
2862     else
2863         $btrace = "";
2864     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2865         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2866         fclose($fp);
2867     }
2868 }
2869
2870 function log_crit($log)
2871 {
2872     GLOBAL $PHP_SELF;
2873
2874     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
2875         return;
2876
2877     $sess = Brisk::sess_cur_get();
2878     if (isset($sess) == FALSE)
2879         $ssess = "XXXX";
2880     else
2881         $ssess = $sess;
2882
2883     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
2884         return;
2885
2886     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2887         $btrace = btrace_line(debug_backtrace());
2888     else
2889         $btrace = "";
2890     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2891         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2892         fclose($fp);
2893     }
2894 }
2895
2896 function log_only($log)
2897 {
2898     GLOBAL $PHP_SELF;
2899
2900     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
2901         return;
2902
2903     $sess = Brisk::sess_cur_get();
2904     if (isset($sess) == FALSE)
2905         $ssess = "XXXX";
2906     else
2907         $ssess = $sess;
2908
2909     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
2910         return;
2911
2912     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2913         $btrace = btrace_line(debug_backtrace());
2914     else
2915         $btrace = "";
2916     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2917         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2918         fclose($fp);
2919     }
2920 }
2921
2922 function log_main($log)
2923 {
2924     GLOBAL $PHP_SELF;
2925
2926     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
2927         return;
2928
2929     $sess = Brisk::sess_cur_get();
2930     if (isset($sess) == FALSE)
2931         $ssess = "XXXX";
2932     else
2933         $ssess = $sess;
2934
2935     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
2936         return;
2937
2938     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2939         $btrace = btrace_line(debug_backtrace());
2940     else
2941         $btrace = "";
2942     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2943         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2944         fclose($fp);
2945     }
2946 }
2947
2948 function log_rd($log)
2949 {
2950     GLOBAL $PHP_SELF;
2951
2952     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
2953         return;
2954
2955     $sess = Brisk::sess_cur_get();
2956     if (isset($sess) == FALSE)
2957         $ssess = "XXXX";
2958     else
2959         $ssess = $sess;
2960
2961     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
2962         return;
2963
2964     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2965         $btrace = btrace_line(debug_backtrace());
2966     else
2967         $btrace = "";
2968     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2969         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2970         fclose($fp);
2971     }
2972 }
2973
2974 function log_rd2($log)
2975 {
2976     GLOBAL $PHP_SELF;
2977
2978     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
2979         return;
2980
2981     $sess = Brisk::sess_cur_get();
2982     if (isset($sess) == FALSE)
2983         $ssess = "XXXX";
2984     else
2985         $ssess = $sess;
2986
2987     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
2988         return;
2989
2990     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2991         $btrace = btrace_line(debug_backtrace());
2992     else
2993         $btrace = "";
2994
2995     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2996         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2997         fclose($fp);
2998     }
2999 }
3000
3001 function log_send($log)
3002 {
3003     GLOBAL $PHP_SELF;
3004
3005     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3006         return;
3007
3008     $sess = Brisk::sess_cur_get();
3009     if (isset($sess) == FALSE)
3010         $ssess = "XXXX";
3011     else
3012         $ssess = $sess;
3013
3014     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3015         return;
3016
3017     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3018         $btrace = btrace_line(debug_backtrace());
3019     else
3020         $btrace = "";
3021     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3022         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3023         fclose($fp);
3024     }
3025 }
3026
3027 function log_lock($log)
3028 {
3029     GLOBAL $PHP_SELF;
3030
3031     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3032         return;
3033
3034     $sess = Brisk::sess_cur_get();
3035     if (isset($sess) == FALSE)
3036         $ssess = "XXXX";
3037     else
3038         $ssess = $sess;
3039
3040     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3041         return;
3042
3043     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3044         $btrace = btrace_line(debug_backtrace());
3045     else
3046         $btrace = "";
3047     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3048         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3049         fclose($fp);
3050     }
3051 }
3052
3053 function log_wr($log)
3054 {
3055     GLOBAL $PHP_SELF;
3056
3057     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3058         return;
3059
3060     $sess = Brisk::sess_cur_get();
3061     if (isset($sess) == FALSE)
3062         $ssess = "XXXX";
3063     else
3064         $ssess = $sess;
3065
3066     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3067         return;
3068
3069     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3070         $btrace = btrace_line(debug_backtrace());
3071     else
3072         $btrace = "";
3073     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3074         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3075         fclose($fp);
3076     }
3077 }
3078
3079 function log_load($log)
3080 {
3081     GLOBAL $PHP_SELF;
3082
3083     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3084         return;
3085
3086     $sess = Brisk::sess_cur_get();
3087     if (isset($sess) == FALSE)
3088         $ssess = "XXXX";
3089     else
3090         $ssess = $sess;
3091
3092     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3093         return;
3094
3095     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3096         $btrace = btrace_line(debug_backtrace());
3097     else
3098         $btrace = "";
3099     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3100         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3101         fclose($fp);
3102     }
3103 }
3104
3105 function log_auth($sess, $log)
3106 {
3107     GLOBAL $PHP_SELF;
3108
3109     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3110         return;
3111
3112     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3113         return;
3114
3115     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3116         $btrace = btrace_line(debug_backtrace());
3117     else
3118         $btrace = "";
3119     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3120         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3121         fclose($fp);
3122     }
3123 }
3124
3125 function log_shme($log)
3126 {
3127     GLOBAL $PHP_SELF;
3128
3129     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3130         return;
3131
3132     $sess = Brisk::sess_cur_get();
3133     if (isset($sess) == FALSE)
3134         $ssess = "XXXX";
3135     else
3136         $ssess = $sess;
3137
3138     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3139         return;
3140
3141     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3142         $btrace = btrace_line(debug_backtrace());
3143     else
3144         $btrace = "";
3145     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3146         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3147         fclose($fp);
3148     }
3149 }
3150
3151
3152
3153 // function log_legal($curtime, $sess, $name, $where, $mesg)
3154 function log_legal($curtime, $addr, $user, $where, $mesg)
3155 {
3156
3157   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3158     /* Unix time | session | nickname | IP | where was | mesg */
3159     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
3160                         ($user->is_auth() ? 'A' : 'N'),
3161                         $user->name, $addr, $where , $mesg));
3162     fclose($fp);
3163   }
3164 }
3165
3166 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3167 {
3168   $ret = "";
3169
3170   if ($isstanding) {
3171     if ($sitted < PLAYERS_N) {
3172       if ($allowed)
3173         $act = 'sit';
3174       else
3175         $act = 'reserved';
3176     }
3177   }
3178   else {
3179     if ($table == $cur_table)
3180       $act = 'wake';
3181     else
3182       $act = 'none';
3183   }
3184
3185   if ($act != '')
3186     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3187
3188   return ($ret);
3189 }
3190
3191 function show_notify($text, $tout, $butt, $w, $h)
3192 {
3193   log_main("SHOW_NOTIFY: ".$text);
3194   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3195 }
3196
3197 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3198 {
3199   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3200   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);
3201 }
3202
3203 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3204 {
3205   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3206
3207   $butts = "";
3208   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3209       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3210   }
3211
3212   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3213                  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);
3214 }
3215
3216
3217 function root_welcome($user)
3218 {
3219   GLOBAL $root_wellarr, $G_lang;
3220   $ret = "";
3221
3222   $curtime = time();
3223   $dt = date("H:i ", $curtime);
3224
3225   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3226       $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3227
3228   return ($ret);
3229 }
3230
3231
3232
3233 function validate_sess($sess)
3234 {
3235   if (strlen($sess) == SESS_LEN)
3236     return (TRUE);
3237   else
3238     return (FALSE);
3239 }
3240
3241 function validate_name($name)
3242 {
3243     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3244
3245   for ($i = 0 ; $i < strlen($name_new) ; $i++) {
3246     $c = $name_new[$i];
3247     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3248       return ($name_new);
3249   }
3250
3251   return (FALSE);
3252 }
3253
3254 function playsound($filename)
3255 {
3256   return (sprintf('playsound("flasou", "%s");', $filename));
3257 }
3258
3259 function secstoword($secs)
3260 {
3261   GLOBAL $G_lang;
3262
3263   $ret = "";
3264
3265   $mins = floor($secs / 60);
3266   $secs = $secs % 60;
3267   if ($G_lang == 'en') {
3268     if ($mins > 0)
3269       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3270
3271     if ($secs > 0)
3272       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3273   }
3274   else {
3275     if ($mins > 0)
3276       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3277
3278     if ($secs > 0)
3279       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3280   }
3281   return ($ret);
3282 }
3283
3284 function sharedmem_sz($tok)
3285 {
3286   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3287     log_main("shmop_open failed");
3288     return (-1);
3289   }
3290   $shm_sz = shmop_size($shm_id);
3291   shmop_close($shm_id);
3292
3293   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3294   return ($shm_sz);
3295 }
3296
3297 class Warrant {
3298     static $delta_t;
3299
3300   static function lock_data($is_exclusive)
3301   {
3302       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3303           self::$delta_t = microtime(TRUE);
3304           log_lock("LOCK   warrant      [".self::$delta_t."]");
3305
3306           return ($res);
3307       }
3308
3309       return (FALSE);
3310   }
3311
3312   static function unlock_data($res)
3313   {
3314     GLOBAL $sess;
3315
3316     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3317
3318     file_unlock($res);
3319   }
3320 }
3321
3322 class Poll {
3323     static $delta_t;
3324
3325   static function lock_data($is_exclusive)
3326   {
3327       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3328           self::$delta_t = microtime(TRUE);
3329           log_lock("LOCK   poll         [".self::$delta_t."]");
3330
3331           return ($res);
3332       }
3333
3334       return (FALSE);
3335   }
3336
3337   static function unlock_data($res)
3338   {
3339     GLOBAL $sess;
3340
3341     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3342
3343     file_unlock($res);
3344   }
3345 }
3346
3347 function carousel_top()
3348 {
3349     $what = rand(1,2);
3350     if ($what == 1) {
3351         $rn = rand(1, 3);
3352         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));
3353         }
3354     else {
3355         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>'));
3356     }
3357 }
3358
3359
3360 ?>