web/Obj/brisk.phh

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