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