web/Obj/brisk.phh

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