web/Obj/brisk.phh

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