/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/libraries/Xmlrpc.php

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/system/libraries/Xmlrpc.php
 
1
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 
2
/**
 
3
 * CodeIgniter
 
4
 *
 
5
 * An open source application development framework for PHP 5.1.6 or newer
 
6
 *
 
7
 * @package             CodeIgniter
 
8
 * @author              ExpressionEngine Dev Team
 
9
 * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
 
10
 * @license             http://codeigniter.com/user_guide/license.html
 
11
 * @link                http://codeigniter.com
 
12
 * @since               Version 1.0
 
13
 * @filesource
 
14
 */
 
15
 
 
16
if ( ! function_exists('xml_parser_create'))
 
17
{
 
18
        show_error('Your PHP installation does not support XML');
 
19
}
 
20
 
 
21
 
 
22
// ------------------------------------------------------------------------
 
23
 
 
24
/**
 
25
 * XML-RPC request handler class
 
26
 *
 
27
 * @package             CodeIgniter
 
28
 * @subpackage  Libraries
 
29
 * @category    XML-RPC
 
30
 * @author              ExpressionEngine Dev Team
 
31
 * @link                http://codeigniter.com/user_guide/libraries/xmlrpc.html
 
32
 */
 
33
class CI_Xmlrpc {
 
34
 
 
35
        var $debug                      = FALSE;        // Debugging on or off
 
36
        var $xmlrpcI4           = 'i4';
 
37
        var $xmlrpcInt          = 'int';
 
38
        var $xmlrpcBoolean      = 'boolean';
 
39
        var $xmlrpcDouble       = 'double';
 
40
        var $xmlrpcString       = 'string';
 
41
        var $xmlrpcDateTime     = 'dateTime.iso8601';
 
42
        var $xmlrpcBase64       = 'base64';
 
43
        var $xmlrpcArray        = 'array';
 
44
        var $xmlrpcStruct       = 'struct';
 
45
 
 
46
        var $xmlrpcTypes        = array();
 
47
        var $valid_parents      = array();
 
48
        var $xmlrpcerr          = array();      // Response numbers
 
49
        var $xmlrpcstr          = array();  // Response strings
 
50
 
 
51
        var $xmlrpc_defencoding = 'UTF-8';
 
52
        var $xmlrpcName                 = 'XML-RPC for CodeIgniter';
 
53
        var $xmlrpcVersion              = '1.1';
 
54
        var $xmlrpcerruser              = 800; // Start of user errors
 
55
        var $xmlrpcerrxml               = 100; // Start of XML Parse errors
 
56
        var $xmlrpc_backslash   = ''; // formulate backslashes for escaping regexp
 
57
 
 
58
        var $client;
 
59
        var $method;
 
60
        var $data;
 
61
        var $message                    = '';
 
62
        var $error                              = '';           // Error string for request
 
63
        var $result;
 
64
        var $response                   = array();  // Response from remote server
 
65
 
 
66
        var $xss_clean                  = TRUE;
 
67
 
 
68
        //-------------------------------------
 
69
        //  VALUES THAT MULTIPLE CLASSES NEED
 
70
        //-------------------------------------
 
71
 
 
72
        public function __construct($config = array())
 
73
        {
 
74
                $this->xmlrpcName               = $this->xmlrpcName;
 
75
                $this->xmlrpc_backslash = chr(92).chr(92);
 
76
 
 
77
                // Types for info sent back and forth
 
78
                $this->xmlrpcTypes = array(
 
79
                        $this->xmlrpcI4                 => '1',
 
80
                        $this->xmlrpcInt                => '1',
 
81
                        $this->xmlrpcBoolean    => '1',
 
82
                        $this->xmlrpcString             => '1',
 
83
                        $this->xmlrpcDouble             => '1',
 
84
                        $this->xmlrpcDateTime   => '1',
 
85
                        $this->xmlrpcBase64             => '1',
 
86
                        $this->xmlrpcArray              => '2',
 
87
                        $this->xmlrpcStruct             => '3'
 
88
                        );
 
89
 
 
90
                // Array of Valid Parents for Various XML-RPC elements
 
91
                $this->valid_parents = array('BOOLEAN'                  => array('VALUE'),
 
92
                                                                         'I4'                           => array('VALUE'),
 
93
                                                                         'INT'                          => array('VALUE'),
 
94
                                                                         'STRING'                       => array('VALUE'),
 
95
                                                                         'DOUBLE'                       => array('VALUE'),
 
96
                                                                         'DATETIME.ISO8601'     => array('VALUE'),
 
97
                                                                         'BASE64'                       => array('VALUE'),
 
98
                                                                         'ARRAY'                        => array('VALUE'),
 
99
                                                                         'STRUCT'                       => array('VALUE'),
 
100
                                                                         'PARAM'                        => array('PARAMS'),
 
101
                                                                         'METHODNAME'           => array('METHODCALL'),
 
102
                                                                         'PARAMS'                       => array('METHODCALL', 'METHODRESPONSE'),
 
103
                                                                         'MEMBER'                       => array('STRUCT'),
 
104
                                                                         'NAME'                         => array('MEMBER'),
 
105
                                                                         'DATA'                         => array('ARRAY'),
 
106
                                                                         'FAULT'                        => array('METHODRESPONSE'),
 
107
                                                                         'VALUE'                        => array('MEMBER', 'DATA', 'PARAM', 'FAULT')
 
108
                                                                         );
 
109
 
 
110
 
 
111
                // XML-RPC Responses
 
112
                $this->xmlrpcerr['unknown_method'] = '1';
 
113
                $this->xmlrpcstr['unknown_method'] = 'This is not a known method for this XML-RPC Server';
 
114
                $this->xmlrpcerr['invalid_return'] = '2';
 
115
                $this->xmlrpcstr['invalid_return'] = 'The XML data received was either invalid or not in the correct form for XML-RPC.  Turn on debugging to examine the XML data further.';
 
116
                $this->xmlrpcerr['incorrect_params'] = '3';
 
117
                $this->xmlrpcstr['incorrect_params'] = 'Incorrect parameters were passed to method';
 
118
                $this->xmlrpcerr['introspect_unknown'] = '4';
 
119
                $this->xmlrpcstr['introspect_unknown'] = "Cannot inspect signature for request: method unknown";
 
120
                $this->xmlrpcerr['http_error'] = '5';
 
121
                $this->xmlrpcstr['http_error'] = "Did not receive a '200 OK' response from remote server.";
 
122
                $this->xmlrpcerr['no_data'] = '6';
 
123
                $this->xmlrpcstr['no_data'] ='No data received from server.';
 
124
 
 
125
                $this->initialize($config);
 
126
 
 
127
                log_message('debug', "XML-RPC Class Initialized");
 
128
        }
 
129
 
 
130
 
 
131
        //-------------------------------------
 
132
        //  Initialize Prefs
 
133
        //-------------------------------------
 
134
 
 
135
        function initialize($config = array())
 
136
        {
 
137
                if (count($config) > 0)
 
138
                {
 
139
                        foreach ($config as $key => $val)
 
140
                        {
 
141
                                if (isset($this->$key))
 
142
                                {
 
143
                                        $this->$key = $val;
 
144
                                }
 
145
                        }
 
146
                }
 
147
        }
 
148
        // END
 
149
 
 
150
        //-------------------------------------
 
151
        //  Take URL and parse it
 
152
        //-------------------------------------
 
153
 
 
154
        function server($url, $port=80)
 
155
        {
 
156
                if (substr($url, 0, 4) != "http")
 
157
                {
 
158
                        $url = "http://".$url;
 
159
                }
 
160
 
 
161
                $parts = parse_url($url);
 
162
 
 
163
                $path = ( ! isset($parts['path'])) ? '/' : $parts['path'];
 
164
 
 
165
                if (isset($parts['query']) && $parts['query'] != '')
 
166
                {
 
167
                        $path .= '?'.$parts['query'];
 
168
                }
 
169
 
 
170
                $this->client = new XML_RPC_Client($path, $parts['host'], $port);
 
171
        }
 
172
        // END
 
173
 
 
174
        //-------------------------------------
 
175
        //  Set Timeout
 
176
        //-------------------------------------
 
177
 
 
178
        function timeout($seconds=5)
 
179
        {
 
180
                if ( ! is_null($this->client) && is_int($seconds))
 
181
                {
 
182
                        $this->client->timeout = $seconds;
 
183
                }
 
184
        }
 
185
        // END
 
186
 
 
187
        //-------------------------------------
 
188
        //  Set Methods
 
189
        //-------------------------------------
 
190
 
 
191
        function method($function)
 
192
        {
 
193
                $this->method = $function;
 
194
        }
 
195
        // END
 
196
 
 
197
        //-------------------------------------
 
198
        //  Take Array of Data and Create Objects
 
199
        //-------------------------------------
 
200
 
 
201
        function request($incoming)
 
202
        {
 
203
                if ( ! is_array($incoming))
 
204
                {
 
205
                        // Send Error
 
206
                }
 
207
 
 
208
                $this->data = array();
 
209
 
 
210
                foreach ($incoming as $key => $value)
 
211
                {
 
212
                        $this->data[$key] = $this->values_parsing($value);
 
213
                }
 
214
        }
 
215
        // END
 
216
 
 
217
 
 
218
        //-------------------------------------
 
219
        //  Set Debug
 
220
        //-------------------------------------
 
221
 
 
222
        function set_debug($flag = TRUE)
 
223
        {
 
224
                $this->debug = ($flag == TRUE) ? TRUE : FALSE;
 
225
        }
 
226
 
 
227
        //-------------------------------------
 
228
        //  Values Parsing
 
229
        //-------------------------------------
 
230
 
 
231
        function values_parsing($value, $return = FALSE)
 
232
        {
 
233
                if (is_array($value) && array_key_exists(0, $value))
 
234
                {
 
235
                        if ( ! isset($value['1']) OR ( ! isset($this->xmlrpcTypes[$value['1']])))
 
236
                        {
 
237
                                if (is_array($value[0]))
 
238
                                {
 
239
                                        $temp = new XML_RPC_Values($value['0'], 'array');
 
240
                                }
 
241
                                else
 
242
                                {
 
243
                                        $temp = new XML_RPC_Values($value['0'], 'string');
 
244
                                }
 
245
                        }
 
246
                        elseif (is_array($value['0']) && ($value['1'] == 'struct' OR $value['1'] == 'array'))
 
247
                        {
 
248
                                while (list($k) = each($value['0']))
 
249
                                {
 
250
                                        $value['0'][$k] = $this->values_parsing($value['0'][$k], TRUE);
 
251
                                }
 
252
 
 
253
                                $temp = new XML_RPC_Values($value['0'], $value['1']);
 
254
                        }
 
255
                        else
 
256
                        {
 
257
                                $temp = new XML_RPC_Values($value['0'], $value['1']);
 
258
                        }
 
259
                }
 
260
                else
 
261
                {
 
262
                        $temp = new XML_RPC_Values($value, 'string');
 
263
                }
 
264
 
 
265
                return $temp;
 
266
        }
 
267
        // END
 
268
 
 
269
 
 
270
        //-------------------------------------
 
271
        //  Sends XML-RPC Request
 
272
        //-------------------------------------
 
273
 
 
274
        function send_request()
 
275
        {
 
276
                $this->message = new XML_RPC_Message($this->method,$this->data);
 
277
                $this->message->debug = $this->debug;
 
278
 
 
279
                if ( ! $this->result = $this->client->send($this->message))
 
280
                {
 
281
                        $this->error = $this->result->errstr;
 
282
                        return FALSE;
 
283
                }
 
284
                elseif ( ! is_object($this->result->val))
 
285
                {
 
286
                        $this->error = $this->result->errstr;
 
287
                        return FALSE;
 
288
                }
 
289
 
 
290
                $this->response = $this->result->decode();
 
291
 
 
292
                return TRUE;
 
293
        }
 
294
        // END
 
295
 
 
296
        //-------------------------------------
 
297
        //  Returns Error
 
298
        //-------------------------------------
 
299
 
 
300
        function display_error()
 
301
        {
 
302
                return $this->error;
 
303
        }
 
304
        // END
 
305
 
 
306
        //-------------------------------------
 
307
        //  Returns Remote Server Response
 
308
        //-------------------------------------
 
309
 
 
310
        function display_response()
 
311
        {
 
312
                return $this->response;
 
313
        }
 
314
        // END
 
315
 
 
316
        //-------------------------------------
 
317
        //  Sends an Error Message for Server Request
 
318
        //-------------------------------------
 
319
 
 
320
        function send_error_message($number, $message)
 
321
        {
 
322
                return new XML_RPC_Response('0',$number, $message);
 
323
        }
 
324
        // END
 
325
 
 
326
 
 
327
        //-------------------------------------
 
328
        //  Send Response for Server Request
 
329
        //-------------------------------------
 
330
 
 
331
        function send_response($response)
 
332
        {
 
333
                // $response should be array of values, which will be parsed
 
334
                // based on their data and type into a valid group of XML-RPC values
 
335
 
 
336
                $response = $this->values_parsing($response);
 
337
 
 
338
                return new XML_RPC_Response($response);
 
339
        }
 
340
        // END
 
341
 
 
342
} // END XML_RPC Class
 
343
 
 
344
 
 
345
 
 
346
/**
 
347
 * XML-RPC Client class
 
348
 *
 
349
 * @category    XML-RPC
 
350
 * @author              ExpressionEngine Dev Team
 
351
 * @link                http://codeigniter.com/user_guide/libraries/xmlrpc.html
 
352
 */
 
353
class XML_RPC_Client extends CI_Xmlrpc
 
354
{
 
355
        var $path                       = '';
 
356
        var $server                     = '';
 
357
        var $port                       = 80;
 
358
        var $errno                      = '';
 
359
        var $errstring          = '';
 
360
        var $timeout            = 5;
 
361
        var $no_multicall       = FALSE;
 
362
 
 
363
        public function __construct($path, $server, $port=80)
 
364
        {
 
365
                parent::__construct();
 
366
 
 
367
                $this->port = $port;
 
368
                $this->server = $server;
 
369
                $this->path = $path;
 
370
        }
 
371
 
 
372
        function send($msg)
 
373
        {
 
374
                if (is_array($msg))
 
375
                {
 
376
                        // Multi-call disabled
 
377
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['multicall_recursion'],$this->xmlrpcstr['multicall_recursion']);
 
378
                        return $r;
 
379
                }
 
380
 
 
381
                return $this->sendPayload($msg);
 
382
        }
 
383
 
 
384
        function sendPayload($msg)
 
385
        {
 
386
                $fp = @fsockopen($this->server, $this->port,$this->errno, $this->errstr, $this->timeout);
 
387
 
 
388
                if ( ! is_resource($fp))
 
389
                {
 
390
                        error_log($this->xmlrpcstr['http_error']);
 
391
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'],$this->xmlrpcstr['http_error']);
 
392
                        return $r;
 
393
                }
 
394
 
 
395
                if (empty($msg->payload))
 
396
                {
 
397
                        // $msg = XML_RPC_Messages
 
398
                        $msg->createPayload();
 
399
                }
 
400
 
 
401
                $r = "\r\n";
 
402
                $op  = "POST {$this->path} HTTP/1.0$r";
 
403
                $op .= "Host: {$this->server}$r";
 
404
                $op .= "Content-Type: text/xml$r";
 
405
                $op .= "User-Agent: {$this->xmlrpcName}$r";
 
406
                $op .= "Content-Length: ".strlen($msg->payload). "$r$r";
 
407
                $op .= $msg->payload;
 
408
 
 
409
 
 
410
                if ( ! fputs($fp, $op, strlen($op)))
 
411
                {
 
412
                        error_log($this->xmlrpcstr['http_error']);
 
413
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']);
 
414
                        return $r;
 
415
                }
 
416
                $resp = $msg->parseResponse($fp);
 
417
                fclose($fp);
 
418
                return $resp;
 
419
        }
 
420
 
 
421
} // end class XML_RPC_Client
 
422
 
 
423
 
 
424
/**
 
425
 * XML-RPC Response class
 
426
 *
 
427
 * @category    XML-RPC
 
428
 * @author              ExpressionEngine Dev Team
 
429
 * @link                http://codeigniter.com/user_guide/libraries/xmlrpc.html
 
430
 */
 
431
class XML_RPC_Response
 
432
{
 
433
        var $val = 0;
 
434
        var $errno = 0;
 
435
        var $errstr = '';
 
436
        var $headers = array();
 
437
        var $xss_clean = TRUE;
 
438
 
 
439
        public function __construct($val, $code = 0, $fstr = '')
 
440
        {
 
441
                if ($code != 0)
 
442
                {
 
443
                        // error
 
444
                        $this->errno = $code;
 
445
                        $this->errstr = htmlentities($fstr);
 
446
                }
 
447
                else if ( ! is_object($val))
 
448
                {
 
449
                        // programmer error, not an object
 
450
                        error_log("Invalid type '" . gettype($val) . "' (value: $val) passed to XML_RPC_Response.  Defaulting to empty value.");
 
451
                        $this->val = new XML_RPC_Values();
 
452
                }
 
453
                else
 
454
                {
 
455
                        $this->val = $val;
 
456
                }
 
457
        }
 
458
 
 
459
        function faultCode()
 
460
        {
 
461
                return $this->errno;
 
462
        }
 
463
 
 
464
        function faultString()
 
465
        {
 
466
                return $this->errstr;
 
467
        }
 
468
 
 
469
        function value()
 
470
        {
 
471
                return $this->val;
 
472
        }
 
473
 
 
474
        function prepare_response()
 
475
        {
 
476
                $result = "<methodResponse>\n";
 
477
                if ($this->errno)
 
478
                {
 
479
                        $result .= '<fault>
 
480
        <value>
 
481
                <struct>
 
482
                        <member>
 
483
                                <name>faultCode</name>
 
484
                                <value><int>' . $this->errno . '</int></value>
 
485
                        </member>
 
486
                        <member>
 
487
                                <name>faultString</name>
 
488
                                <value><string>' . $this->errstr . '</string></value>
 
489
                        </member>
 
490
                </struct>
 
491
        </value>
 
492
</fault>';
 
493
                }
 
494
                else
 
495
                {
 
496
                        $result .= "<params>\n<param>\n" .
 
497
                                        $this->val->serialize_class() .
 
498
                                        "</param>\n</params>";
 
499
                }
 
500
                $result .= "\n</methodResponse>";
 
501
                return $result;
 
502
        }
 
503
 
 
504
        function decode($array=FALSE)
 
505
        {
 
506
                $CI =& get_instance();
 
507
                
 
508
                if ($array !== FALSE && is_array($array))
 
509
                {
 
510
                        while (list($key) = each($array))
 
511
                        {
 
512
                                if (is_array($array[$key]))
 
513
                                {
 
514
                                        $array[$key] = $this->decode($array[$key]);
 
515
                                }
 
516
                                else
 
517
                                {
 
518
                                        $array[$key] = ($this->xss_clean) ? $CI->security->xss_clean($array[$key]) : $array[$key];
 
519
                                }
 
520
                        }
 
521
 
 
522
                        $result = $array;
 
523
                }
 
524
                else
 
525
                {
 
526
                        $result = $this->xmlrpc_decoder($this->val);
 
527
 
 
528
                        if (is_array($result))
 
529
                        {
 
530
                                $result = $this->decode($result);
 
531
                        }
 
532
                        else
 
533
                        {
 
534
                                $result = ($this->xss_clean) ? $CI->security->xss_clean($result) : $result;
 
535
                        }
 
536
                }
 
537
 
 
538
                return $result;
 
539
        }
 
540
 
 
541
 
 
542
 
 
543
        //-------------------------------------
 
544
        //  XML-RPC Object to PHP Types
 
545
        //-------------------------------------
 
546
 
 
547
        function xmlrpc_decoder($xmlrpc_val)
 
548
        {
 
549
                $kind = $xmlrpc_val->kindOf();
 
550
 
 
551
                if ($kind == 'scalar')
 
552
                {
 
553
                        return $xmlrpc_val->scalarval();
 
554
                }
 
555
                elseif ($kind == 'array')
 
556
                {
 
557
                        reset($xmlrpc_val->me);
 
558
                        list($a,$b) = each($xmlrpc_val->me);
 
559
                        $size = count($b);
 
560
 
 
561
                        $arr = array();
 
562
 
 
563
                        for ($i = 0; $i < $size; $i++)
 
564
                        {
 
565
                                $arr[] = $this->xmlrpc_decoder($xmlrpc_val->me['array'][$i]);
 
566
                        }
 
567
                        return $arr;
 
568
                }
 
569
                elseif ($kind == 'struct')
 
570
                {
 
571
                        reset($xmlrpc_val->me['struct']);
 
572
                        $arr = array();
 
573
 
 
574
                        while (list($key,$value) = each($xmlrpc_val->me['struct']))
 
575
                        {
 
576
                                $arr[$key] = $this->xmlrpc_decoder($value);
 
577
                        }
 
578
                        return $arr;
 
579
                }
 
580
        }
 
581
 
 
582
 
 
583
        //-------------------------------------
 
584
        //  ISO-8601 time to server or UTC time
 
585
        //-------------------------------------
 
586
 
 
587
        function iso8601_decode($time, $utc=0)
 
588
        {
 
589
                // return a timet in the localtime, or UTC
 
590
                $t = 0;
 
591
                if (preg_match('/([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})/', $time, $regs))
 
592
                {
 
593
                        $fnc = ($utc == 1) ? 'gmmktime' : 'mktime';
 
594
                        $t = $fnc($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
 
595
                }
 
596
                return $t;
 
597
        }
 
598
 
 
599
} // End Response Class
 
600
 
 
601
 
 
602
 
 
603
/**
 
604
 * XML-RPC Message class
 
605
 *
 
606
 * @category    XML-RPC
 
607
 * @author              ExpressionEngine Dev Team
 
608
 * @link                http://codeigniter.com/user_guide/libraries/xmlrpc.html
 
609
 */
 
610
class XML_RPC_Message extends CI_Xmlrpc
 
611
{
 
612
        var $payload;
 
613
        var $method_name;
 
614
        var $params                     = array();
 
615
        var $xh                         = array();
 
616
 
 
617
        public function __construct($method, $pars=0)
 
618
        {
 
619
                parent::__construct();
 
620
 
 
621
                $this->method_name = $method;
 
622
                if (is_array($pars) && count($pars) > 0)
 
623
                {
 
624
                        for ($i=0; $i<count($pars); $i++)
 
625
                        {
 
626
                                // $pars[$i] = XML_RPC_Values
 
627
                                $this->params[] = $pars[$i];
 
628
                        }
 
629
                }
 
630
        }
 
631
 
 
632
        //-------------------------------------
 
633
        //  Create Payload to Send
 
634
        //-------------------------------------
 
635
 
 
636
        function createPayload()
 
637
        {
 
638
                $this->payload = "<?xml version=\"1.0\"?".">\r\n<methodCall>\r\n";
 
639
                $this->payload .= '<methodName>' . $this->method_name . "</methodName>\r\n";
 
640
                $this->payload .= "<params>\r\n";
 
641
 
 
642
                for ($i=0; $i<count($this->params); $i++)
 
643
                {
 
644
                        // $p = XML_RPC_Values
 
645
                        $p = $this->params[$i];
 
646
                        $this->payload .= "<param>\r\n".$p->serialize_class()."</param>\r\n";
 
647
                }
 
648
 
 
649
                $this->payload .= "</params>\r\n</methodCall>\r\n";
 
650
        }
 
651
 
 
652
        //-------------------------------------
 
653
        //  Parse External XML-RPC Server's Response
 
654
        //-------------------------------------
 
655
 
 
656
        function parseResponse($fp)
 
657
        {
 
658
                $data = '';
 
659
 
 
660
                while ($datum = fread($fp, 4096))
 
661
                {
 
662
                        $data .= $datum;
 
663
                }
 
664
 
 
665
                //-------------------------------------
 
666
                //  DISPLAY HTTP CONTENT for DEBUGGING
 
667
                //-------------------------------------
 
668
 
 
669
                if ($this->debug === TRUE)
 
670
                {
 
671
                        echo "<pre>";
 
672
                        echo "---DATA---\n" . htmlspecialchars($data) . "\n---END DATA---\n\n";
 
673
                        echo "</pre>";
 
674
                }
 
675
 
 
676
                //-------------------------------------
 
677
                //  Check for data
 
678
                //-------------------------------------
 
679
 
 
680
                if ($data == "")
 
681
                {
 
682
                        error_log($this->xmlrpcstr['no_data']);
 
683
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['no_data'], $this->xmlrpcstr['no_data']);
 
684
                        return $r;
 
685
                }
 
686
 
 
687
 
 
688
                //-------------------------------------
 
689
                //  Check for HTTP 200 Response
 
690
                //-------------------------------------
 
691
 
 
692
                if (strncmp($data, 'HTTP', 4) == 0 && ! preg_match('/^HTTP\/[0-9\.]+ 200 /', $data))
 
693
                {
 
694
                        $errstr= substr($data, 0, strpos($data, "\n")-1);
 
695
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']. ' (' . $errstr . ')');
 
696
                        return $r;
 
697
                }
 
698
 
 
699
                //-------------------------------------
 
700
                //  Create and Set Up XML Parser
 
701
                //-------------------------------------
 
702
 
 
703
                $parser = xml_parser_create($this->xmlrpc_defencoding);
 
704
 
 
705
                $this->xh[$parser]                                      = array();
 
706
                $this->xh[$parser]['isf']                       = 0;
 
707
                $this->xh[$parser]['ac']                        = '';
 
708
                $this->xh[$parser]['headers']           = array();
 
709
                $this->xh[$parser]['stack']                     = array();
 
710
                $this->xh[$parser]['valuestack']        = array();
 
711
                $this->xh[$parser]['isf_reason']        = 0;
 
712
 
 
713
                xml_set_object($parser, $this);
 
714
                xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
 
715
                xml_set_element_handler($parser, 'open_tag', 'closing_tag');
 
716
                xml_set_character_data_handler($parser, 'character_data');
 
717
                //xml_set_default_handler($parser, 'default_handler');
 
718
 
 
719
 
 
720
                //-------------------------------------
 
721
                //  GET HEADERS
 
722
                //-------------------------------------
 
723
 
 
724
                $lines = explode("\r\n", $data);
 
725
                while (($line = array_shift($lines)))
 
726
                {
 
727
                        if (strlen($line) < 1)
 
728
                        {
 
729
                                break;
 
730
                        }
 
731
                        $this->xh[$parser]['headers'][] = $line;
 
732
                }
 
733
                $data = implode("\r\n", $lines);
 
734
 
 
735
 
 
736
                //-------------------------------------
 
737
                //  PARSE XML DATA
 
738
                //-------------------------------------
 
739
 
 
740
                if ( ! xml_parse($parser, $data, count($data)))
 
741
                {
 
742
                        $errstr = sprintf('XML error: %s at line %d',
 
743
                                        xml_error_string(xml_get_error_code($parser)),
 
744
                                        xml_get_current_line_number($parser));
 
745
                        //error_log($errstr);
 
746
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'], $this->xmlrpcstr['invalid_return']);
 
747
                        xml_parser_free($parser);
 
748
                        return $r;
 
749
                }
 
750
                xml_parser_free($parser);
 
751
 
 
752
                // ---------------------------------------
 
753
                //  Got Ourselves Some Badness, It Seems
 
754
                // ---------------------------------------
 
755
 
 
756
                if ($this->xh[$parser]['isf'] > 1)
 
757
                {
 
758
                        if ($this->debug === TRUE)
 
759
                        {
 
760
                                echo "---Invalid Return---\n";
 
761
                                echo $this->xh[$parser]['isf_reason'];
 
762
                                echo "---Invalid Return---\n\n";
 
763
                        }
 
764
 
 
765
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'],$this->xmlrpcstr['invalid_return'].' '.$this->xh[$parser]['isf_reason']);
 
766
                        return $r;
 
767
                }
 
768
                elseif ( ! is_object($this->xh[$parser]['value']))
 
769
                {
 
770
                        $r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'],$this->xmlrpcstr['invalid_return'].' '.$this->xh[$parser]['isf_reason']);
 
771
                        return $r;
 
772
                }
 
773
 
 
774
                //-------------------------------------
 
775
                //  DISPLAY XML CONTENT for DEBUGGING
 
776
                //-------------------------------------
 
777
 
 
778
                if ($this->debug === TRUE)
 
779
                {
 
780
                        echo "<pre>";
 
781
 
 
782
                        if (count($this->xh[$parser]['headers'] > 0))
 
783
                        {
 
784
                                echo "---HEADERS---\n";
 
785
                                foreach ($this->xh[$parser]['headers'] as $header)
 
786
                                {
 
787
                                        echo "$header\n";
 
788
                                }
 
789
                                echo "---END HEADERS---\n\n";
 
790
                        }
 
791
 
 
792
                        echo "---DATA---\n" . htmlspecialchars($data) . "\n---END DATA---\n\n";
 
793
 
 
794
                        echo "---PARSED---\n" ;
 
795
                        var_dump($this->xh[$parser]['value']);
 
796
                        echo "\n---END PARSED---</pre>";
 
797
                }
 
798
 
 
799
                //-------------------------------------
 
800
                //  SEND RESPONSE
 
801
                //-------------------------------------
 
802
 
 
803
                $v = $this->xh[$parser]['value'];
 
804
 
 
805
                if ($this->xh[$parser]['isf'])
 
806
                {
 
807
                        $errno_v = $v->me['struct']['faultCode'];
 
808
                        $errstr_v = $v->me['struct']['faultString'];
 
809
                        $errno = $errno_v->scalarval();
 
810
 
 
811
                        if ($errno == 0)
 
812
                        {
 
813
                                // FAULT returned, errno needs to reflect that
 
814
                                $errno = -1;
 
815
                        }
 
816
 
 
817
                        $r = new XML_RPC_Response($v, $errno, $errstr_v->scalarval());
 
818
                }
 
819
                else
 
820
                {
 
821
                        $r = new XML_RPC_Response($v);
 
822
                }
 
823
 
 
824
                $r->headers = $this->xh[$parser]['headers'];
 
825
                return $r;
 
826
        }
 
827
 
 
828
        // ------------------------------------
 
829
        //  Begin Return Message Parsing section
 
830
        // ------------------------------------
 
831
 
 
832
        // quick explanation of components:
 
833
        //   ac - used to accumulate values
 
834
        //   isf - used to indicate a fault
 
835
        //   lv - used to indicate "looking for a value": implements
 
836
        //              the logic to allow values with no types to be strings
 
837
        //   params - used to store parameters in method calls
 
838
        //   method - used to store method name
 
839
        //       stack - array with parent tree of the xml element,
 
840
        //                       used to validate the nesting of elements
 
841
 
 
842
        //-------------------------------------
 
843
        //  Start Element Handler
 
844
        //-------------------------------------
 
845
 
 
846
        function open_tag($the_parser, $name, $attrs)
 
847
        {
 
848
                // If invalid nesting, then return
 
849
                if ($this->xh[$the_parser]['isf'] > 1) return;
 
850
 
 
851
                // Evaluate and check for correct nesting of XML elements
 
852
 
 
853
                if (count($this->xh[$the_parser]['stack']) == 0)
 
854
                {
 
855
                        if ($name != 'METHODRESPONSE' && $name != 'METHODCALL')
 
856
                        {
 
857
                                $this->xh[$the_parser]['isf'] = 2;
 
858
                                $this->xh[$the_parser]['isf_reason'] = 'Top level XML-RPC element is missing';
 
859
                                return;
 
860
                        }
 
861
                }
 
862
                else
 
863
                {
 
864
                        // not top level element: see if parent is OK
 
865
                        if ( ! in_array($this->xh[$the_parser]['stack'][0], $this->valid_parents[$name], TRUE))
 
866
                        {
 
867
                                $this->xh[$the_parser]['isf'] = 2;
 
868
                                $this->xh[$the_parser]['isf_reason'] = "XML-RPC element $name cannot be child of ".$this->xh[$the_parser]['stack'][0];
 
869
                                return;
 
870
                        }
 
871
                }
 
872
 
 
873
                switch($name)
 
874
                {
 
875
                        case 'STRUCT':
 
876
                        case 'ARRAY':
 
877
                                // Creates array for child elements
 
878
 
 
879
                                $cur_val = array('value' => array(),
 
880
                                                                 'type'  => $name);
 
881
 
 
882
                                array_unshift($this->xh[$the_parser]['valuestack'], $cur_val);
 
883
                        break;
 
884
                        case 'METHODNAME':
 
885
                        case 'NAME':
 
886
                                $this->xh[$the_parser]['ac'] = '';
 
887
                        break;
 
888
                        case 'FAULT':
 
889
                                $this->xh[$the_parser]['isf'] = 1;
 
890
                        break;
 
891
                        case 'PARAM':
 
892
                                $this->xh[$the_parser]['value'] = NULL;
 
893
                        break;
 
894
                        case 'VALUE':
 
895
                                $this->xh[$the_parser]['vt'] = 'value';
 
896
                                $this->xh[$the_parser]['ac'] = '';
 
897
                                $this->xh[$the_parser]['lv'] = 1;
 
898
                        break;
 
899
                        case 'I4':
 
900
                        case 'INT':
 
901
                        case 'STRING':
 
902
                        case 'BOOLEAN':
 
903
                        case 'DOUBLE':
 
904
                        case 'DATETIME.ISO8601':
 
905
                        case 'BASE64':
 
906
                                if ($this->xh[$the_parser]['vt'] != 'value')
 
907
                                {
 
908
                                        //two data elements inside a value: an error occurred!
 
909
                                        $this->xh[$the_parser]['isf'] = 2;
 
910
                                        $this->xh[$the_parser]['isf_reason'] = "'Twas a $name element following a ".$this->xh[$the_parser]['vt']." element inside a single value";
 
911
                                        return;
 
912
                                }
 
913
 
 
914
                                $this->xh[$the_parser]['ac'] = '';
 
915
                        break;
 
916
                        case 'MEMBER':
 
917
                                // Set name of <member> to nothing to prevent errors later if no <name> is found
 
918
                                $this->xh[$the_parser]['valuestack'][0]['name'] = '';
 
919
 
 
920
                                // Set NULL value to check to see if value passed for this param/member
 
921
                                $this->xh[$the_parser]['value'] = NULL;
 
922
                        break;
 
923
                        case 'DATA':
 
924
                        case 'METHODCALL':
 
925
                        case 'METHODRESPONSE':
 
926
                        case 'PARAMS':
 
927
                                // valid elements that add little to processing
 
928
                        break;
 
929
                        default:
 
930
                                /// An Invalid Element is Found, so we have trouble
 
931
                                $this->xh[$the_parser]['isf'] = 2;
 
932
                                $this->xh[$the_parser]['isf_reason'] = "Invalid XML-RPC element found: $name";
 
933
                        break;
 
934
                }
 
935
 
 
936
                // Add current element name to stack, to allow validation of nesting
 
937
                array_unshift($this->xh[$the_parser]['stack'], $name);
 
938
 
 
939
                if ($name != 'VALUE') $this->xh[$the_parser]['lv'] = 0;
 
940
        }
 
941
        // END
 
942
 
 
943
 
 
944
        //-------------------------------------
 
945
        //  End Element Handler
 
946
        //-------------------------------------
 
947
 
 
948
        function closing_tag($the_parser, $name)
 
949
        {
 
950
                if ($this->xh[$the_parser]['isf'] > 1) return;
 
951
 
 
952
                // Remove current element from stack and set variable
 
953
                // NOTE: If the XML validates, then we do not have to worry about
 
954
                // the opening and closing of elements.  Nesting is checked on the opening
 
955
                // tag so we be safe there as well.
 
956
 
 
957
                $curr_elem = array_shift($this->xh[$the_parser]['stack']);
 
958
 
 
959
                switch($name)
 
960
                {
 
961
                        case 'STRUCT':
 
962
                        case 'ARRAY':
 
963
                                $cur_val = array_shift($this->xh[$the_parser]['valuestack']);
 
964
                                $this->xh[$the_parser]['value'] = ( ! isset($cur_val['values'])) ? array() : $cur_val['values'];
 
965
                                $this->xh[$the_parser]['vt']    = strtolower($name);
 
966
                        break;
 
967
                        case 'NAME':
 
968
                                $this->xh[$the_parser]['valuestack'][0]['name'] = $this->xh[$the_parser]['ac'];
 
969
                        break;
 
970
                        case 'BOOLEAN':
 
971
                        case 'I4':
 
972
                        case 'INT':
 
973
                        case 'STRING':
 
974
                        case 'DOUBLE':
 
975
                        case 'DATETIME.ISO8601':
 
976
                        case 'BASE64':
 
977
                                $this->xh[$the_parser]['vt'] = strtolower($name);
 
978
 
 
979
                                if ($name == 'STRING')
 
980
                                {
 
981
                                        $this->xh[$the_parser]['value'] = $this->xh[$the_parser]['ac'];
 
982
                                }
 
983
                                elseif ($name=='DATETIME.ISO8601')
 
984
                                {
 
985
                                        $this->xh[$the_parser]['vt']    = $this->xmlrpcDateTime;
 
986
                                        $this->xh[$the_parser]['value'] = $this->xh[$the_parser]['ac'];
 
987
                                }
 
988
                                elseif ($name=='BASE64')
 
989
                                {
 
990
                                        $this->xh[$the_parser]['value'] = base64_decode($this->xh[$the_parser]['ac']);
 
991
                                }
 
992
                                elseif ($name=='BOOLEAN')
 
993
                                {
 
994
                                        // Translated BOOLEAN values to TRUE AND FALSE
 
995
                                        if ($this->xh[$the_parser]['ac'] == '1')
 
996
                                        {
 
997
                                                $this->xh[$the_parser]['value'] = TRUE;
 
998
                                        }
 
999
                                        else
 
1000
                                        {
 
1001
                                                $this->xh[$the_parser]['value'] = FALSE;
 
1002
                                        }
 
1003
                                }
 
1004
                                elseif ($name=='DOUBLE')
 
1005
                                {
 
1006
                                        // we have a DOUBLE
 
1007
                                        // we must check that only 0123456789-.<space> are characters here
 
1008
                                        if ( ! preg_match('/^[+-]?[eE0-9\t \.]+$/', $this->xh[$the_parser]['ac']))
 
1009
                                        {
 
1010
                                                $this->xh[$the_parser]['value'] = 'ERROR_NON_NUMERIC_FOUND';
 
1011
                                        }
 
1012
                                        else
 
1013
                                        {
 
1014
                                                $this->xh[$the_parser]['value'] = (double)$this->xh[$the_parser]['ac'];
 
1015
                                        }
 
1016
                                }
 
1017
                                else
 
1018
                                {
 
1019
                                        // we have an I4/INT
 
1020
                                        // we must check that only 0123456789-<space> are characters here
 
1021
                                        if ( ! preg_match('/^[+-]?[0-9\t ]+$/', $this->xh[$the_parser]['ac']))
 
1022
                                        {
 
1023
                                                $this->xh[$the_parser]['value'] = 'ERROR_NON_NUMERIC_FOUND';
 
1024
                                        }
 
1025
                                        else
 
1026
                                        {
 
1027
                                                $this->xh[$the_parser]['value'] = (int)$this->xh[$the_parser]['ac'];
 
1028
                                        }
 
1029
                                }
 
1030
                                $this->xh[$the_parser]['ac'] = '';
 
1031
                                $this->xh[$the_parser]['lv'] = 3; // indicate we've found a value
 
1032
                        break;
 
1033
                        case 'VALUE':
 
1034
                                // This if() detects if no scalar was inside <VALUE></VALUE>
 
1035
                                if ($this->xh[$the_parser]['vt']=='value')
 
1036
                                {
 
1037
                                        $this->xh[$the_parser]['value'] = $this->xh[$the_parser]['ac'];
 
1038
                                        $this->xh[$the_parser]['vt']    = $this->xmlrpcString;
 
1039
                                }
 
1040
 
 
1041
                                // build the XML-RPC value out of the data received, and substitute it
 
1042
                                $temp = new XML_RPC_Values($this->xh[$the_parser]['value'], $this->xh[$the_parser]['vt']);
 
1043
 
 
1044
                                if (count($this->xh[$the_parser]['valuestack']) && $this->xh[$the_parser]['valuestack'][0]['type'] == 'ARRAY')
 
1045
                                {
 
1046
                                        // Array
 
1047
                                        $this->xh[$the_parser]['valuestack'][0]['values'][] = $temp;
 
1048
                                }
 
1049
                                else
 
1050
                                {
 
1051
                                        // Struct
 
1052
                                        $this->xh[$the_parser]['value'] = $temp;
 
1053
                                }
 
1054
                        break;
 
1055
                        case 'MEMBER':
 
1056
                                $this->xh[$the_parser]['ac']='';
 
1057
 
 
1058
                                // If value add to array in the stack for the last element built
 
1059
                                if ($this->xh[$the_parser]['value'])
 
1060
                                {
 
1061
                                        $this->xh[$the_parser]['valuestack'][0]['values'][$this->xh[$the_parser]['valuestack'][0]['name']] = $this->xh[$the_parser]['value'];
 
1062
                                }
 
1063
                        break;
 
1064
                        case 'DATA':
 
1065
                                $this->xh[$the_parser]['ac']='';
 
1066
                        break;
 
1067
                        case 'PARAM':
 
1068
                                if ($this->xh[$the_parser]['value'])
 
1069
                                {
 
1070
                                        $this->xh[$the_parser]['params'][] = $this->xh[$the_parser]['value'];
 
1071
                                }
 
1072
                        break;
 
1073
                        case 'METHODNAME':
 
1074
                                $this->xh[$the_parser]['method'] = ltrim($this->xh[$the_parser]['ac']);
 
1075
                        break;
 
1076
                        case 'PARAMS':
 
1077
                        case 'FAULT':
 
1078
                        case 'METHODCALL':
 
1079
                        case 'METHORESPONSE':
 
1080
                                // We're all good kids with nuthin' to do
 
1081
                        break;
 
1082
                        default:
 
1083
                                // End of an Invalid Element.  Taken care of during the opening tag though
 
1084
                        break;
 
1085
                }
 
1086
        }
 
1087
 
 
1088
        //-------------------------------------
 
1089
        //  Parses Character Data
 
1090
        //-------------------------------------
 
1091
 
 
1092
        function character_data($the_parser, $data)
 
1093
        {
 
1094
                if ($this->xh[$the_parser]['isf'] > 1) return; // XML Fault found already
 
1095
 
 
1096
                // If a value has not been found
 
1097
                if ($this->xh[$the_parser]['lv'] != 3)
 
1098
                {
 
1099
                        if ($this->xh[$the_parser]['lv'] == 1)
 
1100
                        {
 
1101
                                $this->xh[$the_parser]['lv'] = 2; // Found a value
 
1102
                        }
 
1103
 
 
1104
                        if ( ! @isset($this->xh[$the_parser]['ac']))
 
1105
                        {
 
1106
                                $this->xh[$the_parser]['ac'] = '';
 
1107
                        }
 
1108
 
 
1109
                        $this->xh[$the_parser]['ac'] .= $data;
 
1110
                }
 
1111
        }
 
1112
 
 
1113
 
 
1114
        function addParam($par) { $this->params[]=$par; }
 
1115
 
 
1116
        function output_parameters($array=FALSE)
 
1117
        {
 
1118
                $CI =& get_instance();
 
1119
                
 
1120
                if ($array !== FALSE && is_array($array))
 
1121
                {
 
1122
                        while (list($key) = each($array))
 
1123
                        {
 
1124
                                if (is_array($array[$key]))
 
1125
                                {
 
1126
                                        $array[$key] = $this->output_parameters($array[$key]);
 
1127
                                }
 
1128
                                else
 
1129
                                {
 
1130
                                        // 'bits' is for the MetaWeblog API image bits
 
1131
                                        // @todo - this needs to be made more general purpose
 
1132
                                        $array[$key] = ($key == 'bits' OR $this->xss_clean == FALSE) ? $array[$key] : $CI->security->xss_clean($array[$key]);
 
1133
                                }
 
1134
                        }
 
1135
 
 
1136
                        $parameters = $array;
 
1137
                }
 
1138
                else
 
1139
                {
 
1140
                        $parameters = array();
 
1141
 
 
1142
                        for ($i = 0; $i < count($this->params); $i++)
 
1143
                        {
 
1144
                                $a_param = $this->decode_message($this->params[$i]);
 
1145
 
 
1146
                                if (is_array($a_param))
 
1147
                                {
 
1148
                                        $parameters[] = $this->output_parameters($a_param);
 
1149
                                }
 
1150
                                else
 
1151
                                {
 
1152
                                        $parameters[] = ($this->xss_clean) ? $CI->security->xss_clean($a_param) : $a_param;
 
1153
                                }
 
1154
                        }
 
1155
                }
 
1156
 
 
1157
                return $parameters;
 
1158
        }
 
1159
 
 
1160
 
 
1161
        function decode_message($param)
 
1162
        {
 
1163
                $kind = $param->kindOf();
 
1164
 
 
1165
                if ($kind == 'scalar')
 
1166
                {
 
1167
                        return $param->scalarval();
 
1168
                }
 
1169
                elseif ($kind == 'array')
 
1170
                {
 
1171
                        reset($param->me);
 
1172
                        list($a,$b) = each($param->me);
 
1173
 
 
1174
                        $arr = array();
 
1175
 
 
1176
                        for($i = 0; $i < count($b); $i++)
 
1177
                        {
 
1178
                                $arr[] = $this->decode_message($param->me['array'][$i]);
 
1179
                        }
 
1180
 
 
1181
                        return $arr;
 
1182
                }
 
1183
                elseif ($kind == 'struct')
 
1184
                {
 
1185
                        reset($param->me['struct']);
 
1186
 
 
1187
                        $arr = array();
 
1188
 
 
1189
                        while (list($key,$value) = each($param->me['struct']))
 
1190
                        {
 
1191
                                $arr[$key] = $this->decode_message($value);
 
1192
                        }
 
1193
 
 
1194
                        return $arr;
 
1195
                }
 
1196
        }
 
1197
 
 
1198
} // End XML_RPC_Messages class
 
1199
 
 
1200
 
 
1201
 
 
1202
/**
 
1203
 * XML-RPC Values class
 
1204
 *
 
1205
 * @category    XML-RPC
 
1206
 * @author              ExpressionEngine Dev Team
 
1207
 * @link                http://codeigniter.com/user_guide/libraries/xmlrpc.html
 
1208
 */
 
1209
class XML_RPC_Values extends CI_Xmlrpc
 
1210
{
 
1211
        var $me         = array();
 
1212
        var $mytype     = 0;
 
1213
 
 
1214
        public function __construct($val=-1, $type='')
 
1215
        {
 
1216
                parent::__construct();
 
1217
 
 
1218
                if ($val != -1 OR $type != '')
 
1219
                {
 
1220
                        $type = $type == '' ? 'string' : $type;
 
1221
 
 
1222
                        if ($this->xmlrpcTypes[$type] == 1)
 
1223
                        {
 
1224
                                $this->addScalar($val,$type);
 
1225
                        }
 
1226
                        elseif ($this->xmlrpcTypes[$type] == 2)
 
1227
                        {
 
1228
                                $this->addArray($val);
 
1229
                        }
 
1230
                        elseif ($this->xmlrpcTypes[$type] == 3)
 
1231
                        {
 
1232
                                $this->addStruct($val);
 
1233
                        }
 
1234
                }
 
1235
        }
 
1236
 
 
1237
        function addScalar($val, $type='string')
 
1238
        {
 
1239
                $typeof = $this->xmlrpcTypes[$type];
 
1240
 
 
1241
                if ($this->mytype==1)
 
1242
                {
 
1243
                        echo '<strong>XML_RPC_Values</strong>: scalar can have only one value<br />';
 
1244
                        return 0;
 
1245
                }
 
1246
 
 
1247
                if ($typeof != 1)
 
1248
                {
 
1249
                        echo '<strong>XML_RPC_Values</strong>: not a scalar type (${typeof})<br />';
 
1250
                        return 0;
 
1251
                }
 
1252
 
 
1253
                if ($type == $this->xmlrpcBoolean)
 
1254
                {
 
1255
                        if (strcasecmp($val,'true')==0 OR $val==1 OR ($val==true && strcasecmp($val,'false')))
 
1256
                        {
 
1257
                                $val = 1;
 
1258
                        }
 
1259
                        else
 
1260
                        {
 
1261
                                $val=0;
 
1262
                        }
 
1263
                }
 
1264
 
 
1265
                if ($this->mytype == 2)
 
1266
                {
 
1267
                        // adding to an array here
 
1268
                        $ar = $this->me['array'];
 
1269
                        $ar[] = new XML_RPC_Values($val, $type);
 
1270
                        $this->me['array'] = $ar;
 
1271
                }
 
1272
                else
 
1273
                {
 
1274
                        // a scalar, so set the value and remember we're scalar
 
1275
                        $this->me[$type] = $val;
 
1276
                        $this->mytype = $typeof;
 
1277
                }
 
1278
                return 1;
 
1279
        }
 
1280
 
 
1281
        function addArray($vals)
 
1282
        {
 
1283
                if ($this->mytype != 0)
 
1284
                {
 
1285
                        echo '<strong>XML_RPC_Values</strong>: already initialized as a [' . $this->kindOf() . ']<br />';
 
1286
                        return 0;
 
1287
                }
 
1288
 
 
1289
                $this->mytype = $this->xmlrpcTypes['array'];
 
1290
                $this->me['array'] = $vals;
 
1291
                return 1;
 
1292
        }
 
1293
 
 
1294
        function addStruct($vals)
 
1295
        {
 
1296
                if ($this->mytype != 0)
 
1297
                {
 
1298
                        echo '<strong>XML_RPC_Values</strong>: already initialized as a [' . $this->kindOf() . ']<br />';
 
1299
                        return 0;
 
1300
                }
 
1301
                $this->mytype = $this->xmlrpcTypes['struct'];
 
1302
                $this->me['struct'] = $vals;
 
1303
                return 1;
 
1304
        }
 
1305
 
 
1306
        function kindOf()
 
1307
        {
 
1308
                switch($this->mytype)
 
1309
                {
 
1310
                        case 3:
 
1311
                                return 'struct';
 
1312
                                break;
 
1313
                        case 2:
 
1314
                                return 'array';
 
1315
                                break;
 
1316
                        case 1:
 
1317
                                return 'scalar';
 
1318
                                break;
 
1319
                        default:
 
1320
                                return 'undef';
 
1321
                }
 
1322
        }
 
1323
 
 
1324
        function serializedata($typ, $val)
 
1325
        {
 
1326
                $rs = '';
 
1327
 
 
1328
                switch($this->xmlrpcTypes[$typ])
 
1329
                {
 
1330
                        case 3:
 
1331
                                // struct
 
1332
                                $rs .= "<struct>\n";
 
1333
                                reset($val);
 
1334
                                while (list($key2, $val2) = each($val))
 
1335
                                {
 
1336
                                        $rs .= "<member>\n<name>{$key2}</name>\n";
 
1337
                                        $rs .= $this->serializeval($val2);
 
1338
                                        $rs .= "</member>\n";
 
1339
                                }
 
1340
                                $rs .= '</struct>';
 
1341
                        break;
 
1342
                        case 2:
 
1343
                                // array
 
1344
                                $rs .= "<array>\n<data>\n";
 
1345
                                for($i=0; $i < count($val); $i++)
 
1346
                                {
 
1347
                                        $rs .= $this->serializeval($val[$i]);
 
1348
                                }
 
1349
                                $rs.="</data>\n</array>\n";
 
1350
                                break;
 
1351
                        case 1:
 
1352
                                // others
 
1353
                                switch ($typ)
 
1354
                                {
 
1355
                                        case $this->xmlrpcBase64:
 
1356
                                                $rs .= "<{$typ}>" . base64_encode((string)$val) . "</{$typ}>\n";
 
1357
                                        break;
 
1358
                                        case $this->xmlrpcBoolean:
 
1359
                                                $rs .= "<{$typ}>" . ((bool)$val ? '1' : '0') . "</{$typ}>\n";
 
1360
                                        break;
 
1361
                                        case $this->xmlrpcString:
 
1362
                                                $rs .= "<{$typ}>" . htmlspecialchars((string)$val). "</{$typ}>\n";
 
1363
                                        break;
 
1364
                                        default:
 
1365
                                                $rs .= "<{$typ}>{$val}</{$typ}>\n";
 
1366
                                        break;
 
1367
                                }
 
1368
                        default:
 
1369
                        break;
 
1370
                }
 
1371
                return $rs;
 
1372
        }
 
1373
 
 
1374
        function serialize_class()
 
1375
        {
 
1376
                return $this->serializeval($this);
 
1377
        }
 
1378
 
 
1379
        function serializeval($o)
 
1380
        {
 
1381
                $ar = $o->me;
 
1382
                reset($ar);
 
1383
 
 
1384
                list($typ, $val) = each($ar);
 
1385
                $rs = "<value>\n".$this->serializedata($typ, $val)."</value>\n";
 
1386
                return $rs;
 
1387
        }
 
1388
 
 
1389
        function scalarval()
 
1390
        {
 
1391
                reset($this->me);
 
1392
                list($a,$b) = each($this->me);
 
1393
                return $b;
 
1394
        }
 
1395
 
 
1396
 
 
1397
        //-------------------------------------
 
1398
        // Encode time in ISO-8601 form.
 
1399
        //-------------------------------------
 
1400
 
 
1401
        // Useful for sending time in XML-RPC
 
1402
 
 
1403
        function iso8601_encode($time, $utc=0)
 
1404
        {
 
1405
                if ($utc == 1)
 
1406
                {
 
1407
                        $t = strftime("%Y%m%dT%H:%i:%s", $time);
 
1408
                }
 
1409
                else
 
1410
                {
 
1411
                        if (function_exists('gmstrftime'))
 
1412
                                $t = gmstrftime("%Y%m%dT%H:%i:%s", $time);
 
1413
                        else
 
1414
                                $t = strftime("%Y%m%dT%H:%i:%s", $time - date('Z'));
 
1415
                }
 
1416
                return $t;
 
1417
        }
 
1418
 
 
1419
}
 
1420
// END XML_RPC_Values Class
 
1421
 
 
1422
/* End of file Xmlrpc.php */
 
1423
/* Location: ./system/libraries/Xmlrpc.php */
 
 
b'\\ No newline at end of file'