web/Obj/brisk.phh

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