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