web/Obj/brisk.phh

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