web/Obj/brisk.phh

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