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', 3600);
  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.2.1";
 157
 158 /* MLANG: ALL THE INFO STRINGS IN brisk.phh */
 159 $root_wellarr = array( 'it' => array ( 'Brisk (Ver. '.$G_brisk_version.'), <b>NOVITA\'</b>: puoi creare la tua rete di amicizie con /info, vedere cosa pensano i tuoi amici degli altri utenti e ci sono i nuovi tavoli riservati per registrati e apprendisti, corretti alcuni errori.',
 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   function Table()
 661   {
 662   }
 663
 664   function create($idx)
 665   {
 666     if (($thiz = new Table()) == FALSE)
 667       return (FALSE);
 668
 669     $thiz->idx       =   $idx;
 670     $thiz->player    =   array();
 671     $thiz->player_n  =   0;
 672
 673     if ($idx < TABLES_CERT_N)
 674         $thiz->auth_type =   TABLE_AUTH_TY_CERT;
 675     else if ($idx < TABLES_AUTH_N)
 676         $thiz->auth_type =   TABLE_AUTH_TY_AUTH;
 677     else if ($idx < TABLES_APPR_N)
 678         $thiz->auth_type =   TABLE_AUTH_TY_APPR;
 679     else
 680         $thiz->auth_type =   TABLE_AUTH_TY_PUBL;
 681
 682     $thiz->wag_own   =  -1;
 683     $thiz->wag_com   =  "";
 684     $thiz->wag_tout   =  0;
 685
 686     $thiz->table_token  = "";
 687     $thiz->table_start  = 0;
 688
 689     $thiz->wakeup_time = 0;
 690
 691     return ($thiz);
 692   }
 693
 694   function copy($from)
 695   {
 696     $this->idx = $from->idx;
 697     $this->player = array();
 698     for ($i = 0 ; $i < $from->player_n ; $i++)
 699       $this->player[$i] = $from->player[$i];
 700     $this->player_n = $from->player_n;
 701
 702     log_main("PLAYER_N - parent::copy.".$this->player_n);
 703
 704     $this->auth_type =  $from->auth_type;
 705
 706     $this->wag_own   =  $from->wag_own;
 707     $this->wag_com   =  $from->wag_com;
 708     $this->wag_tout  =  $from->wag_tout;
 709
 710     $this->table_token  = $from->table_token;
 711     $this->table_start  = $from->table_start;
 712
 713     $this->wakeup_time = $from->wakeup_time;
 714   }
 715
 716   function myclone($from)
 717   {
 718     if (($thiz = new Table()) == FALSE)
 719       return (FALSE);
 720
 721     $this->copy($from);
 722
 723     return ($thiz);
 724   }
 725
 726   function spawn($from)
 727   {
 728     if (($thiz = new Table()) == FALSE)
 729       return (FALSE);
 730
 731     $thiz->idx = $from->idx;
 732     $thiz->player = array();
 733     for ($i = 0 ; $i < $from->player_n ; $i++)
 734       $thiz->player[$i] = $i;
 735     $thiz->player_n = $from->player_n;
 736
 737     $thiz->auth_type =  $from->auth_type;
 738
 739     $thiz->wag_own = $from->wag_own;
 740     $thiz->wag_com = $from->wag_com;
 741     $thiz->wag_tout  =  $from->wag_tout;
 742
 743     $thiz->table_token  = $from->table_token;
 744     $thiz->table_start  = $from->table_start;
 745
 746     $thiz->wakeup_time = $from->wakeup_time;
 747
 748     return ($thiz);
 749   }
 750
 751   function wag_set($user_idx, $mesg)
 752   {
 753     log_main("WAG_SET");
 754
 755     $this->wag_own  =  $user_idx;
 756     $this->wag_com  =  $mesg;
 757     $this->wag_tout =  0;
 758   }
 759
 760   function wag_reset($timeout)
 761   {
 762     log_main("WAG_RESET");
 763
 764     unset($this->wag_own);
 765     $this->wag_own  = -1;
 766     $this->wag_com  = "";
 767     $this->wag_tout = $timeout;
 768   }
 769
 770   function player_get($idx)
 771   {
 772     return ($this->player[$idx]);
 773   }
 774
 775   function player_set($idx, $player)
 776   {
 777     $this->player[$idx] = $player;
 778   }
 779
 780   function user_add($idx)
 781   {
 782     $this->player[$this->player_n] = $idx;
 783     $this->player_n++;
 784
 785     return ($this->player_n - 1);
 786   }
 787
 788   function user_rem($brisk, $user)
 789   {
 790     $tabpos = $user->table_pos;
 791
 792     /* verifico la consistenza dei dati */
 793     if ($brisk->user[$this->player[$tabpos]] == $user) {
 794
 795       /* aggiorna l'array dei giocatori al tavolo. */
 796       for ($i = $tabpos ; $i < $this->player_n-1 ; $i++) {
 797         $this->player[$i] = $this->player[$i+1];
 798         $user_cur = $brisk->user[$this->player[$i]];
 799         $user_cur->table_pos = $i;
 800       }
 801       $this->player_n--;
 802     }
 803     else {
 804       log_main("INCONSISTENCY ON TABLE.");
 805     }
 806   }
 807
 808   // Table->act_content - return 'id' of type of output required for table button
 809   function act_content($user)
 810   {
 811     $ret = "";
 812     $isstanding = ($user->subst == 'standup');
 813     $sitted = $this->player_n;
 814     $table = $this->idx;
 815     $cur_table = $user->table;
 816     $allowed = TRUE;
 817
 818     if ($isstanding) {
 819       if ($sitted < PLAYERS_N) {
 820           switch ($this->auth_type) {
 821           case TABLE_AUTH_TY_CERT:
 822               if ($user->is_cert() && !$user->is_appr())
 823                   $act = "sitcert";
 824               else
 825                   $act = 'resercert';
 826               break;
 827           case TABLE_AUTH_TY_AUTH:
 828               if ($user->is_auth() && !$user->is_appr())
 829                   $act = "sitreser";
 830               else
 831                   $act = 'reserved';
 832               break;
 833           case TABLE_AUTH_TY_APPR:
 834               if ($user->is_auth())
 835                   $act = "sitappr";
 836               else
 837                   $act = 'reserved';
 838               break;
 839           default:
 840               $act = 'sit';
 841               break;
 842           }
 843       }
 844       else {
 845         $act = 'none';
 846       }
 847     }
 848     else {
 849       if ($table == $cur_table)
 850         $act = 'wake';
 851       else
 852         $act = 'none';
 853     }
 854
 855     if ($act != '')
 856       $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
 857
 858     return ($ret);
 859   }
 860 } // end class Table
 861
 862
 863 class Delay_Manager
 864 {
 865     var $delta;
 866     var $lastckeck;
 867     var $triglevel;
 868
 869     function Delay_Manager($triglevel)
 870     {
 871         $this->triglevel = $triglevel;
 872         $this->delta = array();
 873         $this->lastcheck = 0;
 874     }
 875
 876     function delta_get($curtime)
 877     {
 878         // clean too old delta items
 879         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 880             if ($this->delta[$i][0] < $curtime) {
 881                 array_splice($this->delta, $i, 1);
 882                 $i--;
 883             }
 884         }
 885
 886         // add new delta items if delay exceeded $this->triglevel sec
 887         if ($curtime > $this->lastcheck + $this->triglevel && $curtime < $this->lastcheck + 1200.0) {
 888             $delta = $curtime - $this->lastcheck - $this->triglevel;
 889             array_push($this->delta, array($curtime + $delta , $delta));
 890             // fprintf(STDERR, "DELTA: add new delta [%f] [%f] [%f]\n", $this->triglevel, $curtime + $delta, $delta);
 891         }
 892
 893         // extract the maximum valid delta
 894         $delta_max = 0.0;
 895         for ($i = 0 ; $i < count($this->delta) ; $i++) {
 896             $delta_cur = $this->delta[$i][1];
 897             if ($delta_max < $delta_cur)
 898                 $delta_max = $delta_cur;
 899         }
 900
 901         // fprintf(STDERR, "DELTA: status %d, delta_max: %f\n", count($this->delta), $delta_max);
 902
 903         return ($delta_max);
 904     }
 905
 906     function lastcheck_set($curtime)
 907     {
 908         $this->lastcheck = $curtime;
 909     }
 910 }
 911
 912 class Client_prefs {
 913     var $listen;
 914     var $supp_comp;
 915
 916     function Client_prefs()
 917     {
 918     }
 919
 920     static function from_user($user)
 921     {
 922         $thiz = new Client_prefs();
 923         $thiz->user_load($user);
 924
 925         return ($thiz);
 926     }
 927
 928     static function from_json($json)
 929     {
 930         $thiz = new Client_prefs();
 931         if ($thiz->json_load($json) == FALSE) {
 932             unset($thiz);
 933             return (FALSE);
 934         }
 935
 936         return ($thiz);
 937     }
 938
 939     function user_load($user)
 940     {
 941         fprintf(STDERR, "QQ %s: %x\n", __FUNCTION__, $user->flags);
 942         $this->listen = ($user->flags & USER_FLAG_MAP_AUTH) >> 2;
 943         if ($user->rec != FALSE) {
 944             $this->supp_comp = $user->rec->supp_comp_get();
 945         }
 946         else {
 947             $this->supp_comp = "000000000000";
 948         }
 949
 950         fprintf(STDERR, "QQ %s: LISTEN: %d\n", __FUNCTION__, $this->listen);
 951     }
 952
 953     function json_load($json_s)
 954     {
 955         $ret = FALSE;
 956
 957         do {
 958             if (gettype($json_s) == "string") {
 959                 if (($json = json_decode($json_s)) == FALSE)
 960                     break;
 961             }
 962             else {
 963                 $json = $json_s;
 964             }
 965             if ($this->listen < 0 || $this->listen > 2)
 966                 break;
 967             $this->listen = $json->listen;
 968
 969             if (mb_strlen($json->supp_comp, "ASCII") != 12)
 970                 break;
 971
 972             for ($i = 0, $idx = 0 ; $i < 12 ; $i++) {
 973                 if (($json->supp_comp[$i] >= '0' && $json->supp_comp[$i] <= '9') ||
 974                     ($json->supp_comp[$i] >= 'a' && $json->supp_comp[$i] <= 'f'))
 975                     continue;
 976                 break;
 977             }
 978             if ($i < 12)
 979                 break;
 980             $this->supp_comp = $json->supp_comp;
 981             $ret = TRUE;
 982         } while (FALSE);
 983
 984         return ($ret);
 985     }
 986
 987     function store($user, $is_save)
 988     {
 989         // save into DB
 990         fprintf(STDERR, "QQ %s::%s PRE: %x\n", __CLASS__, __FUNCTION__,
 991                 $user->flags & (~USER_FLAG_S_ALL & ~USER_FLAG_AUTH));
 992         $user->flags_set(($this->listen << 2), USER_FLAG_MAP_AUTH);
 993         fprintf(STDERR, "QQ %s::%s %x\n", __CLASS__, __FUNCTION__,
 994                 $user->flags);
 995         if ($user->is_supp_custom()) {
 996             $user->rec->supp_comp_set($this->supp_comp);
 997         }
 998         if ($is_save)
 999             $user->prefs_store();
1000     }
1001 }
1002
1003 define('GHOST_SESS_TOUT', 1800);
1004 define('GHOST_SESS_REAS_LOUT', 1); // logout
1005 define('GHOST_SESS_REAS_ANOT', 2); // another user get session
1006 define('GHOST_SESS_REAS_TOUT', 3); // room timeout
1007 define('GHOST_SESS_REAS_TTOT', 4); // table timeout
1008 define('GHOST_SESS_REAS_ANON', 5); // anonymizer access
1009 define('GHOST_SESS_REAS_PROX', 6); // proxy access
1010
1011 class GhostSessEl
1012 {
1013     var $time;
1014     var $sess;
1015     var $reas;
1016
1017     function GhostSessEl($time, $sess, $reas)
1018     {
1019         $this->time = $time + GHOST_SESS_TOUT;
1020         $this->sess = $sess;
1021         $this->reas = $reas;
1022     }
1023 }
1024
1025 class GhostSess
1026 {
1027     var $gs;
1028
1029     function GhostSess()
1030     {
1031         $this->gs = array();
1032     }
1033
1034     // push or update for this session
1035     function push($time, $sess, $reas)
1036     {
1037         foreach($this->gs as $el) {
1038             if ($el->sess == "$sess") {
1039                 $el->reas = $reas;
1040                 $el->time = $time + GHOST_SESS_TOUT;
1041                 return TRUE;
1042             }
1043         }
1044
1045         $this->gs[] = new GhostSessEl($time, $sess, $reas);
1046         return TRUE;
1047     }
1048
1049     function pop($sess)
1050     {
1051         foreach($this->gs as $key => $el) {
1052             if ($el->sess == "$sess") {
1053                 $ret = $this->gs[$key];
1054                 unset($this->gs[$key]);
1055                 return ($ret);
1056             }
1057         }
1058         return FALSE;
1059     }
1060
1061     function garbage_manager($curtime)
1062     {
1063         foreach($this->gs as $key => $el) {
1064             if ($el->time < $curtime) {
1065                 unset($this->gs[$key]);
1066             }
1067         }
1068     }
1069 }
1070
1071 class Brisk
1072 {
1073     static $delta_t;
1074
1075     var $crystal_filename;
1076     var $user;
1077     var $table;
1078     var $match;
1079     var $comm; // commands for many people
1080     var $step; // current step of the comm array
1081     var $garbage_timeout;
1082     var $shm_sz;
1083
1084     var $ban_list;       // ban list (authized allowed)
1085     var $black_list;     // black list (anti-dos, noone allowed)
1086     var $cloud_smasher;  // list of cloud ip ranges to be rejected
1087     var $ghost_sess;
1088     var $delay_mgr;
1089
1090     var $cds;
1091
1092     public static $sess_cur;
1093
1094     function Brisk()
1095     {
1096         $this->cds = NULL;
1097     }
1098
1099     // constructor
1100     static function create($crystal_filename, $ban_list, $black_list, $cloud_smasher) {
1101         if (($brisk_ser = @file_get_contents($crystal_filename)) != FALSE) {
1102             if (($brisk = unserialize($brisk_ser)) != FALSE) {
1103                 fprintf(STDERR, "ROOM FROM FILE\n");
1104                 rename($crystal_filename, $crystal_filename.".old");
1105
1106                 $brisk->reload(TRUE, $ban_list, $black_list, $cloud_smasher);
1107
1108                 return($brisk);
1109             }
1110         }
1111
1112         fprintf(STDERR, "NEW ROOM\n");
1113         $thiz = new Brisk();
1114
1115         $thiz->crystal_filename = $crystal_filename;
1116         $thiz->user  = array();
1117         $thiz->table = array();
1118         $thiz->match = array();
1119
1120         $thiz->ban_list = IpClass::create();
1121         $thiz->black_list = IpClass::create();
1122         $thiz->cloud_smasher = IpClass::create();
1123         $thiz->ghost_sess = new GhostSess();
1124
1125         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1126             $thiz->user[$i] = User::create($thiz, $i, "", "");
1127         }
1128
1129         for ($i = 0 ; $i < TABLES_N ; $i++) {
1130             $thiz->table[$i] = Table::create($i);
1131         }
1132         $thiz->garbage_timeout = 0;
1133         $thiz->shm_sz = SHM_DIMS_MIN;
1134
1135         $thiz->delay_mgr = new Delay_Manager(1.5);
1136
1137         static::$sess_cur = FALSE;
1138
1139         $thiz->reload(TRUE, $ban_list, $black_list, $cloud_smasher);
1140
1141         return ($thiz);
1142     }
1143
1144     function reload($is_first, $ban_list, $black_list, $cloud_smasher)
1145     {
1146         fprintf(STDERR, "RELOAD STUFF (%d)(%d)(%d)\n",
1147                 count($ban_list), count($black_list), count($cloud_smasher));
1148
1149         if (defined('CURL_DE_SAC_VERS')) {
1150             if (brisk_cds_reload($this) == FALSE) {
1151                 exit(12);
1152             }
1153         }
1154         $this->ban_list->update($ban_list);
1155         $this->black_list->update($black_list);
1156         $this->cloud_smasher->update($cloud_smasher);
1157
1158         if (!$is_first) {
1159             $this->banned_kickoff();
1160             $this->garbage_manager(TRUE);
1161         }
1162     }
1163
1164     function banned_kickoff()
1165     {
1166         $is_ban = FALSE;
1167
1168         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1169             $table_cur = $this->table[$table_idx];
1170             // if the table is complete and exists we check users IP
1171
1172             if ($table_cur->player_n == PLAYERS_N) {
1173                 if (isset($this->match[$table_idx]) &&
1174                     $table_cur->table_token == $bin5->table_token) {
1175                     log_main("PLAYERS == N TABLE ".$table_idx);
1176
1177                     $bin5 = $this->match[$table_idx];
1178
1179                     $is_ban |= $bin5->banned_kickoff();
1180                 }
1181             }
1182         }
1183
1184         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1185             $user_cur = $this->user[$i];
1186
1187             if ($user_cur->is_active() == FALSE)
1188                 continue;
1189
1190             // check if the IP is blacklisted
1191             if ($this->black_check($user_cur->ip) ||
1192                 $this->cloud_check($user_cur->ip)) {
1193                 $user_cur->lacc = 0;
1194                 $is_ban = TRUE;
1195                 continue;
1196             }
1197
1198             // if authorized not check if banlisted
1199             if ($user_cur->is_auth()) {
1200                 continue;
1201             }
1202
1203             if ($this->ban_check($user_cur->ip)) {
1204                 $user_cur->lacc = 0;
1205                 $is_ban = TRUE;
1206             }
1207         }
1208
1209         return $is_ban;
1210     }
1211
1212     function ban_check($ip_str)
1213     {
1214         return ($this->ban_list->check($ip_str));
1215     }
1216
1217     function black_check($ip_str)
1218     {
1219         return ($this->black_list->check($ip_str));
1220     }
1221
1222     function cloud_check($ip_str)
1223     {
1224         return ($this->cloud_smasher->check($ip_str));
1225     }
1226
1227     function users_cleanup()
1228     {
1229         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1230             $user_cur = $this->user[$i];
1231
1232             if ($user_cur->the_end) {
1233                 $user_cur->reset(); // users_cleanup, OK
1234             }
1235         }
1236     }
1237
1238   function garbage_manager($force)
1239   {
1240     GLOBAL $G_lang, $mlang_brisk, $G_base;
1241
1242     $ismod = FALSE;
1243
1244     log_rd2("garbage_manager START");
1245
1246     /* Garbage collector degli utenti in timeout */
1247     $curtime = microtime(TRUE);
1248
1249     $delta = $this->delay_mgr->delta_get($curtime);
1250
1251     if (!$force && !($this->garbage_timeout < $curtime)) {
1252         $this->delay_mgr->lastcheck_set($curtime);
1253         return ($ismod);
1254     }
1255
1256     // Before all align times with table timeout
1257     for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1258         $table_cur = $this->table[$table_idx];
1259         // if the table is complete and exists its shared mem we get the info about users lacc
1260
1261         if ($table_cur->player_n == PLAYERS_N) {
1262             log_main("PLAYERS == N TABLE ".$table_idx);
1263
1264
1265             $no_recovery = FALSE;
1266             if (isset($this->match[$table_idx])) {
1267                 $bin5 = $this->match[$table_idx];
1268
1269                 if ($table_cur->table_token != $bin5->table_token) {
1270                     log_main("ERROR: not matching table_token. Brisk: ".$table_cur->table_token."  Table: ".$bin5->table_token);
1271                     log_main("ERROR: not matching table_start. Brisk: ".$table_cur->table_start."  Table: ".$bin5->table_start);
1272                     $no_recovery = TRUE;
1273                     $bin5 = FALSE;
1274                 }
1275
1276                 if ($bin5 != FALSE) {
1277                     //
1278                     //  SPAWN: JOIN
1279                     //
1280                     log_main("garbage_manager: bri loaded successfully.");
1281                     $bin5->garbage_manager(TRUE);
1282
1283                     $bin5_table = $bin5->table[0];
1284
1285                     // is the end of the table
1286
1287                     if ($bin5->the_end == TRUE) {
1288                         /*
1289                          *  DESTROY OF FINISHED TABLE && MOVE PLAYER TO ROOM AGAIN
1290                          */
1291                         log_main("garbage_manager: INSIDE THE END.");
1292
1293                         $plist = "$table_cur->table_token|$table_cur->idx|$table_cur->player_n";
1294                         for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1295                             $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1296                         }
1297
1298                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1299                             // stat must be "table" by definition
1300                             $user_cur = $this->user[$table_cur->player[$i]];
1301                             $bin5_user = $bin5->user[$i];
1302
1303                             $user_cur->subst      = $bin5_user->subst;
1304                             $user_cur->rd_step    = $bin5_user->rd_step;
1305                             $user_cur->step       = $bin5_user->step;
1306                             $user_cur->lacc       = $bin5_user->lacc;
1307                             $user_cur->laccwr     = $bin5_user->lacc;
1308                             $user_cur->bantime    = $bin5_user->bantime;
1309                             $user_cur->the_end    = $bin5_user->the_end;
1310                             if ($user_cur->the_end) {
1311                                 $this->ghost_sess->push($curtime, $user_cur->sess, GHOST_SESS_REAS_TTOT);
1312                             }
1313                         }
1314
1315                         log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME", $plist);
1316
1317                         $this->room_join_wakeup($user_cur, FALSE, 0);
1318                         $table_cur->table_token = "";
1319                         $table_cur->wakeup_time = $curtime + WAKEUP_TIME;
1320
1321                         $this->match_del($table_idx);
1322                     }
1323                     else {
1324                         log_main("gm:: save_data");
1325
1326                         for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
1327                             $this->user[$table_cur->player[$i]]->lacc = $bin5->user[$i]->lacc;
1328                         }
1329                     }
1330                 } // if ($bin5 == FALSE
1331                 else if ($no_recovery == FALSE) {
1332                     log_crit("ERROR: table ".$table_idx." unrecoverable join");
1333
1334                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1335                         $user_cur = $this->user[$table_cur->player[$i]];
1336                         $user_cur->subst = "shutdowner";
1337                         $user_cur->step_inc();
1338
1339                         $ret = sprintf('stat = "%s"; subst = "%s";',  $user_cur->stat, $user_cur->subst);
1340                         $ret .= "gst.st = ".($user_cur->step+1)."; ";
1341                         // MLANG <br>I dati del tavolo n&deg; ".$user_cur->table." sono inconsistenti, verranno resettati.<br><br>Torni in piedi.<br><br>
1342                         $prestr = sprintf($mlang_brisk['tabincon'][$G_lang], $user_cur->table);
1343                         $ret .= show_notify($prestr, 2000, $mlang_brisk['btn_close'][$G_lang], 400, 110);
1344                         $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1345                         $user_cur->step_inc();
1346                     }
1347
1348                     $plist = "$table_cur->table_token|$user_cur->table|$table_cur->player_n";
1349                     for ($i = 0 ; $i < $table_cur->player_n ; $i++) {
1350                         $plist .= '|'.$this->user[$table_cur->player[$i]]->sess;
1351                     }
1352                     log_legal($curtime, $user_cur->ip, $user_cur, "STAT:DESTROY_GAME(RECOVERY)", $plist);
1353
1354                     $this->room_join_wakeup($user_cur, TRUE, -2);
1355                     $table_cur->table_token = "";
1356                 }
1357             }
1358         } //  if ($table_cur->player_n == PLAYERS_N) {
1359     } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
1360
1361     log_rd2("out new loop.");
1362
1363     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1364         $user_cur = $this->user[$i];
1365
1366         log_rd2("User: ".$user_cur->name."  stat: ".$user_cur->stat."  subst: ".$user_cur->subst);
1367
1368         if ($user_cur->is_active() == FALSE)
1369             continue;
1370
1371         if ($user_cur->lacc + EXPIRE_TIME_RD < ($curtime - $delta)) {
1372             // Auto logout dell'utente
1373             log_rd2("AUTO LOGOUT.".($user_cur->lacc + EXPIRE_TIME_RD)." curtime - delta ".($curtime - $delta));
1374
1375             $this->ghost_sess->push($curtime, $user_cur->sess, GHOST_SESS_REAS_TOUT);
1376             $user_cur->the_end = TRUE;
1377
1378             log_rd2("AUTO LOGOUT.");
1379             if ($user_cur->stat == 'table' || $user_cur->stat == 'room') {
1380                 log_auth($user_cur->sess, "Autologout session.");
1381
1382                 if ($user_cur->subst == 'sitdown' || $user_cur->stat == 'table')
1383                     $this->room_wakeup($user_cur);
1384                 else if ($user_cur->subst == 'standup')
1385                     $this->room_outstandup($user_cur);
1386                 else
1387                     log_rd2("LOGOUT FROM WHAT ???");
1388             }
1389         }
1390
1391         if ($user_cur->laccwr + EXPIRE_TIME_SMAMMA < ($curtime - $delta)) { // lo rimettiamo in piedi
1392             if ($user_cur->stat == 'room' && $user_cur->subst == 'sitdown') {
1393                 $this->room_wakeup($user_cur);
1394                 $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ";
1395                 /* 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" */
1396                 $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);
1397                 $user_cur->step_inc();
1398             }
1399         }
1400     }
1401     log_rd2("GARBAGE UPDATED!");
1402
1403     $this->garbage_timeout = $curtime + GARBAGE_TIMEOUT;
1404     $ismod = TRUE;
1405
1406     $this->ghost_sess->garbage_manager($curtime);
1407
1408     $this->delay_mgr->lastcheck_set($curtime);
1409     return ($ismod);
1410   }
1411
1412   function show_room($user_step, $user)
1413   {
1414     GLOBAL $G_lang, $mlang_brisk;
1415     log_main("show_room: username: ".$user->name);
1416
1417     $ret = sprintf('gst.st = %d; ',  $user_step);
1418
1419     if ($user->is_auth()) {
1420         $model = array('listen' => array('__type' => 'radio'));
1421         $content = array('listen' =>  array('val' => ($user->flags_db & USER_FLAG_ISOLAUTH ? "2" :
1422                                                       ($user->flags_db & USER_FLAG_LISTAUTH ? "1" : "0")),
1423                                             'cur' => ($user->flags & USER_FLAG_ISOLAUTH ? "2" :
1424                                                       ($user->flags & USER_FLAG_LISTAUTH ? "1" : "0"))));
1425         if ($user->is_supp_custom()) {
1426             $comps = $user->rec->supp_comp_get_array();
1427             $model['fg'] = array('__type' => 'fields', 'r' => array('__type' => 'value'),
1428                                  'g' => array('__type' => 'value'), 'b' => array('__type' => 'value'));
1429             $model['bg'] = array('__type' => 'fields', 'r' => array('__type' => 'value'),
1430                                  'g' => array('__type' => 'value'), 'b' => array('__type' => 'value'));
1431             $content['fg'] = array('r' => array('val' => $comps['fg']['r'], 'cur' => $comps['fg']['r']),
1432                                    'g' => array('val' => $comps['fg']['g'], 'cur' => $comps['fg']['g']),
1433                                    'b' => array('val' => $comps['fg']['b'], 'cur' => $comps['fg']['b']));
1434             $content['bg'] = array('r' => array('val' => $comps['bg']['r'], 'cur' => $comps['bg']['r']),
1435                                    'g' => array('val' => $comps['bg']['g'], 'cur' => $comps['bg']['g']),
1436                                    'b' => array('val' => $comps['bg']['b'], 'cur' => $comps['bg']['b']));
1437         }
1438
1439         $ret .= sprintf('g_prefsf.fields_descr_set(JSON.parse(\'%s\'));', json_encode($model));
1440         $ret .= sprintf('g_prefsf.json2dom(JSON.parse(\'%s\'));', json_encode($content));
1441     }
1442
1443     if ($user->subst == 'standup')
1444       $ret .= "tra.show(); ";
1445     else
1446       $ret .= "tra.hide(); ";
1447
1448     $ret .= sprintf('stat = "%s";',  $user->stat);
1449
1450     $ret .= root_welcome($user);
1451     if ($user->flags & USER_FLAG_DBFAILED) {
1452         $ret .= "gst.st = ".($user->step+1)."; ";
1453         $ret .= show_notify($mlang_brisk['db_failed'][$G_lang], 0, $mlang_brisk['btn_close'][$G_lang], 400, 140);
1454     }
1455
1456     $ret .= sprintf('subst = "%s";', $user->subst);
1457     $ret .= $user->myname_innerHTML();
1458
1459     for ($i = 0 ; $i < TABLES_N ; $i++) {
1460
1461       $ret .= $this->table_content($user, $i);
1462
1463       $ret .=  $this->table[$i]->act_content($user);
1464       if ($this->table[$i]->wag_own != -1)
1465         $ret .= sprintf('tra.add(%d, "%s: %s"); ', $i,  $this->user[$this->table[$i]->wag_own]->name, $this->table[$i]->wag_com);
1466       else
1467         $ret .= sprintf('tra.rem(%d); ', $i);
1468     }
1469     $ret .= $this->standup_content($user);
1470     $ret .= "setTimeout(preload_images, 0, g_preload_img_arr, g_imgct); ";
1471
1472     return ($ret);
1473   }
1474
1475   function room_wakeup($user)
1476   {
1477     $table_idx = $user->table;
1478     $table = $this->table[$table_idx];
1479
1480     log_main("WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1481
1482     $curtime = time();
1483
1484     $from_table = ($user->stat == "table");
1485     if ($from_table) {
1486         log_main("WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1487
1488         for ($i = 0 ; $i < $table->player_n ; $i++) {
1489             $user_cur = $this->user[$table->player[$i]];
1490             log_main("PREIMPOST: INLOOP name: ".$user_cur->name);
1491
1492             if ($user->idx_get() != $table->player[$i]) {
1493                 $user_cur->stat_set("room");
1494                 $user_cur->subst = "sitdown";
1495                 $user_cur->laccwr = $curtime;
1496             }
1497             else if ($user->is_active()) {
1498                 $user_cur->stat_set("room");
1499                 $user_cur->subst = "standup";
1500                 $user_cur->laccwr = $curtime;
1501                 $user_cur->table = -1;
1502             }
1503         }
1504     }
1505     else {
1506         $user->stat_set("room");
1507         $user->subst = "standup";
1508         $user->laccwr = $curtime;
1509     }
1510
1511     $remove_wagon = FALSE;
1512     if($table->wag_own == $user->idx_get()) {
1513         $table->wag_reset($curtime);
1514         $remove_wagon = TRUE;
1515     }
1516
1517     /* aggiorna l'array dei giocatori al tavolo. */
1518     $table->user_rem($this, $user);
1519
1520     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1521       $user_cur = $this->user[$i];
1522       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1523         continue;
1524
1525       // log_main("VALORI: name: ".$user_cur->name."from_table: ".$from_table."  tab: ".$user_cur->table." taix: ".$table_idx."  ucur: ".$user_cur."  us: ".$user);
1526
1527       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1528       if ($from_table && ($user_cur->table == $table_idx || $user->idx_get() == $i)) {
1529         $ret .= 'gst.st_loc++; xstm.stop(); window.onunload = null; window.onbeforeunload = null; document.location.assign("index.php");|';
1530         // $ret .= 'gst.st_loc++; document.location.assign("index.php");|';
1531         log_main("DOCUMENT.index.php: from table");
1532       }
1533       else if ($user_cur->stat == "room") {
1534         log_main("DOCUMENT.index.php: from table");
1535
1536         $ret .= $this->table_content($user_cur, $table_idx);
1537         $ret .= $this->standup_content($user_cur);
1538
1539         // $ret .= table_act_content(FALSE, 0, $table_idx, $user->table, FALSE);
1540         $ret .= $table->act_content($user);
1541
1542         if ($user->idx_get() == $i) {
1543           // set the new status
1544           $ret .=  'subst = "standup"; tra.show(); ';
1545           // clean the action buttons in other tables
1546           for ($e = 0 ; $e < TABLES_N ; $e++) {
1547             if ($this->table[$e]->player_n < PLAYERS_N) {
1548               $ret .= $this->table[$e]->act_content($user);
1549             }
1550           }
1551         }
1552         else {
1553           $ret .= $table->act_content($user_cur);
1554         }
1555       }
1556       log_wr("ROOM_WAKEUP: ".$ret);
1557       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1558       $user_cur->step_inc();
1559     }
1560   }
1561
1562   function room_join_wakeup($user, $update_lacc = FALSE, $trans_delta)
1563   {
1564     $table_idx = $user->table;
1565     $table = $this->table[$table_idx];
1566
1567     log_main("JOIN_WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1568
1569     $curtime = time();
1570     $user_wup = array();
1571     $user_wup_n = 0;
1572     $user_tab = array();
1573     $user_tab_n = 0;
1574     log_main("JOIN WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1575
1576     for ($i = 0 ; $i < $table->player_n ; $i++) {
1577         $user_cur = $this->user[$table->player[$i]];
1578         log_main("PREIMPOST INLOOP name: ".$user_cur->name);
1579         if ($user_cur->is_empty()) {
1580             continue;
1581         }
1582         if ($update_lacc == TRUE) {
1583             $user_cur->laccwr = $curtime;
1584         }
1585         log_main("cur: ".$user_cur->name."  subst: ".$user_cur->subst);
1586         if ($user_cur->subst == "shutdowned") {
1587             $user_cur->stat_set("room");
1588             $user_cur->subst = "sitdown";
1589         }
1590         else if ($user_cur->subst == "shutdowner") {
1591             $user_cur->stat_set("room");
1592             $user_cur->subst = "standup";
1593             $user_cur->table = -1;
1594             $user_wup[$user_wup_n++] = $user_cur;
1595
1596             $remove_wagon = FALSE;
1597             if($table->wag_own == $table->player[$i]) {
1598                 $remove_wagon = TRUE;
1599                 $table->wag_reset($curtime);
1600             }
1601         }
1602         $user_tab[$user_tab_n++] = $table->player[$i];
1603     }
1604
1605     for ($wup_idx = 0 ; $wup_idx < $user_wup_n  ; $wup_idx++)
1606       $table->user_rem($this, $user_wup[$wup_idx]);
1607
1608     /* aggiorna l'array dei giocatori al tavolo. */
1609
1610     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1611       log_main("START LOOP");
1612       $user_cur = $this->user[$i];
1613       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') { // is not active user or the stat isn't 'room'
1614         log_main("name: ".$user_cur->name."skip   subst: ".$user_cur->subst);
1615         continue;
1616       }
1617
1618       log_main("___");
1619       log_main("VALORI name: ".$user_cur->name."  tab: ".$user_cur->table." taix: ".$table_idx);
1620
1621       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1622       if ($user_cur->stat == "room") {
1623         log_main("DOCUMENT.index.php from table");
1624
1625         $ret .= $this->table_content($user_cur, $table_idx);
1626         $ret .= $this->standup_content($user_cur);
1627
1628         $ret .= $table->act_content($user_cur);
1629
1630
1631         for ($tab_idx = 0 ; $tab_idx < $user_tab_n  ; $tab_idx++)
1632             if ($user_tab[$tab_idx] == $i)
1633                 break;
1634
1635         // for users that wakeup the room will be reconstructed by index_rd.php
1636         if ($tab_idx < $user_tab_n) {
1637           log_main("PRE show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1638
1639 //        ARRAY_POP DISABLED
1640 //           if ($trans_delta == 0)
1641 //             while (array_pop($user_cur->comm) != NULL);
1642
1643           $user_cur->trans_step = $user_cur->step + 1 + $trans_delta;
1644           $user_cur->comm[$user_cur->step % COMM_N] = "";
1645           $user_cur->step_inc();
1646           $user_cur->comm[$user_cur->step % COMM_N] = $this->show_room(($user_cur->step + 1), $user_cur);
1647           $user_cur->step_inc();
1648           log_main("POST show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1649
1650           continue;
1651         }
1652         log_main("JOIN_WAKEUP wup_idx ".$wup_idx."  wup_n ".$user_wup_n);
1653
1654         log_main("JOIN_WAKEUP more");
1655
1656         $ret .= $table->act_content($user_cur);
1657
1658         log_main("JOIN_WAKEUP end more");
1659       }
1660       log_wr("ROOM_JOIN_WAKEUP: ".$ret);
1661       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1662       $user_cur->step_inc();
1663     }
1664   }
1665
1666   /*
1667     function info_show($user, $target, $dt)
1668
1669     if success return assoc. array with "ret" => 0 and other fields
1670     else return an assoc. array with "ret: != 0 and "mesg" with an error description
1671   */
1672   function info_show($user, $target, $dt)
1673   {
1674       GLOBAL $G_lang, $mlang_brisk, $G_base;
1675
1676       $mesg = "";
1677       $user_code = -1;
1678       $ret = 0;
1679
1680       do {
1681           if ($target == "") {
1682               $ret = 1;
1683               break;
1684           }
1685           if (($bdb = BriskDB::create()) == FALSE) {
1686               $ret = 2;
1687               break;
1688           }
1689           if ($target == $user->name) {
1690               $ret = 3;
1691               $mesg = sprintf($mlang_brisk['inf_self'][$G_lang]);
1692               break;
1693           }
1694           if (($user_item = $bdb->getitem_bylogin($target, $user_code)) == FALSE) {
1695               $ret = 4;
1696               break;
1697           }
1698           if (($guar_item = $bdb->getitem_bycode($user_item->guar_code_get())) != FALSE) {
1699               $guar_login = $guar_item->login_get();
1700           }
1701           else {
1702               $guar_login = "";
1703           }
1704           $user_tos_vers = $user_item->tos_vers_get();
1705
1706           $partyskill = $bdb->usersnet_partyskill($user->code, $user_item->code);
1707
1708           $widefriend = $bdb->usersnet_widefriend($user->code, $user_item->code);
1709           $widefriend['skill'] = $bdb->usersnet_wideskill($user->code, $user_item->code);
1710           $narrowfriend = $bdb->usersnet_narrowfriend($user->code, $user_item->code);
1711           $narrowfriend['skill'] = $bdb->usersnet_narrowskill($user->code, $user_item->code);
1712
1713           if (($usersnet_item = $bdb->usersnet_bycode($user->code, $user_item->code,
1714                                                       $widefriend, $narrowfriend)) == FALSE) {
1715               $usersnet_item = $bdb->usersnet_default($user->code, $user_item->code,
1716                                                       $widefriend, $narrowfriend);
1717           }
1718
1719           if (versions_cmp($user_tos_vers, "1.2") < 0) {
1720               $mesg = sprintf($mlang_brisk['tos_old'][$G_lang], xcape($target));
1721           }
1722           else if ($guar_login == "") {
1723               $mesg = sprintf($mlang_brisk['inf_nfd'][$G_lang], xcape($target));
1724           }
1725       } while (0);
1726
1727       if ($ret > 0 && $mesg == "") {
1728           $mesg = sprintf($mlang_brisk['inf_err'][$G_lang], $ret);
1729       }
1730
1731       if ($ret != 0) {
1732           $jret = json_encode(array("ret" => $ret, "mesg" => $mesg));
1733       }
1734       else {
1735           $jret = json_encode(array("ret" => 0,
1736                                     "mesg" => "",
1737                                     "login" => $target,
1738                                     // FIXME: state internationalization
1739                                     "state" =>
1740                                     ($user_item->type & USER_FLAG_TY_APPR ? "Apprendista" :
1741                                      ($user_item->type & USER_FLAG_TY_CERT ? "Certificato" :
1742                                       ($user_item->type & (USER_FLAG_TY_NORM | USER_FLAG_TY_SUPER) ?
1743                                        "Normale" : "Stato sconosciuto"))),
1744                                     "guar" => ($user_item->type & USER_FLAG_TY_APPR ?
1745                                                "" : $guar_login),
1746                                     "party" => $partyskill,
1747                                     "match" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->match_cnt) ,
1748                                     "game" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->game_cnt),
1749                                     "friend" => usersnet_friend_getlabel($usersnet_item->friend),
1750                                     "skill" => $usersnet_item->skill,
1751                                     "trust"  => $usersnet_item->trust,
1752                                     "widefriend" => $usersnet_item->widefriend,
1753                                     "narrowfriend" => $usersnet_item->narrowfriend
1754                                     ));
1755       }
1756
1757       return $jret;
1758   }
1759
1760   function info_save($user, $json_s)
1761   {
1762       GLOBAL $G_lang, $mlang_brisk, $G_base;
1763
1764       $mesg = "";
1765       $user_code = -1;
1766       $ret = 0;
1767       $subret = 0;
1768
1769       do {
1770           if (($json = json_decode($json_s)) == FALSE) {
1771               $ret = 1;
1772               break;
1773           }
1774
1775           if (($bdb = BriskDB::create()) == FALSE) {
1776               $ret = 2;
1777               break;
1778           }
1779
1780           if (($subret = $bdb->usersnet_save($user->code, $json)) != 0) {
1781               $ret = 4000 + $subret;
1782               break;
1783           }
1784       } while(0);
1785
1786       return ($ret);
1787   }
1788
1789   function room_outstandup($user)
1790   {
1791     $this->room_sitdown($user, -1);
1792   }
1793
1794   function table_update($user)
1795   {
1796     log_main("table_update: pre - USER: ".$user->name);
1797
1798     $table_idx = $user->table;
1799
1800     if ($table_idx > -1)
1801       $table = $this->table[$table_idx];
1802
1803     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1804       $ret = "";
1805       $user_cur = $this->user[$i];
1806       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1807           continue;
1808
1809       $ret = "gst.st = ".($user_cur->step+1)."; ";
1810       if ($table_idx > -1)
1811         $ret .= $this->table_content($user_cur, $table_idx);
1812
1813       if ($user->idx_get() == $i) {
1814           $ret .= $user->myname_innerHTML();
1815       }
1816       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1817       $user_cur->step_inc();
1818     }
1819
1820     log_main("table_update: post");
1821   }
1822
1823   function room_sitdown($user, $table_idx)
1824   {
1825       log_main("room_sitdown ".($user == FALSE ? "USER: FALSE" : "USER: ".$user->name));
1826
1827       $train_app = "";
1828
1829       if ($table_idx > -1 && $table_idx < TABLES_N) {
1830           $table = $this->table[$table_idx];
1831
1832           // wagon shutdown
1833           if ($table->wag_own != -1 && $table->player_n == PLAYERS_N) {
1834               for ($i = 0 ; $i < TABLES_N ; $i++) {
1835                   if ($table->wag_own == $table->player[$i]) {
1836                       $train_app = sprintf("tra.rem(%d); ", $table_idx);
1837                       $table->wag_reset(time());
1838                       break;
1839                   }
1840               }
1841           }
1842       }
1843
1844       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1845           $ret = "";
1846           $user_cur = $this->user[$i];
1847           if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1848               continue;
1849
1850           $ret = "gst.st = ".($user_cur->step+1)."; ".$train_app;
1851           if ($table_idx > -1)
1852               $ret .= $this->table_content($user_cur, $table_idx);
1853           $ret .= $this->standup_content($user_cur);
1854
1855           if ($user->idx_get() == $i) {
1856               $ret .=  'subst = "sitdown"; tra.hide(); ';
1857               // clean the action buttons in other tables
1858               for ($e = 0 ; $e < TABLES_N ; $e++) {
1859                   $ret .= $this->table[$e]->act_content($user_cur);
1860               }
1861           }
1862           else if ($table_idx > -1) {
1863               if ($table->player_n == PLAYERS_N) {
1864
1865                   $ret .= $table->act_content($user_cur);
1866               }
1867           }
1868           $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1869           $user_cur->step_inc();
1870       }
1871   }
1872
1873   function kickuser($user, $out_reas)
1874   {
1875       $curtime = time();
1876
1877       fprintf(STDERR, "MOP: GHOST_SESS: %d\n", $out_reas);
1878
1879       $this->ghost_sess->push($curtime, $user->sess, $out_reas);
1880
1881       fprintf(STDERR, "MOP: status out: %s %s %d\n", $user->stat, $user->subst, $user->idx);
1882       if ($user->stat == 'table' && $user->subst != 'sitdown') {
1883           $bin5 = &$this->match[$user->table];
1884           $user_bin5 = &$bin5->user[$user->table_pos];
1885           fprintf(STDERR, "MOP: status in: %s %s %d\n", $user_bin5->stat, $user_bin5->subst, $user_bin5->idx);
1886           $bin5->table_wakeup($user_bin5);
1887           $user->the_end = TRUE;
1888           $this->room_wakeup($user);
1889           return;
1890       }
1891
1892       if ($user->stat == 'table' || $user->stat == 'room') {
1893           $user->the_end = TRUE;
1894           if ($user->subst == 'sitdown' || $user->stat == 'table') {
1895               $this->room_wakeup($user);
1896           }
1897           else if ($user->subst == 'standup') {
1898               fprintf(STDERR, "MOP: KICK here [%s]\n", btrace_line(debug_backtrace()));
1899               $this->room_outstandup($user);
1900           }
1901           else {
1902               log_rd2("LOGOUT FROM WHAT ???");
1903           }
1904       }
1905   }
1906
1907   function kickuser_by_name($name, $out_reas)
1908   {
1909       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1910           $user_out = $this->user[$i];
1911           if (strcmp($user_out->name, $name) == 0) {
1912               return ($this->kickuser($user_out, $out_reas));
1913           }
1914       }
1915       return FALSE;
1916   }
1917
1918   function kickuser_by_sess($sess, $out_reas)
1919   {
1920       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1921           $user_out = $this->user[$i];
1922           if (strcmp($user_out->sess, $sess) == 0) {
1923               return ($this->kickuser($user_out, $out_reas));
1924           }
1925       }
1926       return FALSE;
1927   }
1928
1929   function kickuser_by_idx($idx, $out_reas)
1930   {
1931       $user_out = $this->user[$idx];
1932       return ($this->kickuser($user_out, $out_reas));
1933   }
1934
1935   function chatt_send($user, $mesg, $mlang_indwr = NULL)
1936   {
1937     GLOBAL $G_base, $G_alarm_passwd, $mlang_brisk, $G_lang;
1938     $only_you = FALSE;
1939
1940     fprintf(STDERR, "WE ARE HERE: [%s]\n", $mesg);
1941
1942     // common settings
1943     $msg = mb_substr($mesg, 6, 128, "UTF-8");
1944     $curtime = time();
1945     $dt = date("H:i ", $curtime);
1946     $target = "";
1947
1948     //
1949     //  Compute actions
1950     //
1951
1952     $to_user     = FALSE;
1953     $to_all      = FALSE;
1954     $to_room     = FALSE;
1955     $to_tabl     = FALSE;
1956     $is_normchat = FALSE;
1957     /* for old isolation management $is_ticker   = FALSE; */
1958     $update_room = FALSE;
1959
1960     if (strcmp($msg,  "/tav") == 0 ||
1961         strncmp($msg, "/tav ", 5) == 0) {
1962       do {
1963         if ($user->stat != 'room' || $user->subst != 'sitdown') {
1964           /* 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>" */
1965           $msg = $mlang_brisk['tickmust'][$G_lang];
1966           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1967
1968           break;
1969         }
1970
1971         $table = $this->table[$user->table];
1972
1973         if ($table->wag_own != -1) {
1974           // MLANG <br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br>
1975           $msg = $mlang_brisk['tickjust'][$G_lang];
1976           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1977
1978           break;
1979         }
1980
1981         $dtime = $curtime - $table->wag_tout;
1982         if ($dtime  < EXPIRE_TIME_WAG) {
1983           // MLANG - <br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>
1984           $msg = sprintf($mlang_brisk['tickwait'][$G_lang],
1985                          EXPIRE_TIME_WAG - $dtime, (EXPIRE_TIME_WAG - $dtime == 1 ? ($G_lang == 'en' ? "" : "o") : ($G_lang == 'en' ? "s" : "i")));
1986           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang] , 400, 100);
1987
1988           break;
1989         }
1990
1991         $msg = substr($msg, 5);
1992
1993         $table->wag_set($user->idx_get(), $msg);
1994         $to_user = sprintf('tra.add(%d, "%s");', $user->table, xcape(sprintf("%s: %s", $user->name, $msg)));
1995         $to_room = $to_user;
1996         /* for old isolation management $is_ticker = TRUE; */
1997       } while (0);
1998     } // /tav chat command
1999     // just for development use currently
2000     else if (FALSE && strncmp($msg, "/out ", 5) == 0) {
2001         fprintf(STDERR, "MOP OUT\n");
2002         $target = substr($msg, 5);
2003         $this->kickuser_by_name($target, GHOST_SESS_REAS_ANON);
2004     }
2005     else if (strncmp($msg, "/alarm ", 7) == 0) {
2006       if (strncmp($msg, "/alarm to ", 10) == 0) {
2007         $sp_pos = strpos($msg, " ", 10);
2008         $target = substr($msg, 10, $sp_pos - 10);
2009         $alarm_check = "/alarm to ".$target." ".$G_alarm_passwd." ";
2010       }
2011       else {
2012         $target = "";
2013         $alarm_check = "/alarm ".$G_alarm_passwd." ";
2014       }
2015       do {
2016         if (strncmp($msg, $alarm_check, strlen($alarm_check)) != 0) {
2017           /* MLANG: "<br>La password digitata non &egrave; corretta.<br><br>" */
2018           $msg = $mlang_brisk['alarpass'][$G_lang];
2019           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 100);
2020
2021           break;
2022         }
2023
2024         /* MLANG: "Alarm <b>%s</b> inviato a <b>%s</b>." */
2025         $prestr = sprintf($mlang_brisk['alarret'][$G_lang], xcape(substr($msg, strlen($alarm_check))),
2026                            ($target == "" ? $mlang_brisk['tit_all'][$G_lang] : xcape($target)) );
2027         $to_user = nickserv_msg($dt, $prestr);
2028
2029         $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
2030                        $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
2031         /* MLANG: "chiudi" */
2032         $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
2033       } while (0);
2034     } // /alarm chat command
2035     else if (strncmp($msg, "/listen ", 8) == 0) {
2036       $arg = substr($msg, 8);
2037
2038       if (strcasecmp($arg, "isolation") == 0) {
2039         $flags_old = 0;
2040         if ($user->stat == 'room' && $user->subst == 'sitdown' &&
2041             $user->table >= TABLES_AUTH_N) {
2042           $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
2043
2044         }
2045         else {
2046           $user->flags &= ~USER_FLAG_MAP_AUTH;
2047           $user->flags |= USER_FLAG_ISOLAUTH;
2048           $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
2049         }
2050       }
2051       else if (strcasecmp($arg, "auth") == 0) {
2052         $flags_old = $user->flags;
2053         $user->flags &= ~USER_FLAG_MAP_AUTH;
2054         $user->flags |= USER_FLAG_LISTAUTH;
2055         $to_user = 'list_set(\'auth\', true, \''.$mlang_brisk['tit_onauth'][$G_lang].'\'); ';
2056       }
2057       else {
2058         $flags_old = $user->flags;
2059         $user->flags &= ~USER_FLAG_MAP_AUTH;
2060         $to_user = 'list_set(\'all\', true, \'\'); ';
2061
2062       }
2063       // if from isolation redraw standup area
2064       if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
2065         $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
2066
2067       }
2068     }
2069     else if (strcmp($msg, "/authreq") == 0) {
2070         if ($user->is_cert()) {
2071             $to_user = sprintf('authbox(300,200);');
2072         }
2073         else {
2074             /* 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." */
2075             $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
2076         }
2077     }
2078     else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
2079         if ($user->is_auth()) {
2080         $to_user = sprintf('mesgtoadmbox(500,300);');
2081       }
2082       else {
2083         /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
2084         $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
2085       }
2086     }
2087     else if (FALSE && strncmp($msg, "/nick ", 6) == 0) {
2088       log_main("chatt_send BEGIN");
2089
2090       do {
2091         if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
2092           $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
2093           break;
2094         }
2095
2096         $msg = "COMMAND ".$msg;
2097         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2098           $user_cur = $this->user[$i];
2099
2100           if ($user_cur->is_active() == FALSE)
2101             continue;
2102           if (strcasecmp($user_cur->name,$name_new) == 0)
2103             break;
2104           }
2105         if ($i <  MAX_PLAYERS) {
2106           $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
2107           $to_user = nickserv_msg($dt, $prestr);
2108           break;
2109         }
2110
2111         /* 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>" */
2112         if ($user->is_auth()) {
2113           if (strcasecmp($user->name, $name_new) != 0) {
2114              if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
2115                 ($user->subst == 'standup' ||
2116                  ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
2117                  )
2118                 ) {
2119               $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
2120               for ($i = 0 ; $i < TABLES_N ; $i++) {
2121                 $to_user .= $this->table[$i]->act_content($user);
2122               }
2123             }
2124             else {
2125               $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
2126               break;
2127             }
2128           }
2129         }
2130         $user->name = $name_new; // OK - nick changed
2131         /* se nome gia' in uso, segnala cosa potrebbe capitare */
2132         if ( ! $user->is_auth() ) {
2133             if (($bdb = BriskDB::create()) != FALSE) {
2134                 $bdb->users_load();
2135                 /* 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>" */
2136                 if ($bdb->login_exists(strtolower($name_new))) {
2137                     $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
2138                     $to_user .= nickserv_msg($dt, $prestr);
2139                 }
2140             }
2141         }
2142
2143         log_main("chatt_send start set");
2144
2145         $update_room = TRUE;
2146       } while (0);
2147     } // nick chat command
2148     else if (strncmp($msg, "/info ", 6) == 0) {
2149         do {
2150             if (! $user->is_auth()) {
2151                 if ($mlang_indwr) {
2152                     $to_user = nickserv_msg($dt, $mlang_indwr['info_auth'][$G_lang]);
2153                 }
2154                 else {
2155                     $to_user = nickserv_msg($dt, "error");
2156                 }
2157                 break;
2158             }
2159             $info_user = substr($msg, 6);
2160
2161             echo $this->info_show($user, urldecode($info_user), $dt);
2162         } while(0);
2163     }
2164     else if (strncmp($msg, "/prefsn", 7) == 0) {
2165         do {
2166             if (! $user->is_auth()) {
2167                 if ($mlang_indwr) {
2168                     $to_user = nickserv_msg($dt, $mlang_indwr['info_auth'][$G_lang]);
2169                 }
2170                 else {
2171                     $to_user = nickserv_msg($dt, "error");
2172                 }
2173                 break;
2174             }
2175             echo $this->prefsn_show($user, $dt);
2176         } while(0);
2177     }
2178     else if (strncmp($msg, "/st ", 4) == 0) {
2179       log_main("chatt_send BEGIN");
2180
2181       do {
2182         $st_str = substr($msg, 4);
2183
2184         if (strcasecmp($st_str, "normale") == 0) {
2185           $st = USER_FLAG_S_NORM;
2186         }
2187         else if (strcasecmp($st_str, "pausa") == 0) {
2188           $st = USER_FLAG_S_PAU;
2189         }
2190         else if (strcasecmp($st_str, "fuori") == 0) {
2191           $st = USER_FLAG_S_OUT;
2192         }
2193         else if (strcasecmp($st_str, "cane") == 0) {
2194           $st = USER_FLAG_S_DOG;
2195         }
2196         else if (strcasecmp($st_str, "cibo") == 0) {
2197           $st = USER_FLAG_S_EAT;
2198         }
2199         else if (strcasecmp($st_str, "lavoro") == 0) {
2200           $st = USER_FLAG_S_WRK;
2201         }
2202         else if (strcasecmp($st_str, "sigaretta") == 0) {
2203           $st = USER_FLAG_S_SMK;
2204         }
2205         else if (strcasecmp($st_str, "presente") == 0) {
2206           $st = USER_FLAG_S_EYE;
2207         }
2208         else if (strcasecmp($st_str, "coniglio") == 0) {
2209           $st = USER_FLAG_S_RABB;
2210         }
2211         else if (strcasecmp($st_str, "calcio") == 0) {
2212           $st = USER_FLAG_S_SOCC;
2213         }
2214         else if (strcasecmp($st_str, "pupo") == 0) {
2215           $st = USER_FLAG_S_BABY;
2216         }
2217         else if (strcasecmp($st_str, "pulizie") == 0) {
2218           $st = USER_FLAG_S_MOP;
2219         }
2220         else if (strcasecmp($st_str, "babbo") == 0) {
2221           $st = USER_FLAG_S_BABBO;
2222         }
2223         else if (strcasecmp($st_str, "renna") == 0) {
2224           $st = USER_FLAG_S_RENNA;
2225         }
2226         else if (strcasecmp($st_str, "pupazzo") == 0) {
2227           $st = USER_FLAG_S_PUPAZ;
2228         }
2229         else if (strcasecmp($st_str, "vischio") == 0) {
2230           $st = USER_FLAG_S_VISCH;
2231         }
2232         else {
2233           /* MLANG: "Questo stato non esiste." */
2234           $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
2235           break;
2236         }
2237
2238         log_main("chatt_send start set");
2239         if (($user->flags & USER_FLAG_S_ALL) != $st) {
2240           $update_room = TRUE;
2241           $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
2242         }
2243       } while (0);
2244     } // nick chat command
2245
2246     else { // normal chat line
2247       $is_normchat = TRUE;
2248       if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
2249         $only_you = TRUE;
2250         $user->chat_dlt = $user->chat_dlt * 2;
2251         if ($user->chat_dlt > 120)
2252           $user->chat_dlt = 120;
2253       }
2254       else if ($user->chat_lst == $msg)
2255         $only_you = TRUE;
2256       else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2257         $user->chat_ban = $curtime;
2258         $user->chat_dlt = 5;
2259         $only_you = TRUE;
2260       }
2261       else {
2262         $user->chat_ban = 0;
2263         $user->chat_dlt = 0;
2264       }
2265
2266       if ($only_you) {
2267         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2268       }
2269       else {
2270           // TEMPORARY DISABLED UNTIL test user option will be available
2271           // if ( TRUE && (!$user->is_auth() || $user->is_appr()) ) {
2272           if (!$user->is_auth()) {
2273               $to_user = nickserv_msg($dt, xcape("Visto l'elevato numero di molestatori che ultimamente hanno preso dimora su Brisk abbiamo deciso"));
2274               $to_user .= nickserv_msg($dt, xcape("di disattivare temporaneamente la chat in room per i non registrati, non ce ne vogliate e buone feste."));
2275               if (FALSE) {
2276                   $aug_head = array("Tanti", "Tantissimi", "Un enormità", "Un milione", "Un' esagerazione");
2277                   $aug_body = array("a tutti gli utenti", "a tutti gli uomini", "a tutte le donne", "a tutti gli utenti");
2278                   $aug_tail = array("di Brisk", "del sito", "della ciurma", "della comitiva", "del gruppo");
2279
2280                   $auguri = sprintf("%s auguri %s %s.",
2281                                     $aug_head[mt_rand(0, count($aug_head)-1)],
2282                                     $aug_body[mt_rand(0, count($aug_body)-1)],
2283                                     $aug_tail[mt_rand(0, count($aug_tail)-1)]);
2284
2285                   $to_room = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name),
2286                                      xcape($auguri));
2287               }
2288           }
2289           else {
2290               $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2291               // temporary silentiation for troll (will became array check)
2292               // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2293               $to_room = $to_user;
2294           }
2295       }
2296
2297       log_legal($curtime, $user->ip, $user,
2298                 ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2299
2300       $user->chat_lst = "$msg";
2301       $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2302       $user->chat_cur++;
2303     }
2304
2305     if ($to_all) {
2306       $to_room = $to_all;
2307       $to_tabl = $to_all;
2308     }
2309
2310     //
2311     //  Output to clients
2312     //
2313
2314     if ($to_user != FALSE) {
2315       $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2316       $user->comm[$user->step % COMM_N] .= $to_user;
2317       $user->step_inc();
2318     }
2319
2320     if ($to_room != FALSE) {
2321       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2322         $user_cur = $this->user[$i];
2323         if ($target != "" && $user_cur->name != $target)
2324           continue;
2325         if ($user_cur->is_active() == FALSE // is not active user
2326             || $user_cur->stat == 'table'   // or stat is 'table'
2327             || $user->idx_get() == $i)      // or the $user idx is equal to current var
2328           continue;
2329
2330         if ($is_normchat == TRUE) {
2331           // use MAP_AUTH to check if auth or isolation
2332           if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2333               if ( ! $user->is_auth() ) {
2334                   continue;
2335               }
2336           }
2337         }
2338         /*
2339         else if ($is_ticker) {
2340           if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2341             if ($user->table >= TABLES_AUTH_N)
2342               continue;
2343           }
2344         }
2345         */
2346         $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2347         $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2348         $user_cur->step_inc();
2349       }
2350     }
2351
2352     if ($to_tabl) {
2353         // FIXME BRISK4: include for each kind of table
2354         require_once("${G_base}briskin5/Obj/briskin5.phh");
2355         // Before all align times with table timeout
2356         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2357             if (isset($this->match[$table_idx])) {
2358                 $bin5 = $this->match[$table_idx];
2359
2360                 $bin5_table = $bin5->table[0];
2361                 for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2362                     // stat must be "table" by definition
2363                     $bin5_user = $bin5->user[$i];
2364
2365                     if ($target != "" && $bin5_user->name != $target)
2366                         continue;
2367                     log_main("writa: ".$user_mesg);
2368                     $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2369                     $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2370                     $bin5_user->step_inc();
2371                 }
2372             } // if (isset($this->match
2373         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2374     } // if ($to_tabl == true ...
2375
2376     if ($update_room) {
2377       if ($user->stat == 'room' && $user->subst == 'standup') {
2378         $this->standup_update($user);
2379       }
2380       else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2381         log_main("chatt_send pre table update");
2382         $this->table_update($user);
2383         log_main("chatt_send post table update");
2384       }
2385     } // if ($update_room ...
2386
2387     return;
2388   } // function chatt_send( ...
2389
2390   function get_user($sess, &$idx)
2391   {
2392       GLOBAL $PHP_SELF;
2393
2394       if (validate_sess($sess)) {
2395           for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2396               if ($this->user[$i]->is_empty())
2397                   continue;
2398               if (strcmp($sess, $this->user[$i]->sess) == 0) {
2399                   // find it
2400                   $idx = $i;
2401                   $ret = $this->user[$i];
2402                   return ($ret);
2403               }
2404           }
2405           log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2406           // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2407           // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2408       }
2409       else {
2410           log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2411       }
2412
2413       return (FALSE);
2414   }
2415
2416   /*
2417    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2418    *
2419    * RETURN VALUE:
2420    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2421    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2422    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2423    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2424    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2425    *   if ($idx == -($idx + 1) && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2426    */
2427
2428   function add_user(&$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2429   {
2430     GLOBAL $G_base;
2431
2432     $idx = 0;
2433
2434     $authenticate = FALSE;
2435     $user_type    = 0;
2436     $login_exists = FALSE;
2437     $ghost = -1;
2438     $ghost_auth = FALSE;
2439     $idx = -1;
2440     $idfree = -1;
2441     $code = FALSE;
2442
2443     if (($name_new = validate_name($name)) == FALSE) {
2444       $idx = -2;
2445       return (FALSE);
2446     }
2447
2448     log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2449     if (validate_sess($sess) == FALSE)
2450       $sess = "";
2451
2452     /* if pass != FALSE verify the login with pass */
2453     log_auth("XXX", "auth1");
2454
2455     if (($bdb = BriskDB::create()) != FALSE) {
2456         $bdb->users_load();
2457         if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2458             log_auth("XXX", "auth2");
2459             $authenticate = $bdb->login_verify($name_new, $pass, $code);
2460             log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2461
2462             if ($authenticate != FALSE) {
2463                 $user_type = $authenticate->type_get();
2464             }
2465             else {
2466                 $idx = -3;
2467                 return (FALSE);
2468             }
2469         }
2470         else {
2471             $login_exists =  $bdb->login_exists(strtolower($name_new));
2472         }
2473     }
2474     else {
2475         // if db is down, send a warning and verify only current users
2476         // no actions at this moment
2477     }
2478     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2479         /* free user ? */
2480         if ($this->user[$i]->is_empty()) {
2481             if ($idfree == -1) {
2482                 $idfree = $i;
2483             }
2484             continue;
2485         }
2486         if (strcmp($sess, $this->user[$i]->sess) == 0) {
2487             if ($idx == -1) {
2488                 $idx = $i;
2489             }
2490         }
2491         if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2492             if ($authenticate != FALSE) {
2493                 $ghost = $i;
2494                 $ghost_auth = $this->user[$i]->is_auth();
2495             }
2496             else {
2497                 $idx = $i;
2498                 break;
2499             }
2500         }
2501     }
2502     if ($idx == -1)
2503       $idx = $idfree;
2504
2505     log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2506
2507     /* there is another user logged with your account and you and him have authenticated => new user
2508        get the session of the old user */
2509     if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2510       /* swap session */
2511
2512       $ghost_user = $this->user[$ghost];
2513       $curtime = time();
2514       $this->ghost_sess->push($curtime, $ghost_user->sess, GHOST_SESS_REAS_ANOT);
2515       $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2516       $ghost_user->step_inc();
2517       if ($sess == "") {
2518         $sess = uniqid("");
2519         $ghost_user->sess = $sess;
2520       }
2521       else {
2522         $ghost_user->sess = $sess;
2523       }
2524
2525       // If user at the table we need to update the table data too
2526       $table_idx = $ghost_user->table;
2527       if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2528           require_once("${G_base}briskin5/Obj/briskin5.phh");
2529           if (isset($this->match[$table_idx])) {
2530               $bin5 = $this->match[$table_idx];
2531
2532               if ($bin5->the_end != TRUE) {
2533                   $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2534                   $bin5->user[$ghost_user->table_pos]->step_inc();
2535                   $bin5->user[$ghost_user->table_pos]->sess = $sess;
2536               }
2537           }
2538       }
2539
2540       $idx = $ghost;
2541       if (defined('CURL_DE_SAC_VERS')) {
2542           brisk_cds_execute($this, $ghost, $idx, $sess, $ip, $authenticate, $header);
2543       }
2544       return ($this->user[$ghost]);
2545     }
2546     else if ($idx != -1 && $i == MAX_PLAYERS) {
2547       /* SUCCESS */
2548       $curtime = time();
2549       if ($sess == "") {
2550         $sess = uniqid("");
2551         $this->user[$idx]->sess = $sess;
2552       }
2553       else {
2554         $this->user[$idx]->sess = $sess;
2555       }
2556       $this->user[$idx]->name = $name_new; // OK - add new user
2557       $this->user[$idx]->stat_set("room");
2558       $this->user[$idx]->step_set(0);
2559       while (array_pop($this->user[$idx]->comm) != NULL);
2560       $this->user[$idx]->subst = "standup";
2561       $this->user[$idx]->lacc =   $curtime;
2562       $this->user[$idx]->laccwr = $curtime;
2563       $this->user[$idx]->bantime = 0;
2564       $this->user[$idx]->ip = $ip;
2565
2566       $this->user[$idx]->rec = $authenticate;
2567       $this->user[$idx]->flags_db = $user_type;
2568       $this->user[$idx]->flags_db |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2569       $this->user[$idx]->flags_db |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2570       log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags_db));
2571       $this->user[$idx]->flags = $this->user[$idx]->flags_db;
2572       if ($authenticate != FALSE) {
2573           $this->user[$idx]->code = $authenticate->code_get();
2574       }
2575       fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2576       if ($ghost > -1) {
2577         log_main("ghost: rename!");
2578         $ghost_user = $this->user[$ghost];
2579
2580         if ($ghost_auth == FALSE) {
2581           for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2582             $ghostname = 'ghost'.$sfx;
2583             for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2584               if (strcmp("", $this->user[$i]->sess) == 0)
2585                 continue;
2586
2587               if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2588                 $ghostname = '';
2589                 break;
2590               }
2591             }
2592             if ($ghostname != '')
2593               break;
2594           }
2595
2596           $ghost_user->name = $ghostname;
2597
2598           if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2599             $this->standup_update($ghost_user);
2600           }
2601           else {
2602             log_main("chatt_send pre table update");
2603             $this->table_update($ghost_user);
2604           log_main("chatt_send post table update");
2605           }
2606         } // if ($ghost_auth == FALSE
2607         else {
2608           // FIXME: cacciare il vecchio utente room && table (if needed)
2609           $ghost_user->the_end = TRUE;
2610           $ghost_user->lacc = 0;
2611           $this->garbage_manager(TRUE);
2612         }
2613       } //  if ($ghost > -1) {
2614
2615       $real_idx = $idx;
2616       if ($login_exists)
2617         $idx = -($idx + 1);
2618       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));
2619
2620       $ret = $this->user[$real_idx];
2621       if (defined('CURL_DE_SAC_VERS')) {
2622           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2623       }
2624       return ($ret);
2625     }
2626
2627     return (FALSE);
2628   }
2629
2630   function standup_update($user)
2631   {
2632     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2633       $user_cur = $this->user[$i];
2634       if ($user_cur->is_active() == FALSE)
2635         continue;
2636
2637       log_main("STANDUP START: ".$user_cur->stat);
2638
2639       if ($user_cur->stat == 'room') {
2640         $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2641         if ($user->idx_get() == $i) {
2642           $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2643         }
2644         log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2645
2646         $user_cur->step_inc();
2647       }
2648     }
2649   }
2650
2651   function dump_data()
2652   {
2653       $brisk_ser = serialize($this);
2654       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2655       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2656           return (TRUE);
2657       }
2658
2659       return (FALSE);
2660   }
2661
2662   function standup_content($user)
2663   {
2664     $ret = "";
2665
2666     if ($user->stat != 'room')
2667       return;
2668
2669     $content = ' j_stand_cont( [ ';
2670
2671     $user_cur_id = $user->idx_get();
2672     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2673         if ($this->user[$i]->is_active() == FALSE // is not active user
2674             || $this->user[$i]->stat != "room"    // or the stat isn't 'room'
2675             || $this->user[$i]->name == "")       // or the name is empty, happens when user is reset (TODO: check it)
2676         continue;
2677
2678       $flags = $this->user[$i]->flags;
2679
2680       // sql record exists AND last donate > 2013-01-01
2681       if ($this->user[$i]->is_supp_custom()) {
2682           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2683       }
2684       else {
2685           $supp_comp_s = '';
2686       }
2687
2688       if ($this->user[$i]->subst == "standup") {
2689           if ($user_cur_id == $i) {
2690               $flags |= 1;
2691           }
2692
2693           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2694                               xcape($this->user[$i]->name), $supp_comp_s);
2695           $ct++;
2696       }
2697     }
2698     $content .= ' ]);';
2699
2700     return ($content);
2701   }
2702
2703   function table_content($user, $table_idx)
2704   {
2705     $content = "";
2706     $ret = "";
2707     // TODO
2708     //
2709     //   Si possono usare i dati nella classe table
2710     //
2711
2712     $sess = $user->sess;
2713     $table = $this->table[$table_idx];
2714
2715     if ($user->stat != 'room')
2716       return;
2717
2718     $user_cur_id = $user->idx_get();
2719     $content = "[ ";
2720     for ($i = 0 ; $i < $table->player_n ; $i++) {
2721         $user_cur = $this->user[$table->player[$i]];
2722
2723         $flags = $user_cur->flags;
2724
2725         if ($user_cur_id == $table->player[$i])
2726             $flags |= 1;
2727
2728         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2729         if ($user_cur->is_supp_custom())
2730             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2731         else
2732             $supp_comp_s = '';
2733
2734         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2735                             xcape($user_cur->name), $supp_comp_s);
2736     }
2737
2738     $content .= ' ]';
2739
2740     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2741
2742     return ($ret);
2743   }
2744
2745   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2746   {
2747       GLOBAL $G_ban_list, $G_black_list, $G_cloud_smasher;
2748
2749       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2750
2751       fprintf(STDERR, "\n\n\n PRE_BLACK [%s]\n\n\n", $addr);
2752       if ($this->black_check($addr)) {
2753           // TODO: waiting async 5 sec before close
2754           fprintf(STDERR, "\n\n\n BLACK CHECK\n\n\n");
2755           return (FALSE);
2756       }
2757       if ($path != "" && $path != "index.php") {
2758           if ($this->cloud_check($addr)) {
2759               // TODO: waiting async 5 sec before close
2760               return (FALSE);
2761           }
2762       }
2763
2764       $enc = get_encoding($header);
2765       if (isset($header['User-Agent'])) {
2766           if (strstr($header['User-Agent'], "MSIE")) {
2767               $transp_type = "htmlfile";
2768           }
2769           else {
2770               $transp_type = "xhr";
2771           }
2772       }
2773       else {
2774           $transp_type = "iframe";
2775       }
2776       force_no_cache($header_out);
2777
2778       switch ($path) {
2779       case "":
2780       case "index.php":
2781           ob_start();
2782           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2783           $content = ob_get_contents();
2784           ob_end_clean();
2785
2786           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2787           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2788           return TRUE;
2789
2790           break;
2791       case "index_wr.php":
2792           //
2793           // Enhance required: in the POST case, after the header you must get content
2794           //                   from the socket, waiting if necessary
2795           //
2796
2797           ob_start();
2798           index_wr_main($this, $addr, $get, $post, $cookie);
2799           $content = ob_get_contents();
2800           ob_end_clean();
2801
2802           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2803           return TRUE;
2804
2805           break;
2806       case "index_rd.php":
2807           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2808               $transp = "iframe";
2809           if ($transp == 'websocket')
2810               $enc = 'plain';
2811
2812           do {
2813               if (!isset($cookie['sess'])
2814                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2815
2816                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2817
2818                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2819                   return TRUE;
2820
2821                   break;
2822               }
2823               $this->sess_cur_set($user->sess);
2824               // close a previous opened index_read_ifra socket, if exists
2825               if (($prev = $user->rd_socket_get()) != NULL) {
2826                   $s_a_p->socks_unset($user->rd_socket_get());
2827                   fclose($user->rd_socket_get());
2828                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2829                   $user->rd_socket_set(NULL);
2830               }
2831
2832               $content = "";
2833               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2834               $response = headers_render($header_out, -1).$user->chunked_content($content);
2835               $response_l = mb_strlen($response, "ASCII");
2836
2837               $wret = @fwrite($new_socket, $response, $response_l);
2838               if ($wret < $response_l) {
2839                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2840                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2841               }
2842               else {
2843                   $user->rd_cache_set("");
2844               }
2845               fflush($new_socket);
2846
2847
2848               $s_a_p->socks_set($new_socket, $user, NULL);
2849               $user->rd_socket_set($new_socket);
2850               printf(" - qui ci siamo - ");
2851               return TRUE;
2852           } while (FALSE);
2853
2854           return FALSE;
2855           break;
2856       case 'test.php':
2857           if (!(BRISK_DEBUG & DBG_ENGI))
2858               return (FALSE);
2859           fprintf(STDERR, "TEST.PHP running\n");
2860           if (isset($post['data'])) {
2861               $content = $post['data'];
2862           }
2863           else {
2864               $content = "NO DATA AVAILABLE";
2865           }
2866           $header_out['Content-Type'] = 'text/plain';
2867           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2868           return TRUE;
2869           break;
2870       default:
2871           /* FAR TODO: move all into an array of registered sub-apps */
2872           $subs = "briskin5/";
2873           $subs_l = strlen($subs);
2874           if (!strncmp($path, $subs, $subs_l)) {
2875               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2876               return ($ret);
2877           }
2878           break;
2879       }
2880
2881       return (FALSE);
2882   }
2883
2884   function match_add($idx, $match)
2885   {
2886       $this->match[$idx] = $match;
2887   }
2888
2889   function match_del($idx)
2890   {
2891       unset($this->match[$idx]);
2892   }
2893
2894   function match_get($idx, $token)
2895   {
2896       if (isset($this->match[$idx])) {
2897           if (   $token == NULL
2898               || $token == $this->match[$idx]->table_token) {
2899               return ($this->match[$idx]);
2900           }
2901       }
2902       return NULL;
2903   }
2904   function sess_cur_set($sess)
2905   {
2906       static::$sess_cur = $sess;
2907   }
2908
2909   static function sess_cur_get()
2910   {
2911       return(static::$sess_cur);
2912   }
2913 } // end class Brisk
2914
2915 function make_seed()
2916 {
2917   list($usec, $sec) = explode(' ', microtime());
2918   return (float) $sec + ((float) $usec * 100000);
2919 }
2920
2921 function btrace_line($ar)
2922 {
2923     GLOBAL $G_btrace_pref_sub;
2924
2925     $ret = "";
2926     for ($i = 0 ; $i < count($ar) ; $i++) {
2927         $with_class = isset($ar[$i]['class']);
2928         $with_file  = isset($ar[$i]['file']);
2929         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2930                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2931                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2932                         ($with_file ? $ar[$i]['line'] : ""));
2933     }
2934
2935     return ($ret);
2936 }
2937
2938 function trace_ftok($id, $add)
2939 {
2940     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2941     $tok=@ftok($id, $add);
2942
2943     log_shme($tok.": ".$id." + ".$add);
2944
2945     return ($tok);
2946 }
2947
2948 function log_mop($step, $log)
2949 {
2950     GLOBAL $PHP_SELF;
2951
2952     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2953         return;
2954
2955     $sess = Brisk::sess_cur_get();
2956     if (isset($sess) == FALSE)
2957         $ssess = "XXXX";
2958     else
2959         $ssess = $sess;
2960
2961     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2962         return;
2963
2964     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2965         $btrace = btrace_line(debug_backtrace());
2966     else
2967         $btrace = "";
2968     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2969         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2970         fclose($fp);
2971     }
2972 }
2973
2974 function log_step($log)
2975 {
2976     GLOBAL $PHP_SELF;
2977
2978     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2979         return;
2980
2981     $sess = Brisk::sess_cur_get();
2982     if (isset($sess) == FALSE)
2983         $ssess = "XXXX";
2984     else
2985         $ssess = $sess;
2986
2987     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2988         return;
2989
2990     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2991         $btrace = btrace_line(debug_backtrace());
2992     else
2993         $btrace = "";
2994     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
2995         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
2996         fclose($fp);
2997     }
2998 }
2999
3000
3001
3002 function log_cds($log)
3003 {
3004     GLOBAL $PHP_SELF;
3005
3006     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
3007         return;
3008
3009     $sess = Brisk::sess_cur_get();
3010     if (isset($sess) == FALSE)
3011         $ssess = "XXXX";
3012     else
3013         $ssess = $sess;
3014
3015     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
3016         return;
3017
3018     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3019         $btrace = btrace_line(debug_backtrace());
3020     else
3021         $btrace = "";
3022     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
3023         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3024         fclose($fp);
3025     }
3026 }
3027
3028
3029 function log_only2($log)
3030 {
3031     GLOBAL $PHP_SELF;
3032
3033     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
3034         return;
3035
3036     $sess = Brisk::sess_cur_get();
3037     if (isset($sess) == FALSE)
3038         $ssess = "XXXX";
3039     else
3040         $ssess = $sess;
3041
3042     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
3043         return;
3044
3045     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3046         $btrace = btrace_line(debug_backtrace());
3047     else
3048         $btrace = "";
3049     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3050         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3051         fclose($fp);
3052     }
3053 }
3054
3055 function log_crit($log)
3056 {
3057     GLOBAL $PHP_SELF;
3058
3059     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
3060         return;
3061
3062     $sess = Brisk::sess_cur_get();
3063     if (isset($sess) == FALSE)
3064         $ssess = "XXXX";
3065     else
3066         $ssess = $sess;
3067
3068     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
3069         return;
3070
3071     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3072         $btrace = btrace_line(debug_backtrace());
3073     else
3074         $btrace = "";
3075     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3076         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3077         fclose($fp);
3078     }
3079 }
3080
3081 function log_only($log)
3082 {
3083     GLOBAL $PHP_SELF;
3084
3085     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
3086         return;
3087
3088     $sess = Brisk::sess_cur_get();
3089     if (isset($sess) == FALSE)
3090         $ssess = "XXXX";
3091     else
3092         $ssess = $sess;
3093
3094     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
3095         return;
3096
3097     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3098         $btrace = btrace_line(debug_backtrace());
3099     else
3100         $btrace = "";
3101     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3102         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3103         fclose($fp);
3104     }
3105 }
3106
3107 function log_main($log)
3108 {
3109     GLOBAL $PHP_SELF;
3110
3111     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
3112         return;
3113
3114     $sess = Brisk::sess_cur_get();
3115     if (isset($sess) == FALSE)
3116         $ssess = "XXXX";
3117     else
3118         $ssess = $sess;
3119
3120     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
3121         return;
3122
3123     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3124         $btrace = btrace_line(debug_backtrace());
3125     else
3126         $btrace = "";
3127     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3128         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3129         fclose($fp);
3130     }
3131 }
3132
3133 function log_rd($log)
3134 {
3135     GLOBAL $PHP_SELF;
3136
3137     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
3138         return;
3139
3140     $sess = Brisk::sess_cur_get();
3141     if (isset($sess) == FALSE)
3142         $ssess = "XXXX";
3143     else
3144         $ssess = $sess;
3145
3146     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
3147         return;
3148
3149     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3150         $btrace = btrace_line(debug_backtrace());
3151     else
3152         $btrace = "";
3153     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3154         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3155         fclose($fp);
3156     }
3157 }
3158
3159 function log_rd2($log)
3160 {
3161     GLOBAL $PHP_SELF;
3162
3163     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
3164         return;
3165
3166     $sess = Brisk::sess_cur_get();
3167     if (isset($sess) == FALSE)
3168         $ssess = "XXXX";
3169     else
3170         $ssess = $sess;
3171
3172     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
3173         return;
3174
3175     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3176         $btrace = btrace_line(debug_backtrace());
3177     else
3178         $btrace = "";
3179
3180     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3181         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3182         fclose($fp);
3183     }
3184 }
3185
3186 function log_send($log)
3187 {
3188     GLOBAL $PHP_SELF;
3189
3190     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3191         return;
3192
3193     $sess = Brisk::sess_cur_get();
3194     if (isset($sess) == FALSE)
3195         $ssess = "XXXX";
3196     else
3197         $ssess = $sess;
3198
3199     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3200         return;
3201
3202     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3203         $btrace = btrace_line(debug_backtrace());
3204     else
3205         $btrace = "";
3206     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3207         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3208         fclose($fp);
3209     }
3210 }
3211
3212 function log_lock($log)
3213 {
3214     GLOBAL $PHP_SELF;
3215
3216     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3217         return;
3218
3219     $sess = Brisk::sess_cur_get();
3220     if (isset($sess) == FALSE)
3221         $ssess = "XXXX";
3222     else
3223         $ssess = $sess;
3224
3225     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3226         return;
3227
3228     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3229         $btrace = btrace_line(debug_backtrace());
3230     else
3231         $btrace = "";
3232     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3233         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3234         fclose($fp);
3235     }
3236 }
3237
3238 function log_wr($log)
3239 {
3240     GLOBAL $PHP_SELF;
3241
3242     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3243         return;
3244
3245     $sess = Brisk::sess_cur_get();
3246     if (isset($sess) == FALSE)
3247         $ssess = "XXXX";
3248     else
3249         $ssess = $sess;
3250
3251     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3252         return;
3253
3254     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3255         $btrace = btrace_line(debug_backtrace());
3256     else
3257         $btrace = "";
3258     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3259         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3260         fclose($fp);
3261     }
3262 }
3263
3264 function log_load($log)
3265 {
3266     GLOBAL $PHP_SELF;
3267
3268     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3269         return;
3270
3271     $sess = Brisk::sess_cur_get();
3272     if (isset($sess) == FALSE)
3273         $ssess = "XXXX";
3274     else
3275         $ssess = $sess;
3276
3277     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3278         return;
3279
3280     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3281         $btrace = btrace_line(debug_backtrace());
3282     else
3283         $btrace = "";
3284     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3285         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3286         fclose($fp);
3287     }
3288 }
3289
3290 function log_auth($sess, $log)
3291 {
3292     GLOBAL $PHP_SELF;
3293
3294     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3295         return;
3296
3297     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3298         return;
3299
3300     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3301         $btrace = btrace_line(debug_backtrace());
3302     else
3303         $btrace = "";
3304     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3305         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3306         fclose($fp);
3307     }
3308 }
3309
3310 function log_shme($log)
3311 {
3312     GLOBAL $PHP_SELF;
3313
3314     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3315         return;
3316
3317     $sess = Brisk::sess_cur_get();
3318     if (isset($sess) == FALSE)
3319         $ssess = "XXXX";
3320     else
3321         $ssess = $sess;
3322
3323     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3324         return;
3325
3326     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3327         $btrace = btrace_line(debug_backtrace());
3328     else
3329         $btrace = "";
3330     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3331         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3332         fclose($fp);
3333     }
3334 }
3335
3336
3337
3338 // function log_legal($curtime, $sess, $name, $where, $mesg)
3339 function log_legal($curtime, $addr, $user, $where, $mesg)
3340 {
3341
3342   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3343     /* Unix time | session | nickname | IP | where was | mesg */
3344     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
3345                         ($user->is_auth() ? 'A' : 'N'),
3346                         $user->name, $addr, $where , $mesg));
3347     fclose($fp);
3348   }
3349 }
3350
3351 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3352 {
3353   $ret = "";
3354
3355   if ($isstanding) {
3356     if ($sitted < PLAYERS_N) {
3357       if ($allowed)
3358         $act = 'sit';
3359       else
3360         $act = 'reserved';
3361     }
3362   }
3363   else {
3364     if ($table == $cur_table)
3365       $act = 'wake';
3366     else
3367       $act = 'none';
3368   }
3369
3370   if ($act != '')
3371     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3372
3373   return ($ret);
3374 }
3375
3376 function show_notify($text, $tout, $butt, $w, $h)
3377 {
3378   log_main("SHOW_NOTIFY: ".$text);
3379   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3380 }
3381
3382 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3383 {
3384   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3385   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);
3386 }
3387
3388 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3389 {
3390   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3391
3392   $butts = "";
3393   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3394       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3395   }
3396
3397   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3398                  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);
3399 }
3400
3401
3402 function root_welcome($user)
3403 {
3404   GLOBAL $root_wellarr, $G_lang;
3405   $ret = "";
3406
3407   $curtime = time();
3408   $dt = date("H:i ", $curtime);
3409
3410   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3411       $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3412
3413   return ($ret);
3414 }
3415
3416
3417
3418 function validate_sess($sess)
3419 {
3420   if (strlen($sess) == SESS_LEN)
3421     return (TRUE);
3422   else
3423     return (FALSE);
3424 }
3425
3426 function validate_name($name)
3427 {
3428     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3429
3430   for ($i = 0 ; $i < mb_strlen($name_new) ; $i++) {
3431     $c = $name_new[$i];
3432     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3433       return ($name_new);
3434   }
3435
3436   return (FALSE);
3437 }
3438
3439 function playsound($filename)
3440 {
3441   return (sprintf('playsound("flasou", "%s");', $filename));
3442 }
3443
3444 function secstoword($secs)
3445 {
3446   GLOBAL $G_lang;
3447
3448   $ret = "";
3449
3450   $mins = floor($secs / 60);
3451   $secs = $secs % 60;
3452   if ($G_lang == 'en') {
3453     if ($mins > 0)
3454       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3455
3456     if ($secs > 0)
3457       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3458   }
3459   else {
3460     if ($mins > 0)
3461       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3462
3463     if ($secs > 0)
3464       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3465   }
3466   return ($ret);
3467 }
3468
3469 function sharedmem_sz($tok)
3470 {
3471   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3472     log_main("shmop_open failed");
3473     return (-1);
3474   }
3475   $shm_sz = shmop_size($shm_id);
3476   shmop_close($shm_id);
3477
3478   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3479   return ($shm_sz);
3480 }
3481
3482 class Warrant {
3483     static $delta_t;
3484
3485   static function lock_data($is_exclusive)
3486   {
3487       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3488           self::$delta_t = microtime(TRUE);
3489           log_lock("LOCK   warrant      [".self::$delta_t."]");
3490
3491           return ($res);
3492       }
3493
3494       return (FALSE);
3495   }
3496
3497   static function unlock_data($res)
3498   {
3499     GLOBAL $sess;
3500
3501     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3502
3503     file_unlock($res);
3504   }
3505 }
3506
3507 class Poll {
3508     static $delta_t;
3509
3510   static function lock_data($is_exclusive)
3511   {
3512       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3513           self::$delta_t = microtime(TRUE);
3514           log_lock("LOCK   poll         [".self::$delta_t."]");
3515
3516           return ($res);
3517       }
3518
3519       return (FALSE);
3520   }
3521
3522   static function unlock_data($res)
3523   {
3524     GLOBAL $sess;
3525
3526     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3527
3528     file_unlock($res);
3529   }
3530 }
3531
3532 function carousel_top()
3533 {
3534     $what = rand(1,2);
3535     if ($what == 1) {
3536         $rn = rand(1, 3);
3537         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));
3538         }
3539     else {
3540         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>'));
3541     }
3542 }
3543
3544 /* function login_consistency:
3545        name length must be less or equal than 12 chars,
3546        no more than 2 consecutive same character (or generic digits) are allowed */
3547 function login_consistency($name)
3548 {
3549     $old_c = '';
3550     if (($len = mb_strlen($name)) > 12) {
3551         return FALSE;
3552     }
3553
3554     for ($i = 0 ; $i < mb_strlen($name) ; $i++) {
3555         $c = mb_substr($name, $i, 1);
3556         if (mb_ereg_match ("[a-zA-Z0-9]", $c)) {
3557             if (mb_ereg_match ("[0-9]", $c)) {
3558                 $c = "0";
3559             }
3560             if ($old_c != $c) {
3561                 $old_c = $c;
3562                 $old_ct = 1;
3563             }
3564             else {
3565                 $old_ct++;
3566                 if ($old_ct > 2) {
3567                     return (FALSE);
3568                 }
3569             }
3570         }
3571         else {
3572             return (FALSE);
3573         }
3574     }
3575     return (TRUE);
3576 }
3577 ?>