web/Obj/brisk.phh

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