web/Obj/brisk.phh

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