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