1Net::Jabber::Protocol(3U)ser Contributed Perl DocumentatiNoent::Jabber::Protocol(3)
2
6 Net::Jabber::Protocol - Jabber Protocol Library
7
9 Net::Jabber::Protocol is a module that provides a developer easy
10 access to the Jabber Instant Messaging protocol. It provides high
11 level functions to the Net::Jabber Client, Component, and Server
12 objects. These functions are automatically indluded in those modules
13 through AUTOLOAD and delegates.
14
16 Protocol.pm seeks to provide enough high level APIs and automation of
17 the low level APIs that writing a Jabber Client/Transport in Perl is
18 trivial. For those that wish to work with the low level you can do
19 that too, but those functions are covered in the documentation for
20 each module.
21 Net::Jabber::Protocol provides functions to login, send and receive
23 messages, set personal information, create a new user account, manage
24 the roster, and disconnect. You can use all or none of the functions,
25 there is no requirement.
26 For more information on how the details for how Net::Jabber is written
28 please see the help for Net::Jabber itself.
29 For more information on writing a Client see Net::Jabber::Client.
31 For more information on writing a Transport see Net::Jabber::Transport.
33 Modes
35 Several of the functions take a mode argument that let you specify how
36 the function should behave:
37 block - send the packet with an ID, and then block until an answer
39 comes back. You can optionally specify a timeout so that
40 you do not block forever.
41 nonblock - send the packet with an ID, but then return that id and
43 control to the master program. Net::Jabber is still
44 tracking this packet, so you must use the CheckID function
45 to tell when it comes in. (This might not be very
46 useful...)
47 passthru - send the packet with an ID, but do NOT register it with
49 Net::Jabber, then return the ID. This is useful when
50 combined with the XPath function because you can register
51 a one shot function tied to the id you get back.
52 Basic Functions
54 use Net::Jabber qw( Client );
55 $Con = new Net::Jabber::Client(); # From
56 $status = $Con->Connect(hostname=>"jabber.org"); # Net::Jabber::Client
57 or
59 use Net::Jabber qw( Component );
61 $Con = new Net::Jabber::Component(); #
62 $status = $Con->Connect(hostname=>"jabber.org", # From
63 secret=>"bob"); # Net::Jabber::Component
64 #
67 # For callback setup, see Net::XMPP::Protocol
68 #
69 $Con->Info(name=>"Jarl",
71 version=>"v0.6000");
72 ID Functions
74 $id = $Con->SendWithID($sendObj);
75 $id = $Con->SendWithID("<tag>XML</tag>");
76 $receiveObj = $Con->SendAndReceiveWithID($sendObj);
77 $receiveObj = $Con->SendAndReceiveWithID($sendObj,
78 10);
79 $receiveObj = $Con->SendAndReceiveWithID("<tag>XML</tag>");
80 $receiveObj = $Con->SendAndReceiveWithID("<tag>XML</tag>",
81 5);
82 $yesno = $Con->ReceivedID($id);
83 $receiveObj = $Con->GetID($id);
84 $receiveObj = $Con->WaitForID($id);
85 $receiveObj = $Con->WaitForID($id,
86 20);
87 IQ Functions
89 Agents Functions
90 %agents = $Con->AgentsGet();
91 %agents = $Con->AgentsGet(to=>"transport.jabber.org");
92 Browse Functions
94 %hash = $Con->BrowseRequest(jid=>"jabber.org");
95 %hash = $Con->BrowseRequest(jid=>"jabber.org",
96 timeout=>10);
97 $id = $Con->BrowseRequest(jid=>"jabber.org",
99 mode=>"nonblock");
100 $id = $Con->BrowseRequest(jid=>"jabber.org",
102 mode=>"passthru");
103 Browse DB Functions
105 $Con->BrowseDBDelete("jabber.org");
106 $Con->BrowseDBDelete(Net::Jabber::JID);
107 $presence = $Con->BrowseDBQuery(jid=>"bob\@jabber.org");
109 $presence = $Con->BrowseDBQuery(jid=>Net::Jabber::JID);
110 $presence = $Con->BrowseDBQuery(jid=>"users.jabber.org",
111 timeout=>10);
112 $presence = $Con->BrowseDBQuery(jid=>"conference.jabber.org",
113 refresh=>1);
114 Bystreams Functions
116 %hash = $Con->ByteStreamsProxyRequest(jid=>"proxy.server");
117 %hash = $Con->ByteStreamsProxyRequest(jid=>"proxy.server",
118 timeout=>10);
119 $id = $Con->ByteStreamsProxyRequest(jid=>"proxy.server",
121 mode=>"nonblock");
122 $id = $Con->ByteStreamsProxyRequest(jid=>"proxy.server",
124 mode=>"passthru");
125 %hash = $Con->ByteStreamsProxyParse($query);
128 $status = $Con->ByteStreamsProxyActivate(sid=>"stream_id",
131 jid=>"proxy.server");
132 $status = $Con->ByteStreamsProxyActivate(sid=>"stream_id",
133 jid=>"proxy.server",
134 timeout=>10);
135 $id = $Con->ByteStreamsProxyActivate(sid=>"stream_id",
137 jid=>"proxy.server",
138 mode=>"nonblock");
139 $id = $Con->ByteStreamsProxyActivate(sid=>"stream_id",
141 jid=>"proxy.server",
142 mode=>"passthru");
143 $jid = $Con->ByteStreamsOffer(sid=>"stream_id",
146 streamhosts=>[{jid=>"jid",
147 host=>"host",
148 port=>"port",
149 zeroconf=>"zero",
150 },
151 ...
152 ],
153 jid=>"bob\@jabber.org");
154 $jid = $Con->ByteStreamsOffer(sid=>"stream_id",
155 streamhosts=>[{},{},...],
156 jid=>"bob\@jabber.org",
157 timeout=>10);
158 $id = $Con->ByteStreamsOffer(sid=>"stream_id",
160 streamhosts=>[{},{},...],
161 jid=>"bob\@jabber.org",
162 mode=>"nonblock");
163 $id = $Con->ByteStreamsOffer(sid=>"stream_id",
165 streamhosts=>[{},{},...],
166 jid=>"bob\@jabber.org",
167 mode=>"passthru");
168 Disco Functions
170 %hash = $Con->DiscoInfoRequest(jid=>"jabber.org");
171 %hash = $Con->DiscoInfoRequest(jid=>"jabber.org",
172 node=>"node...");
173 %hash = $Con->DiscoInfoRequest(jid=>"jabber.org",
174 node=>"node...",
175 timeout=>10);
176 $id = $Con->DiscoInfoRequest(jid=>"jabber.org",
178 mode=>"nonblock");
179 $id = $Con->DiscoInfoRequest(jid=>"jabber.org",
180 node=>"node...",
181 mode=>"nonblock");
182 $id = $Con->DiscoInfoRequest(jid=>"jabber.org",
184 mode=>"passthru");
185 $id = $Con->DiscoInfoRequest(jid=>"jabber.org",
186 node=>"node...",
187 mode=>"passthru");
188 %hash = $Con->DiscoInfoParse($query);
191 %hash = $Con->DiscoItemsRequest(jid=>"jabber.org");
194 %hash = $Con->DiscoItemsRequest(jid=>"jabber.org",
195 timeout=>10);
196 $id = $Con->DiscoItemsRequest(jid=>"jabber.org",
198 mode=>"nonblock");
199 $id = $Con->DiscoItemsRequest(jid=>"jabber.org",
201 mode=>"passthru");
202 %hash = $Con->DiscoItemsParse($query);
205 Feature Negotiation Functions
207 %hash = $Con->FeatureNegRequest(jid=>"jabber.org",
208 features=>{ feat1=>["opt1","opt2",...],
209 feat2=>["optA","optB",...]
210 }
211 );
212 %hash = $Con->FeatureNegRequest(jid=>"jabber.org",
213 features=>{ ... },
214 timeout=>10);
215 $id = $Con->FeatureNegRequest(jid=>"jabber.org",
217 features=>{ ... },
218 mode=>"nonblock");
219 $id = $Con->FeatureNegRequest(jid=>"jabber.org",
221 features=>{ ... },
222 mode=>"passthru");
223 my $query = $self->FeatureNegQuery(\{ ... });
225 $iq->AddQuery($query);
226 %hash = $Con->FeatureNegParse($query);
228 File Transfer Functions
230 $method = $Con->FileTransferOffer(jid=>"bob\@jabber.org",
231 sid=>"stream_id",
232 filename=>"/path/to/file",
233 methods=>["http://jabber.org/protocol/si/profile/bytestreams",
234 "jabber:iq:oob",
235 ...
236 ]
237 );
238 $method = $Con->FileTransferOffer(jid=>"bob\@jabber.org",
239 sid=>"stream_id",
240 filename=>"/path/to/file",
241 methods=>\@methods,
242 timeout=>"10");
243 $id = $Con->FileTransferOffer(jid=>"bob\@jabber.org",
245 sid=>"stream_id",
246 filename=>"/path/to/file",
247 methods=>\@methods,
248 mode=>"nonblock");
249 $id = $Con->FileTransferOffer(jid=>"bob\@jabber.org",
251 sid=>"stream_id",
252 filename=>"/path/to/file",
253 methods=>\@methods,
254 mode=>"passthru");
255 Last Functions
257 $Con->LastQuery();
258 $Con->LastQuery(to=>"bob@jabber.org");
259 %result = $Con->LastQuery(mode=>"block");
261 %result = $Con->LastQuery(to=>"bob@jabber.org",
262 mode=>"block");
263 %result = $Con->LastQuery(to=>"bob@jabber.org",
265 mode=>"block",
266 timeout=>10);
267 %result = $Con->LastQuery(mode=>"block",
268 timeout=>10);
269 $Con->LastSend(to=>"bob@jabber.org");
271 $seconds = $Con->LastActivity();
273 Multi-User Chat Functions
275 $Con->MUCJoin(room=>"jabber",
276 server=>"conference.jabber.org",
277 nick=>"nick");
278 $Con->MUCJoin(room=>"jabber",
280 server=>"conference.jabber.org",
281 nick=>"nick",
282 password=>"secret");
283 Register Functions
285 @result = $Con->RegisterSendData("users.jabber.org",
286 first=>"Bob",
287 last=>"Smith",
288 nick=>"bob",
289 email=>"foo@bar.net");
290 RPC Functions
292 $query = $Con->RPCEncode(type=>"methodCall",
293 methodName=>"methodName",
294 params=>[param,param,...]);
295 $query = $Con->RPCEncode(type=>"methodResponse",
296 params=>[param,param,...]);
297 $query = $Con->RPCEncode(type=>"methodResponse",
298 faultCode=>4,
299 faultString=>"Too many params");
300 @response = $Con->RPCParse($iq);
302 @response = $Con->RPCCall(to=>"dataHouse.jabber.org",
304 methodname=>"numUsers",
305 params=>[ param,param,... ]
306 );
307 $Con->RPCResponse(to=>"you\@jabber.org",
309 params=>[ param,param,... ]);
310 $Con->RPCResponse(to=>"you\@jabber.org",
312 faultCode=>"4",
313 faultString=>"Too many parameters"
314 );
315 $Con->RPCSetCallBacks(myMethodA=>\&methoda,
317 myMethodB=>\&do_somthing,
318 etc...
319 );
320 Search Functions
322 %fields = $Con->SearchRequest();
323 %fields = $Con->SearchRequest(to=>"users.jabber.org");
324 %fields = $Con->SearchRequest(to=>"users.jabber.org",
325 timeout=>10);
326 $Con->SearchSend(to=>"somewhere",
328 name=>"",
329 first=>"Bob",
330 last=>"",
331 nick=>"bob",
332 email=>"",
333 key=>"some key");
334 $Con->SearchSendData("users.jabber.org",
336 first=>"Bob",
337 last=>"",
338 nick=>"bob",
339 email=>"");
340 Time Functions
342 $Con->TimeQuery();
343 $Con->TimeQuery(to=>"bob@jabber.org");
344 %result = $Con->TimeQuery(mode=>"block");
346 %result = $Con->TimeQuery(to=>"bob@jabber.org",
347 mode=>"block");
348 $Con->TimeSend(to=>"bob@jabber.org");
350 Version Functions
352 $Con->VersionQuery();
353 $Con->VersionQuery(to=>"bob@jabber.org");
354 %result = $Con->VersionQuery(mode=>"block");
356 %result = $Con->VersionQuery(to=>"bob@jabber.org",
357 mode=>"block");
358 $Con->VersionSend(to=>"bob@jabber.org",
360 name=>"Net::Jabber",
361 ver=>"1.0a",
362 os=>"Perl");
363
365 Basic Functions
366 Info(name=>string, - Set some information so that Net::Jabber
367 version=>string) can auto-reply to some packets for you to
368 reduce the work you have to do.
369 NOTE: This requires that you use the
371 SetIQCallBacks methodology and not the
372 SetCallBacks for <iq/> packets.
373 IQ Functions
375 Agents Functions
376 ********************************
377 * *
378 * Deprecated in favor of Disco *
379 * *
380 ********************************
381 AgentsGet(to=>string, - takes all of the information and
383 AgentsGet() builds a Net::Jabber::IQ::Agents packet.
384 It then sends that packet either to the
385 server, or to the specified transport,
386 with an ID and waits for that ID to return.
387 Then it looks in the resulting packet and
388 builds a hash that contains the values
389 of the agent list. The hash is layed out
390 like this: (NOTE: the jid is the key to
391 distinguish the various agents)
392 $hash{<JID>}->{order} = 4
394 ->{name} = "ICQ Transport"
395 ->{transport} = "ICQ #"
396 ->{description} = "ICQ..blah.."
397 ->{service} = "icq"
398 ->{register} = 1
399 ->{search} = 1
400 etc...
401 The order field determines the order that
403 it came from the server in... in case you
404 care. For more info on the valid fields
405 see the Net::Jabber::Query jabber:iq:agent
406 namespace.
407 Browse Functions
409 ********************************
410 * *
411 * Deprecated in favor of Disco *
412 * *
413 ********************************
414 BrowseRequest(jid=>string, - sends a jabber:iq:browse request to
416 mode=>string, the jid passed as an argument.
417 timeout=>int) Returns a hash with the resulting
418 tree if mode is set to "block":
419 $browse{'category'} = "conference"
421 $browse{'children'}->[0]
422 $browse{'children'}->[1]
423 $browse{'children'}->[11]
424 $browse{'jid'} = "conference.jabber.org"
425 $browse{'name'} = "Jabber.org Conferencing Center"
426 $browse{'ns'}->[0]
427 $browse{'ns'}->[1]
428 $browse{'type'} = "public"
429 The ns array is an array of the
431 namespaces that this jid supports.
432 The children array points to hashs
433 of this form, and represent the fact
434 that they can be browsed to.
435 See MODES above for using the mode
437 and timeout.
438 Browse DB Functions
440 BrowseDBDelete(string|Net::Jabber::JID) - delete thes JID browse
441 data from the DB.
442 BrowseDBQuery(jid=>string | NJ::JID, - returns the browse data
444 timeout=>integer, for the requested JID. If
445 refresh=>0|1) the DB does not contain
446 the data for the JID, then
447 it attempts to fetch the
448 data via BrowseRequest().
449 The timeout is passed to
450 the BrowseRequest() call,
451 and refresh tells the DB
452 to request the data, even
453 if it already has some.
454 Bytestreams Functions
456 ByteStreamsProxyRequest(jid=>string, - sends a bytestreams request
457 mode=>string, to the jid passed as an
458 timeout=>int) argument. Returns an array
459 ref with the resulting tree
460 if mode is set to "block".
461 See ByteStreamsProxyParse
463 for the format of the
464 resulting tree.
465 See MODES above for using
467 the mode and timeout.
468 ByteStreamsProxyParse(Net::Jabber::Query) - parses the query and
470 returns an array ref
471 to the resulting tree:
472 $host[0]->{jid} = "bytestreams1.proxy.server";
474 $host[0]->{host} = "proxy1.server";
475 $host[0]->{port} = "5006";
476 $host[1]->{jid} = "bytestreams2.proxy.server";
477 $host[1]->{host} = "proxy2.server";
478 $host[1]->{port} = "5007";
479 ...
480 ByteStreamsProxyActivate(jid=>string, - sends a bytestreams activate
482 sid=>string, to the jid passed as an
483 mode=>string, argument. Returns 1 if the
484 timeout=>int) proxy activated (undef if
485 it did not) if mode is set
486 to "block".
487 sid is the stream id that
489 is being used to talk about
490 this stream.
491 See MODES above for using
493 the mode and timeout.
494 ByteStreamsOffer(jid=>string, - sends a bytestreams offer
496 sid=>string, to the jid passed as an
497 streamhosts=>arrayref argument. Returns the jid
498 mode=>string, of the streamhost that the
499 timeout=>int) user selected if mode is set
500 to "block".
501 streamhosts is the same
503 format as the array ref
504 returned from
505 ByteStreamsProxyParse.
506 See MODES above for using
508 the mode and timeout.
509 Disco Functions
511 DiscoInfoRequest(jid=>string, - sends a disco#info request to
512 node=>string, the jid passed as an argument,
513 mode=>string, and the node if specified.
514 timeout=>int) Returns a hash with the resulting
515 tree if mode is set to "block".
516 See DiscoInfoParse for the format
518 of the resulting tree.
519 See MODES above for using the mode
521 and timeout.
522 DiscoInfoParse(Net::Jabber::Query) - parses the query and
524 returns a hash ref
525 to the resulting tree:
526 $info{identity}->[0]->{category} = "groupchat";
528 $info{identity}->[0]->{name} = "Public Chatrooms";
529 $info{identity}->[0]->{type} = "public";
530 $info{identity}->[1]->{category} = "groupchat";
532 $info{identity}->[1]->{name} = "Private Chatrooms";
533 $info{identity}->[1]->{type} = "private";
534 $info{feature}->{http://jabber.org/protocol/disco#info} = 1;
536 $info{feature}->{http://jabber.org/protocol/muc#admin} = 1;
537 DiscoItemsRequest(jid=>string, - sends a disco#items request to
539 mode=>string, the jid passed as an argument.
540 timeout=>int) Returns a hash with the resulting
541 tree if mode is set to "block".
542 See DiscoItemsParse for the format
544 of the resulting tree.
545 See MODES above for using the mode
547 and timeout.
548 DiscoItemsParse(Net::Jabber::Query) - parses the query and
550 returns a hash ref
551 to the resulting tree:
552 $items{jid}->{node} = name;
554 $items{"proxy.server"}->{""} = "Bytestream Proxy Server";
556 $items{"conf.server"}->{"public"} = "Public Chatrooms";
557 $items{"conf.server"}->{"private"} = "Private Chatrooms";
558 Feature Negotiation Functions
560 FeatureNegRequest(jid=>string, - sends a feature negotiation to
561 features=>hash ref, the jid passed as an argument,
562 mode=>string, using the features specified.
563 timeout=>int) Returns a hash with the resulting
564 tree if mode is set to "block".
565 See DiscoInfoQuery for the format
567 of the features hash ref.
568 See DiscoInfoParse for the format
570 of the resulting tree.
571 See MODES above for using the mode
573 and timeout.
574 FeatureNegParse(Net::Jabber::Query) - parses the query and
576 returns a hash ref
577 to the resulting tree:
578 $features->{feat1} = ["opt1","opt2",...];
580 $features->{feat2} = ["optA","optB",...];
581 ....
582 If this is a result:
584 $features->{feat1} = "opt2";
586 $features->{feat2} = "optA";
587 ....
588 FeatureNeqQuery(hash ref) - takes a hash ref and turns it into a
590 feature negotiation query that you can
591 AddQuery into your packaet. The format
592 of the hash ref is as follows:
593 $features->{feat1} = ["opt1","opt2",...];
595 $features->{feat2} = ["optA","optB",...];
596 ....
597 File Transfer Functions
599 FileTransferOffer(jid=>string, - sends a file transfer stream
600 sid=>string, initiation to the jid passed
601 filename=>string, as an argument. Returns the
602 mode=>string, method (if the users accepts),
603 timeout=>int) undef (if the user declines),
604 if the mode is set to "block".
605 See MODES above for using
607 the mode and timeout.
608 Last Functions
610 LastQuery(to=>string, - asks the jid specified for its last
611 mode=>string, activity. If the to is blank, then it
612 timeout=>int) queries the server. Returns a hash with
613 LastQuery() the various items set if mode is set to
614 "block":
615 $last{seconds} - Seconds since activity
617 $last{message} - Message for activity
618 See MODES above for using the mode
620 and timeout.
621 LastSend(to=>string, - sends the specified last to the specified jid.
623 hash) the hash is the seconds and message as shown
624 in the Net::Jabber::Query man page.
625 LastActivity() - returns the number of seconds since the last activity
627 by the user.
628 Multi-User Chat Functions
630 MUCJoin(room=>string, - Sends the appropriate MUC protocol to join
631 server=>string, the specified room with the specified nick.
632 nick=>string,
633 password=>string)
634 Register Functions
636 RegisterSendData(string|JID, - takes the contents of the hash and
637 hash) builds a jabebr:x:data return packet
638 which it sends in a Net::Jabber::Query
639 jabber:iq:register namespace packet.
640 The first argument is the JID to send
641 the packet to. This function returns
642 an array that looks like this:
643 [ type , message ]
645 If type is "ok" then registration was
647 successful, otherwise message contains
648 a little more detail about the error.
649 RPC Functions
651 RPCParse(IQ object) - returns an array. The first argument tells
652 the status "ok" or "fault". The second
653 argument is an array if "ok", or a hash if
654 "fault".
655 RPCCall(to=>jid|string, - takes the methodName and params,
657 methodName=>string, builds the RPC calls and sends it
658 params=>array, to the specified address. Returns
659 mode=>string, the above data from RPCParse.
660 timeout=>int)
661 See MODES above for using the mode
662 and timeout.
663 RPCResponse(to=>jid|string, - generates a response back to
665 params=>array, the caller. If any part of
666 faultCode=>int, fault is specified, then it
667 faultString=>string) wins.
668 Note: To ensure that you get the correct type for a param sent
671 back, you can specify the type by prepending the type to
672 the value:
673 "i4:5" or "int:5"
675 "boolean:0"
676 "string:56"
677 "double:5.0"
678 "datetime:20020415T11:11:11"
679 "base64:...."
680 RPCSetCallBacks(method=>function, - sets the callback functions
682 method=>function, for the specified methods.
683 etc...) The method comes from the
684 <methodName/> and is case
685 sensitive. The single
686 arguemnt is a ref to an
687 array that contains the
688 <params/>. The function you
689 write should return one of two
690 things:
691 ["ok", [...] ]
693 The [...] is a list of the
695 <params/> you want to return.
696 ["fault", {faultCode=>1,
698 faultString=>...} ]
699 If you set the function to undef,
701 then the method is removed from
702 the list.
703 Search Functions
705 SearchRequest(to=>string, - send an <iq/> request to the specified
706 mode=>string, server/transport, if not specified it
707 timeout=>int) sends to the current active server.
708 SearchRequest() The function returns a hash that
709 contains the required fields. Here
710 is an example of the hash:
711 $hash{fields} - The raw fields from
713 the iq:register. To
714 be used if there is
715 no x:data in the
716 packet.
717 $hash{instructions} - How to fill out
718 the form.
719 $hash{form} - The new dynamic forms.
720 In $hash{form}, the fields that are
722 present are the required fields the
723 server needs.
724 See MODES above for using the mode
726 and timeout.
727 SearchSend(to=>string|JID, - takes the contents of the hash and
729 hash) passes it to the SetSearch function
730 in the Net::Jabber::Query
731 jabber:iq:search namespace. And then
732 sends the packet.
733 SearchSendData(string|JID, - takes the contents of the hash and
735 hash) builds a jabebr:x:data return packet
736 which it sends in a Net::Jabber::Query
737 jabber:iq:search namespace packet.
738 The first argument is the JID to send
739 the packet to.
740 Time Functions
742 TimeQuery(to=>string, - asks the jid specified for its localtime.
743 mode=>string, If the to is blank, then it queries the
744 timeout=>int) server. Returns a hash with the various
745 TimeQuery() items set if mode is set to "block":
746 $time{utc} - Time in UTC
748 $time{tz} - Timezone
749 $time{display} - Display string
750 See MODES above for using the mode
752 and timeout.
753 TimeSend(to=>string) - sends the current UTC time to the specified
755 jid.
756 Version Functions
758 VersionQuery(to=>string, - asks the jid specified for its
759 mode=>string, client version information. If the
760 timeout=>int) to is blank, then it queries the
761 VersionQuery() server. Returns ahash with the
762 various items set if mode is set to
763 "block":
764 $version{name} - Name
766 $version{ver} - Version
767 $version{os} - Operating System/
768 Platform
769 See MODES above for using the mode
771 and timeout.
772 VersionSend(to=>string, - sends the specified version information
774 name=>string, to the jid specified in the to.
775 ver=>string,
776 os=>string)
777
779 Ryan Eatmon
780
782 This module is free software; you can redistribute it and/or modify it
783 under the same terms as Perl itself.
784perl v5.28.1 2004-08-17 Net::Jabber::Protocol(3)