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