web/Obj/brisk.phh

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