MDL-69583 tool_customlang: add CLI import
[moodle.git] / lib / jabber / XMPP / XMLStream.php
1 <?php
2 /**
3  * XMPPHP: The PHP XMPP Library
4  * Copyright (C) 2008  Nathanael C. Fritz
5  * This file is part of SleekXMPP.
6  * 
7  * XMPPHP is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  * 
12  * XMPPHP is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with XMPPHP; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  *
21  * @category   xmpphp 
22  * @package     XMPPHP
23  * @author       Nathanael C. Fritz <JID: fritzy@netflint.net>
24  * @author       Stephan Wentz <JID: stephan@jabber.wentz.it>
25  * @author       Michael Garvin <JID: gar@netflint.net>
26  * @copyright  2008 Nathanael C. Fritz
27  */
29 /** XMPPHP_Exception */
30 require_once dirname(__FILE__) . '/Exception.php';
32 /** XMPPHP_XMLObj */
33 require_once dirname(__FILE__) . '/XMLObj.php';
35 /** XMPPHP_Log */
36 require_once dirname(__FILE__) . '/Log.php';
38 /**
39  * XMPPHP XML Stream
40  * 
41  * @category   xmpphp 
42  * @package     XMPPHP
43  * @author       Nathanael C. Fritz <JID: fritzy@netflint.net>
44  * @author       Stephan Wentz <JID: stephan@jabber.wentz.it>
45  * @author       Michael Garvin <JID: gar@netflint.net>
46  * @copyright  2008 Nathanael C. Fritz
47  * @version     $Id$
48  */
49 class XMPPHP_XMLStream {
50         /**
51          * @var resource
52          */
53         protected $socket;
54         /**
55          * @var resource
56          */
57         protected $parser;
58         /**
59          * @var string
60          */
61         protected $buffer;
62         /**
63          * @var integer
64          */
65         protected $xml_depth = 0;
66         /**
67          * @var string
68          */
69         protected $host;
70         /**
71          * @var integer
72          */
73         protected $port;
74         /**
75          * @var string
76          */
77         protected $stream_start = '<stream>';
78         /**
79          * @var string
80          */
81         protected $stream_end = '</stream>';
82         /**
83          * @var boolean
84          */
85         protected $disconnected = false;
86         /**
87          * @var boolean
88          */
89         protected $sent_disconnect = false;
90         /**
91          * @var array
92          */
93         protected $ns_map = array();
94         /**
95          * @var array
96          */
97         protected $current_ns = array();
98         /**
99          * @var array
100          */
101         protected $xmlobj = null;
102         /**
103          * @var array
104          */
105         protected $nshandlers = array();
106         /**
107          * @var array
108          */
109         protected $xpathhandlers = array();
110         /**
111          * @var array
112          */
113         protected $idhandlers = array();
114         /**
115          * @var array
116          */
117         protected $eventhandlers = array();
118         /**
119          * @var integer
120          */
121         protected $lastid = 0;
122         /**
123          * @var string
124          */
125         protected $default_ns;
126         /**
127          * @var string
128          */
129         protected $until = [];
130         /**
131          * @var string
132          */
133         protected $until_count = [];
134         /**
135          * @var array
136          */
137         protected $until_happened = false;
138         /**
139          * @var array
140          */
141         protected $until_payload = array();
142         /**
143          * @var XMPPHP_Log
144          */
145         protected $log;
146         /**
147          * @var boolean
148          */
149         protected $reconnect = true;
150         /**
151          * @var boolean
152          */
153         protected $been_reset = false;
154         /**
155          * @var boolean
156          */
157         protected $is_server;
158         /**
159          * @var float
160          */
161         protected $last_send = 0;
162         /**
163          * @var boolean
164          */
165         protected $use_ssl = false;
166         /**
167          * @var integer
168          */
169         protected $reconnectTimeout = 30;
171         /**
172          * Constructor
173          *
174          * @param string  $host
175          * @param string  $port
176          * @param boolean $printlog
177          * @param string  $loglevel
178          * @param boolean $is_server
179          */
180         public function __construct($host = null, $port = null, $printlog = false, $loglevel = null, $is_server = false) {
181                 $this->reconnect = !$is_server;
182                 $this->is_server = $is_server;
183                 $this->host = $host;
184                 $this->port = $port;
185                 $this->setupParser();
186                 $this->log = new XMPPHP_Log($printlog, $loglevel);
187         }
189         /**
190          * Destructor
191          * Cleanup connection
192          */
193         public function __destruct() {
194                 if(!$this->disconnected && $this->socket) {
195                         $this->disconnect();
196                 }
197         }
198         
199         /**
200          * Return the log instance
201          *
202          * @return XMPPHP_Log
203          */
204         public function getLog() {
205                 return $this->log;
206         }
207         
208         /**
209          * Get next ID
210          *
211          * @return integer
212          */
213         public function getId() {
214                 $this->lastid++;
215                 return $this->lastid;
216         }
218         /**
219          * Set SSL
220          *
221          * @return integer
222          */
223         public function useSSL($use=true) {
224                 $this->use_ssl = $use;
225         }
227         /**
228          * Add ID Handler
229          *
230          * @param integer $id
231          * @param string  $pointer
232          * @param string  $obj
233          */
234         public function addIdHandler($id, $pointer, $obj = null) {
235                 $this->idhandlers[$id] = array($pointer, $obj);
236         }
238         /**
239          * Add Handler
240          *
241          * @param string $name
242          * @param string  $ns
243          * @param string  $pointer
244          * @param string  $obj
245          * @param integer $depth
246          */
247         public function addHandler($name, $ns, $pointer, $obj = null, $depth = 1) {
248                 #TODO deprication warning
249                 $this->nshandlers[] = array($name,$ns,$pointer,$obj, $depth);
250         }
252         /**
253          * Add XPath Handler
254          *
255          * @param string $xpath
256          * @param string $pointer
257          * @param
258          */
259         public function addXPathHandler($xpath, $pointer, $obj = null) {
260                 if (preg_match_all("/\(?{[^\}]+}\)?(\/?)[^\/]+/", $xpath, $regs)) {
261                         $ns_tags = $regs[0];
262                 } else {
263                         $ns_tags = array($xpath);
264                 }
265                 foreach($ns_tags as $ns_tag) {
266                         list($l, $r) = explode("}", $ns_tag);
267                         if ($r != null) {
268                                 $xpart = array(substr($l, 1), $r);
269                         } else {
270                                 $xpart = array(null, $l);
271                         }
272                         $xpath_array[] = $xpart;
273                 }
274                 $this->xpathhandlers[] = array($xpath_array, $pointer, $obj);
275         }
277         /**
278          * Add Event Handler
279          *
280          * @param integer $id
281          * @param string  $pointer
282          * @param string  $obj
283          */
284         public function addEventHandler($name, $pointer, $obj) {
285                 $this->eventhandlers[] = array($name, $pointer, $obj);
286         }
288         /**
289          * Connect to XMPP Host
290          *
291          * @param integer $timeout
292          * @param boolean $persistent
293          * @param boolean $sendinit
294          */
295         public function connect($timeout = 30, $persistent = false, $sendinit = true) {
296                 $this->sent_disconnect = false;
297                 $starttime = time();
298                 
299                 do {
300                         $this->disconnected = false;
301                         $this->sent_disconnect = false;
302                         if($persistent) {
303                                 $conflag = STREAM_CLIENT_CONNECT | STREAM_CLIENT_PERSISTENT;
304                         } else {
305                                 $conflag = STREAM_CLIENT_CONNECT;
306                         }
307                         $conntype = 'tcp';
308                         if($this->use_ssl) $conntype = 'ssl';
309                         $this->log->log("Connecting to $conntype://{$this->host}:{$this->port}");
310                         try {
311                                 $this->socket = @stream_socket_client("$conntype://{$this->host}:{$this->port}", $errno, $errstr, $timeout, $conflag);
312                         } catch (Exception $e) {
313                                 throw new XMPPHP_Exception($e->getMessage());
314                         }
315                         if(!$this->socket) {
316                                 $this->log->log("Could not connect.",  XMPPHP_Log::LEVEL_ERROR);
317                                 $this->disconnected = true;
318                                 # Take it easy for a few seconds
319                                 sleep(min($timeout, 5));
320                         }
321                 } while (!$this->socket && (time() - $starttime) < $timeout);
322                 
323                 if ($this->socket) {
324                         stream_set_blocking($this->socket, 1);
325                         if($sendinit) $this->send($this->stream_start);
326                 } else {
327                         throw new XMPPHP_Exception("Could not connect before timeout.");
328                 }
329         }
331         /**
332          * Reconnect XMPP Host
333          */
334         public function doReconnect() {
335                 if(!$this->is_server) {
336                         $this->log->log("Reconnecting ($this->reconnectTimeout)...",  XMPPHP_Log::LEVEL_WARNING);
337                         $this->connect($this->reconnectTimeout, false, false);
338                         $this->reset();
339                         $this->event('reconnect');
340                 }
341         }
343         public function setReconnectTimeout($timeout) {
344                 $this->reconnectTimeout = $timeout;
345         }
346         
347         /**
348          * Disconnect from XMPP Host
349          */
350         public function disconnect() {
351                 $this->log->log("Disconnecting...",  XMPPHP_Log::LEVEL_VERBOSE);
352                 if(false == (bool) $this->socket) {
353                         return;
354                 }
355                 $this->reconnect = false;
356                 $this->send($this->stream_end);
357                 $this->sent_disconnect = true;
358                 $this->processUntil('end_stream', 5);
359                 $this->disconnected = true;
360         }
362         /**
363          * Are we are disconnected?
364          *
365          * @return boolean
366          */
367         public function isDisconnected() {
368                 return $this->disconnected;
369         }
371         /**
372          * Core reading tool
373          * 0 -> only read if data is immediately ready
374          * NULL -> wait forever and ever
375          * integer -> process for this amount of time 
376          */
377         
378         private function __process($maximum=5) {
379                 
380                 $remaining = $maximum;
381                 
382                 do {
383                         $starttime = (microtime(true) * 1000000);
384                         $read = array($this->socket);
385                         $write = array();
386                         $except = array();
387                         if (is_null($maximum)) {
388                                 $secs = NULL;
389                                 $usecs = NULL;
390                         } else if ($maximum == 0) {
391                                 $secs = 0;
392                                 $usecs = 0;
393                         } else {
394                                 $usecs = $remaining % 1000000;
395                                 $secs = floor(($remaining - $usecs) / 1000000);
396                         }
397                         $updated = @stream_select($read, $write, $except, $secs, $usecs);
398                         if ($updated === false) {
399                                 $this->log->log("Error on stream_select()",  XMPPHP_Log::LEVEL_VERBOSE);                                
400                                 if ($this->reconnect) {
401                                         $this->doReconnect();
402                                 } else {
403                                         fclose($this->socket);
404                                         $this->socket = NULL;
405                                         return false;
406                                 }
407                         } else if ($updated > 0) {
408                                 # XXX: Is this big enough?
409                                 $buff = @fread($this->socket, 4096);
410                                 if(!$buff) { 
411                                         if($this->reconnect) {
412                                                 $this->doReconnect();
413                                         } else {
414                                                 fclose($this->socket);
415                                                 $this->socket = NULL;
416                                                 return false;
417                                         }
418                                 }
419                                 $this->log->log("RECV: $buff",  XMPPHP_Log::LEVEL_VERBOSE);
420                                 xml_parse($this->parser, $buff, false);
421                         } else {
422                                 # $updated == 0 means no changes during timeout.
423                         }
424                         $endtime = (microtime(true)*1000000);
425                         $time_past = $endtime - $starttime;
426                         $remaining = $remaining - $time_past;
427                 } while (is_null($maximum) || $remaining > 0);
428                 return true;
429         }
430         
431         /**
432          * Process
433          *
434          * @return string
435          */
436         public function process() {
437                 $this->__process(NULL);
438         }
440         /**
441          * Process until a timeout occurs
442          *
443          * @param integer $timeout
444          * @return string
445          */
446         public function processTime($timeout=NULL) {
447                 if (is_null($timeout)) {
448                         return $this->__process(NULL);
449                 } else {
450                         return $this->__process($timeout * 1000000);
451                 }
452         }
454         /**
455          * Process until a specified event or a timeout occurs
456          *
457          * @param string|array $event
458          * @param integer $timeout
459          * @return string
460          */
461         public function processUntil($event, $timeout=-1) {
462                 $start = time();
463                 if(!is_array($event)) $event = array($event);
464                 $this->until[] = $event;
465                 end($this->until);
466                 $event_key = key($this->until);
467                 reset($this->until);
468                 $this->until_count[$event_key] = 0;
469                 $updated = '';
470                 while(!$this->disconnected and $this->until_count[$event_key] < 1 and (time() - $start < $timeout or $timeout == -1)) {
471                         $this->__process();
472                 }
473                 if(array_key_exists($event_key, $this->until_payload)) {
474                         $payload = $this->until_payload[$event_key];
475                         unset($this->until_payload[$event_key]);
476                         unset($this->until_count[$event_key]);
477                         unset($this->until[$event_key]);
478                 } else {
479                         $payload = array();
480                 }
481                 return $payload;
482         }
484         /**
485          * Obsolete?
486          */
487         public function Xapply_socket($socket) {
488                 $this->socket = $socket;
489         }
491         /**
492          * XML start callback
493          * 
494          * @see xml_set_element_handler
495          *
496          * @param resource $parser
497          * @param string   $name
498          */
499         public function startXML($parser, $name, $attr) {
500                 if($this->been_reset) {
501                         $this->been_reset = false;
502                         $this->xml_depth = 0;
503                 }
504                 $this->xml_depth++;
505                 if(array_key_exists('XMLNS', $attr)) {
506                         $this->current_ns[$this->xml_depth] = $attr['XMLNS'];
507                 } else {
508                         $this->current_ns[$this->xml_depth] = $this->current_ns[$this->xml_depth - 1];
509                         if(!$this->current_ns[$this->xml_depth]) $this->current_ns[$this->xml_depth] = $this->default_ns;
510                 }
511                 $ns = $this->current_ns[$this->xml_depth];
512                 foreach($attr as $key => $value) {
513                         if(strstr($key, ":")) {
514                                 $key = explode(':', $key);
515                                 $key = $key[1];
516                                 $this->ns_map[$key] = $value;
517                         }
518                 }
519                 if(!strstr($name, ":") === false)
520                 {
521                         $name = explode(':', $name);
522                         $ns = $this->ns_map[$name[0]];
523                         $name = $name[1];
524                 }
525                 $obj = new XMPPHP_XMLObj($name, $ns, $attr);
526                 if($this->xml_depth > 1) {
527                         $this->xmlobj[$this->xml_depth - 1]->subs[] = $obj;
528                 }
529                 $this->xmlobj[$this->xml_depth] = $obj;
530         }
532         /**
533          * XML end callback
534          * 
535          * @see xml_set_element_handler
536          *
537          * @param resource $parser
538          * @param string   $name
539          */
540         public function endXML($parser, $name) {
541                 #$this->log->log("Ending $name",  XMPPHP_Log::LEVEL_DEBUG);
542                 #print "$name\n";
543                 if($this->been_reset) {
544                         $this->been_reset = false;
545                         $this->xml_depth = 0;
546                 }
547                 $this->xml_depth--;
548                 if($this->xml_depth == 1) {
549                         #clean-up old objects
550                         #$found = false; #FIXME This didn't appear to be in use --Gar
551                         foreach($this->xpathhandlers as $handler) {
552                                 if (is_array($this->xmlobj) && array_key_exists(2, $this->xmlobj)) {
553                                         $searchxml = $this->xmlobj[2];
554                                         $nstag = array_shift($handler[0]);
555                                         if (($nstag[0] == null or $searchxml->ns == $nstag[0]) and ($nstag[1] == "*" or $nstag[1] == $searchxml->name)) {
556                                                 foreach($handler[0] as $nstag) {
557                                                         if ($searchxml !== null and $searchxml->hasSub($nstag[1], $ns=$nstag[0])) {
558                                                                 $searchxml = $searchxml->sub($nstag[1], $ns=$nstag[0]);
559                                                         } else {
560                                                                 $searchxml = null;
561                                                                 break;
562                                                         }
563                                                 }
564                                                 if ($searchxml !== null) {
565                                                         if($handler[2] === null) $handler[2] = $this;
566                                                         $this->log->log("Calling {$handler[1]}",  XMPPHP_Log::LEVEL_DEBUG);
567                                                         $handler[2]->{$handler[1]}($this->xmlobj[2]);
568                                                 }
569                                         }
570                                 }
571                         }
572                         foreach($this->nshandlers as $handler) {
573                                 if($handler[4] != 1 and array_key_exists(2, $this->xmlobj) and  $this->xmlobj[2]->hasSub($handler[0])) {
574                                         $searchxml = $this->xmlobj[2]->sub($handler[0]);
575                                 } elseif(is_array($this->xmlobj) and array_key_exists(2, $this->xmlobj)) {
576                                         $searchxml = $this->xmlobj[2];
577                                 }
578                                 if($searchxml !== null and $searchxml->name == $handler[0] and ($searchxml->ns == $handler[1] or (!$handler[1] and $searchxml->ns == $this->default_ns))) {
579                                         if($handler[3] === null) $handler[3] = $this;
580                                         $this->log->log("Calling {$handler[2]}",  XMPPHP_Log::LEVEL_DEBUG);
581                                         $handler[3]->{$handler[2]}($this->xmlobj[2]);
582                                 }
583                         }
584                         foreach($this->idhandlers as $id => $handler) {
585                                 if(array_key_exists('id', $this->xmlobj[2]->attrs) and $this->xmlobj[2]->attrs['id'] == $id) {
586                                         if($handler[1] === null) $handler[1] = $this;
587                                         $handler[1]->{$handler[0]}($this->xmlobj[2]);
588                                         #id handlers are only used once
589                                         unset($this->idhandlers[$id]);
590                                         break;
591                                 }
592                         }
593                         if(is_array($this->xmlobj)) {
594                                 $this->xmlobj = array_slice($this->xmlobj, 0, 1);
595                                 if(isset($this->xmlobj[0]) && $this->xmlobj[0] instanceof XMPPHP_XMLObj) {
596                                         $this->xmlobj[0]->subs = null;
597                                 }
598                         }
599                         unset($this->xmlobj[2]);
600                 }
601                 if($this->xml_depth == 0 and !$this->been_reset) {
602                         if(!$this->disconnected) {
603                                 if(!$this->sent_disconnect) {
604                                         $this->send($this->stream_end);
605                                 }
606                                 $this->disconnected = true;
607                                 $this->sent_disconnect = true;
608                                 fclose($this->socket);
609                                 if($this->reconnect) {
610                                         $this->doReconnect();
611                                 }
612                         }
613                         $this->event('end_stream');
614                 }
615         }
617         /**
618          * XML character callback
619          * @see xml_set_character_data_handler
620          *
621          * @param resource $parser
622          * @param string   $data
623          */
624         public function charXML($parser, $data) {
625                 if(array_key_exists($this->xml_depth, $this->xmlobj)) {
626                         $this->xmlobj[$this->xml_depth]->data .= $data;
627                 }
628         }
630         /**
631          * Event?
632          *
633          * @param string $name
634          * @param string $payload
635          */
636         public function event($name, $payload = null) {
637                 $this->log->log("EVENT: $name",  XMPPHP_Log::LEVEL_DEBUG);
638                 foreach($this->eventhandlers as $handler) {
639                         if($name == $handler[0]) {
640                                 if($handler[2] === null) {
641                                         $handler[2] = $this;
642                                 }
643                                 $handler[2]->{$handler[1]}($payload);
644                         }
645                 }
646                 foreach($this->until as $key => $until) {
647                         if(is_array($until)) {
648                                 if(in_array($name, $until)) {
649                                         $this->until_payload[$key][] = array($name, $payload);
650                                         if(!isset($this->until_count[$key])) {
651                                                 $this->until_count[$key] = 0;
652                                         }
653                                         $this->until_count[$key] += 1;
654                                         #$this->until[$key] = false;
655                                 }
656                         }
657                 }
658         }
660         /**
661          * Read from socket
662          */
663         public function read() {
664                 $buff = @fread($this->socket, 1024);
665                 if(!$buff) { 
666                         if($this->reconnect) {
667                                 $this->doReconnect();
668                         } else {
669                                 fclose($this->socket);
670                                 return false;
671                         }
672                 }
673                 $this->log->log("RECV: $buff",  XMPPHP_Log::LEVEL_VERBOSE);
674                 xml_parse($this->parser, $buff, false);
675         }
677         /**
678          * Send to socket
679          *
680          * @param string $msg
681          */
682         public function send($msg, $timeout=NULL) {
684                 if (is_null($timeout)) {
685                         $secs = NULL;
686                         $usecs = NULL;
687                 } else if ($timeout == 0) {
688                         $secs = 0;
689                         $usecs = 0;
690                 } else {
691                         $maximum = $timeout * 1000000;
692                         $usecs = $maximum % 1000000;
693                         $secs = floor(($maximum - $usecs) / 1000000);
694                 }
695                 
696                 $read = array();
697                 $write = array($this->socket);
698                 $except = array();
699                 
700                 $select = @stream_select($read, $write, $except, $secs, $usecs);
701                 
702                 if($select === False) {
703                         $this->log->log("ERROR sending message; reconnecting.");
704                         $this->doReconnect();
705                         # TODO: retry send here
706                         return false;
707                 } elseif ($select > 0) {
708                         $this->log->log("Socket is ready; send it.", XMPPHP_Log::LEVEL_VERBOSE);
709                 } else {
710                         $this->log->log("Socket is not ready; break.", XMPPHP_Log::LEVEL_ERROR);
711                         return false;
712                 }
713                 
714                 $sentbytes = @fwrite($this->socket, $msg);
715                 $this->log->log("SENT: " . mb_substr($msg, 0, $sentbytes, '8bit'), XMPPHP_Log::LEVEL_VERBOSE);
716                 if($sentbytes === FALSE) {
717                         $this->log->log("ERROR sending message; reconnecting.", XMPPHP_Log::LEVEL_ERROR);
718                         $this->doReconnect();
719                         return false;
720                 }
721                 $this->log->log("Successfully sent $sentbytes bytes.", XMPPHP_Log::LEVEL_VERBOSE);
722                 return $sentbytes;
723         }
725         public function time() {
726                 list($usec, $sec) = explode(" ", microtime());
727                 return (float)$sec + (float)$usec;
728         }
730         /**
731          * Reset connection
732          */
733         public function reset() {
734                 $this->xml_depth = 0;
735                 unset($this->xmlobj);
736                 $this->xmlobj = array();
737                 $this->setupParser();
738                 if(!$this->is_server) {
739                         $this->send($this->stream_start);
740                 }
741                 $this->been_reset = true;
742         }
744         /**
745          * Setup the XML parser
746          */
747         public function setupParser() {
748                 $this->parser = xml_parser_create('UTF-8');
749                 xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, 1);
750                 xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
751                 xml_set_object($this->parser, $this);
752                 xml_set_element_handler($this->parser, 'startXML', 'endXML');
753                 xml_set_character_data_handler($this->parser, 'charXML');
754         }
756         public function readyToProcess() {
757                 $read = array($this->socket);
758                 $write = array();
759                 $except = array();
760                 $updated = @stream_select($read, $write, $except, 0);
761                 return (($updated !== false) && ($updated > 0));
762         }