web/Obj/brisk.phh

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