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.9.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 (FALSE && 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               $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2704               xcape($this->user[$i]->name), $supp_comp_s);
2705               $ct++;
2706           }
2707       }
2708       $content .= ' ]);';
2709
2710       return ($content);
2711   }
2712
2713   function table_content($user, $table_idx)
2714   {
2715       $content = "";
2716       $ret = "";
2717       // TODO
2718       //
2719       //   Si possono usare i dati nella classe table
2720       //
2721
2722       $sess = $user->sess;
2723       $table = $this->table[$table_idx];
2724
2725       if ($user->stat != 'room')
2726           return;
2727
2728       $user_cur_id = $user->idx_get();
2729       $content = "[ ";
2730       for ($i = 0 ; $i < $table->player_n ; $i++) {
2731           $user_cur = $this->user[$table->player[$i]];
2732
2733           $flags = $user_cur->flags;
2734
2735           log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2736           if ($user_cur->is_supp_custom())
2737               $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2738           else
2739               $supp_comp_s = '';
2740
2741           $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2742           xcape($user_cur->name), $supp_comp_s);
2743       }
2744
2745       $content .= ' ]';
2746
2747       $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2748
2749       return ($ret);
2750   }
2751
2752   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2753   {
2754       GLOBAL $G_ban_list, $G_black_list, $G_cloud_smasher;
2755
2756       // printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2757
2758       // fprintf(STDERR, "\n\n\n PRE_BLACK [%s]\n\n\n", $addr);
2759       if ($this->black_check($addr)) {
2760           // TODO: waiting async 5 sec before close
2761           // fprintf(STDERR, "\n\n\n BLACK CHECK\n\n\n");
2762           return (FALSE);
2763       }
2764       if ($path != "" && $path != "index.php") {
2765           if ($this->cloud_check($addr)) {
2766               // TODO: waiting async 5 sec before close
2767               return (FALSE);
2768           }
2769       }
2770
2771       $enc = get_encoding($header);
2772       if (isset($header['User-Agent'])) {
2773           if (strstr($header['User-Agent'], "MSIE")) {
2774               $transp_type = "htmlfile";
2775           }
2776           else {
2777               $transp_type = "xhr";
2778           }
2779       }
2780       else {
2781           $transp_type = "iframe";
2782       }
2783       force_no_cache($header_out);
2784
2785       switch ($path) {
2786       case "":
2787       case "index.php":
2788           ob_start();
2789           index_main($this, $transp_type, $header, $header_out, $addr, $get, $post, $cookie);
2790           $content = ob_get_contents();
2791           ob_end_clean();
2792
2793           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2794           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2795           return TRUE;
2796
2797           break;
2798       case "index_wr.php":
2799           //
2800           // Enhance required: in the POST case, after the header you must get content
2801           //                   from the socket, waiting if necessary
2802           //
2803
2804           ob_start();
2805           index_wr_main($this, $addr, $get, $post, $cookie);
2806           $content = ob_get_contents();
2807           ob_end_clean();
2808
2809           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2810           return TRUE;
2811
2812           break;
2813       case "index_rd.php":
2814       case "index_rd_wss.php":
2815           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2816               $transp = "iframe";
2817           if ($transp == 'websocket' || $transp == 'websocketsec')
2818               $enc = 'plain';
2819
2820           do {
2821               if (!isset($cookie['sess'])
2822                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2823
2824                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2825
2826                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2827                   return TRUE;
2828
2829                   break;
2830               }
2831               $this->sess_cur_set($user->sess);
2832               // close a previous opened index_read_ifra socket, if exists
2833               if (($prev = $user->rd_socket_get()) != NULL) {
2834                   $s_a_p->socks_unset($user->rd_socket_get());
2835                   fclose($user->rd_socket_get());
2836                   // printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2837                   $user->rd_socket_set(NULL);
2838               }
2839
2840               $content = "";
2841               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2842               $response = headers_render($header_out, -1).$user->chunked_content($content);
2843               $response_l = mb_strlen($response, "ASCII");
2844
2845               $wret = @fwrite($new_socket, $response, $response_l);
2846               if ($wret < $response_l) {
2847                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2848                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2849               }
2850               else {
2851                   $user->rd_cache_set("");
2852               }
2853               fflush($new_socket);
2854
2855
2856               $s_a_p->socks_set($new_socket, $user, NULL);
2857               $user->rd_socket_set($new_socket);
2858               // printf(" - qui ci siamo - ");
2859               return TRUE;
2860           } while (FALSE);
2861
2862           return FALSE;
2863           break;
2864       case 'test.php':
2865           if (!(BRISK_DEBUG & DBG_ENGI))
2866               return (FALSE);
2867           fprintf(STDERR, "TEST.PHP running\n");
2868           if (isset($post['data'])) {
2869               $content = $post['data'];
2870           }
2871           else {
2872               $content = "NO DATA AVAILABLE";
2873           }
2874           $header_out['Content-Type'] = 'text/plain';
2875           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2876           return TRUE;
2877           break;
2878       default:
2879           /* FAR TODO: move all into an array of registered sub-apps */
2880           $subs = "briskin5/";
2881           $subs_l = strlen($subs);
2882           if (!strncmp($path, $subs, $subs_l)) {
2883               $ret = Bin5::request_mgr($s_a_p, $header, $header_out, $new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2884               return ($ret);
2885           }
2886           break;
2887       }
2888
2889       return (FALSE);
2890   }
2891
2892   function match_add($idx, $match)
2893   {
2894       $this->match[$idx] = $match;
2895   }
2896
2897   function match_del($idx)
2898   {
2899       unset($this->match[$idx]);
2900   }
2901
2902   function match_get($idx, $token)
2903   {
2904       if (isset($this->match[$idx])) {
2905           if (   $token == NULL
2906               || $token == $this->match[$idx]->table_token) {
2907               return ($this->match[$idx]);
2908           }
2909       }
2910       return NULL;
2911   }
2912   function sess_cur_set($sess)
2913   {
2914       static::$sess_cur = $sess;
2915   }
2916
2917   static function sess_cur_get()
2918   {
2919       return(static::$sess_cur);
2920   }
2921 } // end class Brisk
2922
2923 function make_seed()
2924 {
2925     list($usec, $sec) = explode(' ', microtime());
2926     return (float) $sec + ((float) $usec * 100000);
2927 }
2928
2929 function btrace_line($ar)
2930 {
2931     GLOBAL $G_btrace_pref_sub;
2932
2933     $ret = "";
2934     for ($i = 0 ; $i < count($ar) ; $i++) {
2935         $with_class = isset($ar[$i]['class']);
2936         $with_file  = isset($ar[$i]['file']);
2937         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2938                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2939                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2940                         ($with_file ? $ar[$i]['line'] : ""));
2941     }
2942
2943     return ($ret);
2944 }
2945
2946 function trace_ftok($id, $add)
2947 {
2948     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2949     $tok=@ftok($id, $add);
2950
2951     log_shme($tok.": ".$id." + ".$add);
2952
2953     return ($tok);
2954 }
2955
2956 function log_mop($step, $log)
2957 {
2958     GLOBAL $PHP_SELF;
2959
2960     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2961         return;
2962
2963     $sess = Brisk::sess_cur_get();
2964     if (isset($sess) == FALSE)
2965         $ssess = "XXXX";
2966     else
2967         $ssess = $sess;
2968
2969     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2970         return;
2971
2972     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2973         $btrace = btrace_line(debug_backtrace());
2974     else
2975         $btrace = "";
2976     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2977         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2978         fclose($fp);
2979     }
2980 }
2981
2982 function log_step($log)
2983 {
2984     GLOBAL $PHP_SELF;
2985
2986     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_STEP) == 0)
2987         return;
2988
2989     $sess = Brisk::sess_cur_get();
2990     if (isset($sess) == FALSE)
2991         $ssess = "XXXX";
2992     else
2993         $ssess = $sess;
2994
2995     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_STEP) == 0)
2996         return;
2997
2998     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2999         $btrace = btrace_line(debug_backtrace());
3000     else
3001         $btrace = "";
3002     if (($fp = @fopen(LEGAL_PATH."/step.log", 'a')) != FALSE) {
3003         fwrite($fp, sprintf("STEP: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3004         fclose($fp);
3005     }
3006 }
3007
3008
3009
3010 function log_cds($log)
3011 {
3012     GLOBAL $PHP_SELF;
3013
3014     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CDS) == 0)
3015         return;
3016
3017     $sess = Brisk::sess_cur_get();
3018     if (isset($sess) == FALSE)
3019         $ssess = "XXXX";
3020     else
3021         $ssess = $sess;
3022
3023     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CDS) == 0)
3024         return;
3025
3026     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3027         $btrace = btrace_line(debug_backtrace());
3028     else
3029         $btrace = "";
3030     if (($fp = @fopen(LEGAL_PATH."/cds.log", 'a')) != FALSE) {
3031         fwrite($fp, sprintf("CDS: [%f] [%s] [%s]\n", gettimeofday(TRUE), $log, $btrace));
3032         fclose($fp);
3033     }
3034 }
3035
3036
3037 function log_only2($log)
3038 {
3039     GLOBAL $PHP_SELF;
3040
3041     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
3042         return;
3043
3044     $sess = Brisk::sess_cur_get();
3045     if (isset($sess) == FALSE)
3046         $ssess = "XXXX";
3047     else
3048         $ssess = $sess;
3049
3050     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
3051         return;
3052
3053     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3054         $btrace = btrace_line(debug_backtrace());
3055     else
3056         $btrace = "";
3057     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3058         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3059         fclose($fp);
3060     }
3061 }
3062
3063 function log_crit($log)
3064 {
3065     GLOBAL $PHP_SELF;
3066
3067     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
3068         return;
3069
3070     $sess = Brisk::sess_cur_get();
3071     if (isset($sess) == FALSE)
3072         $ssess = "XXXX";
3073     else
3074         $ssess = $sess;
3075
3076     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
3077         return;
3078
3079     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3080         $btrace = btrace_line(debug_backtrace());
3081     else
3082         $btrace = "";
3083     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3084         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3085         fclose($fp);
3086     }
3087 }
3088
3089 function log_only($log)
3090 {
3091     GLOBAL $PHP_SELF;
3092
3093     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
3094         return;
3095
3096     $sess = Brisk::sess_cur_get();
3097     if (isset($sess) == FALSE)
3098         $ssess = "XXXX";
3099     else
3100         $ssess = $sess;
3101
3102     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
3103         return;
3104
3105     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3106         $btrace = btrace_line(debug_backtrace());
3107     else
3108         $btrace = "";
3109     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3110         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3111         fclose($fp);
3112     }
3113 }
3114
3115 function log_main($log)
3116 {
3117     GLOBAL $PHP_SELF;
3118
3119     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
3120         return;
3121
3122     $sess = Brisk::sess_cur_get();
3123     if (isset($sess) == FALSE)
3124         $ssess = "XXXX";
3125     else
3126         $ssess = $sess;
3127
3128     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
3129         return;
3130
3131     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3132         $btrace = btrace_line(debug_backtrace());
3133     else
3134         $btrace = "";
3135     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3136         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3137         fclose($fp);
3138     }
3139 }
3140
3141 function log_rd($log)
3142 {
3143     GLOBAL $PHP_SELF;
3144
3145     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
3146         return;
3147
3148     $sess = Brisk::sess_cur_get();
3149     if (isset($sess) == FALSE)
3150         $ssess = "XXXX";
3151     else
3152         $ssess = $sess;
3153
3154     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
3155         return;
3156
3157     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3158         $btrace = btrace_line(debug_backtrace());
3159     else
3160         $btrace = "";
3161     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3162         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3163         fclose($fp);
3164     }
3165 }
3166
3167 function log_rd2($log)
3168 {
3169     GLOBAL $PHP_SELF;
3170
3171     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
3172         return;
3173
3174     $sess = Brisk::sess_cur_get();
3175     if (isset($sess) == FALSE)
3176         $ssess = "XXXX";
3177     else
3178         $ssess = $sess;
3179
3180     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
3181         return;
3182
3183     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3184         $btrace = btrace_line(debug_backtrace());
3185     else
3186         $btrace = "";
3187
3188     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3189         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3190         fclose($fp);
3191     }
3192 }
3193
3194 function log_send($log)
3195 {
3196     GLOBAL $PHP_SELF;
3197
3198     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
3199         return;
3200
3201     $sess = Brisk::sess_cur_get();
3202     if (isset($sess) == FALSE)
3203         $ssess = "XXXX";
3204     else
3205         $ssess = $sess;
3206
3207     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
3208         return;
3209
3210     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3211         $btrace = btrace_line(debug_backtrace());
3212     else
3213         $btrace = "";
3214     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3215         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3216         fclose($fp);
3217     }
3218 }
3219
3220 function log_lock($log)
3221 {
3222     GLOBAL $PHP_SELF;
3223
3224     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
3225         return;
3226
3227     $sess = Brisk::sess_cur_get();
3228     if (isset($sess) == FALSE)
3229         $ssess = "XXXX";
3230     else
3231         $ssess = $sess;
3232
3233     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
3234         return;
3235
3236     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3237         $btrace = btrace_line(debug_backtrace());
3238     else
3239         $btrace = "";
3240     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3241         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3242         fclose($fp);
3243     }
3244 }
3245
3246 function log_wr($log)
3247 {
3248     GLOBAL $PHP_SELF;
3249
3250     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
3251         return;
3252
3253     $sess = Brisk::sess_cur_get();
3254     if (isset($sess) == FALSE)
3255         $ssess = "XXXX";
3256     else
3257         $ssess = $sess;
3258
3259     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
3260         return;
3261
3262     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3263         $btrace = btrace_line(debug_backtrace());
3264     else
3265         $btrace = "";
3266     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3267         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3268         fclose($fp);
3269     }
3270 }
3271
3272 function log_load($log)
3273 {
3274     GLOBAL $PHP_SELF;
3275
3276     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
3277         return;
3278
3279     $sess = Brisk::sess_cur_get();
3280     if (isset($sess) == FALSE)
3281         $ssess = "XXXX";
3282     else
3283         $ssess = $sess;
3284
3285     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
3286         return;
3287
3288     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3289         $btrace = btrace_line(debug_backtrace());
3290     else
3291         $btrace = "";
3292     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3293         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3294         fclose($fp);
3295     }
3296 }
3297
3298 function log_auth($sess, $log)
3299 {
3300     GLOBAL $PHP_SELF;
3301
3302     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
3303         return;
3304
3305     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
3306         return;
3307
3308     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3309         $btrace = btrace_line(debug_backtrace());
3310     else
3311         $btrace = "";
3312     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3313         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
3314         fclose($fp);
3315     }
3316 }
3317
3318 function log_shme($log)
3319 {
3320     GLOBAL $PHP_SELF;
3321
3322     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
3323         return;
3324
3325     $sess = Brisk::sess_cur_get();
3326     if (isset($sess) == FALSE)
3327         $ssess = "XXXX";
3328     else
3329         $ssess = $sess;
3330
3331     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
3332         return;
3333
3334     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
3335         $btrace = btrace_line(debug_backtrace());
3336     else
3337         $btrace = "";
3338     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
3339         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
3340         fclose($fp);
3341     }
3342 }
3343
3344
3345
3346 // function log_legal($curtime, $sess, $name, $where, $mesg)
3347 function log_legal($curtime, $addr, $user, $where, $mesg)
3348 {
3349     if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
3350         /* Unix time | session | nickname | IP | where was | mesg */
3351         fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, ($user ? $user->sess : "NOSESS"),
3352         ($user ? ($user->is_auth() ? 'A' : 'N') : "U"),
3353         ($user ? $user->name : "NO-USER"), $addr, $where , $mesg));
3354         fclose($fp);
3355     }
3356 }
3357
3358 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
3359 {
3360     $ret = "";
3361
3362     if ($isstanding) {
3363         if ($sitted < PLAYERS_N) {
3364             if ($allowed)
3365                 $act = 'sit';
3366             else
3367                 $act = 'reserved';
3368         }
3369     }
3370     else {
3371         if ($table == $cur_table)
3372             $act = 'wake';
3373         else
3374             $act = 'none';
3375     }
3376
3377     if ($act != '')
3378         $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
3379
3380     return ($ret);
3381 }
3382
3383 function show_notify($text, $tout, $butt, $w, $h)
3384 {
3385     log_main("SHOW_NOTIFY: ".$text);
3386     return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
3387 }
3388
3389 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
3390 {
3391     log_main("SHOW_NOTIFY OPAQUE: ".$text);
3392     return sprintf('var noti = new notify_ex(gst,"%s",%d,"%s",%d,%d, %s, %d);', $text, $tout, $butt, $w, $h, ($is_opaque ? "true" : "false"), $block_time);
3393 }
3394
3395 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
3396 {
3397     log_main("SHOW_NOTIFY OPAQUE: ".$text);
3398
3399     $butts = "";
3400     for ($i = 0 ; $i < count($butt_arr) ; $i++) {
3401         $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
3402     }
3403
3404     return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
3405     escpush($text), $tout, $butts, ($confirm_func == NULL ? "null" : $confirm_func), (($confirm_func == NULL|| $confirm_func_args == NULL) ? "[]" : $confirm_func_args), $w, $h, ($is_opaque ? "true" : "false"), $block_time);
3406 }
3407
3408
3409 function root_welcome($user)
3410 {
3411     GLOBAL $root_wellarr, $G_lang;
3412     $ret = "";
3413
3414     $curtime = time();
3415     $dt = date("H:i ", $curtime);
3416
3417     for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
3418         $ret .= nickserv_msg($dt, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
3419
3420     return ($ret);
3421 }
3422
3423
3424
3425 function validate_sess($sess)
3426 {
3427     if (strlen($sess) == SESS_LEN)
3428         return (TRUE);
3429     else
3430         return (FALSE);
3431 }
3432
3433 function validate_name($name)
3434 {
3435     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
3436
3437     for ($i = 0 ; $i < mb_strlen($name_new) ; $i++) {
3438         $c = $name_new[$i];
3439         if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
3440             return ($name_new);
3441     }
3442
3443     return (FALSE);
3444 }
3445
3446 function playsound($name)
3447 {
3448     return (sprintf('g_jukebox.play("%s");', $name));
3449 }
3450
3451 function secstoword($secs)
3452 {
3453     GLOBAL $G_lang;
3454
3455     $ret = "";
3456
3457     $mins = floor($secs / 60);
3458     $secs = $secs % 60;
3459     if ($G_lang == 'en') {
3460         if ($mins > 0)
3461             $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3462
3463         if ($secs > 0)
3464             $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3465     }
3466     else {
3467         if ($mins > 0)
3468             $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3469
3470         if ($secs > 0)
3471             $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3472     }
3473     return ($ret);
3474 }
3475
3476 function sharedmem_sz($tok)
3477 {
3478     if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3479         log_main("shmop_open failed");
3480         return (-1);
3481     }
3482     $shm_sz = shmop_size($shm_id);
3483     shmop_close($shm_id);
3484
3485     // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3486     return ($shm_sz);
3487 }
3488
3489 class Warrant {
3490     static $delta_t;
3491
3492     static function lock_data($is_exclusive)
3493     {
3494         if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3495             self::$delta_t = microtime(TRUE);
3496             log_lock("LOCK   warrant      [".self::$delta_t."]");
3497
3498             return ($res);
3499         }
3500
3501         return (FALSE);
3502     }
3503
3504     static function unlock_data($res)
3505     {
3506         GLOBAL $sess;
3507
3508         log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3509
3510         file_unlock($res);
3511     }
3512 }
3513
3514 class Poll {
3515     static $delta_t;
3516
3517     static function lock_data($is_exclusive)
3518     {
3519         if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3520             self::$delta_t = microtime(TRUE);
3521             log_lock("LOCK   poll         [".self::$delta_t."]");
3522
3523             return ($res);
3524         }
3525
3526         return (FALSE);
3527     }
3528
3529     static function unlock_data($res)
3530     {
3531         GLOBAL $sess;
3532
3533         log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3534
3535         file_unlock($res);
3536     }
3537 }
3538
3539 function carousel_top()
3540 {
3541     $what = rand(1,2);
3542     if ($what == 1) {
3543         $rn = rand(1, 3);
3544         return (sprintf('<a target="_blank" href="http://shop.alternativeoutput.it"><img class="nobo" style="display: inline; border: 1px solid #808080;" alt="il negozio virtuale di Brisk" title="il negozio virtuale di Brisk" src="img/briskshop%d.gif"></a>', $rn));
3545         }
3546     else {
3547         return (sprintf('<a target="_blank" href="http://www.alternativeoutput.it/briskblog"><img class="nobo" alt="il nuovo blog di Brisk" title="il nuovo blog di Brisk" style="display: inline; border: 1px solid #808080;" src="img/briskblog_bannersmall.png"></a>'));
3548     }
3549 }
3550
3551 function login_consistency($name)
3552 {
3553     $old_c = '';
3554     if (($len = mb_strlen($name)) > 12) {
3555         return FALSE;
3556     }
3557
3558     for ($i = 0 ; $i < mb_strlen($name) ; $i++) {
3559         $c = mb_substr($name, $i, 1);
3560         if (mb_ereg_match ("[a-zA-Z0-9]", $c)) {
3561             if ($old_c != $c) {
3562                 $old_c = $c;
3563                 $old_ct = 1;
3564             }
3565             else {
3566                 $old_ct++;
3567                 if ($old_ct > 2) {
3568                     return (FALSE);
3569                 }
3570             }
3571         }
3572         else {
3573             return (FALSE);
3574         }
3575     }
3576     return (TRUE);
3577 }
3578 ?>