web/Obj/brisk.phh

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