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