web/Obj/brisk.phh

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