← Back to branch summary

~ubuntu-branches/ubuntu/hardy/php5/hardy-updates

« back to all changes in this revision

Viewing changes to ext/msession/msession.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-10-09 03:14:32 UTC
  • Revision ID: james.westby@ubuntu.com-20051009031432-kspik3lobxstafv9
Tags: upstream-5.0.5
Import upstream version 5.0.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/msession/msession.c
 
1
/*
 
2
   +----------------------------------------------------------------------+
 
3
   | msession 1.0                                                         |
 
4
   +----------------------------------------------------------------------+
 
5
   | Copyright (c) 1997-2004 The PHP Group                                |
 
6
   +----------------------------------------------------------------------+
 
7
   | This source file is subject to version 3.0 of the PHP license,       |
 
8
   | that is bundled with this package in the file LICENSE, and is        |
 
9
   | available through the world-wide-web at the following url:           |
 
10
   | http://www.php.net/license/3_0.txt.                                  |
 
11
   | If you did not receive a copy of the PHP license and are unable to   |
 
12
   | obtain it through the world-wide-web, please send a note to          |
 
13
   | license@php.net so we can mail you a copy immediately.               |
 
14
   +----------------------------------------------------------------------+
 
15
   | Authors: Mark Woodward <markw@mohawksoft.com>                        |
 
16
   |    Portions copyright the PHP group.                                 |
 
17
   +----------------------------------------------------------------------+
 
18
 */
 
19
 
 
20
#ifdef HAVE_CONFIG_H
 
21
#include "config.h"
 
22
#endif
 
23
 
 
24
#include "php.h"
 
25
#include "php_ini.h"
 
26
#include "php_msession.h"
 
27
#include "reqclient.h"
 
28
#include "ext/standard/info.h"
 
29
#include "ext/session/php_session.h"
 
30
 
 
31
 
 
32
/* Macros and such */
 
33
#ifndef TRUE
 
34
#define TRUE 1
 
35
#endif
 
36
#ifndef FALSE
 
37
#define FALSE 0
 
38
#endif
 
39
#ifndef SID_LEN
 
40
#define SID_LEN 32
 
41
#endif
 
42
 
 
43
 
 
44
/* Uncomment to get debugging messages */
 
45
/* #define ERR_DEBUG */
 
46
 
 
47
#ifdef ERR_DEBUG
 
48
#define ELOG( str )     php_log_err( str )
 
49
#else
 
50
#define ELOG( str )
 
51
#endif
 
52
 
 
53
/* Test if system is OK fror use. */
 
54
/* Macros may be ugly, but I can globaly add debuging when needed. */
 
55
#define IFCONNECT_BEGIN         if(s_reqb && s_conn) {
 
56
#define IFCONNECT_ENDVAL(V)     } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Msession not initialized"); return V; }
 
57
#define IFCONNECT_END           } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Msession not initialized"); RETURN_FALSE; }
 
58
 
 
59
#ifndef HAVE_PHP_SESSION
 
60
#error HAVE_PHP_SESSION not defined
 
61
#endif
 
62
 
 
63
/* Test if session module contains custom sesson ID patch */
 
64
#ifdef PHP_SESSION_API
 
65
#if (PHP_SESSION_API >= 20020330)
 
66
#define HAVE_PHP_SESSION_CREATESID
 
67
#endif
 
68
#endif
 
69
        
 
70
/* This sets the PHP API version used in the file. */
 
71
/* If this module does not compile on the version of PHP you are using, look for */
 
72
/* this value in Zend/zend_modules.h, and set appropriately */
 
73
#if (ZEND_MODULE_API_NO <=  20001222)
 
74
#define PHP_4_0
 
75
#define TSRMLS_CC
 
76
#define TSRMLS_DC
 
77
#define TSRMLS_FETCH()
 
78
/* Comment out this line if you wish to have msession without php sessions */
 
79
#define HAVE_PHP_SESSION
 
80
#warning Backward compatible msession extension requires PHP sessions. If PHP compiles and links, you can ignore this warning.
 
81
#elif (ZEND_MODULE_API_NO >= 20010901)
 
82
#define PHP_4_1
 
83
#else
 
84
#warning ZEND_MODULE_API_NO not defined
 
85
#define PHP_4_1
 
86
#endif
 
87
 
 
88
/*
 
89
 * Please do not remove backward compatibility from this module.
 
90
 * this same source must also work with the 4.0.6 version of PHP.
 
91
 *
 
92
 * Module Variable naming hints:
 
93
 * All global scope variables begin with "g_" for global.
 
94
 * All static file scoped variables begin with "s_" for static.
 
95
 * Zero terminated strings generally start with "sz" for "string followed by zero."
 
96
 * integers that hold string or data lengths generally start with "cb" for "count of bytes."
 
97
 * Also, please to not reformat braces ;-)
 
98
 * -MLW
 
99
 */
 
100
#if HAVE_MSESSION
 
101
#ifdef HAVE_PHP_SESSION
 
102
#ifdef HAVE_PHP_SESSION_CREATESID
 
103
/* If the PHP Session module is compiled or available, include support */
 
104
PS_FUNCS_SID(msession);
 
105
ps_module ps_mod_msession = {
 
106
        PS_MOD_SID(msession)
 
107
};
 
108
#else
 
109
PS_FUNCS(msession);
 
110
ps_module ps_mod_msession = {
 
111
        PS_MOD(msession)
 
112
};
 
113
#endif
 
114
#endif
 
115
 
 
116
/* Per-process variables need by msession */
 
117
static char     s_szdefhost[]="localhost";
 
118
static char *   s_szhost=s_szdefhost;
 
119
static int      s_port=8086;
 
120
static void *   s_conn=NULL;
 
121
static REQB *   s_reqb=NULL;
 
122
 
 
123
function_entry msession_functions[] = {
 
124
        PHP_FE(msession_connect,NULL)
 
125
        PHP_FE(msession_disconnect,NULL)
 
126
        PHP_FE(msession_lock,NULL)
 
127
        PHP_FE(msession_unlock,NULL)
 
128
        PHP_FE(msession_count,NULL)
 
129
        PHP_FE(msession_create,NULL)
 
130
        PHP_FE(msession_destroy,NULL)
 
131
        PHP_FE(msession_set,NULL)
 
132
        PHP_FE(msession_get,NULL)
 
133
        PHP_FE(msession_find,NULL)
 
134
        PHP_FE(msession_get_array,NULL)
 
135
        PHP_FE(msession_set_array,NULL)
 
136
        PHP_FE(msession_timeout,NULL)
 
137
        PHP_FE(msession_inc,NULL)
 
138
        PHP_FE(msession_set_data,NULL)
 
139
        PHP_FE(msession_get_data,NULL)
 
140
        PHP_FE(msession_listvar,NULL)
 
141
        PHP_FE(msession_list,NULL)
 
142
        PHP_FE(msession_uniq,NULL)
 
143
        PHP_FE(msession_randstr,NULL)
 
144
        PHP_FE(msession_plugin,NULL)
 
145
        PHP_FE(msession_call,NULL)
 
146
        PHP_FE(msession_ctl,NULL)
 
147
        PHP_FE(msession_exec,NULL)
 
148
        PHP_FE(msession_ping,NULL)
 
149
        {NULL, NULL, NULL}
 
150
};
 
151
 
 
152
zend_module_entry msession_module_entry = {
 
153
#ifdef PHP_4_1
 
154
        STANDARD_MODULE_HEADER,
 
155
#endif
 
156
        "msession",
 
157
        msession_functions,
 
158
        PHP_MINIT(msession),
 
159
        PHP_MSHUTDOWN(msession),
 
160
        PHP_RINIT(msession),
 
161
        PHP_RSHUTDOWN(msession),
 
162
        PHP_MINFO(msession),
 
163
#ifdef PHP_4_1
 
164
        NO_VERSION_YET,
 
165
#endif
 
166
        STANDARD_MODULE_PROPERTIES
 
167
};
 
168
 
 
169
#ifdef COMPILE_DL_MSESSION
 
170
ZEND_GET_MODULE(msession)
 
171
#endif
 
172
 
 
173
PHP_MINIT_FUNCTION(msession)
 
174
{
 
175
        s_conn = NULL;
 
176
        s_szhost = s_szdefhost;
 
177
        
 
178
#ifdef HAVE_PHP_SESSION
 
179
        php_session_register_module(&ps_mod_msession);
 
180
#endif
 
181
        return SUCCESS;
 
182
}
 
183
 
 
184
PHP_MSHUTDOWN_FUNCTION(msession)
 
185
{
 
186
        return SUCCESS;
 
187
}
 
188
 
 
189
PHP_RINIT_FUNCTION(msession)
 
190
{
 
191
        return SUCCESS;
 
192
}
 
193
 
 
194
PHP_RSHUTDOWN_FUNCTION(msession)
 
195
{
 
196
        return SUCCESS;
 
197
}
 
198
 
 
199
PHP_MINFO_FUNCTION(msession)
 
200
{
 
201
        php_info_print_table_start();
 
202
        php_info_print_table_header(2, "msession support", "enabled");
 
203
        php_info_print_table_end();
 
204
}
 
205
#define RPT_CONN_ERR
 
206
#ifdef ERR_DEBUG
 
207
#undef RPT_CONN_ERR
 
208
#define RPT_CONN_ERR if(s_reqb->req.stat == REQ_ERR && (result == REQE_BADCONN || result == REQE_NOSEND)) \
 
209
                ELOG("Socket reports closed");                                                  \
 
210
        else if(s_reqb->req.stat == REQ_ERR)\
 
211
                ELOG("MSession call failed");\
 
212
#else
 
213
#endif
 
214
 
 
215
#define CONN_ERR(reqb)\
 
216
        (reqb->req.stat == REQ_ERR) && (reqb->req.param == REQE_BADCONN || reqb->req.param == REQE_NOSEND)
 
217
 
 
218
int PHPExecRequest(int req, char *session, char *d1, char *d2,int param)
 
219
{
 
220
        int result;
 
221
        FormatRequest(&s_reqb, req, session, d1, d2, param);
 
222
        result = DoRequest(s_conn, &s_reqb);
 
223
 
 
224
        /* Server closed the connection! */
 
225
        if(CONN_ERR(s_reqb))
 
226
        {
 
227
                ELOG("Connection was closed by server");
 
228
                if(ReopenReqConn(s_conn))
 
229
                {
 
230
                        FormatRequest(&s_reqb, req, session, d1, d2, param);
 
231
                        result = DoRequest(s_conn, &s_reqb);
 
232
                }
 
233
        }
 
234
        RPT_CONN_ERR
 
235
        return result;
 
236
}
 
237
int PHPExecRequestMulti(int req, char *session, int n, char **pairs, int param)
 
238
{
 
239
        int result;
 
240
        FormatRequestMulti(&s_reqb, req, session, n, pairs, param);
 
241
        result = DoRequest(s_conn, &s_reqb);
 
242
 
 
243
        /* Server closed the connection! */
 
244
        if(CONN_ERR(s_reqb))
 
245
        {
 
246
                ELOG("Connection was closed by server");
 
247
                if(ReopenReqConn(s_conn))
 
248
                {
 
249
                        FormatRequestMulti(&s_reqb, req, session, n, pairs, param);
 
250
                        result = DoRequest(s_conn, &s_reqb);
 
251
                }
 
252
        }
 
253
        RPT_CONN_ERR
 
254
        return result;
 
255
}
 
256
int PHPExecRequestStrings(int req, char *session, int n, char **strings)
 
257
{
 
258
        int result;
 
259
        FormatRequestStrings(&s_reqb, req, session, n, strings);
 
260
        result = DoRequest(s_conn, &s_reqb);
 
261
        /* Server closed the connection! */
 
262
        if(CONN_ERR(s_reqb))
 
263
        {
 
264
                ELOG("Connection was closed by server");
 
265
                if(ReopenReqConn(s_conn))
 
266
                {
 
267
                        FormatRequestStrings(&s_reqb, req, session, n, strings);
 
268
                        result = DoRequest(s_conn, &s_reqb);
 
269
                }
 
270
        }
 
271
        RPT_CONN_ERR
 
272
        return result;
 
273
}
 
274
 
 
275
 
 
276
int PHPMsessionConnect(const char *szhost, int nport)
 
277
{
 
278
        int fNewHost=FALSE;
 
279
        
 
280
        if(!s_reqb)
 
281
                s_reqb = AllocateRequestBuffer(2048);
 
282
 
 
283
        if(!s_reqb) /* no buffer, it won't work! */
 
284
                return 0;
 
285
        
 
286
        if(strcmp(s_szhost, szhost))
 
287
        {
 
288
                if(s_szhost != s_szdefhost)
 
289
                        free(s_szhost);
 
290
                s_szhost = strdup(szhost);
 
291
                fNewHost = TRUE;
 
292
        }
 
293
        if(nport && nport != s_port)
 
294
        {
 
295
                fNewHost = TRUE;
 
296
                s_port = nport;
 
297
        }
 
298
 
 
299
        ELOG("PHPMsessionConnect:new");
 
300
        if(s_conn && fNewHost)
 
301
        {
 
302
                ELOG("Closing old connection, opening new");
 
303
                CloseReqConn(s_conn);
 
304
                s_conn = NULL;
 
305
        }
 
306
        if(!s_conn)
 
307
                s_conn = OpenReqConn(s_szhost, s_port);
 
308
#ifdef ERR_DEBUG
 
309
        else
 
310
        {
 
311
                ELOG("Reusing old connection");
 
312
        }
 
313
#endif
 
314
 
 
315
 
 
316
#ifdef ERR_DEBUG
 
317
{
 
318
        char buffer[256];
 
319
        sprintf(buffer,"Connect: %s [%d] = %d (%X)\n", 
 
320
                s_szhost, s_port, (s_conn != NULL), (unsigned)s_conn);
 
321
        php_log_err(buffer);
 
322
}
 
323
#endif
 
324
        return (s_conn) ? 1 : 0;
 
325
}
 
326
 
 
327
void PHPMsessionDisconnect()
 
328
{
 
329
}
 
330
 
 
331
char *PHPMsessionGetData(char *session TSRMLS_DC)
 
332
{
 
333
        char *ret = NULL;
 
334
        ELOG("PHPMsessionGetData");
 
335
 
 
336
        IFCONNECT_BEGIN
 
337
 
 
338
        PHPExecRequest(REQ_DATAGET, (char *)session,"","",0);
 
339
 
 
340
        if(s_reqb->req.stat==REQ_OK)
 
341
                ret = safe_estrdup(s_reqb->req.datum);
 
342
        IFCONNECT_ENDVAL(0)
 
343
        
 
344
        return ret;
 
345
}
 
346
int PHPMsessionSetData(char *session, char *data TSRMLS_DC)
 
347
{
 
348
        ELOG("PHPMsessionSetData");
 
349
        IFCONNECT_BEGIN
 
350
        int ret=0;
 
351
 
 
352
        PHPExecRequest(REQ_DATASET, session,"",data,0);
 
353
        ret = (s_reqb->req.stat==REQ_OK);
 
354
        if(s_reqb->req.stat!=REQ_OK)
 
355
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
356
 
 
357
        return ret;
 
358
 
 
359
        IFCONNECT_ENDVAL(0)
 
360
}
 
361
int PHPMsessionDestroy(char *session TSRMLS_DC)
 
362
{
 
363
        ELOG("PHPMsessionDestroy");
 
364
        IFCONNECT_BEGIN
 
365
 
 
366
        int ret=0;
 
367
        PHPExecRequest( REQ_DROP, session, "","",0);
 
368
        ret = (s_reqb->req.stat==REQ_OK);
 
369
        if(s_reqb->req.stat!=REQ_OK)
 
370
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
371
        return ret;
 
372
        
 
373
        IFCONNECT_ENDVAL(0)
 
374
}
 
375
 
 
376
/* {{{ proto bool msession_connect(string host, string port)
 
377
         Connect to msession sever */
 
378
PHP_FUNCTION(msession_connect)
 
379
{
 
380
        char *szhost;
 
381
        int nport;
 
382
        
 
383
        zval **zhost;
 
384
        zval **zport;
 
385
        
 
386
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &zhost, &zport) == FAILURE)
 
387
        {
 
388
                WRONG_PARAM_COUNT;
 
389
        }
 
390
        
 
391
        convert_to_string_ex(zhost);
 
392
        convert_to_string_ex(zport);
 
393
 
 
394
        szhost = Z_STRVAL_PP(zhost);
 
395
        nport = atoi(Z_STRVAL_PP(zport));
 
396
 
 
397
        if(PHPMsessionConnect(szhost,nport))
 
398
        {
 
399
                RETURN_TRUE;
 
400
        }
 
401
        else
 
402
        {
 
403
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "MSession connect failed");
 
404
                RETURN_FALSE;
 
405
        }
 
406
}
 
407
/* }}} */
 
408
 
 
409
/* {{{ proto void msession_disconnect(void)
 
410
   Disconnect from msession server */
 
411
PHP_FUNCTION(msession_disconnect)
 
412
{
 
413
        PHPMsessionDisconnect();
 
414
        RETURN_NULL();
 
415
}
 
416
/* }}} */
 
417
 
 
418
/* {{{ proto int msession_count(void)
 
419
   Get session count */
 
420
PHP_FUNCTION(msession_count)
 
421
{
 
422
        IFCONNECT_BEGIN
 
423
 
 
424
        int count;
 
425
        PHPExecRequest( REQ_COUNT, "", "","",0);
 
426
        
 
427
        count = (s_reqb->req.stat == REQ_OK) ? s_reqb->req.param : 0;
 
428
 
 
429
        RETURN_LONG(count);
 
430
 
 
431
        IFCONNECT_END
 
432
}
 
433
/* }}} */
 
434
 
 
435
/* {{{ proto bool msession_create(string session)
 
436
   Create a session */
 
437
PHP_FUNCTION(msession_create)
 
438
{
 
439
        IFCONNECT_BEGIN
 
440
/*      int stat; */
 
441
        char *szsession;
 
442
        zval **session;
 
443
        
 
444
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &session) == FAILURE)
 
445
        {
 
446
                WRONG_PARAM_COUNT;
 
447
        }
 
448
        convert_to_string_ex(session);
 
449
        szsession = Z_STRVAL_PP(session);
 
450
        PHPExecRequest( REQ_CREATE, szsession, "","",0);
 
451
        if(s_reqb->req.stat==REQ_OK)
 
452
        {
 
453
                RETURN_TRUE;
 
454
        }
 
455
        else
 
456
        {
 
457
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
458
                RETURN_FALSE;
 
459
        }
 
460
        IFCONNECT_END
 
461
}
 
462
/* }}} */
 
463
 
 
464
/* {{{ proto bool msession_destroy(string name)
 
465
   Destroy a session */
 
466
PHP_FUNCTION(msession_destroy)
 
467
{
 
468
        char *szsession;
 
469
        zval **session;
 
470
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &session) == FAILURE)
 
471
        {
 
472
                WRONG_PARAM_COUNT;
 
473
        }
 
474
        convert_to_string_ex(session);
 
475
        szsession = Z_STRVAL_PP(session);
 
476
        PHPMsessionDestroy(szsession TSRMLS_CC);
 
477
 
 
478
        RETURN_TRUE;
 
479
}
 
480
/* }}} */
 
481
 
 
482
/* {{{ proto int msession_lock(string name)
 
483
   Lock a session */
 
484
PHP_FUNCTION(msession_lock)
 
485
{
 
486
        IFCONNECT_BEGIN
 
487
        char *szsession;
 
488
        zval **session;
 
489
        
 
490
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &session) == FAILURE)
 
491
        {
 
492
                WRONG_PARAM_COUNT;
 
493
        }
 
494
        convert_to_string_ex(session);
 
495
        szsession = Z_STRVAL_PP(session);
 
496
        PHPExecRequest( REQ_SLOCK, szsession, "","",0);
 
497
 
 
498
        if(s_reqb->req.stat==REQ_OK)
 
499
        {
 
500
                RETURN_LONG(s_reqb->req.param);
 
501
        }
 
502
        else
 
503
        {
 
504
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
505
                RETURN_FALSE;
 
506
        }
 
507
 
 
508
        IFCONNECT_END
 
509
 
 
510
}
 
511
/* }}} */
 
512
/* {{{ proto int msession_ctl(string name)
 
513
   Lock a session */
 
514
PHP_FUNCTION(msession_ctl)
 
515
{
 
516
        static char *parray[] =
 
517
        {       "EXIST",
 
518
                "TTL",
 
519
                "AGE",
 
520
                "TLA",
 
521
                "CTIME",
 
522
                "TOUCH",
 
523
                "NOW",
 
524
                NULL
 
525
        };
 
526
        IFCONNECT_BEGIN
 
527
        char *szsession;
 
528
        zval **session;
 
529
        zval **which;
 
530
        int fn = REQ_STAT_EXIST;
 
531
        
 
532
                        
 
533
        int n = ZEND_NUM_ARGS();
 
534
 
 
535
        if(n != 1 && n != 2)
 
536
        {
 
537
                WRONG_PARAM_COUNT;
 
538
        }
 
539
 
 
540
        if(zend_get_parameters_ex(n,&session,&which) == FAILURE)
 
541
        {
 
542
                WRONG_PARAM_COUNT;
 
543
        }
 
544
 
 
545
        convert_to_string_ex(session);
 
546
        szsession = Z_STRVAL_PP(session);
 
547
 
 
548
        if(n > 1)
 
549
        {
 
550
                char *szwhich;
 
551
                int i;
 
552
                convert_to_string_ex(which);
 
553
                szwhich = Z_STRVAL_PP(which);
 
554
                for(i=0; parray[i]; i++)
 
555
                {
 
556
                        if(strcasecmp(parray[i], szwhich) == 0)
 
557
                        {
 
558
                                ELOG(szwhich);
 
559
                                
 
560
                                fn = i;
 
561
                                break;
 
562
                        }
 
563
                }
 
564
        }
 
565
 
 
566
        PHPExecRequest( REQ_CTL, szsession, "","",fn);
 
567
 
 
568
        if(s_reqb->req.stat==REQ_OK)
 
569
        {
 
570
#ifdef ERR_DEBUG
 
571
                char buffer[128];
 
572
                sprintf(buffer, "ret:%s", s_reqb->req.datum);
 
573
                ELOG(buffer);
 
574
#endif
 
575
                s_reqb->req.param = atoi(s_reqb->req.datum);
 
576
                RETURN_LONG(s_reqb->req.param);
 
577
        }
 
578
        else
 
579
        {
 
580
                ELOG("msession_ctl failed");
 
581
                RETURN_FALSE;
 
582
        }
 
583
        IFCONNECT_END
 
584
}
 
585
 
 
586
/* {{{ proto int msession_unlock(string session, int key)
 
587
   Unlock a session */
 
588
PHP_FUNCTION(msession_unlock)
 
589
{
 
590
        IFCONNECT_BEGIN
 
591
        char *szsession;
 
592
        long lkey;
 
593
        zval **session;
 
594
        zval **key;
 
595
        
 
596
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &session, &key) == FAILURE)
 
597
        {
 
598
                WRONG_PARAM_COUNT;
 
599
        }
 
600
        convert_to_string_ex(session);
 
601
        szsession = Z_STRVAL_PP(session);
 
602
        convert_to_long_ex(key);
 
603
        lkey = Z_LVAL_PP(key);
 
604
        PHPExecRequest( REQ_SUNLOCK, szsession, "","",lkey);
 
605
 
 
606
        if(s_reqb->req.stat==REQ_OK)
 
607
        {
 
608
                RETURN_LONG(s_reqb->req.param);
 
609
        }
 
610
        else
 
611
        {
 
612
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
613
                RETURN_FALSE;
 
614
        }
 
615
        IFCONNECT_END
 
616
}
 
617
/* }}} */
 
618
 
 
619
/* {{{ proto bool msession_set(string session, string name, string value)
 
620
   Set value in session */
 
621
PHP_FUNCTION(msession_set)
 
622
{
 
623
        IFCONNECT_BEGIN
 
624
 
 
625
        char *szsession;
 
626
        char *szname;
 
627
        char *szvalue;
 
628
        zval **session;
 
629
        zval **name;
 
630
        zval **value;
 
631
        
 
632
        if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3,&session,&name,&value) == FAILURE)
 
633
        {
 
634
                WRONG_PARAM_COUNT;
 
635
        }
 
636
        convert_to_string_ex(session);
 
637
        convert_to_string_ex(name);
 
638
        convert_to_string_ex(value);
 
639
 
 
640
        szsession = Z_STRVAL_PP(session);
 
641
        szname = Z_STRVAL_PP(name);
 
642
        szvalue = Z_STRVAL_PP(value);
 
643
 
 
644
        PHPExecRequest( REQ_SETVAL, szsession, szname, szvalue, 0);
 
645
 
 
646
        if(s_reqb->req.stat==REQ_OK)
 
647
        {
 
648
                RETURN_TRUE;
 
649
        }
 
650
        else
 
651
        {
 
652
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
653
                RETURN_FALSE;
 
654
        }
 
655
        IFCONNECT_END
 
656
}
 
657
/* }}} */
 
658
 
 
659
/* {{{ proto string msession_get(string session, string name, string default_value)
 
660
   Get value from session */
 
661
PHP_FUNCTION(msession_get)
 
662
{
 
663
        IFCONNECT_BEGIN
 
664
        char *szsession;
 
665
        char *szname;
 
666
        char *szvalue;
 
667
        zval **session;
 
668
        zval **name;
 
669
        zval **value;
 
670
        
 
671
        if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3,&session,&name,&value) == FAILURE)
 
672
        {
 
673
                WRONG_PARAM_COUNT;
 
674
        }
 
675
        convert_to_string_ex(session);
 
676
        convert_to_string_ex(name);
 
677
        convert_to_string_ex(value);
 
678
        szsession = Z_STRVAL_PP(session);
 
679
        szname = Z_STRVAL_PP(name);
 
680
        szvalue = Z_STRVAL_PP(value);
 
681
 
 
682
        PHPExecRequest( REQ_GETVAL, szsession, szname, szvalue,0);
 
683
 
 
684
        if(s_reqb->req.stat==REQ_OK)
 
685
        {
 
686
                szvalue = safe_estrdup(s_reqb->req.datum);
 
687
                RETURN_STRING(szvalue, 0)
 
688
        }
 
689
        else
 
690
        {
 
691
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
692
                RETURN_NULL();
 
693
        }
 
694
        IFCONNECT_END
 
695
}
 
696
/* }}} */
 
697
 
 
698
/* {{{ proto string msession_uniq(int num_chars)
 
699
   Get uniq id */
 
700
PHP_FUNCTION(msession_uniq)
 
701
{
 
702
        IFCONNECT_BEGIN
 
703
 
 
704
        long val;
 
705
        zval **param;
 
706
        
 
707
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1,&param) == FAILURE)
 
708
        {
 
709
                WRONG_PARAM_COUNT;
 
710
        }
 
711
        convert_to_long_ex(param);
 
712
        val = Z_LVAL_PP(param);
 
713
 
 
714
        PHPExecRequest( REQ_UNIQ,"", "", "",val);
 
715
 
 
716
        if(s_reqb->req.stat==REQ_OK)
 
717
        {
 
718
                char *szval = safe_estrdup(s_reqb->req.datum);
 
719
                RETURN_STRING(szval, 0)
 
720
        }
 
721
        else
 
722
        {
 
723
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
724
                RETURN_NULL();
 
725
        }
 
726
        IFCONNECT_END
 
727
 
 
728
}
 
729
/* }}} */
 
730
 
 
731
/* {{{ proto string msession_randstr(int num_chars)
 
732
   Get random string */
 
733
PHP_FUNCTION(msession_randstr)
 
734
{
 
735
        IFCONNECT_BEGIN
 
736
        long val;
 
737
        zval **param;
 
738
        
 
739
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1,&param) == FAILURE)
 
740
        {
 
741
                        WRONG_PARAM_COUNT;
 
742
        }
 
743
        convert_to_long_ex(param);
 
744
        val = Z_LVAL_PP(param);
 
745
 
 
746
        PHPExecRequest( REQ_RANDSTR,"", "", "",val);
 
747
 
 
748
        if(s_reqb->req.stat==REQ_OK)
 
749
        {
 
750
                char *szval = safe_estrdup(s_reqb->req.datum);
 
751
                RETURN_STRING(szval, 0)
 
752
        }
 
753
        else
 
754
        {
 
755
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
756
                RETURN_NULL();
 
757
        }
 
758
        IFCONNECT_END
 
759
}
 
760
/* }}} */
 
761
 
 
762
/* {{{ proto array msession_find(string name, string value)
 
763
   Find all sessions with name and value */
 
764
PHP_FUNCTION(msession_find)
 
765
{
 
766
        IFCONNECT_BEGIN
 
767
 
 
768
        char *szname;
 
769
        char *szvalue;
 
770
        zval **name;
 
771
        zval **value;
 
772
        
 
773
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &name, &value) == FAILURE)
 
774
        {
 
775
                WRONG_PARAM_COUNT;
 
776
        }
 
777
        convert_to_string_ex(name);
 
778
        convert_to_string_ex(value);
 
779
        szname = Z_STRVAL_PP(name);
 
780
        szvalue = Z_STRVAL_PP(value);
 
781
 
 
782
        PHPExecRequest( REQ_FIND, "", szname, szvalue,0);
 
783
 
 
784
        if(s_reqb->req.stat==REQ_OK && s_reqb->req.param)
 
785
        {
 
786
                int i;
 
787
                char *str = s_reqb->req.datum;
 
788
                array_init(return_value);
 
789
 
 
790
                for(i=0; i < s_reqb->req.param; i++)
 
791
                {
 
792
                        int cbstr = strlen(str);
 
793
                        char *data = safe_estrdup(str);
 
794
                        add_index_string(return_value, i, data, 0);
 
795
                        str += (cbstr+1);
 
796
                }
 
797
        }
 
798
        else if(s_reqb->req.stat != REQ_OK)
 
799
        {
 
800
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
801
                RETURN_NULL();
 
802
        }
 
803
        IFCONNECT_END
 
804
}
 
805
/* }}} */
 
806
 
 
807
/* {{{ proto array msession_list(void)
 
808
   List all sessions  */
 
809
PHP_FUNCTION(msession_list)
 
810
{
 
811
        IFCONNECT_BEGIN
 
812
        PHPExecRequest( REQ_LIST, "", "", "",0);
 
813
 
 
814
        if(s_reqb->req.stat==REQ_OK && s_reqb->req.param)
 
815
        {
 
816
                int i;
 
817
                char *str = s_reqb->req.datum;
 
818
                array_init(return_value);
 
819
 
 
820
                for(i=0; i < s_reqb->req.param; i++)
 
821
                {
 
822
                        int cbstr = strlen(str);
 
823
                        char *data = safe_estrdup(str);
 
824
                        add_index_string(return_value, i, data, 0);
 
825
                        str += (cbstr+1);
 
826
                }
 
827
        }
 
828
        else if(s_reqb->req.stat != REQ_OK)
 
829
        {
 
830
                /* May this should be an error? */
 
831
                if(s_reqb->req.param !=  REQE_NOSESSION) 
 
832
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
833
                RETURN_NULL();
 
834
        }
 
835
        IFCONNECT_END
 
836
}
 
837
/* }}} */
 
838
 
 
839
/* {{{ proto array msession_get_array(string session)
 
840
   Get array of msession variables  */
 
841
PHP_FUNCTION(msession_get_array)
 
842
{
 
843
        IFCONNECT_BEGIN
 
844
        char *szsession;
 
845
        zval **session;
 
846
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &session) == FAILURE)
 
847
        {
 
848
                WRONG_PARAM_COUNT;
 
849
  }
 
850
        convert_to_string_ex(session);
 
851
        szsession = Z_STRVAL_PP(session);
 
852
        PHPExecRequest( REQ_GETALL, szsession, "", "",0);
 
853
 
 
854
        array_init(return_value);
 
855
 
 
856
        if(s_reqb->req.stat == REQ_OK)
 
857
        {
 
858
                int i;
 
859
                char *str = s_reqb->req.datum;
 
860
                int num = s_reqb->req.param*2;
 
861
 
 
862
                for(i=0; i < num; i+=2)
 
863
                {
 
864
                        int cbvalue;
 
865
                        int cbname;
 
866
                        char *szvalue;
 
867
                        char *szname;
 
868
 
 
869
                        cbname = strlen(str);
 
870
                        szname = safe_estrndup(str,cbname);
 
871
                        str += (cbname+1);
 
872
 
 
873
                        cbvalue = strlen(str);
 
874
                        szvalue = safe_estrndup(str,cbvalue);
 
875
                        str += (cbvalue+1);
 
876
                        add_assoc_string(return_value, szname, szvalue, 0);
 
877
                }
 
878
        }
 
879
        else
 
880
        {
 
881
                if(s_reqb->req.param !=  REQE_NOSESSION)
 
882
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
883
                RETURN_NULL();
 
884
        }
 
885
        IFCONNECT_END
 
886
}
 
887
/* }}} */
 
888
 
 
889
/* {{{ proto bool msession_set_array(string session, array tuples)
 
890
   Set msession variables from an array*/
 
891
PHP_FUNCTION(msession_set_array)
 
892
{
 
893
        IFCONNECT_BEGIN
 
894
        zval **session;
 
895
        zval **tuples;
 
896
        HashPosition pos;
 
897
        zval **entry;
 
898
        char *key;
 
899
#ifdef PHP_4_1
 
900
        uint keylen;
 
901
#endif
 
902
#ifdef PHP_4_0
 
903
        ulong keylen;
 
904
#endif
 
905
        ulong numndx;
 
906
        int ndx=0;
 
907
        char **pairs;
 
908
        HashTable *htTuples;
 
909
        int i;
 
910
        
 
911
        int countpair; 
 
912
        
 
913
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &session, &tuples) == FAILURE)
 
914
        {
 
915
                WRONG_PARAM_COUNT;
 
916
        }
 
917
        htTuples = Z_ARRVAL_PP(tuples);
 
918
 
 
919
        countpair = zend_hash_num_elements(htTuples);
 
920
 
 
921
        pairs = (char **)safe_emalloc(sizeof(char *), countpair * 2, 0);
 
922
 
 
923
        ELOG("have pairs");
 
924
 
 
925
        /* Initializes pos */
 
926
        zend_hash_internal_pointer_reset_ex(htTuples, &pos);
 
927
 
 
928
        ELOG("reset pointer");
 
929
 
 
930
        for(i=0; i < countpair; i++)
 
931
        {
 
932
                if(zend_hash_get_current_data_ex(htTuples, (void **)&entry, &pos) != SUCCESS) 
 
933
                        break;
 
934
 
 
935
                if(entry)
 
936
                {
 
937
                        char *szentry;
 
938
                        convert_to_string_ex(entry);
 
939
                        szentry = Z_STRVAL_PP(entry);
 
940
                        
 
941
                        if(zend_hash_get_current_key_ex(htTuples,&key,&keylen,&numndx,0,&pos)== HASH_KEY_IS_STRING)
 
942
                        {
 
943
#ifdef ERR_DEBUG
 
944
{
 
945
                                char buffer [256];
 
946
                                sprintf(buffer, "%s=%s\n", key, szentry);
 
947
                                ELOG(buffer);
 
948
}
 
949
#endif
 
950
                                pairs[ndx++] = key;
 
951
                                pairs[ndx++] = szentry;
 
952
                        }
 
953
                }
 
954
                zend_hash_move_forward_ex(htTuples, &pos);
 
955
        }
 
956
 
 
957
        PHPExecRequestMulti(REQ_SETVAL, Z_STRVAL_PP(session), countpair, pairs,0);
 
958
 
 
959
        if(s_reqb->req.stat != REQ_OK)
 
960
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
961
        efree((void *)pairs);
 
962
        IFCONNECT_END
 
963
}
 
964
/* }}} */
 
965
 
 
966
/* {{{ proto array msession_listvar(string name)
 
967
   return associative array of value:session for all sessions with a variable named 'name' */
 
968
PHP_FUNCTION(msession_listvar)
 
969
{
 
970
        IFCONNECT_BEGIN
 
971
        zval **name;
 
972
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &name) == FAILURE)
 
973
        {
 
974
                WRONG_PARAM_COUNT;
 
975
        }
 
976
        convert_to_string_ex(name);
 
977
        PHPExecRequest( REQ_LISTVAR, "", Z_STRVAL_PP(name), "",0);
 
978
 
 
979
        array_init(return_value);
 
980
 
 
981
        if(s_reqb->req.stat == REQ_OK)
 
982
        {
 
983
                int i;
 
984
                char *str = s_reqb->req.datum;
 
985
                int num = s_reqb->req.param*2;
 
986
 
 
987
                for(i=0; i < num; i+=2)
 
988
                {
 
989
                        int cbvalue;
 
990
                        int cbname;
 
991
                        char *szvalue;
 
992
                        char *szname;
 
993
 
 
994
                        cbname= strlen(str);
 
995
                        szname= safe_estrndup(str,cbname);
 
996
                        str += (cbname+1);
 
997
 
 
998
                        cbvalue = strlen(str);
 
999
                        szvalue = safe_estrndup(str,cbvalue);
 
1000
                        str += (cbvalue+1);
 
1001
                        add_assoc_string(return_value, szname, szvalue, 0);
 
1002
                }
 
1003
        }
 
1004
        else
 
1005
        {
 
1006
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1007
                RETURN_NULL();
 
1008
        }
 
1009
        IFCONNECT_END
 
1010
}
 
1011
/* }}} */
 
1012
 
 
1013
/* {{{ proto int msession_timeout(string session [, int param ])
 
1014
   Set/get session timeout */
 
1015
PHP_FUNCTION(msession_timeout)
 
1016
{
 
1017
        IFCONNECT_BEGIN
 
1018
        zval **session;
 
1019
        int ac = ZEND_NUM_ARGS();
 
1020
        int zstat = FAILURE;
 
1021
        int timeout = 0;
 
1022
        if(ac == 1)
 
1023
        {
 
1024
                zstat = zend_get_parameters_ex(1, &session);
 
1025
        }
 
1026
        else if(ac == 2)
 
1027
        {
 
1028
                zval **param;
 
1029
                zstat = zend_get_parameters_ex(2, &session, &param);
 
1030
                convert_to_long_ex(param);
 
1031
                timeout = Z_LVAL_PP(param);
 
1032
        }
 
1033
        if(zstat == FAILURE)
 
1034
        {
 
1035
                WRONG_PARAM_COUNT;
 
1036
        }
 
1037
        convert_to_string_ex(session);
 
1038
        PHPExecRequest( REQ_TIMEOUT, Z_STRVAL_PP(session), "","",timeout);
 
1039
 
 
1040
        if(s_reqb->req.stat == REQ_OK)
 
1041
        {
 
1042
                RETURN_LONG( s_reqb->req.param);
 
1043
        }
 
1044
        else
 
1045
        {
 
1046
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1047
                RETURN_NULL();
 
1048
        }
 
1049
        IFCONNECT_END
 
1050
}
 
1051
/* }}} */
 
1052
 
 
1053
/* {{{ proto string msession_inc(string session, string name) 
 
1054
   Increment value in session */
 
1055
PHP_FUNCTION(msession_inc)
 
1056
{
 
1057
        IFCONNECT_BEGIN
 
1058
        char *val;
 
1059
        zval **session;
 
1060
        zval **name;
 
1061
        
 
1062
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &session, &name) == FAILURE)
 
1063
        {
 
1064
                WRONG_PARAM_COUNT;
 
1065
        }
 
1066
        convert_to_string_ex(session);
 
1067
        convert_to_string_ex(name);
 
1068
 
 
1069
        PHPExecRequest( REQ_INC, Z_STRVAL_PP(session), Z_STRVAL_PP(name),0,0);
 
1070
 
 
1071
        if(s_reqb->req.stat==REQ_OK)
 
1072
        {
 
1073
                val = safe_estrdup(s_reqb->req.datum);
 
1074
                RETURN_STRING(val, 0)
 
1075
        }
 
1076
        else
 
1077
        {
 
1078
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1079
                RETURN_FALSE;
 
1080
        }
 
1081
        IFCONNECT_END
 
1082
}
 
1083
/* }}} */
 
1084
 
 
1085
/* {{{ proto string msession_get_data(string session)
 
1086
   Get data session unstructured data. (PHP sessions use this)  */
 
1087
PHP_FUNCTION(msession_get_data)
 
1088
{
 
1089
        IFCONNECT_BEGIN
 
1090
        char *val;
 
1091
        zval **session;
 
1092
        
 
1093
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &session) == FAILURE)
 
1094
        {
 
1095
                WRONG_PARAM_COUNT;
 
1096
        }
 
1097
        convert_to_string_ex(session);
 
1098
 
 
1099
        val = PHPMsessionGetData(Z_STRVAL_PP(session) TSRMLS_CC);
 
1100
 
 
1101
        if(val)
 
1102
        {
 
1103
                RETURN_STRING(val, 0)
 
1104
        }
 
1105
        else
 
1106
        {
 
1107
                RETURN_NULL();
 
1108
        }
 
1109
        IFCONNECT_END
 
1110
}
 
1111
/* }}} */
 
1112
 
 
1113
/* {{{ proto bool msession_set_data(string session, string value)
 
1114
   Set data session unstructured data. (PHP sessions use this)  */
 
1115
PHP_FUNCTION(msession_set_data)
 
1116
{
 
1117
        IFCONNECT_BEGIN
 
1118
        zval **session;
 
1119
        zval **value;
 
1120
        
 
1121
        if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &session, &value) == FAILURE)
 
1122
        {
 
1123
                WRONG_PARAM_COUNT;
 
1124
        }
 
1125
        convert_to_string_ex(session);
 
1126
        convert_to_string_ex(value);
 
1127
 
 
1128
        if(PHPMsessionSetData(Z_STRVAL_PP(session), Z_STRVAL_PP(value) TSRMLS_CC))
 
1129
        {
 
1130
                RETURN_TRUE;
 
1131
        }
 
1132
        else
 
1133
        {
 
1134
                RETURN_FALSE;
 
1135
        }
 
1136
        IFCONNECT_END
 
1137
}
 
1138
/* }}} */
 
1139
 
 
1140
/* {{{ proto string msession_plugin(string session, string val [, string param ])
 
1141
   Call the personality plugin escape function */
 
1142
PHP_FUNCTION(msession_plugin)
 
1143
{
 
1144
        IFCONNECT_BEGIN
 
1145
        int ret;
 
1146
        char *retval;
 
1147
        zval **session;
 
1148
        zval **val;
 
1149
        zval **param=NULL;
 
1150
        
 
1151
        if(ZEND_NUM_ARGS() == 3)
 
1152
        {
 
1153
                ret = zend_get_parameters_ex(3, &session, &val, &param);
 
1154
                convert_to_string_ex(param);
 
1155
        }
 
1156
        else if(ZEND_NUM_ARGS() == 2)
 
1157
        {
 
1158
                ret = zend_get_parameters_ex(2, &session, &val);
 
1159
        }
 
1160
        else
 
1161
        {
 
1162
                WRONG_PARAM_COUNT;
 
1163
        }
 
1164
        if(ret == FAILURE)
 
1165
        {
 
1166
                WRONG_PARAM_COUNT;
 
1167
        }
 
1168
        convert_to_string_ex(session);
 
1169
        convert_to_string_ex(val);
 
1170
 
 
1171
        ret = atoi(Z_STRVAL_PP(val));
 
1172
 
 
1173
        PHPExecRequest( REQ_PLUGIN, Z_STRVAL_PP(session), Z_STRVAL_PP(val), param ? Z_STRVAL_PP(param) : "",ret);
 
1174
 
 
1175
        if(s_reqb->req.stat==REQ_OK && s_reqb->req.len)
 
1176
        {
 
1177
                retval = safe_estrdup(s_reqb->req.datum);
 
1178
                RETURN_STRING(retval, 0)
 
1179
        }
 
1180
        else if(s_reqb->req.stat != REQ_OK)
 
1181
        {
 
1182
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1183
                RETURN_FALSE;
 
1184
                
 
1185
        }
 
1186
        IFCONNECT_END
 
1187
}
 
1188
/* }}} */
 
1189
#define MAX_EXT_VAL     5
 
1190
/* {{{ proto string msession_call(string fn_name, [, string param1 ], ... [,string param4])
 
1191
   Call the plugin function named fn_name */
 
1192
PHP_FUNCTION(msession_call)
 
1193
{
 
1194
        IFCONNECT_BEGIN
 
1195
        int n;
 
1196
        int i;
 
1197
        int ret;
 
1198
        char *retval;
 
1199
        zval **val[MAX_EXT_VAL];
 
1200
        char *strings[MAX_EXT_VAL+1];
 
1201
/*      zval **param=NULL; */
 
1202
        
 
1203
        n = ZEND_NUM_ARGS();
 
1204
 
 
1205
        if((n < 1) || (n > MAX_EXT_VAL))
 
1206
        {
 
1207
                WRONG_PARAM_COUNT;
 
1208
        }
 
1209
 
 
1210
        ret = zend_get_parameters_ex(ZEND_NUM_ARGS(), &val[0],&val[1],&val[2],&val[3],&val[4]);
 
1211
 
 
1212
        if(ret == FAILURE)
 
1213
        {
 
1214
                WRONG_PARAM_COUNT;
 
1215
        }
 
1216
        for(i=0; i < n; i++)
 
1217
        {
 
1218
                convert_to_string_ex(val[i]);
 
1219
                strings[i] = Z_STRVAL_PP(val[i]);
 
1220
        }
 
1221
 
 
1222
        PHPExecRequestStrings(REQ_CALL, NULL , n, strings);
 
1223
 
 
1224
        if(s_reqb->req.stat==REQ_OK && s_reqb->req.len)
 
1225
        {
 
1226
                retval = safe_estrdup(s_reqb->req.datum);
 
1227
                RETURN_STRING(retval, 0)
 
1228
        }
 
1229
        else if(s_reqb->req.stat != REQ_OK)
 
1230
        {
 
1231
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1232
                RETURN_FALSE;
 
1233
        }
 
1234
        IFCONNECT_END
 
1235
}
 
1236
/* }}} */
 
1237
/* {{{ proto string msession_exec(string cmdline)
 
1238
   executes a program on msession system  */
 
1239
PHP_FUNCTION(msession_exec)
 
1240
{
 
1241
        IFCONNECT_BEGIN
 
1242
        char *val;
 
1243
        zval **cmdline;
 
1244
        
 
1245
        if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &cmdline) == FAILURE)
 
1246
        {
 
1247
                WRONG_PARAM_COUNT;
 
1248
        }
 
1249
        convert_to_string_ex(cmdline);
 
1250
 
 
1251
        PHPExecRequest( REQ_EXEC, Z_STRVAL_PP(cmdline), "","",0);
 
1252
 
 
1253
        if(s_reqb->req.stat == REQ_OK)
 
1254
        {
 
1255
                val = safe_estrdup(s_reqb->req.datum);
 
1256
                RETURN_STRING(val, 0)
 
1257
        }
 
1258
        else
 
1259
        {
 
1260
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1261
                RETURN_NULL();
 
1262
        }
 
1263
        IFCONNECT_END
 
1264
}
 
1265
/* }}} */
 
1266
/* {{{ proto bool msession_ping(void)
 
1267
   returns non-zero if msession is alive*/
 
1268
PHP_FUNCTION(msession_ping)
 
1269
{
 
1270
        IFCONNECT_BEGIN
 
1271
 
 
1272
        PHPExecRequest(REQ_PING,"","","", 0);
 
1273
 
 
1274
        if(s_reqb->req.stat==REQ_OK)
 
1275
        {
 
1276
                RETURN_TRUE;
 
1277
        }
 
1278
        else
 
1279
        {
 
1280
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1281
                RETURN_FALSE;
 
1282
        }
 
1283
        IFCONNECT_END
 
1284
}
 
1285
/* }}} */
 
1286
 
 
1287
#ifdef HAVE_PHP_SESSION
 
1288
 
 
1289
PS_OPEN_FUNC(msession)
 
1290
{
 
1291
        int port;
 
1292
        int len = strlen(save_path)+1;
 
1293
        char * path = emalloc(len);
 
1294
        char * szport;
 
1295
 
 
1296
        strcpy(path, save_path);
 
1297
 
 
1298
        szport = strchr(path, ':');
 
1299
 
 
1300
        if(szport)
 
1301
        {
 
1302
                *szport++=0;
 
1303
                port = atoi(szport);
 
1304
        }
 
1305
        else
 
1306
        {
 
1307
                port = s_port;
 
1308
        }
 
1309
        
 
1310
        ELOG( "ps_open_msession");
 
1311
        PS_SET_MOD_DATA((void *)1); /* session.c needs a non-zero here! */
 
1312
        if (PHPMsessionConnect(path, port)) {
 
1313
                efree(path);
 
1314
                return SUCCESS;
 
1315
        } else {
 
1316
                efree(path);
 
1317
                return FAILURE;
 
1318
        }
 
1319
}
 
1320
 
 
1321
PS_CLOSE_FUNC(msession)
 
1322
{
 
1323
        ELOG( "ps_close_msession");
 
1324
        PHPMsessionDisconnect();
 
1325
        return SUCCESS;
 
1326
}
 
1327
 
 
1328
PS_READ_FUNC(msession)
 
1329
{
 
1330
        ELOG( "ps_read_msession");
 
1331
        *val = PHPMsessionGetData((char *)key TSRMLS_CC);
 
1332
        if(*val)
 
1333
                {
 
1334
                        *vallen = strlen(*val);
 
1335
                }
 
1336
        else
 
1337
        {
 
1338
                *val = emalloc(1);
 
1339
                **val=0;
 
1340
                *vallen = 0;
 
1341
        }
 
1342
        return SUCCESS;
 
1343
}
 
1344
 
 
1345
PS_WRITE_FUNC(msession)
 
1346
{
 
1347
        ELOG( "ps_write_msession");
 
1348
        return (PHPMsessionSetData((char *)key, (char *)val TSRMLS_CC)) ? SUCCESS : FAILURE;
 
1349
}
 
1350
 
 
1351
PS_DESTROY_FUNC(msession)
 
1352
{
 
1353
        ELOG( "ps_destroy_msession");
 
1354
        return (PHPMsessionDestroy((char *)key TSRMLS_CC)) ? SUCCESS : FAILURE;
 
1355
}
 
1356
 
 
1357
PS_GC_FUNC(msession)
 
1358
{
 
1359
        ELOG( "ps_gc_msession");
 
1360
        return SUCCESS;
 
1361
}
 
1362
 
 
1363
#ifdef HAVE_PHP_SESSION_CREATESID
 
1364
PS_CREATE_SID_FUNC(msession)
 
1365
{
 
1366
        if(s_reqb && s_conn) 
 
1367
        {
 
1368
                ELOG("Should create a new session");
 
1369
                PHPExecRequest( REQ_UNIQ,"", "", "",SID_LEN);
 
1370
 
 
1371
                if(s_reqb->req.stat==REQ_OK)
 
1372
                {
 
1373
                        ELOG("Reports UNIQ success");
 
1374
                        if(newlen)
 
1375
                                *newlen = SID_LEN;
 
1376
                        return safe_estrdup(s_reqb->req.datum);
 
1377
                }
 
1378
                else
 
1379
                {
 
1380
                        ELOG("Reports that UNIQ failed");
 
1381
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ReqbErr(s_reqb));
 
1382
                }
 
1383
        }
 
1384
        ELOG("Yikes, could not get sid from msession 2003");
 
1385
        return php_session_create_id(mod_data, newlen TSRMLS_CC);
 
1386
}
 
1387
#endif  /* HAVE_PHP_SESSION_CREATESID */
 
1388
#endif  /* HAVE_PHP_SESSION */
 
1389
#endif  /* HAVE_MSESSION */
 
1390