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