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.4";
 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, nuovi colori',
 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 nickserv_msg($dt, $msg) {
 346     return sprintf('chatt_sub("%s",[0x040003,"%s"],"%s");', $dt, NICKSERV, $msg);
 347 }
 348
 349 function passwd_gen($seed = NULL)
 350 {
 351     GLOBAL $G_PG_vow, $G_PG_vow_n, $G_PG_cons, $G_PG_cons_n;
 352
 353     $pw = "";
 354
 355     if ($seed != NULL)
 356         mt_srand($seed);
 357     else
 358         mt_srand();
 359
 360     for ($sil = 0 ; $sil < 7 ; $sil++) {
 361         if (($sil % 2) == 0) {
 362             // vowels
 363             for ($n = 0 ; $n < mt_rand(1,2) ; $n++) {
 364                 if ($n == 0) {
 365                     $old = mt_rand(0, $G_PG_vow_n-1);
 366                     $pw .= $G_PG_vow[$old];
 367                 }
 368                 else {
 369                     $new = mt_rand(0, $G_PG_vow_n-1);
 370                     if ($new == $old)
 371                         $new = ($new + mt_rand(0, $G_PG_vow_n-2)) % $G_PG_vow_n;
 372                     $pw .= $G_PG_vow[$new];
 373                 }
 374             }
 375         }
 376         else {
 377             // consonants
 378             $pw .= $G_PG_cons[mt_rand(0, $G_PG_cons_n-1)];
 379         }
 380     }
 381
 382     return $pw;
 383 }
 384
 385 function cmd_return($val, $desc)
 386 {
 387     return array('val' => $val, 'desc' => $desc);
 388 }
 389
 390 function cmd_serialize($attrs)
 391 {
 392     $ret = "";
 393
 394     $sep = "";
 395     foreach ($attrs as $key => $value) {
 396         $ret .= $sep . $key . '=' . urlencode($value);
 397         $sep = "&";
 398     }
 399     return $ret;
 400 }
 401
 402 function cmd_deserialize($cmd)
 403 {
 404     $ret = array();
 405     $a = explode('&', $cmd);
 406     $i = 0;
 407     while ($i < count($a)) {
 408         $b = split('=', $a[$i]);
 409         $ret[urldecode($b[0])] = urldecode($b[1]);
 410         $i++;
 411     }
 412
 413     return $ret;
 414 }
 415
 416 //  return values
 417 // -1 v1 < v2
 418 //  0 equal
 419 //  1 v1 > v2
 420 function versions_cmp($v1, $v2)
 421 {
 422     // printf("V1: [%s]\nV2: [%s]\n", $v1, $v2);
 423     if ($v1 == $v2)
 424         return 0;
 425
 426     $v1_ar = split('\.', $v1);
 427     $v2_ar = split('\.', $v2);
 428
 429     $v2_ct = count($v2_ar);
 430
 431     for ($i = 0 ; $i < count($v1_ar) ; $i++) {
 432         if (($v2_ct - 1) < $i) {
 433             break;
 434         }
 435         // printf("here [%s] [%s]\n", $v1_ar[$i], $v2_ar[$i]);
 436         if ($v1_ar[$i] != $v2_ar[$i]) {
 437             if (strval($v1_ar[$i]) < strval($v2_ar[$i]))
 438                 return -1;
 439             else
 440                 return  1;
 441         }
 442     }
 443     return 0;
 444 }
 445
 446 function addrtoipv4($addr)
 447 {
 448     $ipv4addr_arr = explode(':' , $addr);
 449     if (isset($ipv4addr_arr[3])) {
 450         $ipv4addr = $ipv4addr_arr[3];
 451     }
 452     else {
 453         $ipv4addr = $addr;
 454     }
 455     return $ipv4addr;
 456 }
 457
 458 function mop_flush()
 459 {
 460     for ($i = 0; $i < ob_get_level(); $i++)
 461         ob_end_flush();
 462     ob_implicit_flush(1);
 463     flush();
 464 }
 465
 466 function force_no_cache(&$header_out)
 467 {
 468     $header_out['Pragma'] = 'no-cache, must-revalidate';
 469     $header_out['Cache-Control'] = 'no-cache';
 470     $header_out['Expires'] = '-1';
 471 }
 472
 473 function file_lock($fname, $is_exclusive)
 474 {
 475     if (($res = @fopen($fname, "r+")) == FALSE) {
 476         return (FALSE);
 477     }
 478
 479     if (flock($res, ($is_exclusive ? LOCK_EX : LOCK_SH)) == FALSE) {
 480         fclose($res);
 481         return (FALSE);
 482     }
 483
 484     return ($res);
 485 }
 486
 487 function file_unlock($res)
 488 {
 489     if ($res != FALSE) {
 490         flock($res, LOCK_UN);
 491         fclose($res);
 492     }
 493 }
 494
 495 $escpush_from = array("\\", "\"");
 496 $escpush_to   = array("\\\\", "\\\"");
 497 function escpush($s)
 498 {
 499     GLOBAL $escpush_from, $escpush_to;
 500
 501     return str_replace($escpush_from, $escpush_to, $s);
 502 }
 503
 504 $escinp_from = array( "\""     );
 505 $escinp_to = array(   "&quot;" );
 506
 507 function escinput($s)
 508 {
 509     GLOBAL $escinp_from, $escinp_to;
 510
 511     return str_replace($escinp_from, $escinp_to, $s);
 512 }
 513
 514 function eschtml($s)
 515 {
 516     return htmlentities($s, ENT_COMPAT, "UTF-8");
 517 }
 518
 519 function esclfhtml($s)
 520 {
 521     return str_replace(" ", "&nbsp;", str_replace("\n", "<br>", htmlspecialchars($s)));
 522 }
 523
 524 function langtolng($lang)
 525 {
 526   GLOBAL $G_lang;
 527
 528   return ($G_lang == 'en' ? '-en' : '');
 529 }
 530
 531 function csplitter($in, $sep)
 532 {
 533   $st = 0;
 534   $id = 0;
 535   $out = array();
 536   $out[$id] = "";
 537   for ($i = 0 ; $i < strlen($in) ; $i++) {
 538     $ini = substr($in, $i, 1);
 539     if ($st == 0) {
 540       if ($ini == '\\')
 541         $st = 1;
 542       else if ($ini == $sep) {
 543         $id++;
 544         $out[$id] = "";
 545       }
 546       else {
 547         $out[$id] .= $ini;
 548       }
 549     }
 550     else if ($st == 1) {
 551       $out[$id] .= $ini;
 552       $st = 0;
 553     }
 554   }
 555
 556   return ($out);
 557 }
 558
 559 function xcape($s)
 560 {
 561   $from = array (   '\\',     '@',        '|' );
 562   $to   = array ( '\\\\', '&#64;', '&brvbar;' );
 563
 564   return (str_replace($from, $to, htmlentities($s,ENT_COMPAT,"UTF-8")));
 565 }
 566
 567 function xcapelt($s)
 568 {
 569   $from = array (   '\\',     '|',  "\t",  "\n");
 570   $to   = array ( '\\\\',   '\\|', "\\t", "\\n");
 571
 572   return (str_replace($from, $to, $s));
 573 }
 574
 575 function xcapemesg($s)
 576 {
 577   $from = array (  "\n");
 578   $to   = array ( "\\n");
 579
 580   return (str_replace($from, $to, $s));
 581 }
 582
 583
 584 class IPClass {
 585     var $addr;
 586     var $mask;
 587
 588     function IPClass($ipset)
 589     {
 590         //split
 591         $elem = split("/", $ipset, 2);
 592         $addr = $elem[0];
 593         $mask = (int)$elem[1];
 594
 595         //convert mask
 596
 597         $this->mask = ((1<<($mask))-1) << (32 - $mask);
 598         $this->addr = ip2long($addr) & $this->mask;
 599
 600         fprintf(STDERR, "New ipclass: %x (%x)\n", $this->addr, $this->mask);
 601     }
 602
 603     function match($ip)
 604     {
 605         fprintf(STDERR, "IP: %x, ADDR: %x, MASK: %x -> (%d)\n",
 606                 $ip, $this->addr, $this->mask, ((ip2long($ip) & $this->mask) == $this->addr));
 607         return (($ip & $this->mask) == $this->addr);
 608     }
 609 }
 610
 611 class Vect {
 612     function Vect($a)
 613     {
 614         $this->el = $a;
 615     }
 616
 617     function getbyid($idx)
 618     {
 619         return ($this->el[$idx]);
 620     }
 621
 622     function setbyid($idx, $v)
 623     {
 624         $this->el[$idx] = $v;
 625     }
 626 }
 627
 628 define('TABLE_AUTH_TY_PUBL', 0);
 629 define('TABLE_AUTH_TY_AUTH', 1);
 630 define('TABLE_AUTH_TY_CERT', 2);
 631
 632
 633 class Table {
 634   var $idx;
 635   var $player;
 636   var $player_n;
 637
 638   var $auth_type;     // required authorization to sit down
 639
 640   var $wag_own;
 641   var $wag_com;
 642   var $wag_tout;
 643
 644   var $table_token;
 645   var $table_start;   // information field
 646
 647   var $wakeup_time;
 648
 649   function Table()
 650   {
 651   }
 652
 653   function create($idx)
 654   {
 655     if (($thiz = new Table()) == FALSE)
 656       return (FALSE);
 657
 658     $thiz->idx       =   $idx;
 659     $thiz->player    =   array();
 660     $thiz->player_n  =   0;
 661
 662     if ($idx < TABLES_CERT_N)
 663         $thiz->auth_type =   TABLE_AUTH_TY_CERT;
 664     else if ($idx < TABLES_AUTH_N)
 665         $thiz->auth_type =   TABLE_AUTH_TY_AUTH;
 666     else
 667         $thiz->auth_type =   TABLE_AUTH_TY_PUBL;
 668
 669     $thiz->wag_own   =  -1;
 670     $thiz->wag_com   =  "";
 671     $thiz->wag_tout   =  0;
 672
 673     $thiz->table_token  = "";
 674     $thiz->table_start  = 0;
 675
 676     $thiz->wakeup_time = 0;
 677
 678     return ($thiz);
 679   }
 680
 681   function copy($from)
 682   {
 683     $this->idx = $from->idx;
 684     $this->player = array();
 685     for ($i = 0 ; $i < $from->player_n ; $i++)
 686       $this->player[$i] = $from->player[$i];
 687     $this->player_n = $from->player_n;
 688
 689     log_main("PLAYER_N - parent::copy.".$this->player_n);
 690
 691     $this->auth_type =  $from->auth_type;
 692
 693     $this->wag_own   =  $from->wag_own;
 694     $this->wag_com   =  $from->wag_com;
 695     $this->wag_tout  =  $from->wag_tout;
 696
 697     $this->table_token  = $from->table_token;
 698     $this->table_start  = $from->table_start;
 699
 700     $this->wakeup_time = $from->wakeup_time;
 701   }
 702
 703   function myclone($from)
 704   {
 705     if (($thiz = new Table()) == FALSE)
 706       return (FALSE);
 707
 708     $this->copy($from);
 709
 710     return ($thiz);
 711   }
 712
 713   function spawn($from)
 714   {
 715     if (($thiz = new Table()) == FALSE)
 716       return (FALSE);
 717
 718     $thiz->idx = $from->idx;
 719     $thiz->player = array();
 720     for ($i = 0 ; $i < $from->player_n ; $i++)
 721       $thiz->player[$i] = $i;
 722     $thiz->player_n = $from->player_n;
 723
 724     $thiz->auth_type =  $from->auth_type;
 725
 726     $thiz->wag_own = $from->wag_own;
 727     $thiz->wag_com = $from->wag_com;
 728     $thiz->wag_tout  =  $from->wag_tout;
 729
 730     $thiz->table_token  = $from->table_token;
 731     $thiz->table_start  = $from->table_start;
 732
 733     $thiz->wakeup_time = $from->wakeup_time;
 734
 735     return ($thiz);
 736   }
 737
 738   function wag_set($user_idx, $mesg)
 739   {
 740     log_main("WAG_SET");
 741
 742     $this->wag_own  =  $user_idx;
 743     $this->wag_com  =  $mesg;
 744     $this->wag_tout =  0;
 745   }
 746
 747   function wag_reset($timeout)
 748   {
 749     log_main("WAG_RESET");
 750
 751     unset($this->wag_own);
 752     $this->wag_own  = -1;
 753     $this->wag_com  = "";
 754     $this->wag_tout = $timeout;
 755   }
 756
 757   function player_get($idx)
 758   {
 759     return ($this->player[$idx]);
 760   }
 761
 762   function player_set($idx, $player)
 763   {
 764     $this->player[$idx] = $player;
 765   }
 766
 767   function user_add($idx)
 768   {
 769     $this->player[$this->player_n] = $idx;
 770     $this->player_n++;
 771
 772     return ($this->player_n - 1);
 773   }
 774
 775   function user_rem($brisk, $user)
 776   {
 777     $tabpos = $user->table_pos;
 778
 779     /* verifico la consistenza dei dati */
 780     if ($brisk->user[$this->player[$tabpos]] == $user) {
 781
 782       /* aggiorna l'array dei giocatori al tavolo. */
 783       for ($i = $tabpos ; $i < $this->player_n-1 ; $i++) {
 784         $this->player[$i] = $this->player[$i+1];
 785         $user_cur = $brisk->user[$this->player[$i]];
 786         $user_cur->table_pos = $i;
 787       }
 788       $this->player_n--;
 789     }
 790     else {
 791       log_main("INCONSISTENCY ON TABLE.");
 792     }
 793   }
 794
 795   // Table->act_content - return 'id' of type of output required for table button
 796   function act_content($user)
 797   {
 798     $ret = "";
 799     $isstanding = ($user->subst == 'standup');
 800     $sitted = $this->player_n;
 801     $table = $this->idx;
 802     $cur_table = $user->table;
 803     $allowed = TRUE;
 804
 805     if ($isstanding) {
 806       if ($sitted < PLAYERS_N) {
 807           switch ($this->auth_type) {
 808           case TABLE_AUTH_TY_CERT:
 809               if ($user->is_cert())
 810                   $act = "sitcert";
 811               else
 812                   $act = 'resercert';
 813               break;
 814           case TABLE_AUTH_TY_AUTH:
 815               if ($user->is_auth())
 816                   $act = "sitreser";
 817               else
 818                   $act = 'reserved';
 819               break;
 820           default:
 821               $act = 'sit';
 822               break;
 823           }
 824       }
 825       else {
 826         $act = 'none';
 827       }
 828     }
 829     else {
 830       if ($table == $cur_table)
 831         $act = 'wake';
 832       else
 833         $act = 'none';
 834     }
 835
 836     if ($act != '')
 837       $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
 838
 839     return ($ret);
 840   }
 841 } // end class Table
 842
 843
 844 class Delay_Manager
 845 {
 846     var $delta;
 847     var $lastckeck;
 848     var $triglevel;
 849
 850     function Delay_Manager($triglevel)
 851     {
 852         $this->triglevel = $triglevel;
 853         $this->delta = array();
 854         $this->lastcheck = 0;
 855     }
 856
 857     function delta_get($curtime)
 858     {
 859         // clean too old delta items
 860         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 861             if ($this->delta[$i][0] < $curtime) {
 862                 array_splice($this->delta, $i, 1);
 863                 $i--;
 864             }
 865         }
 866
 867         // add new delta items if delay exceeded $this->triglevel sec
 868         if ($curtime > $this->lastcheck + $this->triglevel && $curtime < $this->lastcheck + 1200.0) {
 869             $delta = $curtime - $this->lastcheck - $this->triglevel;
 870             array_push($this->delta, array($curtime + $delta , $delta));
 871             // fprintf(STDERR, "DELTA: add new delta [%f] [%f] [%f]\n", $this->triglevel, $curtime + $delta, $delta);
 872         }
 873
 874         // extract the maximum valid delta
 875         $delta_max = 0.0;
 876         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 877             $delta_cur = $this->delta[$i][1];
 878             if ($delta_max < $delta_cur)
 879                 $delta_max = $delta_cur;
 880         }
 881
 882         // fprintf(STDERR, "DELTA: status %d, delta_max: %f\n", count($this->delta), $delta_max);
 883
 884         return ($delta_max);
 885     }
 886
 887     function lastcheck_set($curtime)
 888     {
 889         $this->lastcheck = $curtime;
 890     }
 891 }
 892
 893 class Client_prefs {
 894     var $listen;
 895     var $supp_comp;
 896
 897     function Client_prefs()
 898     {
 899     }
 900
 901     static function from_user($user)
 902     {
 903         $thiz = new Client_prefs();
 904         $thiz->user_load($user);
 905
 906         return ($thiz);
 907     }
 908
 909     static function from_json($json)
 910     {
 911         $thiz = new Client_prefs();
 912         if ($thiz->json_load($json) == FALSE) {
 913             unset($thiz);
 914             return (FALSE);
 915         }
 916
 917         return ($thiz);
 918     }
 919
 920     function user_load($user)
 921     {
 922         fprintf(STDERR, "QQ %s: %x\n", __FUNCTION__, $user->flags);
 923         $this->listen = ($user->flags & USER_FLAG_MAP_AUTH) >> 2;
 924         if ($user->rec != FALSE) {
 925             $this->supp_comp = $user->rec->supp_comp_get();
 926         }
 927         else {
 928             $this->supp_comp = "000000000000";
 929         }
 930
 931         fprintf(STDERR, "QQ %s: LISTEN: %d\n", __FUNCTION__, $this->listen);
 932     }
 933
 934     function json_load($json_s)
 935     {
 936         $ret = FALSE;
 937
 938         do {
 939             if (gettype($json_s) == "string") {
 940                 if (($json = json_decode($json_s)) == FALSE)
 941                     break;
 942             }
 943             else {
 944                 $json = $json_s;
 945             }
 946             if ($this->listen < 0 || $this->listen > 2)
 947                 break;
 948             $this->listen = $json->listen;
 949
 950             if (mb_strlen($json->supp_comp, "ASCII") != 12)
 951                 break;
 952
 953             for ($i = 0, $idx = 0 ; $i < 12 ; $i++) {
 954                 if (($json->supp_comp[$i] >= '0' && $json->supp_comp[$i] <= '9') ||
 955                     ($json->supp_comp[$i] >= 'a' && $json->supp_comp[$i] <= 'f'))
 956                     continue;
 957                 break;
 958             }
 959             if ($i < 12)
 960                 break;
 961             $this->supp_comp = $json->supp_comp;
 962             $ret = TRUE;
 963         } while (FALSE);
 964
 965         return ($ret);
 966     }
 967
 968     function store($user, $is_save)
 969     {
 970         // save into DB
 971         fprintf(STDERR, "QQ %s::%s PRE: %x\n", __CLASS__, __FUNCTION__,
 972                 $user->flags & (~USER_FLAG_S_ALL & ~USER_FLAG_AUTH));
 973         $user->flags_set(($this->listen << 2), USER_FLAG_MAP_AUTH);
 974         fprintf(STDERR, "QQ %s::%s %x\n", __CLASS__, __FUNCTION__,
 975                 $user->flags);
 976         if ($user->is_supp_custom()) {
 977             $user->rec->supp_comp_set($this->supp_comp);
 978         }
 979         if ($is_save)
 980             $user->prefs_store();
 981     }
 982 }
 983
 984
 985 class Brisk
 986 {
 987     static $delta_t;
 988
 989     var $crystal_filename;
 990     var $user;
 991     var $table;
 992     var $match;
 993     var $comm; // commands for many people
 994     var $step; // current step of the comm array
 995     var $garbage_timeout;
 996     var $shm_sz;
 997
 998     var $ban_list;  // ban list (authized allowed)
 999     var $black_list;  // black list (anti-dos, noone allowed)
1000
1001     var $delay_mgr;
1002
1003     public static $sess_cur;
1004
1005     function Brisk()
1006     {
1007     }
1008
1009     // constructor
1010     static function create($crystal_filename, $ban_list, $black_list) {
1011         if (($brisk_ser = @file_get_contents($crystal_filename)) != FALSE) {
1012             if (($brisk = unserialize($brisk_ser)) != FALSE) {
1013                 fprintf(STDERR, "ROOM FROM FILE\n");
1014                 rename($crystal_filename, $crystal_filename.".old");
1015
1016                 $brisk->reload($ban_list, $black_list);
1017
1018                 return($brisk);
1019             }
1020         }
1021
1022         fprintf(STDERR, "NEW ROOM\n");
1023         $thiz = new Brisk();
1024
1025         $thiz->crystal_filename = $crystal_filename;
1026         $thiz->user  = array();
1027         $thiz->table = array();
1028         $thiz->match = array();
1029
1030         $thiz->ban_list = NULL;
1031         $thiz->black_list = NULL;
1032
1033         fprintf(STDERR, "PRE IPCLASS_UPDATE (%d, %d)\n", count($ban_list), count($black_list));
1034         $thiz->ipclass_update('ban_list', $ban_list);
1035         $thiz->ipclass_update('black_list', $black_list);
1036         fprintf(STDERR, "POST IPCLASS_UPDATE %d %d\n", count($thiz->ban_list), count($thiz->black_list));
1037
1038         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1039             $thiz->user[$i] = User::create($thiz, $i, "", "");
1040         }
1041
1042         for ($i = 0 ; $i < TABLES_N ; $i++) {
1043             $thiz->table[$i] = Table::create($i);
1044         }
1045         $thiz->garbage_timeout = 0;
1046         $thiz->shm_sz = SHM_DIMS_MIN;
1047
1048         $thiz->delay_mgr = new Delay_Manager(1.5);
1049
1050         static::$sess_cur = FALSE;
1051
1052         return ($thiz);
1053     }
1054
1055     function ipclass_update($ip_out_s, $ip_in)
1056     {
1057         fprintf(STDERR, "N_IN: %d\n", count($ip_in));
1058
1059         $ip_out = &$this->$ip_out_s;
1060
1061         // if already set clean the ban_list property
1062         if ($ip_out) {
1063             $ct = count($ip_out);
1064             for ($i = 0 ; $i < $ct ; $i++) {
1065                 unset($ip_out[$i]);
1066             }
1067             unset($ip_out);
1068         }
1069
1070         $ip_out = array();
1071         for ($i = 0 ; $i < count($ip_in) ; $i++) {
1072             $ip_out[$i] = new IPClass($ip_in[$i]);
1073         }
1074     }
1075
1076     function reload($ban_list, $black_list)
1077     {
1078         fprintf(STDERR, "RELOAD STUFF (%d)(%d)\n", count($ban_list), count($black_list));
1079
1080         $this->ipclass_update("ban_list", $ban_list);
1081         $this->ipclass_update("black_list", $black_list);
1082
1083         $this->banned_kickoff();
1084         $this->garbage_manager(TRUE);
1085     }
1086
1087     function banned_kickoff()
1088     {
1089         $is_ban = FALSE;
1090
1091         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1092             $table_cur = $this->table[$table_idx];
1093             // if the table is complete and exists we check users IP
1094
1095             if ($table_cur->player_n == PLAYERS_N) {
1096                 if (isset($this->match[$table_idx]) &&
1097                     $table_cur->table_token == $bin5->table_token) {
1098                     log_main("PLAYERS == N TABLE ".$table_idx);
1099
1100                     $bin5 = $this->match[$table_idx];
1101
1102                     $is_ban |= $bin5->banned_kickoff();
1103                 }
1104             }
1105         }
1106
1107         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1108             $user_cur = $this->user[$i];
1109
1110             if ($user_cur->sess == "")
1111                 continue;
1112
1113             // check if the IP is blacklisted
1114             if ($this->black_check($user_cur->ip)) {
1115                 $user_cur->lacc = 0;
1116                 $is_ban = TRUE;
1117                 continue;
1118             }
1119
1120             // if authorized not check if banlisted
1121             if ($user_cur->is_auth()) {
1122                 continue;
1123             }
1124
1125             if ($this->ban_check($user_cur->ip)) {
1126                 $user_cur->lacc = 0;
1127                 $is_ban = TRUE;
1128             }
1129         }
1130
1131         return $is_ban;
1132     }
1133
1134     function ban_check($ip_str)
1135     {
1136         $ip = ip2long($ip_str);
1137         fprintf(STDERR, "Brisk::ban_check %d\n", count($this->ban_list));
1138         for ($i = 0 ; $i < count($this->ban_list) ; $i++) {
1139             fprintf(STDERR, "ban_list[%d] = %x (%x)\n", $i,
1140                     $this->ban_list[$i]->addr, $this->ban_list[$i]->mask);
1141             if ($this->ban_list[$i]->match($ip)) {
1142                 fprintf(STDERR, "\n\nMATCHA!\n\n");
1143                 return(TRUE);
1144             }
1145         }
1146         return (FALSE);
1147     }
1148
1149     function black_check($ip_str)
1150     {
1151         $ip = ip2long($ip_str);
1152         fprintf(STDERR, "Brisk::black_check %d\n", count($this->black_list));
1153         for ($i = 0 ; $i < count($this->black_list) ; $i++) {
1154             fprintf(STDERR, "black_list[%d] = %x (%x)\n", $i,
1155                    $this->black_list[$i]->addr, $this->black_list[$i]->mask);
1156             if ($this->black_list[$i]->match($ip)) {
1157                 fprintf(STDERR, "\n\nMATCHA!\n\n");
1158                 return(TRUE);
1159             }
1160         }
1161         return (FALSE);
1162     }
1163
1164   function garbage_manager($force)
1165   {
1166     GLOBAL $G_lang, $mlang_brisk, $G_base;
1167
1168     $ismod = FALSE;
1169
1170     log_rd2("garbage_manager START");
1171
1172     /* Garbage collector degli utenti in timeout */
1173     $curtime = microtime(TRUE);
1174
1175     $delta = $this->delay_mgr->delta_get($curtime);
1176
1177     if (!$force && !($this->garbage_timeout < $curtime)) {
1178         $this->delay_mgr->lastcheck_set($curtime);
1179         return ($ismod);
1180     }
1181
1182     // Before all align times with table timeout
1183     for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1184         $table_cur = $this->table[$table_idx];
1185         // if the table is complete and exists its shared mem we get the info about users lacc
1186
1187         if ($table_cur->player_n == PLAYERS_N) {
1188             log_main("PLAYERS == N TABLE ".$table_idx);
1189
1190
1191             $no_recovery = FALSE;
1192             if (isset($this->match[$table_idx])) {
1193                 $bin5 = $this->match[$table_idx];
1194
1195                 if ($table_cur->table_token != $bin5->table_token) {
1196                     log_main("ERROR: not matching table_token. Brisk: ".$table_cur->table_token."  Table: ".$bin5->table_token);
1197                     log_main("ERROR: not matching table_start. Brisk: ".$table_cur->table_start."  Table: ".$bin5->table_start);
1198                     $no_recovery = TRUE;
1199                     $bin5 = FALSE;
1200                 }
1201
1202                 if ($bin5 != FALSE) {
1203                     //
1204                     //  SPAWN: JOIN
1205                     //
1206                     log_main("garbage_manager: bri loaded successfully.");
1207                     $bin5->garbage_manager(TRUE);
1208
1209                     $bin5_table = $bin5->table[0];
1210
1211                     // is the end of the table
1212
1213                     if ($bin5->the_end == TRUE) {
1214                         /*
1215                          *  DESTROY OF FINISHED TABLE && MOVE PLAYER TO ROOM AGAIN
1216                          */
1217                         log_main("garbage_manager: INSIDE THE END.");
1218
1219                         $plist = "$table_cur->table_token|$table_cur->idx|$table_cur->player_n";
1220                         for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1221                             $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1222                         }
1223
1224                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1225                             // stat must be "table" by definition
1226                             $user_cur = $this->user[$table_cur->player[$i]];
1227                             $bin5_user = $bin5->user[$i];
1228
1229                             $user_cur->subst      = $bin5_user->subst;
1230                             $user_cur->step       = $bin5_user->step;
1231                             $user_cur->lacc       = $bin5_user->lacc;
1232                             $user_cur->laccwr     = $bin5_user->lacc;
1233                             $user_cur->bantime    = $bin5_user->bantime;
1234                         }
1235
1236                         log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME", $plist);
1237
1238                         $this->room_join_wakeup($user_cur, FALSE, 0);
1239                         $table_cur->table_token = "";
1240                         $table_cur->wakeup_time = $curtime + WAKEUP_TIME;
1241
1242                         $this->match_del($table_idx);
1243                     }
1244                     else {
1245                         log_main("gm:: save_data");
1246
1247                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1248                             $this->user[$table_cur->player[$i]]->lacc = $bin5->user[$i]->lacc;
1249                         }
1250                     }
1251                 } // if ($bin5 == FALSE
1252                 else if ($no_recovery == FALSE) {
1253                     log_crit("ERROR: table ".$table_idx." unrecoverable join");
1254
1255                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1256                         $user_cur = $this->user[$table_cur->player[$i]];
1257                         $user_cur->subst = "shutdowner";
1258                         $user_cur->step_inc();
1259
1260                         $ret = sprintf('stat = "%s"; subst = "%s";',  $user_cur->stat, $user_cur->subst);
1261                         $ret .= "gst.st = ".($user_cur->step+1)."; ";
1262                         // MLANG <br>I dati del tavolo n&deg; ".$user_cur->table." sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>
1263                         $prestr = sprintf($mlang_brisk['tabincon'][$G_lang], $user_cur->table);
1264                         $ret .= show_notify($prestr, 2000, $mlang_brisk['btn_close'][$G_lang], 400, 110);
1265                         $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1266                         $user_cur->step_inc();
1267                     }
1268
1269                     $plist = "$table_cur->table_token|$user_cur->table|$table_cur->player_n";
1270                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1271                         $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1272                     }
1273                     log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME(RECOVERY)", $plist);
1274
1275                     $this->room_join_wakeup($user_cur, TRUE, -2);
1276                     $table_cur->table_token = "";
1277                 }
1278             }
1279         } //  if ($table_cur->player_n == PLAYERS_N) {
1280     } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1281
1282     log_rd2("out new loop.");
1283
1284     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1285         $user_cur = $this->user[$i];
1286
1287         log_rd2("User: ".$user_cur->name."  stat: ".$user_cur->stat."  subst: ".$user_cur->subst);
1288
1289         if ($user_cur->sess == "")
1290             continue;
1291
1292         if ($user_cur->lacc + EXPIRE_TIME_RD < ($curtime - $delta)) {
1293             // Auto logout dell'utente
1294             log_rd2("AUTO LOGOUT.".($user_cur->lacc + EXPIRE_TIME_RD)." curtime - delta ".($curtime - $delta));
1295
1296             if ($user_cur->stat == 'table' || $user_cur->stat == 'room') {
1297                 log_auth($user_cur->sess, "Autologout session.");
1298
1299                 $user_cur->reset();
1300
1301                 log_rd2("AUTO LOGOUT.");
1302                 if ($user_cur->subst == 'sitdown' || $user_cur->stat == 'table')
1303                     $this->room_wakeup($user_cur);
1304                 else if ($user_cur->subst == 'standup')
1305                     $this->room_outstandup($user_cur);
1306                 else
1307                     log_rd2("LOGOUT FROM WHAT ???");
1308             }
1309         }
1310
1311         if ($user_cur->laccwr + EXPIRE_TIME_SMAMMA < ($curtime - $delta)) { // lo rimettiamo in piedi
1312             if ($user_cur->stat == 'room' && $user_cur->subst == 'sitdown') {
1313                 $this->room_wakeup($user_cur);
1314                 $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ";
1315                 /* 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" */
1316                 $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);
1317                 $user_cur->step_inc();
1318             }
1319         }
1320     }
1321     log_rd2("GARBAGE UPDATED!");
1322
1323     $this->garbage_timeout = $curtime + GARBAGE_TIMEOUT;
1324     $ismod = TRUE;
1325
1326     $this->delay_mgr->lastcheck_set($curtime);
1327     return ($ismod);
1328   }
1329
1330   function show_room($user_step, $user)
1331   {
1332     GLOBAL $G_lang, $mlang_brisk;
1333     log_main("show_room: username: ".$user->name);
1334
1335     $ret = sprintf('gst.st = %d; ',  $user_step);
1336
1337     $prefs = Client_prefs::from_user($user);
1338     $ret .= sprintf('prefs_load(\'%s\', false, false);', json_encode($prefs));
1339
1340     if(false) {
1341         if ($user->flags & USER_FLAG_ISOLAUTH) {
1342             $ret .= 'list_set(\'isolation\', false, \''.$mlang_brisk['tit_onisol'][$G_lang].'\' ); ';
1343         }
1344         else if ($user->flags & USER_FLAG_LISTAUTH) {
1345             $ret .= 'list_set(\'auth\', false, \''.$mlang_brisk['tit_onauth'][$G_lang].'\' ); ';
1346         }
1347         else {
1348             $ret .= 'list_set(\'all\', false, \'\' ); ';
1349         }
1350     }
1351
1352     if ($user->subst == 'standup')
1353       $ret .= "tra.show(); ";
1354     else
1355       $ret .= "tra.hide(); ";
1356
1357     $ret .= sprintf('stat = "%s";',  $user->stat);
1358
1359     $ret .= root_welcome($user);
1360     if ($user->flags & USER_FLAG_DBFAILED) {
1361         $ret .= "gst.st = ".($user->step+1)."; ";
1362         $ret .= show_notify($mlang_brisk['db_failed'][$G_lang], 0, $mlang_brisk['btn_close'][$G_lang], 400, 140);
1363     }
1364
1365     $ret .= sprintf('subst = "%s";', $user->subst);
1366     $ret .= $user->myname_innerHTML();
1367
1368     for ($i = 0 ; $i < TABLES_N ; $i++) {
1369
1370       $ret .= $this->table_content($user, $i);
1371
1372       $ret .=  $this->table[$i]->act_content($user);
1373       if ($this->table[$i]->wag_own != -1)
1374         $ret .= sprintf('tra.add(%d, "%s: %s"); ', $i,  $this->user[$this->table[$i]->wag_own]->name, $this->table[$i]->wag_com);
1375       else
1376         $ret .= sprintf('tra.rem(%d); ', $i);
1377     }
1378     $ret .= $this->standup_content($user);
1379     $ret .= "setTimeout(preload_images, 0, g_preload_img_arr, g_imgct); ";
1380
1381     return ($ret);
1382   }
1383
1384
1385   function room_wakeup($user)
1386   {
1387     $table_idx = $user->table;
1388     $table = $this->table[$table_idx];
1389
1390     log_main("WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1391
1392     $curtime = time();
1393
1394     $from_table = ($user->stat == "table");
1395     if ($from_table) {
1396       log_main("WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1397
1398       for ($i = 0 ; $i < $table->player_n ; $i++) {
1399         $user_cur = $this->user[$table->player[$i]];
1400         log_main("PREIMPOST: INLOOP name: ".$user_cur->name);
1401
1402         if ($user->idx_get() != $table->player[$i]) {
1403           $user_cur->stat_set("room");
1404           $user_cur->subst = "sitdown";
1405           $user_cur->laccwr = $curtime;
1406         }
1407         else if ($user->sess != "") {
1408           $user_cur->stat_set("room");
1409           $user_cur->subst = "standup";
1410           $user_cur->laccwr = $curtime;
1411           $user_cur->table = -1;
1412         }
1413       }
1414     }
1415     else {
1416       $user->stat_set("room");
1417       $user->subst = "standup";
1418       $user->laccwr = $curtime;
1419     }
1420
1421     $remove_wagon = FALSE;
1422     if($table->wag_own == $user->idx_get()) {
1423       $table->wag_reset($curtime);
1424       $remove_wagon = TRUE;
1425     }
1426
1427
1428     /* aggiorna l'array dei giocatori al tavolo. */
1429     $table->user_rem($this, $user);
1430
1431     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1432       $user_cur = $this->user[$i];
1433       if ($user_cur->sess == '' || $user_cur->stat != 'room')
1434         continue;
1435
1436       // log_main("VALORI: name: ".$user_cur->name."from_table: ".$from_table."  tab: ".$user_cur->table." taix: ".$table_idx."  ucur: ".$user_cur."  us: ".$user);
1437
1438       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1439       if ($from_table && ($user_cur->table == $table_idx || $user->idx_get() == $i)) {
1440         $ret .= 'gst.st_loc++; xstm.stop(); window.onunload = null; window.onbeforeunload = null; document.location.assign("index.php");|';
1441         // $ret .= 'gst.st_loc++; document.location.assign("index.php");|';
1442         log_main("DOCUMENT.index.php: from table");
1443       }
1444       else if ($user_cur->stat == "room") {
1445         log_main("DOCUMENT.index.php: from table");
1446
1447         $ret .= $this->table_content($user_cur, $table_idx);
1448         $ret .= $this->standup_content($user_cur);
1449
1450         // $ret .= table_act_content(FALSE, 0, $table_idx, $user->table, FALSE);
1451         $ret .= $table->act_content($user);
1452
1453         if ($user->idx_get() == $i) {
1454           // set the new status
1455           $ret .=  'subst = "standup"; tra.show(); ';
1456           // clean the action buttons in other tables
1457           for ($e = 0 ; $e < TABLES_N ; $e++) {
1458             if ($this->table[$e]->player_n < PLAYERS_N) {
1459               $ret .= $this->table[$e]->act_content($user);
1460             }
1461           }
1462         }
1463         else {
1464           $ret .= $table->act_content($user_cur);
1465         }
1466       }
1467       log_wr("ROOM_WAKEUP: ".$ret);
1468       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1469       $user_cur->step_inc();
1470     }
1471   }
1472
1473   function room_join_wakeup($user, $update_lacc = FALSE, $trans_delta)
1474   {
1475     $table_idx = $user->table;
1476     $table = $this->table[$table_idx];
1477
1478     log_main("JOIN_WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1479
1480     $curtime = time();
1481     $user_wup = array();
1482     $user_wup_n = 0;
1483     $user_tab = array();
1484     $user_tab_n = 0;
1485     log_main("JOIN WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1486
1487     for ($i = 0 ; $i < $table->player_n ; $i++) {
1488       $user_cur = $this->user[$table->player[$i]];
1489       log_main("PREIMPOST INLOOP name: ".$user_cur->name);
1490       if ($user_cur->sess != "") {
1491         if ($update_lacc == TRUE) {
1492           $user_cur->laccwr = $curtime;
1493         }
1494         log_main("cur: ".$user_cur->name."  subst: ".$user_cur->subst);
1495         if ($user_cur->subst == "shutdowned") {
1496           $user_cur->stat_set("room");
1497           $user_cur->subst = "sitdown";
1498         }
1499         else if ($user_cur->subst == "shutdowner") {
1500           $user_cur->stat_set("room");
1501           $user_cur->subst = "standup";
1502           $user_cur->table = -1;
1503           $user_wup[$user_wup_n++] = $user_cur;
1504
1505           $remove_wagon = FALSE;
1506           if($table->wag_own == $table->player[$i]) {
1507             $remove_wagon = TRUE;
1508             $table->wag_reset($curtime);
1509           }
1510         }
1511         $user_tab[$user_tab_n++] = $table->player[$i];
1512       }
1513     }
1514
1515     for ($wup_idx = 0 ; $wup_idx < $user_wup_n  ; $wup_idx++)
1516       $table->user_rem($this, $user_wup[$wup_idx]);
1517
1518     /* aggiorna l'array dei giocatori al tavolo. */
1519
1520     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1521       log_main("START LOOP");
1522       $user_cur = $this->user[$i];
1523       if ($user_cur->sess == '' || $user_cur->stat != 'room') {
1524         log_main("name: ".$user_cur->name."skip   subst: ".$user_cur->subst);
1525         continue;
1526       }
1527
1528       log_main("___");
1529       log_main("VALORI name: ".$user_cur->name."  tab: ".$user_cur->table." taix: ".$table_idx);
1530
1531       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1532       if ($user_cur->stat == "room") {
1533         log_main("DOCUMENT.index.php from table");
1534
1535         $ret .= $this->table_content($user_cur, $table_idx);
1536         $ret .= $this->standup_content($user_cur);
1537
1538         $ret .= $table->act_content($user_cur);
1539
1540
1541         for ($tab_idx = 0 ; $tab_idx < $user_tab_n  ; $tab_idx++)
1542             if ($user_tab[$tab_idx] == $i)
1543                 break;
1544
1545         // for users that wakeup the room will be reconstructed by index_rd.php
1546         if ($tab_idx < $user_tab_n) {
1547           log_main("PRE show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1548
1549 //        ARRAY_POP DISABLED
1550 //           if ($trans_delta == 0)
1551 //             while (array_pop($user_cur->comm) != NULL);
1552
1553           $user_cur->trans_step = $user_cur->step + 1 + $trans_delta;
1554           $user_cur->comm[$user_cur->step % COMM_N] = "";
1555           $user_cur->step_inc();
1556           $user_cur->comm[$user_cur->step % COMM_N] = $this->show_room(($user_cur->step + 1), $user_cur);
1557           $user_cur->step_inc();
1558           log_main("POST show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1559
1560           continue;
1561         }
1562         log_main("JOIN_WAKEUP wup_idx ".$wup_idx."  wup_n ".$user_wup_n);
1563
1564         log_main("JOIN_WAKEUP more");
1565
1566         $ret .= $table->act_content($user_cur);
1567
1568         log_main("JOIN_WAKEUP end more");
1569       }
1570       log_wr("ROOM_JOIN_WAKEUP: ".$ret);
1571       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1572       $user_cur->step_inc();
1573     }
1574   }
1575
1576   function guarantee_show($user, $user_login, $dt)
1577   {
1578       GLOBAL $G_lang, $mlang_brisk, $G_base;
1579
1580       $user_code = -1;
1581       $ret = 0;
1582
1583       do {
1584           if ($user_login == "") {
1585               $ret = 1;
1586               break;
1587           }
1588           if (($bdb = BriskDB::create()) == FALSE) {
1589               $ret = 2;
1590               break;
1591           }
1592           if (($user_item = $bdb->getitem_bylogin($user_login, $user_code)) == FALSE) {
1593               $ret = 3;
1594               break;
1595           }
1596           if (($guar_item = $bdb->getitem_bycode($user_item->guar_code_get())) != FALSE) {
1597               $guar_login = $guar_item->login_get();
1598           }
1599           else {
1600               $guar_login = "";
1601           }
1602           $user_tos_vers = $user_item->tos_vers_get();
1603
1604           if (versions_cmp($user_tos_vers, "1.2") < 0) {
1605               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['tos_old'][$G_lang], xcape($user_login)));
1606           }
1607           else if ($guar_login == "") {
1608               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_nfd'][$G_lang], xcape($user_login)));
1609           }
1610           else if ($guar_login == $user_login) {
1611               $mesg = nickserv_msg($dt, sprintf($mlang_brisk['gua_self'][$G_lang], xcape($user_login)));
1612           }
1613           else {
1614               $mesg = nickserv_msg($dt, 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 = nickserv_msg($dt, 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 = nickserv_msg($dt, $prestr);
1799
1800         $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
1801                        $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
1802         /* MLANG: "chiudi" */
1803         $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
1804       } while (0);
1805     } // /alarm chat command
1806     else if (strncmp($msg, "/listen ", 8) == 0) {
1807       $arg = substr($msg, 8);
1808
1809       if (strcasecmp($arg, "isolation") == 0) {
1810         $flags_old = 0;
1811         if ($user->stat == 'room' && $user->subst == 'sitdown' &&
1812             $user->table >= TABLES_AUTH_N) {
1813           $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
1814
1815         }
1816         else {
1817           $user->flags &= ~USER_FLAG_MAP_AUTH;
1818           $user->flags |= USER_FLAG_ISOLAUTH;
1819           $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
1820         }
1821       }
1822       else if (strcasecmp($arg, "auth") == 0) {
1823         $flags_old = $user->flags;
1824         $user->flags &= ~USER_FLAG_MAP_AUTH;
1825         $user->flags |= USER_FLAG_LISTAUTH;
1826         $to_user = 'list_set(\'auth\', true, \''.$mlang_brisk['tit_onauth'][$G_lang].'\'); ';
1827       }
1828       else {
1829         $flags_old = $user->flags;
1830         $user->flags &= ~USER_FLAG_MAP_AUTH;
1831         $to_user = 'list_set(\'all\', true, \'\'); ';
1832
1833       }
1834       // if from isolation redraw standup area
1835       if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
1836         $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
1837
1838       }
1839     }
1840     else if (strcmp($msg, "/authreq") == 0) {
1841         if ($user->is_cert()) {
1842             $to_user = sprintf('authbox(300,200);');
1843         }
1844         else {
1845             /* 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." */
1846             $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
1847         }
1848     }
1849     else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
1850         if ($user->is_auth()) {
1851         $to_user = sprintf('mesgtoadmbox(500,300);');
1852       }
1853       else {
1854         /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
1855         $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
1856       }
1857     }
1858     else if (strncmp($msg, "/nick ", 6) == 0) {
1859       log_main("chatt_send BEGIN");
1860
1861       do {
1862         if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
1863           $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
1864           break;
1865         }
1866
1867         $msg = "COMMAND ".$msg;
1868         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1869           $user_cur = $this->user[$i];
1870
1871           if ($user_cur->sess == '')
1872             continue;
1873           if (strcasecmp($user_cur->name,$name_new) == 0)
1874             break;
1875           }
1876         if ($i <  MAX_PLAYERS) {
1877           $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
1878           $to_user = nickserv_msg($dt, $prestr);
1879           break;
1880         }
1881
1882         /* 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>" */
1883         if ($user->is_auth()) {
1884           if (strcasecmp($user->name,$name_new) != 0) {
1885              if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
1886                 ($user->subst == 'standup' ||
1887                  ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
1888                  )
1889                 ) {
1890               $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
1891               for ($i = 0 ; $i < TABLES_N ; $i++) {
1892                 $to_user .= $this->table[$i]->act_content($user);
1893               }
1894             }
1895             else {
1896               $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
1897               break;
1898             }
1899           }
1900         }
1901         $user->name = $name_new; // OK - nick changed
1902         /* se nome gia' in uso, segnala cosa potrebbe capitare */
1903         if ( ! $user->is_auth() ) {
1904             if (($bdb = BriskDB::create()) != FALSE) {
1905                 $bdb->users_load();
1906                 /* 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>" */
1907                 if ($bdb->login_exists($name_new)) {
1908                     $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
1909                     $to_user .= nickserv_msg($dt, $prestr);
1910                 }
1911             }
1912         }
1913
1914         log_main("chatt_send start set");
1915
1916         $update_room = TRUE;
1917       } while (0);
1918     } // nick chat command
1919     else if (strncmp($msg, "/guar ", 6) == 0 || $msg == "/guar") {
1920         $guar_user = substr($msg, 6);
1921
1922         $this->guarantee_show($user, $guar_user, $dt);
1923     }
1924     else if (strncmp($msg, "/st ", 4) == 0) {
1925       log_main("chatt_send BEGIN");
1926
1927       do {
1928         $st_str = substr($msg, 4);
1929
1930         if (strcasecmp($st_str, "normale") == 0) {
1931           $st = USER_FLAG_S_NORM;
1932         }
1933         else if (strcasecmp($st_str, "pausa") == 0) {
1934           $st = USER_FLAG_S_PAU;
1935         }
1936         else if (strcasecmp($st_str, "fuori") == 0) {
1937           $st = USER_FLAG_S_OUT;
1938         }
1939         else if (strcasecmp($st_str, "cane") == 0) {
1940           $st = USER_FLAG_S_DOG;
1941         }
1942         else if (strcasecmp($st_str, "cibo") == 0) {
1943           $st = USER_FLAG_S_EAT;
1944         }
1945         else if (strcasecmp($st_str, "lavoro") == 0) {
1946           $st = USER_FLAG_S_WRK;
1947         }
1948         else if (strcasecmp($st_str, "sigaretta") == 0) {
1949           $st = USER_FLAG_S_SMK;
1950         }
1951         else if (strcasecmp($st_str, "presente") == 0) {
1952           $st = USER_FLAG_S_EYE;
1953         }
1954         else if (strcasecmp($st_str, "coniglio") == 0) {
1955           $st = USER_FLAG_S_RABB;
1956         }
1957         else if (strcasecmp($st_str, "calcio") == 0) {
1958           $st = USER_FLAG_S_SOCC;
1959         }
1960         else if (strcasecmp($st_str, "pupo") == 0) {
1961           $st = USER_FLAG_S_BABY;
1962         }
1963         else if (strcasecmp($st_str, "pulizie") == 0) {
1964           $st = USER_FLAG_S_MOP;
1965         }
1966         else if (strcasecmp($st_str, "babbo") == 0) {
1967           $st = USER_FLAG_S_BABBO;
1968         }
1969         else if (strcasecmp($st_str, "renna") == 0) {
1970           $st = USER_FLAG_S_RENNA;
1971         }
1972         else if (strcasecmp($st_str, "pupazzo") == 0) {
1973           $st = USER_FLAG_S_PUPAZ;
1974         }
1975         else if (strcasecmp($st_str, "vischio") == 0) {
1976           $st = USER_FLAG_S_VISCH;
1977         }
1978         else {
1979           /* MLANG: "Questo stato non esiste." */
1980           $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
1981           break;
1982         }
1983
1984         log_main("chatt_send start set");
1985         if (($user->flags & USER_FLAG_S_ALL) != $st) {
1986           $update_room = TRUE;
1987           $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
1988         }
1989       } while (0);
1990     } // nick chat command
1991
1992     else { // normal chat line
1993       $is_normchat = TRUE;
1994       if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
1995         $only_you = TRUE;
1996         $user->chat_dlt = $user->chat_dlt * 2;
1997         if ($user->chat_dlt > 120)
1998           $user->chat_dlt = 120;
1999       }
2000       else if ($user->chat_lst == $msg)
2001         $only_you = TRUE;
2002       else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2003         $user->chat_ban = $curtime;
2004         $user->chat_dlt = 5;
2005         $only_you = TRUE;
2006       }
2007       else {
2008         $user->chat_ban = 0;
2009         $user->chat_dlt = 0;
2010       }
2011
2012       if ($only_you) {
2013         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2014       }
2015       else {
2016         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2017         // temporary silentiation for troll (will became array check)
2018         // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2019         $to_room = $to_user;
2020       }
2021
2022       log_legal($curtime, $user->ip, $user,
2023                 ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2024
2025       $user->chat_lst = "$msg";
2026       $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2027       $user->chat_cur++;
2028     }
2029
2030     if ($to_all) {
2031       $to_room = $to_all;
2032       $to_tabl = $to_all;
2033     }
2034
2035     //
2036     //  Output to clients
2037     //
2038
2039     if ($to_user != FALSE) {
2040       $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2041       $user->comm[$user->step % COMM_N] .= $to_user;
2042       $user->step_inc();
2043     }
2044
2045     if ($to_room != FALSE) {
2046       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2047         $user_cur = $this->user[$i];
2048         if ($target != "" && $user_cur->name != $target)
2049           continue;
2050         if ($user_cur->sess == '' || $user_cur->stat == 'table' || $user->idx_get() == $i)
2051           continue;
2052
2053         if ($is_normchat == TRUE) {
2054           // use MAP_AUTH to check if auth or isolation
2055           if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2056               if ( ! $user->is_auth() ) {
2057                   continue;
2058               }
2059           }
2060         }
2061         /*
2062         else if ($is_ticker) {
2063           if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2064             if ($user->table >= TABLES_AUTH_N)
2065               continue;
2066           }
2067         }
2068         */
2069         $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2070         $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2071         $user_cur->step_inc();
2072       }
2073     }
2074
2075     if ($to_tabl) {
2076         // FIXME BRISK4: include for each kind of table
2077         require_once("${G_base}briskin5/Obj/briskin5.phh");
2078         // Before all align times with table timeout
2079         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2080             if (isset($this->match[$table_idx])) {
2081                 $bin5 = $this->match[$table_idx];
2082
2083                 $bin5_table = $bin5->table[0];
2084                 for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2085                     // stat must be "table" by definition
2086                     $bin5_user = $bin5->user[$i];
2087
2088                     if ($target != "" && $bin5_user->name != $target)
2089                         continue;
2090                     log_main("writa: ".$user_mesg);
2091                     $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2092                     $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2093                     $bin5_user->step_inc();
2094                 }
2095             } // if (isset($this->match
2096         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2097     } // if ($to_tabl == true ...
2098
2099     if ($update_room) {
2100       if ($user->stat == 'room' && $user->subst == 'standup') {
2101         $this->standup_update($user);
2102       }
2103       else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2104         log_main("chatt_send pre table update");
2105         $this->table_update($user);
2106         log_main("chatt_send post table update");
2107       }
2108     } // if ($update_room ...
2109
2110     return;
2111   } // function chatt_send( ...
2112
2113   function get_user($sess, &$idx)
2114   {
2115     GLOBAL $PHP_SELF;
2116
2117     if (validate_sess($sess)) {
2118       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2119         if (strcmp($sess, $this->user[$i]->sess) == 0) {
2120           // find it
2121           $idx = $i;
2122           $ret = $this->user[$i];
2123           return ($ret);
2124         }
2125       }
2126       log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2127       // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2128       // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2129     }
2130     else {
2131       log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2132     }
2133
2134     return (FALSE);
2135   }
2136
2137   /*
2138    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip)
2139    *
2140    * RETURN VALUE:
2141    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2142    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2143    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2144    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2145    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2146    *   if ($idx == -$idx && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2147    */
2148
2149   function add_user(&$sess, &$idx, $name, $pass, $ip, $cookie)
2150   {
2151     GLOBAL $G_base;
2152
2153     $idx = 0;
2154
2155     $authenticate = FALSE;
2156     $user_type    = 0;
2157     $login_exists = FALSE;
2158     $ghost = -1;
2159     $ghost_auth = FALSE;
2160     $idx = -1;
2161     $idfree = -1;
2162     $code = FALSE;
2163
2164     if (($name_new = validate_name($name)) == FALSE) {
2165       $idx = -2;
2166       return (FALSE);
2167     }
2168
2169     log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2170     if (validate_sess($sess) == FALSE)
2171       $sess = "";
2172
2173     /* if pass != FALSE verify the login with pass */
2174     log_auth("XXX", "auth1");
2175
2176     if (($bdb = BriskDB::create()) != FALSE) {
2177         $bdb->users_load();
2178         if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2179             log_auth("XXX", "auth2");
2180             $authenticate = $bdb->login_verify($name_new, $pass, $code);
2181             log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2182
2183             if ($authenticate != FALSE) {
2184                 $user_type = $authenticate->type_get();
2185             }
2186             else {
2187                 $idx = -3;
2188                 return (FALSE);
2189             }
2190         }
2191         else {
2192             $login_exists =  $bdb->login_exists($name_new);
2193         }
2194     }
2195     else {
2196         // if db is down, send a warning and verify only current users
2197         // no actions at this moment
2198     }
2199     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2200       /* free user ? */
2201       if (strcmp($sess, $this->user[$i]->sess) == 0) {
2202         if ($idx == -1)
2203           $idx = $i;
2204       }
2205       if ($idfree == -1 && strcmp($this->user[$i]->sess, "") == 0) {
2206         $idfree = $i;
2207         continue; // NOTE: CHECK IT !!
2208       }
2209       if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2210           if ($authenticate != FALSE) {
2211               $ghost = $i;
2212               $ghost_auth = $this->user[$i]->is_auth();
2213           }
2214           else {
2215               $idx = $i;
2216               break;
2217           }
2218       }
2219     }
2220     if ($idx == -1)
2221       $idx = $idfree;
2222
2223     log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2224
2225     /* there is another user logged with your account and you and him have authenticated => new user
2226        get the session of the old user */
2227     if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2228       /* swap session */
2229
2230       $ghost_user = $this->user[$ghost];
2231       $curtime = time();
2232       $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2233       $ghost_user->step_inc();
2234       if ($sess == "") {
2235         $sess = uniqid("");
2236         $ghost_user->sess = $sess;
2237       }
2238       else {
2239         $ghost_user->sess = $sess;
2240       }
2241
2242       // If user at the table we need to update the table data too
2243       $table_idx = $ghost_user->table;
2244       if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2245           require_once("${G_base}briskin5/Obj/briskin5.phh");
2246           if (isset($this->match[$table_idx])) {
2247               $bin5 = $this->match[$table_idx];
2248
2249               if ($bin5->the_end != TRUE) {
2250                   $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2251                   $bin5->user[$ghost_user->table_pos]->step_inc();
2252                   $bin5->user[$ghost_user->table_pos]->sess = $sess;
2253               }
2254           }
2255       }
2256
2257       $idx = $ghost;
2258       return ($this->user[$ghost]);
2259     }
2260     else if ($idx != -1 && $i == MAX_PLAYERS) {
2261       /* SUCCESS */
2262       $curtime = time();
2263       if ($sess == "") {
2264         $sess = uniqid("");
2265         $this->user[$idx]->sess = $sess;
2266       }
2267       else {
2268         $this->user[$idx]->sess = $sess;
2269       }
2270       $this->user[$idx]->name = $name_new; // OK - add new user
2271       $this->user[$idx]->stat_set("room");
2272       $this->user[$idx]->step_set(0);
2273       while (array_pop($this->user[$idx]->comm) != NULL);
2274       $this->user[$idx]->subst = "standup";
2275       $this->user[$idx]->lacc =   $curtime;
2276       $this->user[$idx]->laccwr = $curtime;
2277       $this->user[$idx]->bantime = 0;
2278       $this->user[$idx]->ip = $ip;
2279
2280       $this->user[$idx]->rec = $authenticate;
2281       $this->user[$idx]->flags = $user_type;
2282       $this->user[$idx]->flags |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2283       $this->user[$idx]->flags |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2284       log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags));
2285
2286       if ($authenticate != FALSE) {
2287           $this->user[$idx]->code = $authenticate->code_get();
2288           if (0 == 1) {
2289               // all this part is included in the db server
2290               $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2291
2292               if (isset($cookie['CO_list'])) {
2293                   fprintf(STDERR, "QQ: %s CO_list: [%s]\n", __FUNCTION__, $cookie['CO_list']);
2294                   if (strcmp($cookie['CO_list'], "auth") == 0) {
2295                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2296                       $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2297                   }
2298                   if (strcmp($cookie['CO_list'], "isolation") == 0) {
2299                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2300                       $this->user[$idx]->flags |= USER_FLAG_ISOLAUTH;
2301                   }
2302                   else {
2303                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2304                   }
2305               }
2306           }
2307           else {
2308               fprintf(STDERR, "QQ: CO_list not set flags: %x\n", __FUNCTION__, $this->user[$idx]->flags);
2309           }
2310       }
2311       fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2312       if ($ghost > -1) {
2313         log_main("ghost: rename!");
2314         $ghost_user = $this->user[$ghost];
2315
2316         if ($ghost_auth == FALSE) {
2317           for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2318             $ghostname = 'ghost'.$sfx;
2319             for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2320               if (strcmp("", $this->user[$i]->sess) == 0)
2321                 continue;
2322
2323               if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2324                 $ghostname = '';
2325                 break;
2326               }
2327             }
2328             if ($ghostname != '')
2329               break;
2330           }
2331
2332           $ghost_user->name = $ghostname;
2333
2334           if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2335             $this->standup_update($ghost_user);
2336           }
2337           else {
2338             log_main("chatt_send pre table update");
2339             $this->table_update($ghost_user);
2340           log_main("chatt_send post table update");
2341           }
2342         } // if ($ghost_auth == FALSE
2343         else {
2344           // FIXME: cacciare il vecchio utente room && table (if needed)
2345           $ghost_user->the_end = TRUE;
2346           $ghost_user->lacc = 0;
2347           $this->garbage_manager(TRUE);
2348         }
2349       } //  if ($ghost > -1) {
2350
2351       $real_idx = $idx;
2352       if ($login_exists)
2353         $idx = -($idx + 1);
2354       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));
2355
2356       $ret = $this->user[$real_idx];
2357       return ($ret);
2358     }
2359
2360     return (FALSE);
2361   }
2362
2363   function standup_update($user)
2364   {
2365     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2366       $user_cur = $this->user[$i];
2367       if ($user_cur->sess == '')
2368         continue;
2369
2370       log_main("STANDUP START: ".$user_cur->stat);
2371
2372       if ($user_cur->stat == 'room') {
2373         $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2374         if ($user->idx_get() == $i) {
2375           $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2376         }
2377         log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2378
2379         $user_cur->step_inc();
2380       }
2381     }
2382   }
2383
2384   function dump_data()
2385   {
2386       $brisk_ser = serialize($this);
2387       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2388       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2389           return (TRUE);
2390       }
2391
2392       return (FALSE);
2393   }
2394
2395   function standup_content($user)
2396   {
2397     $ret = "";
2398     $content = "";
2399
2400     if ($user->stat != 'room')
2401       return;
2402
2403     for ($i = 0 , $ct = 0 ; $ct < 4 && $i < MAX_PLAYERS ; $i++) {
2404       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2405         continue;
2406       $ct++;
2407     }
2408
2409     // $content .= sprintf('<table cols=\\"%d\\" class=\\"table_standup\\">', $ct);
2410
2411     $content = ' j_stand_cont( [ ';
2412
2413     $user_cur_id = $user->idx_get();
2414     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2415       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2416         continue;
2417
2418       $flags = $this->user[$i]->flags;
2419
2420       // sql record exists AND last donate > 2013-01-01
2421       if ($this->user[$i]->is_supp_custom()) {
2422           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2423       }
2424       else {
2425           $supp_comp_s = '';
2426       }
2427
2428       if ($this->user[$i]->subst == "standup") {
2429           if ($user_cur_id == $i) {
2430               $flags |= 1;
2431           }
2432
2433           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2434                               xcape($this->user[$i]->name), $supp_comp_s);
2435           $ct++;
2436       }
2437     }
2438     $content .= ' ]);';
2439
2440     return ($content);
2441   }
2442
2443   function table_content($user, $table_idx)
2444   {
2445     $content = "";
2446     $ret = "";
2447     // TODO
2448     //
2449     //   Si possono usare i dati nella classe table
2450     //
2451
2452     $sess = $user->sess;
2453     $table = $this->table[$table_idx];
2454
2455     if ($user->stat != 'room')
2456       return;
2457
2458     $user_cur_id = $user->idx_get();
2459     $content = "[ ";
2460     for ($i = 0 ; $i < $table->player_n ; $i++) {
2461         $user_cur = $this->user[$table->player[$i]];
2462
2463         $flags = $user_cur->flags;
2464
2465         if ($user_cur_id == $table->player[$i])
2466             $flags |= 1;
2467
2468         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2469         if ($user_cur->is_supp_custom())
2470             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2471         else
2472             $supp_comp_s = '';
2473
2474         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2475                             xcape($user_cur->name), $supp_comp_s);
2476     }
2477
2478     $content .= ' ]';
2479
2480     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2481
2482     return ($ret);
2483   }
2484
2485   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2486   {
2487       GLOBAL $G_ban_list, $G_black_list;
2488
2489       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2490       $remote_addr = addrtoipv4($addr);
2491
2492           fprintf(STDERR, "\n\n\n PRE_BLACK_CHECK \n\n\n");
2493       if ($this->black_check($remote_addr)) {
2494           // TODO: waiting async 5 sec before close
2495           fprintf(STDERR, "\n\n\n BLACK_CHECK \n\n\n");
2496           return (FALSE);
2497       }
2498
2499       $enc = get_encoding($header);
2500       if (isset($header['User-Agent'])) {
2501           if (strstr($header['User-Agent'], "MSIE")) {
2502               $transp_type = "htmlfile";
2503           }
2504           else {
2505               $transp_type = "xhr";
2506           }
2507       }
2508       else {
2509           $transp_type = "iframe";
2510       }
2511       force_no_cache($header_out);
2512
2513       switch ($path) {
2514       case "":
2515       case "index.php":
2516           ob_start();
2517           index_main($this, $transp_type, $header_out, $addr, $get, $post, $cookie);
2518           $content = ob_get_contents();
2519           ob_end_clean();
2520
2521           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2522           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2523           return TRUE;
2524
2525           break;
2526       case "index_wr.php":
2527           //
2528           // Enhance required: in the POST case, after the header you must get content
2529           //                   from the socket, waiting if necessary
2530           //
2531
2532           ob_start();
2533           index_wr_main($this, $addr, $get, $post, $cookie);
2534           $content = ob_get_contents();
2535           ob_end_clean();
2536
2537           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2538           return TRUE;
2539
2540           break;
2541       case "index_rd.php":
2542           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2543               $transp = "iframe";
2544           if ($transp == 'websocket')
2545               $enc = 'plain';
2546
2547           do {
2548               if (!isset($cookie['sess'])
2549                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2550
2551                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2552
2553                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2554                   return TRUE;
2555
2556                   break;
2557               }
2558               $this->sess_cur_set($user->sess);
2559               // close a previous opened index_read_ifra socket, if exists
2560               if (($prev = $user->rd_socket_get()) != NULL) {
2561                   $s_a_p->socks_unset($user->rd_socket_get());
2562                   fclose($user->rd_socket_get());
2563                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2564                   $user->rd_socket_set(NULL);
2565               }
2566
2567               $content = "";
2568               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2569               $response = headers_render($header_out, -1).$user->chunked_content($content);
2570               $response_l = mb_strlen($response, "ASCII");
2571
2572               $wret = @fwrite($new_socket, $response, $response_l);
2573               if ($wret < $response_l) {
2574                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2575                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2576               }
2577               else {
2578                   $user->rd_cache_set("");
2579               }
2580               fflush($new_socket);
2581
2582
2583               $s_a_p->socks_set($new_socket, $user, NULL);
2584               $user->rd_socket_set($new_socket);
2585               printf(" - qui ci siamo - ");
2586               return TRUE;
2587           } while (FALSE);
2588
2589           return FALSE;
2590           break;
2591       case 'test.php':
2592           if (!(BRISK_DEBUG & DBG_ENGI))
2593               return (FALSE);
2594           fprintf(STDERR, "TEST.PHP running\n");
2595           if (isset($post['data'])) {
2596               $content = $post['data'];
2597           }
2598           else {
2599               $content = "NO DATA AVAILABLE";
2600           }
2601           $header_out['Content-Type'] = 'text/plain';
2602           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2603           return TRUE;
2604           break;
2605       default:
2606           /* FAR TODO: move all into an array of registered sub-apps */
2607           $subs = "briskin5/";
2608           $subs_l = strlen($subs);
2609           if (!strncmp($path, $subs, $subs_l)) {
2610               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2611               return ($ret);
2612           }
2613           break;
2614       }
2615
2616       return (FALSE);
2617   }
2618
2619   function match_add($idx, $match)
2620   {
2621       $this->match[$idx] = $match;
2622   }
2623
2624   function match_del($idx)
2625   {
2626       unset($this->match[$idx]);
2627   }
2628
2629   function match_get($idx, $token)
2630   {
2631       if (isset($this->match[$idx])) {
2632           if (   $token == NULL
2633               || $token == $this->match[$idx]->table_token) {
2634               return ($this->match[$idx]);
2635           }
2636       }
2637       return NULL;
2638   }
2639   function sess_cur_set($sess)
2640   {
2641       static::$sess_cur = $sess;
2642   }
2643
2644   static function sess_cur_get()
2645   {
2646       return(static::$sess_cur);
2647   }
2648 } // end class Brisk
2649
2650 function make_seed()
2651 {
2652   list($usec, $sec) = explode(' ', microtime());
2653   return (float) $sec + ((float) $usec * 100000);
2654 }
2655
2656 function btrace_line($ar)
2657 {
2658     GLOBAL $G_btrace_pref_sub;
2659
2660     $ret = "";
2661     for ($i = 0 ; $i < count($ar) ; $i++) {
2662         $with_class = isset($ar[$i]['class']);
2663         $with_file  = isset($ar[$i]['file']);
2664         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2665                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2666                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2667                         ($with_file ? $ar[$i]['line'] : ""));
2668     }
2669
2670     return ($ret);
2671 }
2672
2673 function trace_ftok($id, $add)
2674 {
2675     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2676     $tok=@ftok($id, $add);
2677
2678     log_shme($tok.": ".$id." + ".$add);
2679
2680     return ($tok);
2681 }
2682
2683 function log_mop($step, $log)
2684 {
2685     GLOBAL $PHP_SELF;
2686
2687     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2688         return;
2689
2690     $sess = Brisk::sess_cur_get();
2691     if (isset($sess) == FALSE)
2692         $ssess = "XXXX";
2693     else
2694         $ssess = $sess;
2695
2696     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2697         return;
2698
2699     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2700         $btrace = btrace_line(debug_backtrace());
2701     else
2702         $btrace = "";
2703     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2704         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2705         fclose($fp);
2706     }
2707 }
2708
2709
2710 function log_only2($log)
2711 {
2712     GLOBAL $PHP_SELF;
2713
2714     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
2715         return;
2716
2717     $sess = Brisk::sess_cur_get();
2718     if (isset($sess) == FALSE)
2719         $ssess = "XXXX";
2720     else
2721         $ssess = $sess;
2722
2723     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
2724         return;
2725
2726     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2727         $btrace = btrace_line(debug_backtrace());
2728     else
2729         $btrace = "";
2730     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2731         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2732         fclose($fp);
2733     }
2734 }
2735
2736 function log_crit($log)
2737 {
2738     GLOBAL $PHP_SELF;
2739
2740     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
2741         return;
2742
2743     $sess = Brisk::sess_cur_get();
2744     if (isset($sess) == FALSE)
2745         $ssess = "XXXX";
2746     else
2747         $ssess = $sess;
2748
2749     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
2750         return;
2751
2752     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2753         $btrace = btrace_line(debug_backtrace());
2754     else
2755         $btrace = "";
2756     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2757         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2758         fclose($fp);
2759     }
2760 }
2761
2762 function log_only($log)
2763 {
2764     GLOBAL $PHP_SELF;
2765
2766     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
2767         return;
2768
2769     $sess = Brisk::sess_cur_get();
2770     if (isset($sess) == FALSE)
2771         $ssess = "XXXX";
2772     else
2773         $ssess = $sess;
2774
2775     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
2776         return;
2777
2778     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2779         $btrace = btrace_line(debug_backtrace());
2780     else
2781         $btrace = "";
2782     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2783         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2784         fclose($fp);
2785     }
2786 }
2787
2788 function log_main($log)
2789 {
2790     GLOBAL $PHP_SELF;
2791
2792     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
2793         return;
2794
2795     $sess = Brisk::sess_cur_get();
2796     if (isset($sess) == FALSE)
2797         $ssess = "XXXX";
2798     else
2799         $ssess = $sess;
2800
2801     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
2802         return;
2803
2804     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2805         $btrace = btrace_line(debug_backtrace());
2806     else
2807         $btrace = "";
2808     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2809         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2810         fclose($fp);
2811     }
2812 }
2813
2814 function log_rd($log)
2815 {
2816     GLOBAL $PHP_SELF;
2817
2818     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
2819         return;
2820
2821     $sess = Brisk::sess_cur_get();
2822     if (isset($sess) == FALSE)
2823         $ssess = "XXXX";
2824     else
2825         $ssess = $sess;
2826
2827     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
2828         return;
2829
2830     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2831         $btrace = btrace_line(debug_backtrace());
2832     else
2833         $btrace = "";
2834     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2835         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2836         fclose($fp);
2837     }
2838 }
2839
2840 function log_rd2($log)
2841 {
2842     GLOBAL $PHP_SELF;
2843
2844     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
2845         return;
2846
2847     $sess = Brisk::sess_cur_get();
2848     if (isset($sess) == FALSE)
2849         $ssess = "XXXX";
2850     else
2851         $ssess = $sess;
2852
2853     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
2854         return;
2855
2856     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2857         $btrace = btrace_line(debug_backtrace());
2858     else
2859         $btrace = "";
2860
2861     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2862         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2863         fclose($fp);
2864     }
2865 }
2866
2867 function log_send($log)
2868 {
2869     GLOBAL $PHP_SELF;
2870
2871     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
2872         return;
2873
2874     $sess = Brisk::sess_cur_get();
2875     if (isset($sess) == FALSE)
2876         $ssess = "XXXX";
2877     else
2878         $ssess = $sess;
2879
2880     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
2881         return;
2882
2883     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2884         $btrace = btrace_line(debug_backtrace());
2885     else
2886         $btrace = "";
2887     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2888         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2889         fclose($fp);
2890     }
2891 }
2892
2893 function log_lock($log)
2894 {
2895     GLOBAL $PHP_SELF;
2896
2897     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
2898         return;
2899
2900     $sess = Brisk::sess_cur_get();
2901     if (isset($sess) == FALSE)
2902         $ssess = "XXXX";
2903     else
2904         $ssess = $sess;
2905
2906     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
2907         return;
2908
2909     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2910         $btrace = btrace_line(debug_backtrace());
2911     else
2912         $btrace = "";
2913     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2914         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2915         fclose($fp);
2916     }
2917 }
2918
2919 function log_wr($log)
2920 {
2921     GLOBAL $PHP_SELF;
2922
2923     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
2924         return;
2925
2926     $sess = Brisk::sess_cur_get();
2927     if (isset($sess) == FALSE)
2928         $ssess = "XXXX";
2929     else
2930         $ssess = $sess;
2931
2932     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
2933         return;
2934
2935     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2936         $btrace = btrace_line(debug_backtrace());
2937     else
2938         $btrace = "";
2939     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2940         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2941         fclose($fp);
2942     }
2943 }
2944
2945 function log_load($log)
2946 {
2947     GLOBAL $PHP_SELF;
2948
2949     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
2950         return;
2951
2952     $sess = Brisk::sess_cur_get();
2953     if (isset($sess) == FALSE)
2954         $ssess = "XXXX";
2955     else
2956         $ssess = $sess;
2957
2958     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
2959         return;
2960
2961     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2962         $btrace = btrace_line(debug_backtrace());
2963     else
2964         $btrace = "";
2965     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2966         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2967         fclose($fp);
2968     }
2969 }
2970
2971 function log_auth($sess, $log)
2972 {
2973     GLOBAL $PHP_SELF;
2974
2975     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
2976         return;
2977
2978     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
2979         return;
2980
2981     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2982         $btrace = btrace_line(debug_backtrace());
2983     else
2984         $btrace = "";
2985     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2986         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
2987         fclose($fp);
2988     }
2989 }
2990
2991 function log_shme($log)
2992 {
2993     GLOBAL $PHP_SELF;
2994
2995     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
2996         return;
2997
2998     $sess = Brisk::sess_cur_get();
2999     if (isset($sess) == FALSE)
3000         $ssess = "XXXX";
3001     else
3002         $ssess = $sess;
3003
3004     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3005         return;
3006
3007     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3008         $btrace = btrace_line(debug_backtrace());
3009     else
3010         $btrace = "";
3011     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3012         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3013         fclose($fp);
3014     }
3015 }
3016
3017
3018
3019 // function log_legal($curtime, $sess, $name, $where, $mesg)
3020 function log_legal($curtime, $addr, $user, $where, $mesg)
3021 {
3022
3023   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3024     /* Unix time | session | nickname | IP | where was | mesg */
3025     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
3026                         ($user->is_auth() ? 'A' : 'N'),
3027                         $user->name, $addr, $where , $mesg));
3028     fclose($fp);
3029   }
3030 }
3031
3032 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3033 {
3034   $ret = "";
3035
3036   if ($isstanding) {
3037     if ($sitted < PLAYERS_N) {
3038       if ($allowed)
3039         $act = 'sit';
3040       else
3041         $act = 'reserved';
3042     }
3043   }
3044   else {
3045     if ($table == $cur_table)
3046       $act = 'wake';
3047     else
3048       $act = 'none';
3049   }
3050
3051   if ($act != '')
3052     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3053
3054   return ($ret);
3055 }
3056
3057 function show_notify($text, $tout, $butt, $w, $h)
3058 {
3059   log_main("SHOW_NOTIFY: ".$text);
3060   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3061 }
3062
3063 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3064 {
3065   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3066   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);
3067 }
3068
3069 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3070 {
3071   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3072
3073   $butts = "";
3074   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3075       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3076   }
3077
3078   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3079                  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);
3080 }
3081
3082
3083 function root_welcome($user)
3084 {
3085   GLOBAL $root_wellarr, $G_lang;
3086   $ret = "";
3087
3088   $curtime = time();
3089   $dt = date("H:i ", $curtime);
3090
3091   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3092       $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3093
3094   return ($ret);
3095 }
3096
3097
3098
3099 function validate_sess($sess)
3100 {
3101   if (strlen($sess) == SESS_LEN)
3102     return (TRUE);
3103   else
3104     return (FALSE);
3105 }
3106
3107 function validate_name($name)
3108 {
3109     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3110
3111   for ($i = 0 ; $i < strlen($name_new) ; $i++) {
3112     $c = $name_new[$i];
3113     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3114       return ($name_new);
3115   }
3116
3117   return (FALSE);
3118 }
3119
3120 function playsound($filename)
3121 {
3122   return (sprintf('playsound("flasou", "%s");', $filename));
3123 }
3124
3125 function secstoword($secs)
3126 {
3127   GLOBAL $G_lang;
3128
3129   $ret = "";
3130
3131   $mins = floor($secs / 60);
3132   $secs = $secs % 60;
3133   if ($G_lang == 'en') {
3134     if ($mins > 0)
3135       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3136
3137     if ($secs > 0)
3138       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3139   }
3140   else {
3141     if ($mins > 0)
3142       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3143
3144     if ($secs > 0)
3145       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3146   }
3147   return ($ret);
3148 }
3149
3150 function sharedmem_sz($tok)
3151 {
3152   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3153     log_main("shmop_open failed");
3154     return (-1);
3155   }
3156   $shm_sz = shmop_size($shm_id);
3157   shmop_close($shm_id);
3158
3159   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3160   return ($shm_sz);
3161 }
3162
3163 class Warrant {
3164     static $delta_t;
3165
3166   static function lock_data($is_exclusive)
3167   {
3168       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3169           self::$delta_t = microtime(TRUE);
3170           log_lock("LOCK   warrant      [".self::$delta_t."]");
3171
3172           return ($res);
3173       }
3174
3175       return (FALSE);
3176   }
3177
3178   static function unlock_data($res)
3179   {
3180     GLOBAL $sess;
3181
3182     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3183
3184     file_unlock($res);
3185   }
3186 }
3187
3188 class Poll {
3189     static $delta_t;
3190
3191   static function lock_data($is_exclusive)
3192   {
3193       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3194           self::$delta_t = microtime(TRUE);
3195           log_lock("LOCK   poll         [".self::$delta_t."]");
3196
3197           return ($res);
3198       }
3199
3200       return (FALSE);
3201   }
3202
3203   static function unlock_data($res)
3204   {
3205     GLOBAL $sess;
3206
3207     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3208
3209     file_unlock($res);
3210   }
3211 }
3212
3213 function carousel_top()
3214 {
3215     $what = rand(1,2);
3216     if ($what == 1) {
3217         $rn = rand(1, 3);
3218         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));
3219         }
3220     else {
3221         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>'));
3222     }
3223 }
3224
3225
3226 ?>