web/Obj/brisk.phh

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