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