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