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 dump_data()
2248   {
2249       $brisk_ser = serialize($this);
2250       $brisk_ser_len = mb_strlen($brisk_ser, "ASCII");
2251       if (file_put_contents($this->crystal_filename, $brisk_ser) == $brisk_ser_len) {
2252           return (TRUE);
2253       }
2254
2255       return (FALSE);
2256   }
2257
2258   static function lock_data($is_exclusive)
2259   {
2260       if (($res = file_lock(FTOK_PATH."/main", $is_exclusive)) != FALSE) {
2261           self::$delta_t = microtime(TRUE);
2262           log_lock("LOCK   room         [".self::$delta_t."]");
2263
2264           return ($res);
2265       }
2266
2267       return (FALSE);
2268   }
2269
2270   static function unlock_data($res)
2271   {
2272     GLOBAL $sess;
2273
2274     log_lock("UNLOCK room         [".(microtime(TRUE) - (self::$delta_t))."]");
2275
2276     file_unlock($res);
2277   }
2278
2279
2280   function standup_content($user)
2281   {
2282     $ret = "";
2283     $content = "";
2284
2285     if ($user->stat != 'room')
2286       return;
2287
2288     for ($i = 0 , $ct = 0 ; $ct < 4 && $i < MAX_PLAYERS ; $i++) {
2289       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2290         continue;
2291       $ct++;
2292     }
2293
2294     // $content .= sprintf('<table cols=\\"%d\\" class=\\"table_standup\\">', $ct);
2295
2296     $content = ' j_stand_cont( [ ';
2297
2298     $user_cur_id = $user->idx_get();
2299     for ($i = 0 , $ct = 0 ; $i < MAX_PLAYERS ; $i++) {
2300       if ($this->user[$i]->sess == "" || $this->user[$i]->stat != "room" || $this->user[$i]->name == "")
2301         continue;
2302
2303       $flags = $this->user[$i]->flags;
2304
2305       // sql record exists AND last donate > 2013-01-01
2306       if ($this->user[$i]->is_supp_custom()) {
2307           $supp_comp_s = sprintf(', "%s"', $this->user[$i]->rec->supp_comp_get());
2308       }
2309       else {
2310           $supp_comp_s = '';
2311       }
2312
2313       if ($this->user[$i]->subst == "standup") {
2314           if ($user_cur_id == $i) {
2315               $flags |= 1;
2316           }
2317
2318           $content .= sprintf('%s[ %d, "%s"%s ]',($ct > 0 ? ', ' : ''), $flags,
2319                               xcape($this->user[$i]->name), $supp_comp_s);
2320           $ct++;
2321       }
2322     }
2323     $content .= ' ]);';
2324
2325     return ($content);
2326   }
2327
2328   function table_content($user, $table_idx)
2329   {
2330     $content = "";
2331     $ret = "";
2332     // TODO
2333     //
2334     //   Si possono usare i dati nella classe table
2335     //
2336
2337     $sess = $user->sess;
2338     $table = $this->table[$table_idx];
2339
2340     if ($user->stat != 'room')
2341       return;
2342
2343     $user_cur_id = $user->idx_get();
2344     $content = "[ ";
2345     for ($i = 0 ; $i < $table->player_n ; $i++) {
2346         $user_cur = $this->user[$table->player[$i]];
2347
2348         $flags = $user_cur->flags;
2349
2350         if ($user_cur_id == $table->player[$i])
2351             $flags |= 1;
2352
2353         log_main($user_cur->name. sprintf(" IN TABLE [%d]", $table_idx));
2354         if ($user_cur->is_supp_custom())
2355             $supp_comp_s = sprintf(', "%s"', $user_cur->rec->supp_comp_get());
2356         else
2357             $supp_comp_s = '';
2358
2359         $content .= sprintf('%s[ %d, "%s"%s ]',($i == 0 ? '' : ', '), $flags,
2360                             xcape($user_cur->name), $supp_comp_s);
2361     }
2362
2363     $content .= ' ]';
2364
2365     $ret .= sprintf('j_tab_cont(%d, %s);', $table_idx, $content);
2366
2367     return ($ret);
2368   }
2369
2370   function request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, $path, $addr, $get, $post, $cookie)
2371   {
2372       GLOBAL $G_black_list;
2373
2374       printf("NEW_SOCKET (root): %d PATH [%s]\n", intval($new_socket), $path);
2375
2376       $enc = get_encoding($header);
2377       if (isset($header['User-Agent'])) {
2378           if (strstr($header['User-Agent'], "MSIE")) {
2379               $transp_type = "htmlfile";
2380           }
2381           else {
2382               $transp_type = "xhr";
2383           }
2384       }
2385       else {
2386           $transp_type = "iframe";
2387       }
2388       force_no_cache($header_out);
2389
2390       switch ($path) {
2391       case "":
2392       case "index.php":
2393           ob_start();
2394           index_main($this, $transp_type, $header_out, $addr, $get, $post, $cookie);
2395           $content = ob_get_contents();
2396           ob_end_clean();
2397
2398           // fprintf(STDERR, "\n\nCONTENT [%s]\n\n", $content);
2399           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2400           return TRUE;
2401
2402           break;
2403       case "index_wr.php":
2404           //
2405           // Enhance required: in the POST case, after the header you must get content
2406           //                   from the socket, waiting if necessary
2407           //
2408
2409           ob_start();
2410           index_wr_main($this, $addr, $get, $post, $cookie);
2411           $content = ob_get_contents();
2412           ob_end_clean();
2413
2414           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2415           return TRUE;
2416
2417           break;
2418       case "index_rd.php":
2419           if (($transp  = gpcs_var('transp', $get, $post, $cookie)) === FALSE)
2420               $transp = "iframe";
2421           if ($transp == 'websocket')
2422               $enc = 'plain';
2423
2424           do {
2425               if (!isset($cookie['sess'])
2426                   || (($user = $this->get_user($cookie['sess'], $idx)) == FALSE)) {
2427
2428                   $content = User::stream_fini($transp, $s_a_p->rndstr, TRUE);
2429
2430                   $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2431                   return TRUE;
2432
2433                   break;
2434               }
2435               $this->sess_cur_set($user->sess);
2436               // close a previous opened index_read_ifra socket, if exists
2437               if (($prev = $user->rd_socket_get()) != NULL) {
2438                   $s_a_p->socks_unset($user->rd_socket_get());
2439                   fclose($user->rd_socket_get());
2440                   printf("CLOSE AND OPEN AGAIN ON IFRA2\n");
2441                   $user->rd_socket_set(NULL);
2442               }
2443
2444               $content = "";
2445               $user->stream_init($s_a_p->rndstr, $enc, $header, $header_out, $content, $get, $post, $cookie);
2446               $response = headers_render($header_out, -1).$user->chunked_content($content);
2447               $response_l = mb_strlen($response, "ASCII");
2448
2449               $wret = @fwrite($new_socket, $response, $response_l);
2450               if ($wret < $response_l) {
2451                   printf("TROUBLES WITH FWRITE: %d\n", $wret);
2452                   $user->rd_cache_set(mb_substr($content, $wret, $response_l - $wret, "ASCII"));
2453               }
2454               else {
2455                   $user->rd_cache_set("");
2456               }
2457               fflush($new_socket);
2458
2459
2460               $s_a_p->socks_set($new_socket, $user, NULL);
2461               $user->rd_socket_set($new_socket);
2462               printf(" - qui ci siamo - ");
2463               return TRUE;
2464           } while (FALSE);
2465
2466           return FALSE;
2467           break;
2468       case 'test.php':
2469           if (!(BRISK_DEBUG & DBG_ENGI))
2470               return (FALSE);
2471           fprintf(STDERR, "TEST.PHP running\n");
2472           if (isset($post['data'])) {
2473               $content = $post['data'];
2474           }
2475           else {
2476               $content = "NO DATA AVAILABLE";
2477           }
2478           $header_out['Content-Type'] = 'text/plain';
2479           $s_a_p->pendpage_try_addflush($new_socket, 20, $enc, $header_out, $content);
2480           return TRUE;
2481           break;
2482       default:
2483           /* FAR TODO: move all into an array of registered sub-apps */
2484           $subs = "briskin5/";
2485           $subs_l = strlen($subs);
2486           if (!strncmp($path, $subs, $subs_l)) {
2487               $ret = Bin5::request_mgr(&$s_a_p, $header, &$header_out, &$new_socket, substr($path, $subs_l) , $addr, $get, $post, $cookie);
2488               return ($ret);
2489           }
2490           break;
2491       }
2492
2493       return (FALSE);
2494   }
2495
2496   function match_add($idx, $match)
2497   {
2498       $this->match[$idx] = $match;
2499   }
2500
2501   function match_del($idx)
2502   {
2503       unset($this->match[$idx]);
2504   }
2505
2506   function match_get($idx, $token)
2507   {
2508       if (isset($this->match[$idx])) {
2509           if (   $token == NULL
2510               || $token == $this->match[$idx]->table_token) {
2511               return ($this->match[$idx]);
2512           }
2513       }
2514       return NULL;
2515   }
2516   function sess_cur_set($sess)
2517   {
2518       static::$sess_cur = $sess;
2519   }
2520
2521   static function sess_cur_get()
2522   {
2523       return(static::$sess_cur);
2524   }
2525 } // end class Brisk
2526
2527 function make_seed()
2528 {
2529   list($usec, $sec) = explode(' ', microtime());
2530   return (float) $sec + ((float) $usec * 100000);
2531 }
2532
2533 function btrace_line($ar)
2534 {
2535     GLOBAL $G_btrace_pref_sub;
2536
2537     $ret = "";
2538     for ($i = 0 ; $i < count($ar) ; $i++) {
2539         $with_class = isset($ar[$i]['class']);
2540         $with_file  = isset($ar[$i]['file']);
2541         $ret .= sprintf("%s%s%s (%s:%d)", ($i == 0 ? "" : ", "),
2542                         ($with_class ?  $ar[$i]['class'].$ar[$i]['type'] : ""),
2543                         $ar[$i]['function'], ($with_file ? str_replace($G_btrace_pref_sub, "", $ar[$i]['file']) : ""),
2544                         ($with_file ? $ar[$i]['line'] : ""));
2545     }
2546
2547     return ($ret);
2548 }
2549
2550 function trace_ftok($id, $add)
2551 {
2552     // NOTE: without space to use sed to substitute "= @ftok("  with "= @ftok("
2553     $tok=@ftok($id, $add);
2554
2555     log_shme($tok.": ".$id." + ".$add);
2556
2557     return ($tok);
2558 }
2559
2560 function log_mop($step, $log)
2561 {
2562     GLOBAL $PHP_SELF;
2563
2564     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LMOP) == 0)
2565         return;
2566
2567     $sess = Brisk::sess_cur_get();
2568     if (isset($sess) == FALSE)
2569         $ssess = "XXXX";
2570     else
2571         $ssess = $sess;
2572
2573     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LMOP) == 0)
2574         return;
2575
2576     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2577         $btrace = btrace_line(debug_backtrace());
2578     else
2579         $btrace = "";
2580     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2581         fwrite($fp, sprintf("LMOP: [%f] [%05d] [%s] [%s]\n", gettimeofday(TRUE), $step, $log, $btrace));
2582         fclose($fp);
2583     }
2584 }
2585
2586
2587 function log_only2($log)
2588 {
2589     GLOBAL $PHP_SELF;
2590
2591     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONL2) == 0)
2592         return;
2593
2594     $sess = Brisk::sess_cur_get();
2595     if (isset($sess) == FALSE)
2596         $ssess = "XXXX";
2597     else
2598         $ssess = $sess;
2599
2600     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONL2) == 0)
2601         return;
2602
2603     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2604         $btrace = btrace_line(debug_backtrace());
2605     else
2606         $btrace = "";
2607     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2608         fwrite($fp, sprintf("ONL2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2609         fclose($fp);
2610     }
2611 }
2612
2613 function log_crit($log)
2614 {
2615     GLOBAL $PHP_SELF;
2616
2617     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_CRIT) == 0)
2618         return;
2619
2620     $sess = Brisk::sess_cur_get();
2621     if (isset($sess) == FALSE)
2622         $ssess = "XXXX";
2623     else
2624         $ssess = $sess;
2625
2626     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_CRIT) == 0)
2627         return;
2628
2629     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2630         $btrace = btrace_line(debug_backtrace());
2631     else
2632         $btrace = "";
2633     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2634         fwrite($fp, sprintf("CRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2635         fclose($fp);
2636     }
2637 }
2638
2639 function log_only($log)
2640 {
2641     GLOBAL $PHP_SELF;
2642
2643     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_ONLY) == 0)
2644         return;
2645
2646     $sess = Brisk::sess_cur_get();
2647     if (isset($sess) == FALSE)
2648         $ssess = "XXXX";
2649     else
2650         $ssess = $sess;
2651
2652     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_ONLY) == 0)
2653         return;
2654
2655     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2656         $btrace = btrace_line(debug_backtrace());
2657     else
2658         $btrace = "";
2659     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2660         fwrite($fp, sprintf("ONLY: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2661         fclose($fp);
2662     }
2663 }
2664
2665 function log_main($log)
2666 {
2667     GLOBAL $PHP_SELF;
2668
2669     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_MAIN) == 0)
2670         return;
2671
2672     $sess = Brisk::sess_cur_get();
2673     if (isset($sess) == FALSE)
2674         $ssess = "XXXX";
2675     else
2676         $ssess = $sess;
2677
2678     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_MAIN) == 0)
2679         return;
2680
2681     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2682         $btrace = btrace_line(debug_backtrace());
2683     else
2684         $btrace = "";
2685     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2686         fwrite($fp, sprintf("MAIN: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2687         fclose($fp);
2688     }
2689 }
2690
2691 function log_rd($log)
2692 {
2693     GLOBAL $PHP_SELF;
2694
2695     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_READ) == 0)
2696         return;
2697
2698     $sess = Brisk::sess_cur_get();
2699     if (isset($sess) == FALSE)
2700         $ssess = "XXXX";
2701     else
2702         $ssess = $sess;
2703
2704     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_READ) == 0)
2705         return;
2706
2707     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2708         $btrace = btrace_line(debug_backtrace());
2709     else
2710         $btrace = "";
2711     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2712         fwrite($fp, sprintf("READ: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2713         fclose($fp);
2714     }
2715 }
2716
2717 function log_rd2($log)
2718 {
2719     GLOBAL $PHP_SELF;
2720
2721     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_REA2) == 0)
2722         return;
2723
2724     $sess = Brisk::sess_cur_get();
2725     if (isset($sess) == FALSE)
2726         $ssess = "XXXX";
2727     else
2728         $ssess = $sess;
2729
2730     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_REA2) == 0)
2731         return;
2732
2733     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2734         $btrace = btrace_line(debug_backtrace());
2735     else
2736         $btrace = "";
2737
2738     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2739         fwrite($fp, sprintf("REA2: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2740         fclose($fp);
2741     }
2742 }
2743
2744 function log_send($log)
2745 {
2746     GLOBAL $PHP_SELF;
2747
2748     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SEND) == 0)
2749         return;
2750
2751     $sess = Brisk::sess_cur_get();
2752     if (isset($sess) == FALSE)
2753         $ssess = "XXXX";
2754     else
2755         $ssess = $sess;
2756
2757     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SEND) == 0)
2758         return;
2759
2760     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2761         $btrace = btrace_line(debug_backtrace());
2762     else
2763         $btrace = "";
2764     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2765         fwrite($fp, sprintf("SEND: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2766         fclose($fp);
2767     }
2768 }
2769
2770 function log_lock($log)
2771 {
2772     GLOBAL $PHP_SELF;
2773
2774     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOCK) == 0)
2775         return;
2776
2777     $sess = Brisk::sess_cur_get();
2778     if (isset($sess) == FALSE)
2779         $ssess = "XXXX";
2780     else
2781         $ssess = $sess;
2782
2783     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOCK) == 0)
2784         return;
2785
2786     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2787         $btrace = btrace_line(debug_backtrace());
2788     else
2789         $btrace = "";
2790     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2791         fwrite($fp, sprintf("LOCK: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2792         fclose($fp);
2793     }
2794 }
2795
2796 function log_wr($log)
2797 {
2798     GLOBAL $PHP_SELF;
2799
2800     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_WRIT) == 0)
2801         return;
2802
2803     $sess = Brisk::sess_cur_get();
2804     if (isset($sess) == FALSE)
2805         $ssess = "XXXX";
2806     else
2807         $ssess = $sess;
2808
2809     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_WRIT) == 0)
2810         return;
2811
2812     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2813         $btrace = btrace_line(debug_backtrace());
2814     else
2815         $btrace = "";
2816     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2817         fwrite($fp, sprintf("WRIT: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2818         fclose($fp);
2819     }
2820 }
2821
2822 function log_load($log)
2823 {
2824     GLOBAL $PHP_SELF;
2825
2826     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_LOAD) == 0)
2827         return;
2828
2829     $sess = Brisk::sess_cur_get();
2830     if (isset($sess) == FALSE)
2831         $ssess = "XXXX";
2832     else
2833         $ssess = $sess;
2834
2835     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_LOAD) == 0)
2836         return;
2837
2838     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2839         $btrace = btrace_line(debug_backtrace());
2840     else
2841         $btrace = "";
2842     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2843         fwrite($fp, sprintf("LOAD: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2844         fclose($fp);
2845     }
2846 }
2847
2848 function log_auth($sess, $log)
2849 {
2850     GLOBAL $PHP_SELF;
2851
2852     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_AUTH) == 0)
2853         return;
2854
2855     if (( (BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_AUTH) == 0)
2856         return;
2857
2858     if ((BRISK_DEBUG | ($sess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2859         $btrace = btrace_line(debug_backtrace());
2860     else
2861         $btrace = "";
2862     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2863         fwrite($fp, sprintf("LOAD: [%s] [%d] [%s] [%s]\n", $sess, time(), $log, $btrace));
2864         fclose($fp);
2865     }
2866 }
2867
2868 function log_shme($log)
2869 {
2870     GLOBAL $PHP_SELF;
2871
2872     if (BRISK_SINGLE_SESS == "" && (BRISK_DEBUG & DBG_SHME) == 0)
2873         return;
2874
2875     $sess = Brisk::sess_cur_get();
2876     if (isset($sess) == FALSE)
2877         $ssess = "XXXX";
2878     else
2879         $ssess = $sess;
2880
2881     if (( (BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_SHME) == 0)
2882         return;
2883
2884     if ((BRISK_DEBUG | ($ssess == BRISK_SINGLE_SESS ? BRISK_SINGLE_DEBUG : 0) ) & DBG_TRAC)
2885         $btrace = btrace_line(debug_backtrace());
2886     else
2887         $btrace = "";
2888     if (($fp = @fopen(LEGAL_PATH."/brisk.log", 'a')) != FALSE) {
2889         fwrite($fp, sprintf("SHME: [%s] [%s] [%s]\n", $ssess, $log, $btrace));
2890         fclose($fp);
2891     }
2892 }
2893
2894
2895
2896 // function log_legal($curtime, $sess, $name, $where, $mesg)
2897 function log_legal($curtime, $addr, $user, $where, $mesg)
2898 {
2899
2900   if (($fp = @fopen(LEGAL_PATH."/legal.log", 'a')) != FALSE) {
2901     /* Unix time | session | nickname | IP | where was | mesg */
2902     fwrite($fp, sprintf("%ld|%s|%s|%s|%s|%s|%s|\n", $curtime, $user->sess,
2903                         ($user->flags & USER_FLAG_AUTH ? 'A' : 'N'),
2904                         $user->name, $addr, $where , $mesg));
2905     fclose($fp);
2906   }
2907 }
2908
2909 function table_act_content($isstanding, $sitted, $table, $cur_table, $allowed)
2910 {
2911   $ret = "";
2912
2913   if ($isstanding) {
2914     if ($sitted < PLAYERS_N) {
2915       if ($allowed)
2916         $act = 'sit';
2917       else
2918         $act = 'reserved';
2919     }
2920   }
2921   else {
2922     if ($table == $cur_table)
2923       $act = 'wake';
2924     else
2925       $act = 'none';
2926   }
2927
2928   if ($act != '')
2929     $ret = sprintf('j_tab_act_cont(%d, \'%s\');', $table, $act);
2930
2931   return ($ret);
2932 }
2933
2934 function show_notify($text, $tout, $butt, $w, $h)
2935 {
2936   log_main("SHOW_NOTIFY: ".$text);
2937   return sprintf('var noti = new notify(gst,"%s",%d,"%s",%d,%d);', $text, $tout, $butt, $w, $h);
2938 }
2939
2940 function show_notify_ex($text, $tout, $butt, $w, $h, $is_opaque, $block_time)
2941 {
2942   log_main("SHOW_NOTIFY OPAQUE: ".$text);
2943   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);
2944 }
2945
2946 function show_notify_document($text, $tout, $butt_arr, $confirm_func, $confirm_func_args, $w, $h, $is_opaque, $block_time)
2947 {
2948   log_main("SHOW_NOTIFY OPAQUE: ".$text);
2949
2950   $butts = "";
2951   for ($i = 0 ; $i < count($butt_arr) ; $i++) {
2952       $butts .= sprintf("%s'%s'", ($i == 0 ? "" : ","), $butt_arr[$i]);
2953   }
2954
2955   return sprintf('g_nd = new notify_document(gst, "%s", %d, [ %s ], %s, %s, %d, %d, %s, %d);|',
2956                  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);
2957 }
2958
2959
2960 function root_welcome($user)
2961 {
2962   GLOBAL $root_wellarr, $G_lang;
2963   $ret = "";
2964
2965   $curtime = time();
2966   $dt = date("H:i ", $curtime);
2967
2968   for ($i = 0 ; $i < count($root_wellarr[$G_lang]) ; $i++)
2969     $ret .= sprintf('chatt_sub("%s", [2, "%s"],"%s");', $dt, NICKSERV, str_replace('"', '\"', $root_wellarr[$G_lang][$i]));
2970
2971   return ($ret);
2972 }
2973
2974
2975
2976 function validate_sess($sess)
2977 {
2978   if (strlen($sess) == SESS_LEN)
2979     return (TRUE);
2980   else
2981     return (FALSE);
2982 }
2983
2984 function validate_name($name)
2985 {
2986     $name_new = str_replace(' ', '_', mb_substr(trim($name),0,12, "UTF-8"));
2987
2988   for ($i = 0 ; $i < strlen($name_new) ; $i++) {
2989     $c = $name_new[$i];
2990     if (($c >= "a" && $c <= "z") || ($c >= "A" && $c <= "Z") || ($c >= "0" && $c <= "9"))
2991       return ($name_new);
2992   }
2993
2994   return (FALSE);
2995 }
2996
2997 function playsound($filename)
2998 {
2999   return (sprintf('playsound("flasou", "%s");', $filename));
3000 }
3001
3002 function secstoword($secs)
3003 {
3004   GLOBAL $G_lang;
3005
3006   $ret = "";
3007
3008   $mins = floor($secs / 60);
3009   $secs = $secs % 60;
3010   if ($G_lang == 'en') {
3011     if ($mins > 0)
3012       $ret = sprintf("%d minute%s%s", $mins, ($mins > 1 ? "s" : ""), ($secs > 0 ? " and " : ""));
3013
3014     if ($secs > 0)
3015       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "s" : ""));
3016   }
3017   else {
3018     if ($mins > 0)
3019       $ret = sprintf("%d minut%s%s", $mins, ($mins > 1 ? "i" : "o"), ($secs > 0 ? " e " : ""));
3020
3021     if ($secs > 0)
3022       $ret .= sprintf("%d second%s", $secs, ($secs > 1 ? "i" : "o"));
3023   }
3024   return ($ret);
3025 }
3026
3027 function sharedmem_sz($tok)
3028 {
3029   if (($shm_id = @shmop_open($tok, 'a', 0, 0)) == FALSE) {
3030     log_main("shmop_open failed");
3031     return (-1);
3032   }
3033   $shm_sz = shmop_size($shm_id);
3034   shmop_close($shm_id);
3035
3036   // log_main("shm_sz: ".$shm_sz."   SHM_DIMS: ".SHM_DIMS);
3037   return ($shm_sz);
3038 }
3039
3040 class Warrant {
3041     static $delta_t;
3042
3043   static function lock_data($is_exclusive)
3044   {
3045       if (($res = file_lock(FTOK_PATH."/warrant", $is_exclusive)) != FALSE) {
3046           self::$delta_t = microtime(TRUE);
3047           log_lock("LOCK   warrant      [".self::$delta_t."]");
3048
3049           return ($res);
3050       }
3051
3052       return (FALSE);
3053   }
3054
3055   static function unlock_data($res)
3056   {
3057     GLOBAL $sess;
3058
3059     log_lock("UNLOCK warrant      [".(microtime(TRUE) - (self::$delta_t))."]");
3060
3061     file_unlock($res);
3062   }
3063 }
3064
3065 class Poll {
3066     static $delta_t;
3067
3068   static function lock_data($is_exclusive)
3069   {
3070       if (($res = file_lock(FTOK_PATH."/poll", $is_exclusive)) != FALSE) {
3071           self::$delta_t = microtime(TRUE);
3072           log_lock("LOCK   poll         [".self::$delta_t."]");
3073
3074           return ($res);
3075       }
3076
3077       return (FALSE);
3078   }
3079
3080   static function unlock_data($res)
3081   {
3082     GLOBAL $sess;
3083
3084     log_lock("UNLOCK poll         [".(microtime(TRUE) - (self::$delta_t))."]");
3085
3086     file_unlock($res);
3087   }
3088 }
3089
3090 function carousel_top()
3091 {
3092     $what = rand(1,2);
3093     if ($what == 1) {
3094         $rn = rand(1, 3);
3095         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));
3096         }
3097     else {
3098         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>'));
3099     }
3100 }
3101
3102
3103 ?>