brisk.phh

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