web/Obj/brisk.phh

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