web/Obj/brisk.phh

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