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