web/Obj/brisk.phh

   1 <?php
   2 /*
   3  *  brisk - brisk.phh
   4  *
   5  *  Copyright (C) 2006-2015 Matteo Nastasi
   6  *                          mailto: nastasi@alternativeoutput.it
   7  *                                  matteo.nastasi@milug.org
   8  *                          web: http://www.alternativeoutput.it
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABLILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details. You should have received a
  19  * copy of the GNU General Public License along with this program; if
  20  * not, write to the Free Software Foundation, Inc, 59 Temple Place -
  21  * Suite 330, Boston, MA 02111-1307, USA.
  22  *
  23  */
  24
  25
  26 define('BRISK_CONF', "brisk.conf.pho");
  27 define('FTOK_PATH', "/var/lib/brisk");
  28 define('LEGAL_PATH', "/tmp/legal_brisk");
  29 define('PROXY_PATH', "/var/lib/brisk_proxy");
  30 define('TABLES_N', 36);
  31 define('TABLES_APPR_N', 12);
  32 define('TABLES_AUTH_N', 8);
  33 define('TABLES_CERT_N', 4);
  34 define('PLAYERS_N', 3);
  35 define('MAX_POINTS', 5);
  36 define('MAX_PLAYERS', (20 + (PLAYERS_N * TABLES_N)));
  37 define('SHM_DIMS_MIN', (50000 + 10000 * TABLES_N + 15000 * MAX_PLAYERS));
  38 define('SHM_DIMS_MAX', SHM_DIMS_MIN + 1048576);
  39 define('SHM_DIMS_DLT', 65536);
  40
  41 define('SHM_DIMS_U_MIN', 4096);
  42 define('SHM_DIMS_U_MAX', 65536);
  43 define('SHM_DIMS_U_DLT', 4096);
  44
  45 define('COMM_N', 18);
  46 define('COMM_GEN_N', 50);
  47
  48 define('CHAT_N', 3);
  49 define('CHAT_ILL_TIME', 6);
  50 define('CHAT_ENABLED', TRUE);
  51
  52 define('SESS_LEN', 13);
  53 define('STREAM_TIMEOUT', 60);
  54 /* FIXME: move to sac-a-push .phh */
  55 /* TIME_RD define the server-side timeout, after half of it a ping request
  56    is sent to client, after this time the client is log out */
  57 define('EXPIRE_TIME_RD', 180);
  58 define('EXPIRE_TIME_SMAMMA', 360);
  59 define('EXPIRE_TIME_WAG', 10);
  60 define('WAKEUP_TIME', 12);
  61 // BAN_TIME da allineare anche in commons.js
  62 define('BAN_TIME', 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 = '{ "listen": { "__type": "radio" } }';
1421         $content = '{ "listen": {"val": "' . ($user->flags & USER_FLAG_ISOLAUTH ? "2" :
1422                                               ($user->flags & USER_FLAG_LISTAUTH ? "1" : "0")) .
1423             '" } }';
1424         $ret .= sprintf('g_prefsf.fields_descr_set(JSON.parse(\'%s\'));', $model);
1425         $ret .= sprintf('g_prefsf.json2dom(JSON.parse(\'%s\'));', $content);
1426     }
1427
1428     if ($user->subst == 'standup')
1429       $ret .= "tra.show(); ";
1430     else
1431       $ret .= "tra.hide(); ";
1432
1433     $ret .= sprintf('stat = "%s";',  $user->stat);
1434
1435     $ret .= root_welcome($user);
1436     if ($user->flags & USER_FLAG_DBFAILED) {
1437         $ret .= "gst.st = ".($user->step+1)."; ";
1438         $ret .= show_notify($mlang_brisk['db_failed'][$G_lang], 0, $mlang_brisk['btn_close'][$G_lang], 400, 140);
1439     }
1440
1441     $ret .= sprintf('subst = "%s";', $user->subst);
1442     $ret .= $user->myname_innerHTML();
1443
1444     for ($i = 0 ; $i < TABLES_N ; $i++) {
1445
1446       $ret .= $this->table_content($user, $i);
1447
1448       $ret .=  $this->table[$i]->act_content($user);
1449       if ($this->table[$i]->wag_own != -1)
1450         $ret .= sprintf('tra.add(%d, "%s: %s"); ', $i,  $this->user[$this->table[$i]->wag_own]->name, $this->table[$i]->wag_com);
1451       else
1452         $ret .= sprintf('tra.rem(%d); ', $i);
1453     }
1454     $ret .= $this->standup_content($user);
1455     $ret .= "setTimeout(preload_images, 0, g_preload_img_arr, g_imgct); ";
1456
1457     return ($ret);
1458   }
1459
1460   function room_wakeup($user)
1461   {
1462     $table_idx = $user->table;
1463     $table = $this->table[$table_idx];
1464
1465     log_main("WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1466
1467     $curtime = time();
1468
1469     $from_table = ($user->stat == "table");
1470     if ($from_table) {
1471         log_main("WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1472
1473         for ($i = 0 ; $i < $table->player_n ; $i++) {
1474             $user_cur = $this->user[$table->player[$i]];
1475             log_main("PREIMPOST: INLOOP name: ".$user_cur->name);
1476
1477             if ($user->idx_get() != $table->player[$i]) {
1478                 $user_cur->stat_set("room");
1479                 $user_cur->subst = "sitdown";
1480                 $user_cur->laccwr = $curtime;
1481             }
1482             else if ($user->is_active()) {
1483                 $user_cur->stat_set("room");
1484                 $user_cur->subst = "standup";
1485                 $user_cur->laccwr = $curtime;
1486                 $user_cur->table = -1;
1487             }
1488         }
1489     }
1490     else {
1491         $user->stat_set("room");
1492         $user->subst = "standup";
1493         $user->laccwr = $curtime;
1494     }
1495
1496     $remove_wagon = FALSE;
1497     if($table->wag_own == $user->idx_get()) {
1498         $table->wag_reset($curtime);
1499         $remove_wagon = TRUE;
1500     }
1501
1502     /* aggiorna l'array dei giocatori al tavolo. */
1503     $table->user_rem($this, $user);
1504
1505     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1506       $user_cur = $this->user[$i];
1507       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1508         continue;
1509
1510       // log_main("VALORI: name: ".$user_cur->name."from_table: ".$from_table."  tab: ".$user_cur->table." taix: ".$table_idx."  ucur: ".$user_cur."  us: ".$user);
1511
1512       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1513       if ($from_table && ($user_cur->table == $table_idx || $user->idx_get() == $i)) {
1514         $ret .= 'gst.st_loc++; xstm.stop(); window.onunload = null; window.onbeforeunload = null; document.location.assign("index.php");|';
1515         // $ret .= 'gst.st_loc++; document.location.assign("index.php");|';
1516         log_main("DOCUMENT.index.php: from table");
1517       }
1518       else if ($user_cur->stat == "room") {
1519         log_main("DOCUMENT.index.php: from table");
1520
1521         $ret .= $this->table_content($user_cur, $table_idx);
1522         $ret .= $this->standup_content($user_cur);
1523
1524         // $ret .= table_act_content(FALSE, 0, $table_idx, $user->table, FALSE);
1525         $ret .= $table->act_content($user);
1526
1527         if ($user->idx_get() == $i) {
1528           // set the new status
1529           $ret .=  'subst = "standup"; tra.show(); ';
1530           // clean the action buttons in other tables
1531           for ($e = 0 ; $e < TABLES_N ; $e++) {
1532             if ($this->table[$e]->player_n < PLAYERS_N) {
1533               $ret .= $this->table[$e]->act_content($user);
1534             }
1535           }
1536         }
1537         else {
1538           $ret .= $table->act_content($user_cur);
1539         }
1540       }
1541       log_wr("ROOM_WAKEUP: ".$ret);
1542       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1543       $user_cur->step_inc();
1544     }
1545   }
1546
1547   function room_join_wakeup($user, $update_lacc = FALSE, $trans_delta)
1548   {
1549     $table_idx = $user->table;
1550     $table = $this->table[$table_idx];
1551
1552     log_main("JOIN_WAKEUP: begin function table:".$table_idx."  stat: ".$user->stat."  subst: ".$user->subst);
1553
1554     $curtime = time();
1555     $user_wup = array();
1556     $user_wup_n = 0;
1557     $user_tab = array();
1558     $user_tab_n = 0;
1559     log_main("JOIN WAKEUP: from table [".$user->table."] nplayers_n: ".$this->table[$user->table]->player_n);
1560
1561     for ($i = 0 ; $i < $table->player_n ; $i++) {
1562         $user_cur = $this->user[$table->player[$i]];
1563         log_main("PREIMPOST INLOOP name: ".$user_cur->name);
1564         if ($user_cur->is_empty()) {
1565             continue;
1566         }
1567         if ($update_lacc == TRUE) {
1568             $user_cur->laccwr = $curtime;
1569         }
1570         log_main("cur: ".$user_cur->name."  subst: ".$user_cur->subst);
1571         if ($user_cur->subst == "shutdowned") {
1572             $user_cur->stat_set("room");
1573             $user_cur->subst = "sitdown";
1574         }
1575         else if ($user_cur->subst == "shutdowner") {
1576             $user_cur->stat_set("room");
1577             $user_cur->subst = "standup";
1578             $user_cur->table = -1;
1579             $user_wup[$user_wup_n++] = $user_cur;
1580
1581             $remove_wagon = FALSE;
1582             if($table->wag_own == $table->player[$i]) {
1583                 $remove_wagon = TRUE;
1584                 $table->wag_reset($curtime);
1585             }
1586         }
1587         $user_tab[$user_tab_n++] = $table->player[$i];
1588     }
1589
1590     for ($wup_idx = 0 ; $wup_idx < $user_wup_n  ; $wup_idx++)
1591       $table->user_rem($this, $user_wup[$wup_idx]);
1592
1593     /* aggiorna l'array dei giocatori al tavolo. */
1594
1595     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1596       log_main("START LOOP");
1597       $user_cur = $this->user[$i];
1598       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') { // is not active user or the stat isn't 'room'
1599         log_main("name: ".$user_cur->name."skip   subst: ".$user_cur->subst);
1600         continue;
1601       }
1602
1603       log_main("___");
1604       log_main("VALORI name: ".$user_cur->name."  tab: ".$user_cur->table." taix: ".$table_idx);
1605
1606       $ret = "gst.st = ".($user_cur->step+1)."; ".($remove_wagon ? sprintf("tra.rem(%d);",$table_idx) : "");
1607       if ($user_cur->stat == "room") {
1608         log_main("DOCUMENT.index.php from table");
1609
1610         $ret .= $this->table_content($user_cur, $table_idx);
1611         $ret .= $this->standup_content($user_cur);
1612
1613         $ret .= $table->act_content($user_cur);
1614
1615
1616         for ($tab_idx = 0 ; $tab_idx < $user_tab_n  ; $tab_idx++)
1617             if ($user_tab[$tab_idx] == $i)
1618                 break;
1619
1620         // for users that wakeup the room will be reconstructed by index_rd.php
1621         if ($tab_idx < $user_tab_n) {
1622           log_main("PRE show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1623
1624 //        ARRAY_POP DISABLED
1625 //           if ($trans_delta == 0)
1626 //             while (array_pop($user_cur->comm) != NULL);
1627
1628           $user_cur->trans_step = $user_cur->step + 1 + $trans_delta;
1629           $user_cur->comm[$user_cur->step % COMM_N] = "";
1630           $user_cur->step_inc();
1631           $user_cur->comm[$user_cur->step % COMM_N] = $this->show_room(($user_cur->step + 1), $user_cur);
1632           $user_cur->step_inc();
1633           log_main("POST show_room username: ".$user_cur->name."  STEP: ".$user_cur->step);
1634
1635           continue;
1636         }
1637         log_main("JOIN_WAKEUP wup_idx ".$wup_idx."  wup_n ".$user_wup_n);
1638
1639         log_main("JOIN_WAKEUP more");
1640
1641         $ret .= $table->act_content($user_cur);
1642
1643         log_main("JOIN_WAKEUP end more");
1644       }
1645       log_wr("ROOM_JOIN_WAKEUP: ".$ret);
1646       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1647       $user_cur->step_inc();
1648     }
1649   }
1650
1651   /*
1652     function info_show($user, $target, $dt)
1653
1654     if success return assoc. array with "ret" => 0 and other fields
1655     else return an assoc. array with "ret: != 0 and "mesg" with an error description
1656   */
1657   function info_show($user, $target, $dt)
1658   {
1659       GLOBAL $G_lang, $mlang_brisk, $G_base;
1660
1661       $mesg = "";
1662       $user_code = -1;
1663       $ret = 0;
1664
1665       do {
1666           if ($target == "") {
1667               $ret = 1;
1668               break;
1669           }
1670           if (($bdb = BriskDB::create()) == FALSE) {
1671               $ret = 2;
1672               break;
1673           }
1674           if ($target == $user->name) {
1675               $ret = 3;
1676               $mesg = sprintf($mlang_brisk['inf_self'][$G_lang]);
1677               break;
1678           }
1679           if (($user_item = $bdb->getitem_bylogin($target, $user_code)) == FALSE) {
1680               $ret = 4;
1681               break;
1682           }
1683           if (($guar_item = $bdb->getitem_bycode($user_item->guar_code_get())) != FALSE) {
1684               $guar_login = $guar_item->login_get();
1685           }
1686           else {
1687               $guar_login = "";
1688           }
1689           $user_tos_vers = $user_item->tos_vers_get();
1690
1691           $partyskill = $bdb->usersnet_partyskill($user->code, $user_item->code);
1692
1693           $widefriend = $bdb->usersnet_widefriend($user->code, $user_item->code);
1694           $widefriend['skill'] = $bdb->usersnet_wideskill($user->code, $user_item->code);
1695           $narrowfriend = $bdb->usersnet_narrowfriend($user->code, $user_item->code);
1696           $narrowfriend['skill'] = $bdb->usersnet_narrowskill($user->code, $user_item->code);
1697
1698           if (($usersnet_item = $bdb->usersnet_bycode($user->code, $user_item->code,
1699                                                       $widefriend, $narrowfriend)) == FALSE) {
1700               $usersnet_item = $bdb->usersnet_default($user->code, $user_item->code,
1701                                                       $widefriend, $narrowfriend);
1702           }
1703
1704           if (versions_cmp($user_tos_vers, "1.2") < 0) {
1705               $mesg = sprintf($mlang_brisk['tos_old'][$G_lang], xcape($target));
1706           }
1707           else if ($guar_login == "") {
1708               $mesg = sprintf($mlang_brisk['inf_nfd'][$G_lang], xcape($target));
1709           }
1710       } while (0);
1711
1712       if ($ret > 0 && $mesg == "") {
1713           $mesg = sprintf($mlang_brisk['inf_err'][$G_lang], $ret);
1714       }
1715
1716       if ($ret != 0) {
1717           $jret = json_encode(array("ret" => $ret, "mesg" => $mesg));
1718       }
1719       else {
1720           $jret = json_encode(array("ret" => 0,
1721                                     "mesg" => "",
1722                                     "login" => $target,
1723                                     // FIXME: state internationalization
1724                                     "state" =>
1725                                     ($user_item->type & USER_FLAG_TY_APPR ? "Apprendista" :
1726                                      ($user_item->type & USER_FLAG_TY_CERT ? "Certificato" :
1727                                       ($user_item->type & (USER_FLAG_TY_NORM | USER_FLAG_TY_SUPER) ?
1728                                        "Normale" : "Stato sconosciuto"))),
1729                                     "guar" => ($user_item->type & USER_FLAG_TY_APPR ?
1730                                                "" : $guar_login),
1731                                     "party" => $partyskill,
1732                                     "match" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->match_cnt) ,
1733                                     "game" => (versions_cmp($user_tos_vers, "1.4") < 0 ? "non autorizzato" : $user_item->game_cnt),
1734                                     "friend" => usersnet_friend_getlabel($usersnet_item->friend),
1735                                     "skill" => $usersnet_item->skill,
1736                                     "trust"  => $usersnet_item->trust,
1737                                     "widefriend" => $usersnet_item->widefriend,
1738                                     "narrowfriend" => $usersnet_item->narrowfriend
1739                                     ));
1740       }
1741
1742       return $jret;
1743   }
1744
1745   function info_save($user, $json_s)
1746   {
1747       GLOBAL $G_lang, $mlang_brisk, $G_base;
1748
1749       $mesg = "";
1750       $user_code = -1;
1751       $ret = 0;
1752       $subret = 0;
1753
1754       do {
1755           if (($json = json_decode($json_s)) == FALSE) {
1756               $ret = 1;
1757               break;
1758           }
1759
1760           if (($bdb = BriskDB::create()) == FALSE) {
1761               $ret = 2;
1762               break;
1763           }
1764
1765           if (($subret = $bdb->usersnet_save($user->code, $json)) != 0) {
1766               $ret = 4000 + $subret;
1767               break;
1768           }
1769       } while(0);
1770
1771       return ($ret);
1772   }
1773
1774   function room_outstandup($user)
1775   {
1776     $this->room_sitdown($user, -1);
1777   }
1778
1779   function table_update($user)
1780   {
1781     log_main("table_update: pre - USER: ".$user->name);
1782
1783     $table_idx = $user->table;
1784
1785     if ($table_idx > -1)
1786       $table = $this->table[$table_idx];
1787
1788     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1789       $ret = "";
1790       $user_cur = $this->user[$i];
1791       if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1792           continue;
1793
1794       $ret = "gst.st = ".($user_cur->step+1)."; ";
1795       if ($table_idx > -1)
1796         $ret .= $this->table_content($user_cur, $table_idx);
1797
1798       if ($user->idx_get() == $i) {
1799           $ret .= $user->myname_innerHTML();
1800       }
1801       $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1802       $user_cur->step_inc();
1803     }
1804
1805     log_main("table_update: post");
1806   }
1807
1808   function room_sitdown($user, $table_idx)
1809   {
1810       log_main("room_sitdown ".($user == FALSE ? "USER: FALSE" : "USER: ".$user->name));
1811
1812       $train_app = "";
1813
1814       if ($table_idx > -1 && $table_idx < TABLES_N) {
1815           $table = $this->table[$table_idx];
1816
1817           // wagon shutdown
1818           if ($table->wag_own != -1 && $table->player_n == PLAYERS_N) {
1819               for ($i = 0 ; $i < TABLES_N ; $i++) {
1820                   if ($table->wag_own == $table->player[$i]) {
1821                       $train_app = sprintf("tra.rem(%d); ", $table_idx);
1822                       $table->wag_reset(time());
1823                       break;
1824                   }
1825               }
1826           }
1827       }
1828
1829       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1830           $ret = "";
1831           $user_cur = $this->user[$i];
1832           if ($user_cur->is_active() == FALSE || $user_cur->stat != 'room') // is not active user or the stat isn't 'room'
1833               continue;
1834
1835           $ret = "gst.st = ".($user_cur->step+1)."; ".$train_app;
1836           if ($table_idx > -1)
1837               $ret .= $this->table_content($user_cur, $table_idx);
1838           $ret .= $this->standup_content($user_cur);
1839
1840           if ($user->idx_get() == $i) {
1841               $ret .=  'subst = "sitdown"; tra.hide(); ';
1842               // clean the action buttons in other tables
1843               for ($e = 0 ; $e < TABLES_N ; $e++) {
1844                   $ret .= $this->table[$e]->act_content($user_cur);
1845               }
1846           }
1847           else if ($table_idx > -1) {
1848               if ($table->player_n == PLAYERS_N) {
1849
1850                   $ret .= $table->act_content($user_cur);
1851               }
1852           }
1853           $user_cur->comm[$user_cur->step % COMM_N] = $ret;
1854           $user_cur->step_inc();
1855       }
1856   }
1857
1858   function kickuser($user, $out_reas)
1859   {
1860       $curtime = time();
1861
1862       fprintf(STDERR, "MOP: GHOST_SESS: %d\n", $out_reas);
1863
1864       $this->ghost_sess->push($curtime, $user->sess, $out_reas);
1865
1866       fprintf(STDERR, "MOP: status out: %s %s %d\n", $user->stat, $user->subst, $user->idx);
1867       if ($user->stat == 'table' && $user->subst != 'sitdown') {
1868           $bin5 = &$this->match[$user->table];
1869           $user_bin5 = &$bin5->user[$user->table_pos];
1870           fprintf(STDERR, "MOP: status in: %s %s %d\n", $user_bin5->stat, $user_bin5->subst, $user_bin5->idx);
1871           $bin5->table_wakeup($user_bin5);
1872           $user->the_end = TRUE;
1873           $this->room_wakeup($user);
1874           return;
1875       }
1876
1877       if ($user->stat == 'table' || $user->stat == 'room') {
1878           $user->the_end = TRUE;
1879           if ($user->subst == 'sitdown' || $user->stat == 'table') {
1880               $this->room_wakeup($user);
1881           }
1882           else if ($user->subst == 'standup') {
1883               fprintf(STDERR, "MOP: KICK here [%s]\n", btrace_line(debug_backtrace()));
1884               $this->room_outstandup($user);
1885           }
1886           else {
1887               log_rd2("LOGOUT FROM WHAT ???");
1888           }
1889       }
1890   }
1891
1892   function kickuser_by_name($name, $out_reas)
1893   {
1894       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1895           $user_out = $this->user[$i];
1896           if (strcmp($user_out->name, $name) == 0) {
1897               return ($this->kickuser($user_out, $out_reas));
1898           }
1899       }
1900       return FALSE;
1901   }
1902
1903   function kickuser_by_sess($sess, $out_reas)
1904   {
1905       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
1906           $user_out = $this->user[$i];
1907           if (strcmp($user_out->sess, $sess) == 0) {
1908               return ($this->kickuser($user_out, $out_reas));
1909           }
1910       }
1911       return FALSE;
1912   }
1913
1914   function kickuser_by_idx($idx, $out_reas)
1915   {
1916       $user_out = $this->user[$idx];
1917       return ($this->kickuser($user_out, $out_reas));
1918   }
1919
1920   function chatt_send($user, $mesg, $mlang_indwr = NULL)
1921   {
1922     GLOBAL $G_base, $G_alarm_passwd, $mlang_brisk, $G_lang;
1923     $only_you = FALSE;
1924
1925     fprintf(STDERR, "WE ARE HERE: [%s]\n", $mesg);
1926
1927     // common settings
1928     $msg = mb_substr($mesg, 6, 128, "UTF-8");
1929     $curtime = time();
1930     $dt = date("H:i ", $curtime);
1931     $target = "";
1932
1933     //
1934     //  Compute actions
1935     //
1936
1937     $to_user     = FALSE;
1938     $to_all      = FALSE;
1939     $to_room     = FALSE;
1940     $to_tabl     = FALSE;
1941     $is_normchat = FALSE;
1942     /* for old isolation management $is_ticker   = FALSE; */
1943     $update_room = FALSE;
1944
1945     if (strcmp($msg,  "/tav") == 0 ||
1946         strncmp($msg, "/tav ", 5) == 0) {
1947       do {
1948         if ($user->stat != 'room' || $user->subst != 'sitdown') {
1949           /* 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>" */
1950           $msg = $mlang_brisk['tickmust'][$G_lang];
1951           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1952
1953           break;
1954         }
1955
1956         $table = $this->table[$user->table];
1957
1958         if ($table->wag_own != -1) {
1959           // MLANG <br>Il messaggio di segnalazione del tavolo &egrave; gi&agrave; attivato.<br><br>
1960           $msg = $mlang_brisk['tickjust'][$G_lang];
1961           $to_user = show_notify($msg, 0, "chiudi", 400, 100);
1962
1963           break;
1964         }
1965
1966         $dtime = $curtime - $table->wag_tout;
1967         if ($dtime  < EXPIRE_TIME_WAG) {
1968           // MLANG - <br>Il messaggio di segnalazione del tavolo<br>&egrave; disattivato ancora per %d second%s.<br><br>
1969           $msg = sprintf($mlang_brisk['tickwait'][$G_lang],
1970                          EXPIRE_TIME_WAG - $dtime, (EXPIRE_TIME_WAG - $dtime == 1 ? ($G_lang == 'en' ? "" : "o") : ($G_lang == 'en' ? "s" : "i")));
1971           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang] , 400, 100);
1972
1973           break;
1974         }
1975
1976         $msg = substr($msg, 5);
1977
1978         $table->wag_set($user->idx_get(), $msg);
1979         $to_user = sprintf('tra.add(%d, "%s");', $user->table, xcape(sprintf("%s: %s", $user->name, $msg)));
1980         $to_room = $to_user;
1981         /* for old isolation management $is_ticker = TRUE; */
1982       } while (0);
1983     } // /tav chat command
1984     // just for development use currently
1985     else if (FALSE && strncmp($msg, "/out ", 5) == 0) {
1986         fprintf(STDERR, "MOP OUT\n");
1987         $target = substr($msg, 5);
1988         $this->kickuser_by_name($target, GHOST_SESS_REAS_ANON);
1989     }
1990     else if (strncmp($msg, "/alarm ", 7) == 0) {
1991       if (strncmp($msg, "/alarm to ", 10) == 0) {
1992         $sp_pos = strpos($msg, " ", 10);
1993         $target = substr($msg, 10, $sp_pos - 10);
1994         $alarm_check = "/alarm to ".$target." ".$G_alarm_passwd." ";
1995       }
1996       else {
1997         $target = "";
1998         $alarm_check = "/alarm ".$G_alarm_passwd." ";
1999       }
2000       do {
2001         if (strncmp($msg, $alarm_check, strlen($alarm_check)) != 0) {
2002           /* MLANG: "<br>La password digitata non &egrave; corretta.<br><br>" */
2003           $msg = $mlang_brisk['alarpass'][$G_lang];
2004           $to_user = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 100);
2005
2006           break;
2007         }
2008
2009         /* MLANG: "Alarm <b>%s</b> inviato a <b>%s</b>." */
2010         $prestr = sprintf($mlang_brisk['alarret'][$G_lang], xcape(substr($msg, strlen($alarm_check))),
2011                            ($target == "" ? $mlang_brisk['tit_all'][$G_lang] : xcape($target)) );
2012         $to_user = nickserv_msg($dt, $prestr);
2013
2014         $msg = sprintf("<br><b>%s<br><br>%s</b><br><br>",
2015                        $dt.NICKSERV, xcape(substr($msg, strlen($alarm_check))));
2016         /* MLANG: "chiudi" */
2017         $to_all = show_notify($msg, 0, $mlang_brisk['btn_close'][$G_lang], 400, 120);
2018       } while (0);
2019     } // /alarm chat command
2020     else if (strncmp($msg, "/listen ", 8) == 0) {
2021       $arg = substr($msg, 8);
2022
2023       if (strcasecmp($arg, "isolation") == 0) {
2024         $flags_old = 0;
2025         if ($user->stat == 'room' && $user->subst == 'sitdown' &&
2026             $user->table >= TABLES_AUTH_N) {
2027           $to_user = nickserv_msg($dt, $mlang_brisk['listmust'][$G_lang]);
2028
2029         }
2030         else {
2031           $user->flags &= ~USER_FLAG_MAP_AUTH;
2032           $user->flags |= USER_FLAG_ISOLAUTH;
2033           $to_user = 'list_set(\'isolation\', true, \''.$mlang_brisk['tit_onisol'][$G_lang].'\'); ';
2034         }
2035       }
2036       else if (strcasecmp($arg, "auth") == 0) {
2037         $flags_old = $user->flags;
2038         $user->flags &= ~USER_FLAG_MAP_AUTH;
2039         $user->flags |= USER_FLAG_LISTAUTH;
2040         $to_user = 'list_set(\'auth\', true, \''.$mlang_brisk['tit_onauth'][$G_lang].'\'); ';
2041       }
2042       else {
2043         $flags_old = $user->flags;
2044         $user->flags &= ~USER_FLAG_MAP_AUTH;
2045         $to_user = 'list_set(\'all\', true, \'\'); ';
2046
2047       }
2048       // if from isolation redraw standup area
2049       if (($flags_old ^ $user->flags) & USER_FLAG_ISOLAUTH) {
2050         $to_user .= 'standup_data_old = null; '.$this->standup_content($user);
2051
2052       }
2053     }
2054     else if (strcmp($msg, "/authreq") == 0) {
2055         if ($user->is_cert()) {
2056             $to_user = sprintf('authbox(300,200);');
2057         }
2058         else {
2059             /* 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." */
2060             $to_user = nickserv_msg($dt, $mlang_brisk['authmust'][$G_lang]);
2061         }
2062     }
2063     else if (strncmp($msg, "/mesgtoadm", 8) == 0) {
2064         if ($user->is_auth()) {
2065         $to_user = sprintf('mesgtoadmbox(500,300);');
2066       }
2067       else {
2068         /* MLANG: "<b>Per inviare un messaggio devi essere autenticato.</b>" */
2069         $to_user = nickserv_msg($dt, $mlang_brisk['mesgmust'][$G_lang]);
2070       }
2071     }
2072     else if (FALSE && strncmp($msg, "/nick ", 6) == 0) {
2073       log_main("chatt_send BEGIN");
2074
2075       do {
2076         if (($name_new = validate_name(substr($msg, 6))) == FALSE) {
2077           $to_user = nickserv_msg($dt, $mlang_brisk['nickmust'][$G_lang]);
2078           break;
2079         }
2080
2081         $msg = "COMMAND ".$msg;
2082         for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2083           $user_cur = $this->user[$i];
2084
2085           if ($user_cur->is_active() == FALSE)
2086             continue;
2087           if (strcasecmp($user_cur->name,$name_new) == 0)
2088             break;
2089           }
2090         if ($i <  MAX_PLAYERS) {
2091           $prestr = sprintf($mlang_brisk['nickdupl'][$G_lang], xcape($name_new));
2092           $to_user = nickserv_msg($dt, $prestr);
2093           break;
2094         }
2095
2096         /* 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>" */
2097         if ($user->is_auth()) {
2098           if (strcasecmp($user->name,$name_new) != 0) {
2099              if (( ($user->flags & USER_FLAG_MAP_AUTH) != USER_FLAG_ISOLAUTH) &&
2100                 ($user->subst == 'standup' ||
2101                  ($user->subst != 'standup' && $this->table[$user->table]->auth_type == TABLE_AUTH_TY_PUBL)
2102                  )
2103                 ) {
2104               $user->flags &= ~(USER_FLAG_AUTH | USER_FLAG_TY_ALL); // Remove auth if name changed
2105               for ($i = 0 ; $i < TABLES_N ; $i++) {
2106                 $to_user .= $this->table[$i]->act_content($user);
2107               }
2108             }
2109             else {
2110               $to_user = nickserv_msg($dt, $mlang_brisk['authchan'][$G_lang]);
2111               break;
2112             }
2113           }
2114         }
2115         $user->name = $name_new; // OK - nick changed
2116         /* se nome gia' in uso, segnala cosa potrebbe capitare */
2117         if ( ! $user->is_auth() ) {
2118             if (($bdb = BriskDB::create()) != FALSE) {
2119                 $bdb->users_load();
2120                 /* 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>" */
2121                 if ($bdb->login_exists(strtolower($name_new))) {
2122                     $prestr = sprintf($mlang_brisk['nickjust'][$G_lang], xcape($name_new));
2123                     $to_user .= nickserv_msg($dt, $prestr);
2124                 }
2125             }
2126         }
2127
2128         log_main("chatt_send start set");
2129
2130         $update_room = TRUE;
2131       } while (0);
2132     } // nick chat command
2133     else if (strncmp($msg, "/info ", 6) == 0) {
2134         do {
2135             if (! $user->is_auth()) {
2136                 if ($mlang_indwr) {
2137                     $to_user = nickserv_msg($dt, $mlang_indwr['info_auth'][$G_lang]);
2138                 }
2139                 else {
2140                     $to_user = nickserv_msg($dt, "error");
2141                 }
2142                 break;
2143             }
2144             $info_user = substr($msg, 6);
2145
2146             echo $this->info_show($user, urldecode($info_user), $dt);
2147         } while(0);
2148     }
2149     else if (strncmp($msg, "/prefsn", 7) == 0) {
2150         do {
2151             if (! $user->is_auth()) {
2152                 if ($mlang_indwr) {
2153                     $to_user = nickserv_msg($dt, $mlang_indwr['info_auth'][$G_lang]);
2154                 }
2155                 else {
2156                     $to_user = nickserv_msg($dt, "error");
2157                 }
2158                 break;
2159             }
2160             echo $this->prefsn_show($user, $dt);
2161         } while(0);
2162     }
2163     else if (strncmp($msg, "/st ", 4) == 0) {
2164       log_main("chatt_send BEGIN");
2165
2166       do {
2167         $st_str = substr($msg, 4);
2168
2169         if (strcasecmp($st_str, "normale") == 0) {
2170           $st = USER_FLAG_S_NORM;
2171         }
2172         else if (strcasecmp($st_str, "pausa") == 0) {
2173           $st = USER_FLAG_S_PAU;
2174         }
2175         else if (strcasecmp($st_str, "fuori") == 0) {
2176           $st = USER_FLAG_S_OUT;
2177         }
2178         else if (strcasecmp($st_str, "cane") == 0) {
2179           $st = USER_FLAG_S_DOG;
2180         }
2181         else if (strcasecmp($st_str, "cibo") == 0) {
2182           $st = USER_FLAG_S_EAT;
2183         }
2184         else if (strcasecmp($st_str, "lavoro") == 0) {
2185           $st = USER_FLAG_S_WRK;
2186         }
2187         else if (strcasecmp($st_str, "sigaretta") == 0) {
2188           $st = USER_FLAG_S_SMK;
2189         }
2190         else if (strcasecmp($st_str, "presente") == 0) {
2191           $st = USER_FLAG_S_EYE;
2192         }
2193         else if (strcasecmp($st_str, "coniglio") == 0) {
2194           $st = USER_FLAG_S_RABB;
2195         }
2196         else if (strcasecmp($st_str, "calcio") == 0) {
2197           $st = USER_FLAG_S_SOCC;
2198         }
2199         else if (strcasecmp($st_str, "pupo") == 0) {
2200           $st = USER_FLAG_S_BABY;
2201         }
2202         else if (strcasecmp($st_str, "pulizie") == 0) {
2203           $st = USER_FLAG_S_MOP;
2204         }
2205         else if (strcasecmp($st_str, "babbo") == 0) {
2206           $st = USER_FLAG_S_BABBO;
2207         }
2208         else if (strcasecmp($st_str, "renna") == 0) {
2209           $st = USER_FLAG_S_RENNA;
2210         }
2211         else if (strcasecmp($st_str, "pupazzo") == 0) {
2212           $st = USER_FLAG_S_PUPAZ;
2213         }
2214         else if (strcasecmp($st_str, "vischio") == 0) {
2215           $st = USER_FLAG_S_VISCH;
2216         }
2217         else {
2218           /* MLANG: "Questo stato non esiste." */
2219           $to_user = nickserv_msg($dt, $mlang_brisk['statunkn'][$G_lang]);
2220           break;
2221         }
2222
2223         log_main("chatt_send start set");
2224         if (($user->flags & USER_FLAG_S_ALL) != $st) {
2225           $update_room = TRUE;
2226           $user->flags = ($user->flags & ~USER_FLAG_S_ALL) | $st;
2227         }
2228       } while (0);
2229     } // nick chat command
2230
2231     else { // normal chat line
2232       $is_normchat = TRUE;
2233       if (CHAT_ENABLED && $curtime < ($user->chat_ban + $user->chat_dlt)) {
2234         $only_you = TRUE;
2235         $user->chat_dlt = $user->chat_dlt * 2;
2236         if ($user->chat_dlt > 120)
2237           $user->chat_dlt = 120;
2238       }
2239       else if ($user->chat_lst == $msg)
2240         $only_you = TRUE;
2241       else if (CHAT_ENABLED && $curtime - $user->chattime[($user->chat_cur + 1) % CHAT_N] < CHAT_ILL_TIME) {
2242         $user->chat_ban = $curtime;
2243         $user->chat_dlt = 5;
2244         $only_you = TRUE;
2245       }
2246       else {
2247         $user->chat_ban = 0;
2248         $user->chat_dlt = 0;
2249       }
2250
2251       if ($only_you) {
2252         $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape("== chat ban =="));
2253       }
2254       else {
2255           // TEMPORARY DISABLED UNTIL test user option will be available
2256           // if ( TRUE && (!$user->is_auth() || $user->is_appr()) ) {
2257           if (!$user->is_auth()) {
2258               $to_user = nickserv_msg($dt, xcape("Visto l'elevato numero di molestatori che ultimamente hanno preso dimora su Brisk abbiamo deciso"));
2259               $to_user .= nickserv_msg($dt, xcape("di disattivare temporaneamente la chat in room per i non registrati, non ce ne vogliate e buone feste."));
2260               if (FALSE) {
2261                   $aug_head = array("Tanti", "Tantissimi", "Un enormità", "Un milione", "Un' esagerazione");
2262                   $aug_body = array("a tutti gli utenti", "a tutti gli uomini", "a tutte le donne", "a tutti gli utenti");
2263                   $aug_tail = array("di Brisk", "del sito", "della ciurma", "della comitiva", "del gruppo");
2264
2265                   $auguri = sprintf("%s auguri %s %s.",
2266                                     $aug_head[mt_rand(0, count($aug_head)-1)],
2267                                     $aug_body[mt_rand(0, count($aug_body)-1)],
2268                                     $aug_tail[mt_rand(0, count($aug_tail)-1)]);
2269
2270                   $to_room = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name),
2271                                      xcape($auguri));
2272               }
2273           }
2274           else {
2275               $to_user = sprintf('chatt_sub("%s",[%d,"%s"],"%s");', $dt, $user->flags, xcape($user->name), xcape($msg));
2276               // temporary silentiation for troll (will became array check)
2277               // if (strcasecmp($user->name,'JackRokka') != 0 && $user->sess != '47ea653f602e8')
2278               $to_room = $to_user;
2279           }
2280       }
2281
2282       log_legal($curtime, $user->ip, $user,
2283                 ($user->stat == 'room' ? 'room' : 'table '.$user->table),$msg);
2284
2285       $user->chat_lst = "$msg";
2286       $user->chattime[$user->chat_cur % CHAT_N] = $curtime;
2287       $user->chat_cur++;
2288     }
2289
2290     if ($to_all) {
2291       $to_room = $to_all;
2292       $to_tabl = $to_all;
2293     }
2294
2295     //
2296     //  Output to clients
2297     //
2298
2299     if ($to_user != FALSE) {
2300       $user->comm[$user->step % COMM_N] =  "gst.st = ".($user->step+1)."; ";
2301       $user->comm[$user->step % COMM_N] .= $to_user;
2302       $user->step_inc();
2303     }
2304
2305     if ($to_room != FALSE) {
2306       for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2307         $user_cur = $this->user[$i];
2308         if ($target != "" && $user_cur->name != $target)
2309           continue;
2310         if ($user_cur->is_active() == FALSE // is not active user
2311             || $user_cur->stat == 'table'   // or stat is 'table'
2312             || $user->idx_get() == $i)      // or the $user idx is equal to current var
2313           continue;
2314
2315         if ($is_normchat == TRUE) {
2316           // use MAP_AUTH to check if auth or isolation
2317           if ($user_cur->flags & USER_FLAG_MAP_AUTH) {
2318               if ( ! $user->is_auth() ) {
2319                   continue;
2320               }
2321           }
2322         }
2323         /*
2324         else if ($is_ticker) {
2325           if (($user_cur->flags & USER_FLAG_MAP_AUTH) == USER_FLAG_ISOLAUTH) {
2326             if ($user->table >= TABLES_AUTH_N)
2327               continue;
2328           }
2329         }
2330         */
2331         $user_cur->comm[$user_cur->step % COMM_N] =  "gst.st = ".($user_cur->step+1)."; ";
2332         $user_cur->comm[$user_cur->step % COMM_N] .= $to_room;
2333         $user_cur->step_inc();
2334       }
2335     }
2336
2337     if ($to_tabl) {
2338         // FIXME BRISK4: include for each kind of table
2339         require_once("${G_base}briskin5/Obj/briskin5.phh");
2340         // Before all align times with table timeout
2341         for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2342             if (isset($this->match[$table_idx])) {
2343                 $bin5 = $this->match[$table_idx];
2344
2345                 $bin5_table = $bin5->table[0];
2346                 for ($i = 0 ; $i < $bin5_table->player_n ; $i++) {
2347                     // stat must be "table" by definition
2348                     $bin5_user = $bin5->user[$i];
2349
2350                     if ($target != "" && $bin5_user->name != $target)
2351                         continue;
2352                     log_main("writa: ".$user_mesg);
2353                     $bin5_user->comm[$bin5_user->step % COMM_N] = "gst.st = ".($bin5_user->step+1)."; ";
2354                     $bin5_user->comm[$bin5_user->step % COMM_N] .= $to_tabl;
2355                     $bin5_user->step_inc();
2356                 }
2357             } // if (isset($this->match
2358         } //  for ($table_idx = 0 ; $table_idx < TABLES_N ; $table_idx++) {
2359     } // if ($to_tabl == true ...
2360
2361     if ($update_room) {
2362       if ($user->stat == 'room' && $user->subst == 'standup') {
2363         $this->standup_update($user);
2364       }
2365       else if ($user->stat == 'room' && $user->subst == 'sitdown') {
2366         log_main("chatt_send pre table update");
2367         $this->table_update($user);
2368         log_main("chatt_send post table update");
2369       }
2370     } // if ($update_room ...
2371
2372     return;
2373   } // function chatt_send( ...
2374
2375   function get_user($sess, &$idx)
2376   {
2377       GLOBAL $PHP_SELF;
2378
2379       if (validate_sess($sess)) {
2380           for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2381               if ($this->user[$i]->is_empty())
2382                   continue;
2383               if (strcmp($sess, $this->user[$i]->sess) == 0) {
2384                   // find it
2385                   $idx = $i;
2386                   $ret = $this->user[$i];
2387                   return ($ret);
2388               }
2389           }
2390           log_main(sprintf("get_user: Wrong sess from page [%s]",$PHP_SELF));
2391           // for ($i = 0 ; $i < MAX_PLAYERS ; $i++)
2392           // log_main(sprintf("get_user: Wrong sess compared with [%s]",$this->user[$i]->sess));
2393       }
2394       else {
2395           log_main(sprintf("get_user: Wrong strlen [%s]",$sess));
2396       }
2397
2398       return (FALSE);
2399   }
2400
2401   /*
2402    * function add_user(&$brisk, &$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2403    *
2404    * RETURN VALUE:
2405    *   if ($idx >  -1    && ret == FALSE)  =>  duplicated nick
2406    *   if ($idx == -2    && ret == FALSE)  =>  invalid name
2407    *   if ($idx == -3    && ret == FALSE)  =>  wrong password
2408    *   if ($idx == -1    && ret == FALSE)  =>  no space left
2409    *   if ($idx ==  0    && ret == user)   =>  SUCCESS
2410    *   if ($idx == -($idx + 1) && ret == user)   =>  SUCCESS (but the login exists in the auth db)
2411    */
2412
2413   function add_user(&$sess, &$idx, $name, $pass, $ip, $header, $cookie)
2414   {
2415     GLOBAL $G_base;
2416
2417     $idx = 0;
2418
2419     $authenticate = FALSE;
2420     $user_type    = 0;
2421     $login_exists = FALSE;
2422     $ghost = -1;
2423     $ghost_auth = FALSE;
2424     $idx = -1;
2425     $idfree = -1;
2426     $code = FALSE;
2427
2428     if (($name_new = validate_name($name)) == FALSE) {
2429       $idx = -2;
2430       return (FALSE);
2431     }
2432
2433     log_auth("XXX", sprintf("ARRIVA: [%s] pass:[%s]", $sess, ($pass == FALSE ? "FALSE" : $pass)));
2434     if (validate_sess($sess) == FALSE)
2435       $sess = "";
2436
2437     /* if pass != FALSE verify the login with pass */
2438     log_auth("XXX", "auth1");
2439
2440     if (($bdb = BriskDB::create()) != FALSE) {
2441         $bdb->users_load();
2442         if ($pass != FALSE) { // TODO: here add a method to $bdb to check if the db is available.
2443             log_auth("XXX", "auth2");
2444             $authenticate = $bdb->login_verify($name_new, $pass, $code);
2445             log_auth("XXX", "authenticate: ".($authenticate != FALSE ? "TRUE" : "FALSE"));
2446
2447             if ($authenticate != FALSE) {
2448                 $user_type = $authenticate->type_get();
2449             }
2450             else {
2451                 $idx = -3;
2452                 return (FALSE);
2453             }
2454         }
2455         else {
2456             $login_exists =  $bdb->login_exists(strtolower($name_new));
2457         }
2458     }
2459     else {
2460         // if db is down, send a warning and verify only current users
2461         // no actions at this moment
2462     }
2463     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2464         /* free user ? */
2465         if ($this->user[$i]->is_empty()) {
2466             if ($idfree == -1) {
2467                 $idfree = $i;
2468             }
2469             continue;
2470         }
2471         if (strcmp($sess, $this->user[$i]->sess) == 0) {
2472             if ($idx == -1) {
2473                 $idx = $i;
2474             }
2475         }
2476         if (strcasecmp($this->user[$i]->name, $name_new) == 0) {
2477             if ($authenticate != FALSE) {
2478                 $ghost = $i;
2479                 $ghost_auth = $this->user[$i]->is_auth();
2480             }
2481             else {
2482                 $idx = $i;
2483                 break;
2484             }
2485         }
2486     }
2487     if ($idx == -1)
2488       $idx = $idfree;
2489
2490     log_auth("XXX", sprintf("TROVATO A QUESTO PUNTO [%d] sess [%s] name [%s]", $idx, $sess, $name_new));
2491
2492     /* there is another user logged with your account and you and him have authenticated => new user
2493        get the session of the old user */
2494     if ($ghost > -1 && $ghost_auth && ($authenticate != FALSE)) {
2495       /* swap session */
2496
2497       $ghost_user = $this->user[$ghost];
2498       $curtime = time();
2499       $this->ghost_sess->push($curtime, $ghost_user->sess, GHOST_SESS_REAS_ANOT);
2500       $ghost_user->comm[$ghost_user->step % COMM_N] = "";
2501       $ghost_user->step_inc();
2502       if ($sess == "") {
2503         $sess = uniqid("");
2504         $ghost_user->sess = $sess;
2505       }
2506       else {
2507         $ghost_user->sess = $sess;
2508       }
2509
2510       // If user at the table we need to update the table data too
2511       $table_idx = $ghost_user->table;
2512       if ($ghost_user->stat == "table" && $this->table[$table_idx]->player_n == PLAYERS_N) {
2513           require_once("${G_base}briskin5/Obj/briskin5.phh");
2514           if (isset($this->match[$table_idx])) {
2515               $bin5 = $this->match[$table_idx];
2516
2517               if ($bin5->the_end != TRUE) {
2518                   $bin5->user[$ghost_user->table_pos]->comm[$bin5->user[$ghost_user->table_pos]->step % COMM_N] = "";
2519                   $bin5->user[$ghost_user->table_pos]->step_inc();
2520                   $bin5->user[$ghost_user->table_pos]->sess = $sess;
2521               }
2522           }
2523       }
2524
2525       $idx = $ghost;
2526       if (defined('CURL_DE_SAC_VERS')) {
2527           brisk_cds_execute($this, $ghost, $idx, $sess, $ip, $authenticate, $header);
2528       }
2529       return ($this->user[$ghost]);
2530     }
2531     else if ($idx != -1 && $i == MAX_PLAYERS) {
2532       /* SUCCESS */
2533       $curtime = time();
2534       if ($sess == "") {
2535         $sess = uniqid("");
2536         $this->user[$idx]->sess = $sess;
2537       }
2538       else {
2539         $this->user[$idx]->sess = $sess;
2540       }
2541       $this->user[$idx]->name = $name_new; // OK - add new user
2542       $this->user[$idx]->stat_set("room");
2543       $this->user[$idx]->step_set(0);
2544       while (array_pop($this->user[$idx]->comm) != NULL);
2545       $this->user[$idx]->subst = "standup";
2546       $this->user[$idx]->lacc =   $curtime;
2547       $this->user[$idx]->laccwr = $curtime;
2548       $this->user[$idx]->bantime = 0;
2549       $this->user[$idx]->ip = $ip;
2550
2551       $this->user[$idx]->rec = $authenticate;
2552       $this->user[$idx]->flags = $user_type;
2553       $this->user[$idx]->flags |= ($authenticate != FALSE ? USER_FLAG_AUTH : 0x00);
2554       $this->user[$idx]->flags |= ( ($pass != FALSE && $bdb == FALSE) ? USER_FLAG_DBFAILED : 0x00);
2555       log_auth("XXX", sprintf("FLAGS: [%x]", $this->user[$idx]->flags));
2556
2557       if ($authenticate != FALSE) {
2558           $this->user[$idx]->code = $authenticate->code_get();
2559           if (0 == 1) {
2560               // all this part is included in the db server
2561               $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2562
2563               if (isset($cookie['CO_list'])) {
2564                   fprintf(STDERR, "QQ: %s CO_list: [%s]\n", __FUNCTION__, $cookie['CO_list']);
2565                   if (strcmp($cookie['CO_list'], "auth") == 0) {
2566                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2567                       $this->user[$idx]->flags |= USER_FLAG_LISTAUTH;
2568                   }
2569                   if (strcmp($cookie['CO_list'], "isolation") == 0) {
2570                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2571                       $this->user[$idx]->flags |= USER_FLAG_ISOLAUTH;
2572                   }
2573                   else {
2574                       $this->user[$idx]->flags &= ~USER_FLAG_MAP_AUTH;
2575                   }
2576               }
2577           }
2578           else {
2579               fprintf(STDERR, "QQ: CO_list not set flags: %x\n", __FUNCTION__, $this->user[$idx]->flags);
2580           }
2581       }
2582       fprintf(STDERR, "QQ %s: flag %x\n", __FUNCTION__, $this->user[$idx]->flags);
2583       if ($ghost > -1) {
2584         log_main("ghost: rename!");
2585         $ghost_user = $this->user[$ghost];
2586
2587         if ($ghost_auth == FALSE) {
2588           for ($sfx = 1 ; $sfx <= MAX_PLAYERS ; $sfx++) {
2589             $ghostname = 'ghost'.$sfx;
2590             for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2591               if (strcmp("", $this->user[$i]->sess) == 0)
2592                 continue;
2593
2594               if (strcasecmp($this->user[$i]->name, $ghostname) == 0) {
2595                 $ghostname = '';
2596                 break;
2597               }
2598             }
2599             if ($ghostname != '')
2600               break;
2601           }
2602
2603           $ghost_user->name = $ghostname;
2604
2605           if ($ghost_user->stat == 'room' && $ghost_user->subst == 'standup') {
2606             $this->standup_update($ghost_user);
2607           }
2608           else {
2609             log_main("chatt_send pre table update");
2610             $this->table_update($ghost_user);
2611           log_main("chatt_send post table update");
2612           }
2613         } // if ($ghost_auth == FALSE
2614         else {
2615           // FIXME: cacciare il vecchio utente room && table (if needed)
2616           $ghost_user->the_end = TRUE;
2617           $ghost_user->lacc = 0;
2618           $this->garbage_manager(TRUE);
2619         }
2620       } //  if ($ghost > -1) {
2621
2622       $real_idx = $idx;
2623       if ($login_exists)
2624         $idx = -($idx + 1);
2625       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));
2626
2627       $ret = $this->user[$real_idx];
2628       if (defined('CURL_DE_SAC_VERS')) {
2629           brisk_cds_execute($this, $ghost, $real_idx, $sess, $ip, $authenticate, $header);
2630       }
2631       return ($ret);
2632     }
2633
2634     return (FALSE);
2635   }
2636
2637   function standup_update($user)
2638   {
2639     for ($i = 0 ; $i < MAX_PLAYERS ; $i++) {
2640       $user_cur = $this->user[$i];
2641       if ($user_cur->is_active() == FALSE)
2642         continue;
2643
2644       log_main("STANDUP START: ".$user_cur->stat);
2645
2646       if ($user_cur->stat == 'room') {
2647         $user_cur->comm[$user_cur->step % COMM_N] = "gst.st = ".($user_cur->step+1)."; ".$this->standup_content($user_cur);
2648         if ($user->idx_get() == $i) {
2649           $user_cur->comm[$user_cur->step % COMM_N] .= $user->myname_innerHTML();
2650         }
2651         log_main("FROM STANDUP: NAME: ".$user_cur->name." SENDED: ".$user_cur->comm[$user_cur->step % COMM_N]);
2652
2653         $user_cur->step_inc();
2654       }
2655     }
2656   }
2657
2658   function dump_data()
2659   {
2660       $brisk_ser = serialize($this);
2661       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2662       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2663           return (TRUE);
2664       }
2665
2666       return (FALSE);
2667   }
2668
2669   function standup_content($user)
2670   {
2671     $ret = "";
2672
2673     if ($user->stat != 'room')
2674       return;
2675
2676     $content = ' j_stand_cont( [ ';
2677
2678     $user_cur_id = $user->idx_get();
2679     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2680         if ($this->user[$i]->is_active() == FALSE // is not active user
2681             || $this->user[$i]->stat != "room"    // or the stat isn't 'room'
2682             || $this->user[$i]->name == "")       // or the name is empty, happens when user is reset (TODO: check it)
2683         continue;
2684
2685       $flags = $this->user[$i]->flags;
2686
2687       // sql record exists AND last donate > 2013-01-01
2688       if ($this->user[$i]->is_supp_custom()) {
2689           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2690       }
2691       else {
2692           $supp_comp_s = '';
2693       }
2694
2695       if ($this->user[$i]->subst == "standup") {
2696           if ($user_cur_id == $i) {
2697               $flags |= 1;
2698           }
2699
2700           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2701                               xcape($this->user[$i]->name), $supp_comp_s);
2702           $ct++;
2703       }
2704     }
2705     $content .= ' ]);';
2706
2707     return ($content);
2708   }
2709
2710   function table_content($user, $table_idx)
2711   {
2712     $content = "";
2713     $ret = "";
2714     // TODO
2715     //
2716     //   Si possono usare i dati nella classe table
2717     //
2718
2719     $sess = $user->sess;
2720     $table = $this->table[$table_idx];
2721
2722     if ($user->stat != 'room')
2723       return;
2724
2725     $user_cur_id = $user->idx_get();
2726     $content = "[ ";
2727     for ($i = 0 ; $i < $table->player_n ; $i++) {
2728         $user_cur = $this->user[$table->player[$i]];
2729
2730         $flags = $user_cur->flags;
2731
2732         if ($user_cur_id == $table->player[$i])
2733             $flags |= 1;
2734
2735         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2736         if ($user_cur->is_supp_custom())
2737             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2738         else
2739             $supp_comp_s = '';
2740
2741         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2742                             xcape($user_cur->name), $supp_comp_s);
2743     }
2744
2745     $content .= ' ]';
2746
2747     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2748
2749     return ($ret);
2750   }
2751
2752   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2753   {
2754       GLOBAL $G_ban_list, $G_black_list, $G_cloud_smasher;
2755
2756       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2757
2758       fprintf(STDERR, "\n\n\n PRE_BLACK [%s]\n\n\n", $addr);
2759       if ($this->black_check($addr)) {
2760           // TODO: waiting async 5 sec before close
2761           fprintf(STDERR, "\n\n\n BLACK CHECK\n\n\n");
2762           return (FALSE);
2763       }
2764       if ($path != "" && $path != "index.php") {
2765           if ($this->cloud_check($addr)) {
2766               // TODO: waiting async 5 sec before close
2767               return (FALSE);
2768           }
2769       }
2770
2771       $enc = get_encoding($header);
2772       if (isset($header['User-Agent'])) {
2773           if (strstr($header['User-Agent'], "MSIE")) {
2774               $transp_type = "htmlfile";
2775           }
2776           else {
2777               $transp_type = "xhr";
2778           }
2779       }
2780       else {
2781           $transp_type = "iframe";
2782       }
2783       force_no_cache($header_out);
2784
2785       switch ($path) {
2786       case "":
2787       case "index.php":
2788           ob_start();
2789           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2790           $content = ob_get_contents();
2791           ob_end_clean();
2792
2793           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2794           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2795           return TRUE;
2796
2797           break;
2798       case "index_wr.php":
2799           //
2800           // Enhance required: in the POST case, after the header you must get content
2801           //                   from the socket, waiting if necessary
2802           //
2803
2804           ob_start();
2805           index_wr_main($this, $addr, $get, $post, $cookie);
2806           $content = ob_get_contents();
2807           ob_end_clean();
2808
2809           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2810           return TRUE;
2811
2812           break;
2813       case "index_rd.php":
2814           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2815               $transp = "iframe";
2816           if ($transp == 'websocket')
2817               $enc = 'plain';
2818
2819           do {
2820               if (!isset($cookie['sess'])
2821                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2822
2823                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2824
2825                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2826                   return TRUE;
2827
2828                   break;
2829               }
2830               $this->sess_cur_set($user->sess);
2831               // close a previous opened index_read_ifra socket, if exists
2832               if (($prev = $user->rd_socket_get()) != NULL) {
2833                   $s_a_p->socks_unset($user->rd_socket_get());
2834                   fclose($user->rd_socket_get());
2835                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2836                   $user->rd_socket_set(NULL);
2837               }
2838
2839               $content = "";
2840               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2841               $response = headers_render($header_out, -1).$user->chunked_content($content);
2842               $response_l = mb_strlen($response, "ASCII");
2843
2844               $wret = @fwrite($new_socket, $response, $response_l);
2845               if ($wret < $response_l) {
2846                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2847                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2848               }
2849               else {
2850                   $user->rd_cache_set("");
2851               }
2852               fflush($new_socket);
2853
2854
2855               $s_a_p->socks_set($new_socket, $user, NULL);
2856               $user->rd_socket_set($new_socket);
2857               printf(" - qui ci siamo - ");
2858               return TRUE;
2859           } while (FALSE);
2860
2861           return FALSE;
2862           break;
2863       case 'test.php':
2864           if (!(BRISK_DEBUG & DBG_ENGI))
2865               return (FALSE);
2866           fprintf(STDERR, "TEST.PHP running\n");
2867           if (isset($post['data'])) {
2868               $content = $post['data'];
2869           }
2870           else {
2871               $content = "NO DATA AVAILABLE";
2872           }
2873           $header_out['Content-Type'] = 'text/plain';
2874           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2875           return TRUE;
2876           break;
2877       default:
2878           /* FAR TODO: move all into an array of registered sub-apps */
2879           $subs = "briskin5/";
2880           $subs_l = strlen($subs);
2881           if (!strncmp($path, $subs, $subs_l)) {
2882               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2883               return ($ret);
2884           }
2885           break;
2886       }
2887
2888       return (FALSE);
2889   }
2890
2891   function match_add($idx, $match)
2892   {
2893       $this->match[$idx] = $match;
2894   }
2895
2896   function match_del($idx)
2897   {
2898       unset($this->match[$idx]);
2899   }
2900
2901   function match_get($idx, $token)
2902   {
2903       if (isset($this->match[$idx])) {
2904           if (   $token == NULL
2905               || $token == $this->match[$idx]->table_token) {
2906               return ($this->match[$idx]);
2907           }
2908       }
2909       return NULL;
2910   }
2911   function sess_cur_set($sess)
2912   {
2913       static::$sess_cur = $sess;
2914   }
2915
2916   static function sess_cur_get()
2917   {
2918       return(static::$sess_cur);
2919   }
2920 } // end class Brisk
2921
2922 function make_seed()
2923 {
2924   list($usec, $sec) = explode(' ', microtime());
2925   return (float) $sec + ((float) $usec * 100000);
2926 }
2927
2928 function btrace_line($ar)
2929 {
2930     GLOBAL $G_btrace_pref_sub;
2931
2932     $ret = "";
2933     for ($i = 0 ; $i < count($ar) ; $i++) {
2934         $with_class = isset($ar[$i]['class']);
2935         $with_file  = isset($ar[$i]['file']);
2936         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2937                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2938                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2939                         ($with_file ? $ar[$i]['line'] : ""));
2940     }
2941
2942     return ($ret);
2943 }
2944
2945 function trace_ftok($id, $add)
2946 {
2947     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2948     $tok=@ftok($id, $add);
2949
2950     log_shme($tok.": ".$id." + ".$add);
2951
2952     return ($tok);
2953 }
2954
2955 function log_mop($step, $log)
2956 {
2957     GLOBAL $PHP_SELF;
2958
2959     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2960         return;
2961
2962     $sess = Brisk::sess_cur_get();
2963     if (isset($sess) == FALSE)
2964         $ssess = "XXXX";
2965     else
2966         $ssess = $sess;
2967
2968     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2969         return;
2970
2971     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2972         $btrace = btrace_line(debug_backtrace());
2973     else
2974         $btrace = "";
2975     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2976         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2977         fclose($fp);
2978     }
2979 }
2980
2981 function log_step($log)
2982 {
2983     GLOBAL $PHP_SELF;
2984
2985     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2986         return;
2987
2988     $sess = Brisk::sess_cur_get();
2989     if (isset($sess) == FALSE)
2990         $ssess = "XXXX";
2991     else
2992         $ssess = $sess;
2993
2994     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2995         return;
2996
2997     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2998         $btrace = btrace_line(debug_backtrace());
2999     else
3000         $btrace = "";
3001     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
3002         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3003         fclose($fp);
3004     }
3005 }
3006
3007
3008
3009 function log_cds($log)
3010 {
3011     GLOBAL $PHP_SELF;
3012
3013     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
3014         return;
3015
3016     $sess = Brisk::sess_cur_get();
3017     if (isset($sess) == FALSE)
3018         $ssess = "XXXX";
3019     else
3020         $ssess = $sess;
3021
3022     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
3023         return;
3024
3025     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3026         $btrace = btrace_line(debug_backtrace());
3027     else
3028         $btrace = "";
3029     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
3030         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3031         fclose($fp);
3032     }
3033 }
3034
3035
3036 function log_only2($log)
3037 {
3038     GLOBAL $PHP_SELF;
3039
3040     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
3041         return;
3042
3043     $sess = Brisk::sess_cur_get();
3044     if (isset($sess) == FALSE)
3045         $ssess = "XXXX";
3046     else
3047         $ssess = $sess;
3048
3049     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
3050         return;
3051
3052     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3053         $btrace = btrace_line(debug_backtrace());
3054     else
3055         $btrace = "";
3056     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3057         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3058         fclose($fp);
3059     }
3060 }
3061
3062 function log_crit($log)
3063 {
3064     GLOBAL $PHP_SELF;
3065
3066     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
3067         return;
3068
3069     $sess = Brisk::sess_cur_get();
3070     if (isset($sess) == FALSE)
3071         $ssess = "XXXX";
3072     else
3073         $ssess = $sess;
3074
3075     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
3076         return;
3077
3078     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3079         $btrace = btrace_line(debug_backtrace());
3080     else
3081         $btrace = "";
3082     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3083         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3084         fclose($fp);
3085     }
3086 }
3087
3088 function log_only($log)
3089 {
3090     GLOBAL $PHP_SELF;
3091
3092     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
3093         return;
3094
3095     $sess = Brisk::sess_cur_get();
3096     if (isset($sess) == FALSE)
3097         $ssess = "XXXX";
3098     else
3099         $ssess = $sess;
3100
3101     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
3102         return;
3103
3104     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3105         $btrace = btrace_line(debug_backtrace());
3106     else
3107         $btrace = "";
3108     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3109         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3110         fclose($fp);
3111     }
3112 }
3113
3114 function log_main($log)
3115 {
3116     GLOBAL $PHP_SELF;
3117
3118     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
3119         return;
3120
3121     $sess = Brisk::sess_cur_get();
3122     if (isset($sess) == FALSE)
3123         $ssess = "XXXX";
3124     else
3125         $ssess = $sess;
3126
3127     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
3128         return;
3129
3130     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3131         $btrace = btrace_line(debug_backtrace());
3132     else
3133         $btrace = "";
3134     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3135         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3136         fclose($fp);
3137     }
3138 }
3139
3140 function log_rd($log)
3141 {
3142     GLOBAL $PHP_SELF;
3143
3144     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
3145         return;
3146
3147     $sess = Brisk::sess_cur_get();
3148     if (isset($sess) == FALSE)
3149         $ssess = "XXXX";
3150     else
3151         $ssess = $sess;
3152
3153     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
3154         return;
3155
3156     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3157         $btrace = btrace_line(debug_backtrace());
3158     else
3159         $btrace = "";
3160     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3161         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3162         fclose($fp);
3163     }
3164 }
3165
3166 function log_rd2($log)
3167 {
3168     GLOBAL $PHP_SELF;
3169
3170     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
3171         return;
3172
3173     $sess = Brisk::sess_cur_get();
3174     if (isset($sess) == FALSE)
3175         $ssess = "XXXX";
3176     else
3177         $ssess = $sess;
3178
3179     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
3180         return;
3181
3182     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3183         $btrace = btrace_line(debug_backtrace());
3184     else
3185         $btrace = "";
3186
3187     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3188         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3189         fclose($fp);
3190     }
3191 }
3192
3193 function log_send($log)
3194 {
3195     GLOBAL $PHP_SELF;
3196
3197     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3198         return;
3199
3200     $sess = Brisk::sess_cur_get();
3201     if (isset($sess) == FALSE)
3202         $ssess = "XXXX";
3203     else
3204         $ssess = $sess;
3205
3206     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3207         return;
3208
3209     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3210         $btrace = btrace_line(debug_backtrace());
3211     else
3212         $btrace = "";
3213     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3214         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3215         fclose($fp);
3216     }
3217 }
3218
3219 function log_lock($log)
3220 {
3221     GLOBAL $PHP_SELF;
3222
3223     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3224         return;
3225
3226     $sess = Brisk::sess_cur_get();
3227     if (isset($sess) == FALSE)
3228         $ssess = "XXXX";
3229     else
3230         $ssess = $sess;
3231
3232     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3233         return;
3234
3235     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3236         $btrace = btrace_line(debug_backtrace());
3237     else
3238         $btrace = "";
3239     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3240         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3241         fclose($fp);
3242     }
3243 }
3244
3245 function log_wr($log)
3246 {
3247     GLOBAL $PHP_SELF;
3248
3249     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3250         return;
3251
3252     $sess = Brisk::sess_cur_get();
3253     if (isset($sess) == FALSE)
3254         $ssess = "XXXX";
3255     else
3256         $ssess = $sess;
3257
3258     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3259         return;
3260
3261     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3262         $btrace = btrace_line(debug_backtrace());
3263     else
3264         $btrace = "";
3265     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3266         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3267         fclose($fp);
3268     }
3269 }
3270
3271 function log_load($log)
3272 {
3273     GLOBAL $PHP_SELF;
3274
3275     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3276         return;
3277
3278     $sess = Brisk::sess_cur_get();
3279     if (isset($sess) == FALSE)
3280         $ssess = "XXXX";
3281     else
3282         $ssess = $sess;
3283
3284     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3285         return;
3286
3287     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3288         $btrace = btrace_line(debug_backtrace());
3289     else
3290         $btrace = "";
3291     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3292         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3293         fclose($fp);
3294     }
3295 }
3296
3297 function log_auth($sess, $log)
3298 {
3299     GLOBAL $PHP_SELF;
3300
3301     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3302         return;
3303
3304     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3305         return;
3306
3307     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3308         $btrace = btrace_line(debug_backtrace());
3309     else
3310         $btrace = "";
3311     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3312         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3313         fclose($fp);
3314     }
3315 }
3316
3317 function log_shme($log)
3318 {
3319     GLOBAL $PHP_SELF;
3320
3321     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3322         return;
3323
3324     $sess = Brisk::sess_cur_get();
3325     if (isset($sess) == FALSE)
3326         $ssess = "XXXX";
3327     else
3328         $ssess = $sess;
3329
3330     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3331         return;
3332
3333     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3334         $btrace = btrace_line(debug_backtrace());
3335     else
3336         $btrace = "";
3337     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3338         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3339         fclose($fp);
3340     }
3341 }
3342
3343
3344
3345 // function log_legal($curtime, $sess, $name, $where, $mesg)
3346 function log_legal($curtime, $addr, $user, $where, $mesg)
3347 {
3348
3349   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3350     /* Unix time | session | nickname | IP | where was | mesg */
3351     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
3352                         ($user->is_auth() ? 'A' : 'N'),
3353                         $user->name, $addr, $where , $mesg));
3354     fclose($fp);
3355   }
3356 }
3357
3358 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3359 {
3360   $ret = "";
3361
3362   if ($isstanding) {
3363     if ($sitted < PLAYERS_N) {
3364       if ($allowed)
3365         $act = 'sit';
3366       else
3367         $act = 'reserved';
3368     }
3369   }
3370   else {
3371     if ($table == $cur_table)
3372       $act = 'wake';
3373     else
3374       $act = 'none';
3375   }
3376
3377   if ($act != '')
3378     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3379
3380   return ($ret);
3381 }
3382
3383 function show_notify($text, $tout, $butt, $w, $h)
3384 {
3385   log_main("SHOW_NOTIFY: ".$text);
3386   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3387 }
3388
3389 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3390 {
3391   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3392   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);
3393 }
3394
3395 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3396 {
3397   log_main("SHOW_NOTIFY OPAQUE: ".$text);
3398
3399   $butts = "";
3400   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3401       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3402   }
3403
3404   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3405                  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);
3406 }
3407
3408
3409 function root_welcome($user)
3410 {
3411   GLOBAL $root_wellarr, $G_lang;
3412   $ret = "";
3413
3414   $curtime = time();
3415   $dt = date("H:i ", $curtime);
3416
3417   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3418       $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3419
3420   return ($ret);
3421 }
3422
3423
3424
3425 function validate_sess($sess)
3426 {
3427   if (strlen($sess) == SESS_LEN)
3428     return (TRUE);
3429   else
3430     return (FALSE);
3431 }
3432
3433 function validate_name($name)
3434 {
3435     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3436
3437   for ($i = 0 ; $i < mb_strlen($name_new) ; $i++) {
3438     $c = $name_new[$i];
3439     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3440       return ($name_new);
3441   }
3442
3443   return (FALSE);
3444 }
3445
3446 function playsound($filename)
3447 {
3448   return (sprintf('playsound("flasou", "%s");', $filename));
3449 }
3450
3451 function secstoword($secs)
3452 {
3453   GLOBAL $G_lang;
3454
3455   $ret = "";
3456
3457   $mins = floor($secs / 60);
3458   $secs = $secs % 60;
3459   if ($G_lang == 'en') {
3460     if ($mins > 0)
3461       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3462
3463     if ($secs > 0)
3464       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3465   }
3466   else {
3467     if ($mins > 0)
3468       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3469
3470     if ($secs > 0)
3471       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3472   }
3473   return ($ret);
3474 }
3475
3476 function sharedmem_sz($tok)
3477 {
3478   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3479     log_main("shmop_open failed");
3480     return (-1);
3481   }
3482   $shm_sz = shmop_size($shm_id);
3483   shmop_close($shm_id);
3484
3485   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3486   return ($shm_sz);
3487 }
3488
3489 class Warrant {
3490     static $delta_t;
3491
3492   static function lock_data($is_exclusive)
3493   {
3494       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3495           self::$delta_t = microtime(TRUE);
3496           log_lock("LOCK   warrant      [".self::$delta_t."]");
3497
3498           return ($res);
3499       }
3500
3501       return (FALSE);
3502   }
3503
3504   static function unlock_data($res)
3505   {
3506     GLOBAL $sess;
3507
3508     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3509
3510     file_unlock($res);
3511   }
3512 }
3513
3514 class Poll {
3515     static $delta_t;
3516
3517   static function lock_data($is_exclusive)
3518   {
3519       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3520           self::$delta_t = microtime(TRUE);
3521           log_lock("LOCK   poll         [".self::$delta_t."]");
3522
3523           return ($res);
3524       }
3525
3526       return (FALSE);
3527   }
3528
3529   static function unlock_data($res)
3530   {
3531     GLOBAL $sess;
3532
3533     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3534
3535     file_unlock($res);
3536   }
3537 }
3538
3539 function carousel_top()
3540 {
3541     $what = rand(1,2);
3542     if ($what == 1) {
3543         $rn = rand(1, 3);
3544         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));
3545         }
3546     else {
3547         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>'));
3548     }
3549 }
3550
3551 /* function login_consistency:
3552        name length must be less or equal than 12 chars,
3553        no more than 2 consecutive same character (or generic digits) are allowed */
3554 function login_consistency($name)
3555 {
3556     $old_c = '';
3557     if (($len = mb_strlen($name)) > 12) {
3558         return FALSE;
3559     }
3560
3561     for ($i = 0 ; $i < mb_strlen($name) ; $i++) {
3562         $c = mb_substr($name, $i, 1);
3563         if (mb_ereg_match ("[a-zA-Z0-9]", $c)) {
3564             if (mb_ereg_match ("[0-9]", $c)) {
3565                 $c = "0";
3566             }
3567             if ($old_c != $c) {
3568                 $old_c = $c;
3569                 $old_ct = 1;
3570             }
3571             else {
3572                 $old_ct++;
3573                 if ($old_ct > 2) {
3574                     return (FALSE);
3575                 }
3576             }
3577         }
3578         else {
3579             return (FALSE);
3580         }
3581     }
3582     return (TRUE);
3583 }
3584 ?>