web/Obj/brisk.phh

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