web/Obj/brisk.phh

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