web/Obj/brisk.phh

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