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