web/Obj/brisk.phh

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