web/Obj/brisk.phh

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