web/Obj/brisk.phh

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