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