LP#1703411: Move OpenSRF XMPP attrs to subelement
[OpenSRF.git] / src / libopensrf / transport_session.c
1 #include <opensrf/transport_session.h>
2
3 /**
4         @file transport_session.c
5         @brief Routines to manage a connection to a Jabber server.
6
7         In all cases, a transport_session acts as a client with regard to Jabber.
8 */
9
10 #define CONNECTING_1 1   /**< just starting the connection to Jabber */
11 #define CONNECTING_2 2   /**< XML stream opened but not yet logged in */
12
13
14 /* Note. these are growing buffers, so all that's necessary is a sane starting point */
15 #define JABBER_BODY_BUFSIZE    4096  /**< buffer size for message body */
16 #define JABBER_SUBJECT_BUFSIZE   64  /**< buffer size for message subject */
17 #define JABBER_THREAD_BUFSIZE    64  /**< buffer size for message thread */
18 #define JABBER_JID_BUFSIZE       64  /**< buffer size for various ids */
19 #define JABBER_STATUS_BUFSIZE    16  /**< buffer size for status code */
20
21 // ---------------------------------------------------------------------------------
22 // Callback for handling the startElement event.  Much of the jabber logic occurs
23 // in this and the characterHandler callbacks.
24 // Here we check for the various top level jabber elements: body, iq, etc.
25 // ---------------------------------------------------------------------------------
26 static void startElementHandler(
27                 void *session, const xmlChar *name, const xmlChar **atts);
28
29 // ---------------------------------------------------------------------------------
30 // Callback for handling the endElement event.  Updates the Jabber state machine
31 // to let us know the element is over.
32 // ---------------------------------------------------------------------------------
33 static void endElementHandler( void *session, const xmlChar *name);
34
35 // ---------------------------------------------------------------------------------
36 // This is where we extract XML text content.  In particular, this is useful for
37 // extracting Jabber message bodies.
38 // ---------------------------------------------------------------------------------
39 static void characterHandler(
40                 void *session, const xmlChar *ch, int len);
41
42 static void parseWarningHandler( void *session, const char* msg, ... );
43 static void parseErrorHandler( void *session, const char* msg, ... );
44
45 // ---------------------------------------------------------------------------------
46 // Tells the SAX parser which functions will be used as event callbacks
47 // ---------------------------------------------------------------------------------
48 static xmlSAXHandler SAXHandlerStruct = {
49         NULL,                  /* internalSubset */
50         NULL,                  /* isStandalone */
51         NULL,                  /* hasInternalSubset */
52         NULL,                  /* hasExternalSubset */
53         NULL,                  /* resolveEntity */
54         NULL,                  /* getEntity */
55         NULL,                  /* entityDecl */
56         NULL,                  /* notationDecl */
57         NULL,                  /* attributeDecl */
58         NULL,                  /* elementDecl */
59         NULL,                  /* unparsedEntityDecl */
60         NULL,                  /* setDocumentLocator */
61         NULL,                  /* startDocument */
62         NULL,                  /* endDocument */
63         startElementHandler,   /* startElement */
64         endElementHandler,     /* endElement */
65         NULL,                  /* reference */
66         characterHandler,      /* characters */
67         NULL,                  /* ignorableWhitespace */
68         NULL,                  /* processingInstruction */
69         NULL,                  /* comment */
70         parseWarningHandler,   /* xmlParserWarning */
71         parseErrorHandler,     /* xmlParserError */
72         NULL,                  /* xmlParserFatalError : unused */
73         NULL,                  /* getParameterEntity */
74         NULL,                  /* cdataBlock; */
75         NULL,                  /* externalSubset; */
76         1,
77         NULL,
78         NULL,                  /* startElementNs */
79         NULL,                  /* endElementNs */
80         NULL                   /* xmlStructuredErrorFunc */
81 };
82
83 // ---------------------------------------------------------------------------------
84 // Our SAX handler pointer.
85 // ---------------------------------------------------------------------------------
86 static const xmlSAXHandlerPtr SAXHandler = &SAXHandlerStruct;
87
88 #ifndef HOST_NAME_MAX
89 #define HOST_NAME_MAX 256
90 #endif
91
92 static void grab_incoming(void* blob, socket_manager* mgr, int sockid, char* data, int parent);
93 static void reset_session_buffers( transport_session* session );
94 static const char* get_xml_attr( const xmlChar** atts, const char* attr_name );
95
96 /**
97         @brief Allocate and initialize a transport_session.
98         @param server Hostname or IP address where the Jabber server resides.
99         @param port Port used for connecting to Jabber (0 if using UNIX domain socket).
100         @param unix_path Name of Jabber's socket in file system (if using UNIX domain socket).
101         @param user_data An opaque pointer stored on behalf of the calling code.
102         @param component Boolean; true if we're a component.
103         @return Pointer to a newly allocated transport_session.
104
105         This function initializes memory but does not open any sockets or otherwise access
106         the network.
107
108         If @a port is greater than zero, we will use TCP to connect to Jabber, and ignore
109         @a unix_path.  Otherwise we will open a UNIX domain socket using @a unix_path.
110
111         The calling code is responsible for freeing the transport_session by calling
112         session_free().
113 */
114 transport_session* init_transport( const char* server,
115         int port, const char* unix_path, void* user_data, int component ) {
116
117         if( ! server )
118                 server = "";
119
120         /* create the session struct */
121         transport_session* session =
122                 (transport_session*) safe_malloc( sizeof(transport_session) );
123
124         session->user_data = user_data;
125
126         session->component = component;
127
128         /* initialize the data buffers */
129         session->body_buffer        = buffer_init( JABBER_BODY_BUFSIZE );
130         session->subject_buffer     = buffer_init( JABBER_SUBJECT_BUFSIZE );
131         session->thread_buffer      = buffer_init( JABBER_THREAD_BUFSIZE );
132         session->from_buffer        = buffer_init( JABBER_JID_BUFSIZE );
133         session->status_buffer      = buffer_init( JABBER_STATUS_BUFSIZE );
134         session->recipient_buffer   = buffer_init( JABBER_JID_BUFSIZE );
135         session->message_error_type = buffer_init( JABBER_JID_BUFSIZE );
136         session->session_id         = buffer_init( 64 );
137
138         session->message_error_code = 0;
139
140         /* for OpenSRF extensions */
141         session->router_to_buffer   = buffer_init( JABBER_JID_BUFSIZE );
142         session->router_from_buffer = buffer_init( JABBER_JID_BUFSIZE );
143         session->osrf_xid_buffer    = buffer_init( JABBER_JID_BUFSIZE );
144         session->router_class_buffer    = buffer_init( JABBER_JID_BUFSIZE );
145         session->router_command_buffer  = buffer_init( JABBER_JID_BUFSIZE );
146
147         session->router_broadcast   = 0;
148
149         /* initialize the jabber state machine */
150         session->state_machine = (jabber_machine*) safe_malloc( sizeof(jabber_machine) );
151         session->state_machine->connected        = 0;
152         session->state_machine->connecting       = 0;
153         session->state_machine->in_message       = 0;
154         session->state_machine->in_message_body  = 0;
155         session->state_machine->in_thread        = 0;
156         session->state_machine->in_subject       = 0;
157         session->state_machine->in_error         = 0;
158         session->state_machine->in_message_error = 0;
159         session->state_machine->in_iq            = 0;
160         session->state_machine->in_presence      = 0;
161         session->state_machine->in_status        = 0;
162
163         /* initialize the sax push parser */
164         session->parser_ctxt = xmlCreatePushParserCtxt(SAXHandler, session, "", 0, NULL);
165
166         /* initialize the socket_manager structure */
167         session->sock_mgr = (socket_manager*) safe_malloc( sizeof(socket_manager) );
168
169         session->sock_mgr->data_received = &grab_incoming;
170         session->sock_mgr->on_socket_closed = NULL;
171         session->sock_mgr->socket = NULL;
172         session->sock_mgr->blob = session;
173
174         session->port = port;
175         session->server = strdup(server);
176         if(unix_path)
177                 session->unix_path = strdup(unix_path);
178         else session->unix_path = NULL;
179
180         session->sock_id = 0;
181         session->message_callback = NULL;
182
183         return session;
184 }
185
186 /**
187         @brief Disconnect from Jabber, destroy a transport_session, and close its socket.
188         @param session Pointer to the transport_session to be destroyed.
189         @return 1 if successful, or 0 if not.
190
191         The only error condition is a NULL pointer argument.
192 */
193 int session_free( transport_session* session ) {
194         if( ! session )
195                 return 0;
196         else {
197                 session_disconnect( session );
198                 return session_discard( session );
199         }
200 }
201
202 /**
203         @brief Destroy a transport_session and close its socket, without disconnecting from Jabber.
204         @param session Pointer to the transport_session to be destroyed.
205         @return 1 if successful, or 0 if not.
206
207         This function may be called from a child process in order to free resources associated
208         with the parent's transport_session, but without sending a disconnect to Jabber (since
209         that would disconnect the parent).
210
211         The only error condition is a NULL pointer argument.
212 */
213 int session_discard( transport_session* session ) {
214         if( ! session )
215                 return 0;
216
217         if(session->sock_mgr)
218                 socket_manager_free(session->sock_mgr);
219
220         if( session->state_machine ) free( session->state_machine );
221         if( session->parser_ctxt) {
222                 xmlFreeDoc( session->parser_ctxt->myDoc );
223                 xmlFreeParserCtxt(session->parser_ctxt);
224         }
225
226         xmlCleanupCharEncodingHandlers();
227         xmlDictCleanup();
228         xmlCleanupParser();
229
230         buffer_free(session->body_buffer);
231         buffer_free(session->subject_buffer);
232         buffer_free(session->thread_buffer);
233         buffer_free(session->from_buffer);
234         buffer_free(session->recipient_buffer);
235         buffer_free(session->status_buffer);
236         buffer_free(session->message_error_type);
237         buffer_free(session->router_to_buffer);
238         buffer_free(session->router_from_buffer);
239         buffer_free(session->osrf_xid_buffer);
240         buffer_free(session->router_class_buffer);
241         buffer_free(session->router_command_buffer);
242         buffer_free(session->session_id);
243
244         free(session->server);
245         free(session->unix_path);
246
247         free( session );
248         return 1;
249 }
250
251 /**
252         @brief Determine whether a transport_session is connected.
253         @param session Pointer to the transport_session to be tested.
254         @return 1 if connected, or 0 if not.
255 */
256 int session_connected( transport_session* session ) {
257         return session ? session->state_machine->connected : 0;
258 }
259
260 /**
261         @brief Wait on the client socket connected to Jabber, and process any resulting input.
262         @param session Pointer to the transport_session.
263         @param timeout How seconds to wait before timing out (see notes).
264         @return 0 if successful, or -1 if a timeout or other error occurs, or if the server
265                 closes the connection at the other end.
266
267         If @a timeout is -1, wait indefinitely for input activity to appear.  If @a timeout is
268         zero, don't wait at all.  If @a timeout is positive, wait that number of seconds
269         before timing out.  If @a timeout has a negative value other than -1, the results are not
270         well defined.
271
272         Read all available input from the socket and pass it through grab_incoming() (a
273         callback function previously installed in the socket_manager).
274
275         There is no guarantee that we will get a complete message from a single call.  As a
276         result, the calling code should call this function in a loop until it gets a complete
277         message, or until an error occurs.
278 */
279 int session_wait( transport_session* session, int timeout ) {
280         if( ! session || ! session->sock_mgr ) {
281                 return 0;
282         }
283
284         int ret =  socket_wait( session->sock_mgr, timeout, session->sock_id );
285
286         if( ret ) {
287                 osrfLogDebug(OSRF_LOG_MARK, "socket_wait returned error code %d", ret);
288         }
289         return ret;
290 }
291
292 /**
293         @brief Convert a transport_message to XML and send it to Jabber.
294         @param session Pointer to the transport_session.
295         @param msg Pointer to a transport_message enclosing the message.
296         @return 0 if successful, or -1 upon error.
297 */
298 int session_send_msg(
299                 transport_session* session, transport_message* msg ) {
300
301         if( ! session ) { return -1; }
302
303         if( ! session->state_machine->connected ) {
304                 osrfLogWarning(OSRF_LOG_MARK, "State machine is not connected in send_msg()");
305                 return -1;
306         }
307
308         message_prepare_xml( msg );
309         return socket_send( session->sock_id, msg->msg_xml );
310
311 }
312
313
314 /**
315         @brief Connect to the Jabber server as a client and open a Jabber session.
316         @param session Pointer to a transport_session.
317         @param username Jabber user name.
318         @param password Jabber password.
319         @param resource name of Jabber resource.
320         @param connect_timeout Timeout interval, in seconds, for receiving data (see notes).
321         @param auth_type An enum: either AUTH_PLAIN or AUTH_DIGEST (see notes).
322         @return 1 if successful, or 0 upon error.
323
324         If @a connect_timeout is -1, wait indefinitely for the Jabber server to respond.  If
325         @a connect_timeout is zero, don't wait at all.  If @a timeout is positive, wait that
326         number of seconds before timing out.  If @a connect_timeout has a negative value other
327         than -1, the results are not well defined.
328
329         The value of @a connect_timeout applies to each of two stages in the logon procedure.
330         Hence the logon may take up to twice the amount of time indicated.
331
332         If we connect as a Jabber component, we send the password as an SHA1 hash.  Otherwise
333         we look at the @a auth_type.  If it's AUTH_PLAIN, we send the password as plaintext; if
334         it's AUTH_DIGEST, we send it as a hash.
335
336         At this writing, we only use AUTH_DIGEST.
337 */
338 int session_connect( transport_session* session,
339                 const char* username, const char* password,
340                 const char* resource, int connect_timeout, enum TRANSPORT_AUTH_TYPE auth_type ) {
341
342         // Sanity checks
343         if( ! session ) {
344                 osrfLogWarning(OSRF_LOG_MARK, "session is null in session_connect()" );
345                 return 0;
346         }
347
348         if( session->sock_id != 0 ) {
349                 osrfLogWarning(OSRF_LOG_MARK, "transport session is already open, on socket %d",
350                         session->sock_id );
351                 return 0;
352         }
353
354         // Open a client socket connecting to the Jabber server
355         if(session->port > 0) {   // use TCP
356                 session->sock_id = socket_open_tcp_client(
357                                 session->sock_mgr, session->port, session->server );
358                 if( session->sock_id <= 0 ) {
359                         session->sock_id = 0;
360                         return 0;
361                 }
362         } else if(session->unix_path != NULL) {  // use UNIX domain
363                 session->sock_id = socket_open_unix_client( session->sock_mgr, session->unix_path );
364                 if( session->sock_id <= 0 ) {
365                         session->sock_id = 0;
366                         return 0;
367                 }
368         }
369         else {
370                 osrfLogWarning( OSRF_LOG_MARK, "Can't open session: no port or unix path" );
371                 return 0;
372         }
373
374         const char* server = session->server;
375         int size1 = 0;
376         int size2 = 0;
377
378         /*
379         We establish the session in two stages.
380
381         First we establish an XMPP stream with the Jabber server by sending an opening tag of
382         stream:stream.  This is not a complete XML document.  We don't send the corresponding
383         closing tag until we close the session.
384
385         If the Jabber server responds by sending an opening stream:stream tag of its own, we can
386         proceed to the second stage by sending a second stanza to log in.  This stanza is an XML
387         element with the tag <handshake> (if we're a Jabber component) or <iq> (if we're not),
388         enclosing the username, password, and resource.
389
390         If all goes well, the Jabber server responds with a <handshake> or <iq> stanza of its own,
391         and we're logged in.
392
393         If authentication fails, the Jabber server returns a <stream:error> (if we used a <handshake>
394         or an <iq> of type "error" (if we used an <iq>).
395         */
396         if( session->component ) {
397
398                 /* the first Jabber connect stanza */
399                 char our_hostname[HOST_NAME_MAX + 1] = "";
400                 gethostname(our_hostname, sizeof(our_hostname) );
401                 our_hostname[HOST_NAME_MAX] = '\0';
402                 size1 = 150 + strlen( username ) + strlen( our_hostname );
403                 char stanza1[ size1 ];
404                 snprintf( stanza1, sizeof(stanza1),
405                                 "<stream:stream version='1.0' xmlns:stream='http://etherx.jabber.org/streams' "
406                                 "xmlns='jabber:component:accept' to='%s' from='%s' xml:lang='en'>",
407                                 username, our_hostname );
408
409                 /* send the first stanze */
410                 session->state_machine->connecting = CONNECTING_1;
411
412                 if( socket_send( session->sock_id, stanza1 ) ) {
413                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
414                         socket_disconnect( session->sock_mgr, session->sock_id );
415                         session->sock_id = 0;
416                         return 0;
417                 }
418
419                 /* wait for reply */
420                 socket_wait(session->sock_mgr, connect_timeout, session->sock_id);
421
422                 /* server acknowledges our existence, now see if we can login */
423                 if( session->state_machine->connecting == CONNECTING_2 ) {
424
425                         int ss = buffer_length( session->session_id ) + strlen( password ) + 5;
426                         char hashstuff[ss];
427                         snprintf( hashstuff, sizeof(hashstuff), "%s%s",
428                                         OSRF_BUFFER_C_STR( session->session_id ), password );
429
430                         char* hash = shahash( hashstuff );
431                         size2 = 100 + strlen( hash );
432                         char stanza2[ size2 ];
433                         snprintf( stanza2, sizeof(stanza2), "<handshake>%s</handshake>", hash );
434
435                         if( socket_send( session->sock_id, stanza2 )  ) {
436                                 osrfLogWarning(OSRF_LOG_MARK, "error sending");
437                                 socket_disconnect( session->sock_mgr, session->sock_id );
438                                 session->sock_id = 0;
439                                 return 0;
440                         }
441                 }
442
443         } else { /* we're not a component */
444
445                 /* the first Jabber connect stanza */
446                 size1 = 100 + strlen( server );
447                 char stanza1[ size1 ];
448                 snprintf( stanza1, sizeof(stanza1),
449                                 "<stream:stream to='%s' xmlns='jabber:client' "
450                                 "xmlns:stream='http://etherx.jabber.org/streams'>",
451                         server );
452
453                 /* send the first stanze */
454                 session->state_machine->connecting = CONNECTING_1;
455                 if( socket_send( session->sock_id, stanza1 ) ) {
456                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
457                         socket_disconnect( session->sock_mgr, session->sock_id );
458                         session->sock_id = 0;
459                         return 0;
460                 }
461
462
463                 /* wait for reply */
464                 socket_wait( session->sock_mgr, connect_timeout, session->sock_id ); /* make the timeout smarter XXX */
465
466                 if( auth_type == AUTH_PLAIN ) {
467
468                         /* the second jabber connect stanza including login info*/
469                         size2 = 150 + strlen( username ) + strlen( password ) + strlen( resource );
470                         char stanza2[ size2 ];
471                         snprintf( stanza2, sizeof(stanza2),
472                                         "<iq id='123456789' type='set'><query xmlns='jabber:iq:auth'>"
473                                         "<username>%s</username><password>%s</password><resource>%s</resource></query></iq>",
474                                         username, password, resource );
475
476                         /* server acknowledges our existence, now see if we can login */
477                         if( session->state_machine->connecting == CONNECTING_2 ) {
478                                 if( socket_send( session->sock_id, stanza2 )  ) {
479                                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
480                                         socket_disconnect( session->sock_mgr, session->sock_id );
481                                         session->sock_id = 0;
482                                         return 0;
483                                 }
484                         }
485
486                 } else if( auth_type == AUTH_DIGEST ) {
487
488                         int ss = buffer_length( session->session_id ) + strlen( password ) + 5;
489                         char hashstuff[ss];
490                         snprintf( hashstuff, sizeof(hashstuff), "%s%s", OSRF_BUFFER_C_STR( session->session_id ), password );
491
492                         char* hash = shahash( hashstuff );
493
494                         /* the second jabber connect stanza including login info */
495                         size2 = 150 + strlen( username ) + strlen( hash ) + strlen(resource);
496                         char stanza2[ size2 ];
497                         snprintf( stanza2, sizeof(stanza2),
498                                         "<iq id='123456789' type='set'><query xmlns='jabber:iq:auth'>"
499                                         "<username>%s</username><digest>%s</digest><resource>%s</resource></query></iq>",
500                                         username, hash, resource );
501
502                         /* server acknowledges our existence, now see if we can login */
503                         if( session->state_machine->connecting == CONNECTING_2 ) {
504                                 if( socket_send( session->sock_id, stanza2 )  ) {
505                                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
506                                         socket_disconnect( session->sock_mgr, session->sock_id );
507                                         session->sock_id = 0;
508                                         return 0;
509                                 }
510                         }
511
512                 } else {
513                         osrfLogWarning(OSRF_LOG_MARK, "Invalid auth_type parameter: %d",
514                                         (int) auth_type );
515                         socket_disconnect( session->sock_mgr, session->sock_id );
516                         session->sock_id = 0;
517                         return 0;
518                 }
519
520         } // not component
521
522
523         /* wait for reply to login request */
524         socket_wait( session->sock_mgr, connect_timeout, session->sock_id );
525
526         if( session->state_machine->connected ) {
527                 /* yar! */
528                 return 1;
529         } else {
530                 socket_disconnect( session->sock_mgr, session->sock_id );
531                 session->sock_id = 0;
532                 return 0;
533         }
534 }
535
536 /**
537         @brief Callback function: push a buffer of XML into an XML parser.
538         @param blob Void pointer pointing to the transport_session.
539         @param mgr Pointer to the socket_manager (not used).
540         @param sockid Socket file descriptor (not used)
541         @param data Pointer to a buffer of received data, as a nul-terminated string.
542         @param parent Not applicable.
543
544         The socket_manager calls this function when it reads a buffer's worth of data from
545         the Jabber socket.  The XML parser calls other callback functions when it sees various
546         features of the XML.
547 */
548 static void grab_incoming(void* blob, socket_manager* mgr, int sockid, char* data, int parent) {
549         transport_session* ses = (transport_session*) blob;
550         if( ! ses ) { return; }
551         xmlParseChunk(ses->parser_ctxt, data, strlen(data), 0);
552 }
553
554
555 /**
556         @brief Respond to the beginning of an XML element.
557         @param session Pointer to the transport_session, cast to a void pointer.
558         @param name Name of the XML element.
559         @param atts Pointer to a ragged array containing attributes and values.
560
561         The XML parser calls this when it sees the beginning of an XML element.  We note what
562         element it is by setting the corresponding switch in the state machine, and grab whatever
563         attributes we expect to find.
564 */
565 static void startElementHandler(
566         void *session, const xmlChar *name, const xmlChar **atts) {
567
568         transport_session* ses = (transport_session*) session;
569         if( ! ses ) { return; }
570
571
572         if( strcmp( (char*) name, "message" ) == 0 ) {
573                 ses->state_machine->in_message = 1;
574                 buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) );
575                 buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) );
576
577                 return;
578         }
579
580         if( ses->state_machine->in_message ) {
581
582                 if( strcmp( (char*) name, "opensrf" ) == 0 ) {
583                         buffer_add( ses->router_from_buffer, get_xml_attr( atts, "router_from" ) );
584                         buffer_add( ses->osrf_xid_buffer, get_xml_attr( atts, "osrf_xid" ) );
585                         buffer_add( ses->router_to_buffer, get_xml_attr( atts, "router_to" ) );
586                         buffer_add( ses->router_class_buffer, get_xml_attr( atts, "router_class" ) );
587                         buffer_add( ses->router_command_buffer, get_xml_attr( atts, "router_command" ) );
588                         const char* broadcast = get_xml_attr( atts, "broadcast" );
589                         if( broadcast )
590                                 ses->router_broadcast = atoi( broadcast );
591
592                         return;
593                 }
594
595                 if( strcmp( (char*) name, "body" ) == 0 ) {
596                         ses->state_machine->in_message_body = 1;
597                         return;
598                 }
599
600                 if( strcmp( (char*) name, "subject" ) == 0 ) {
601                         ses->state_machine->in_subject = 1;
602                         return;
603                 }
604
605                 if( strcmp( (char*) name, "thread" ) == 0 ) {
606                         ses->state_machine->in_thread = 1;
607                         return;
608                 }
609
610         }
611
612         if( strcmp( (char*) name, "presence" ) == 0 ) {
613                 ses->state_machine->in_presence = 1;
614                 buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) );
615                 buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) );
616                 return;
617         }
618
619         if( strcmp( (char*) name, "status" ) == 0 ) {
620                 ses->state_machine->in_status = 1;
621                 return;
622         }
623
624
625         if( strcmp( (char*) name, "stream:error" ) == 0 ) {
626                 ses->state_machine->in_error = 1;
627                 ses->state_machine->connected = 0;
628                 osrfLogWarning(  OSRF_LOG_MARK, "Received <stream:error> message from Jabber server" );
629                 return;
630         }
631
632
633         /* first server response from a connect attempt */
634         if( strcmp( (char*) name, "stream:stream" ) == 0 ) {
635                 if( ses->state_machine->connecting == CONNECTING_1 ) {
636                         ses->state_machine->connecting = CONNECTING_2;
637                         buffer_add( ses->session_id, get_xml_attr(atts, "id") );
638                 }
639                 return;
640         }
641
642         if( strcmp( (char*) name, "handshake" ) == 0 ) {
643                 ses->state_machine->connected = 1;
644                 ses->state_machine->connecting = 0;
645                 return;
646         }
647
648
649         if( strcmp( (char*) name, "error" ) == 0 ) {
650                 ses->state_machine->in_message_error = 1;
651                 buffer_add( ses->message_error_type, get_xml_attr( atts, "type" ) );
652                 ses->message_error_code = atoi( get_xml_attr( atts, "code" ) );
653                 osrfLogInfo( OSRF_LOG_MARK, "Received <error> message with type %s and code %d",
654                         OSRF_BUFFER_C_STR( ses->message_error_type ), ses->message_error_code );
655                 return;
656         }
657
658         if( strcmp( (char*) name, "iq" ) == 0 ) {
659                 ses->state_machine->in_iq = 1;
660
661                 const char* type = get_xml_attr(atts, "type");
662
663                 if( strcmp( type, "result") == 0
664                                 && ses->state_machine->connecting == CONNECTING_2 ) {
665                         ses->state_machine->connected = 1;
666                         ses->state_machine->connecting = 0;
667                         return;
668                 }
669
670                 if( strcmp( type, "error") == 0 ) {
671                         osrfLogWarning( OSRF_LOG_MARK,  "Error connecting to jabber" );
672                         return;
673                 }
674         }
675 }
676
677 /**
678         @brief Return the value of a given XML attribute.
679         @param atts Pointer to a NULL terminated array of strings.
680         @param attr_name Name of the attribute you're looking for.
681         @return The value of the attribute if found, or NULL if not.
682
683         In the array to which @a atts points, the zeroth entry is an attribute name, and the
684         one after that is its value.  Subsequent entries alternate between names and values.
685         The last entry is NULL to terminate the list.
686 */
687 static const char* get_xml_attr( const xmlChar** atts, const char* attr_name ) {
688         int i;
689         if (atts != NULL) {
690                 for(i = 0;(atts[i] != NULL);i++) {
691                         if( strcmp( (const char*) atts[i++], attr_name ) == 0 ) {
692                                 if( atts[i] != NULL ) {
693                                         return (const char*) atts[i];
694                                 }
695                         }
696                 }
697         }
698         return NULL;
699 }
700
701
702 /**
703         @brief React to the closing of an XML tag.
704         @param session Pointer to a transport_session, cast to a void pointer.
705         @param name Pointer to the name of the tag that is closing.
706
707         See what kind of tag is closing, and respond accordingly.
708 */
709 static void endElementHandler( void *session, const xmlChar *name) {
710         transport_session* ses = (transport_session*) session;
711         if( ! ses ) { return; }
712
713         // Bypass a level of indirection, since we'll examine the machine repeatedly:
714         jabber_machine* machine = ses->state_machine;
715
716         if( machine->in_message && strcmp( (char*) name, "message" ) == 0 ) {
717
718                 /* pass off the message info the callback */
719                 if( ses->message_callback ) {
720
721                         transport_message* msg =  message_init(
722                                 OSRF_BUFFER_C_STR( ses->body_buffer ),
723                                 OSRF_BUFFER_C_STR( ses->subject_buffer ),
724                                 OSRF_BUFFER_C_STR( ses->thread_buffer ),
725                                 OSRF_BUFFER_C_STR( ses->recipient_buffer ),
726                                 OSRF_BUFFER_C_STR( ses->from_buffer ) );
727
728                         message_set_router_info( msg,
729                                 ses->router_from_buffer->buf,
730                                 ses->router_to_buffer->buf,
731                                 ses->router_class_buffer->buf,
732                                 ses->router_command_buffer->buf,
733                                 ses->router_broadcast );
734
735                         message_set_osrf_xid( msg, ses->osrf_xid_buffer->buf );
736
737                         if( ses->message_error_type->n_used > 0 ) {
738                                 set_msg_error( msg, ses->message_error_type->buf, ses->message_error_code );
739                         }
740
741                         if( msg == NULL ) { return; }
742                         ses->message_callback( ses->user_data, msg );
743                 }
744
745                 machine->in_message = 0;
746                 reset_session_buffers( session );
747                 return;
748         }
749
750         if( machine->in_message_body && strcmp( (const char*) name, "body" ) == 0 ) {
751                 machine->in_message_body = 0;
752                 return;
753         }
754
755         if( machine->in_subject && strcmp( (const char*) name, "subject" ) == 0 ) {
756                 machine->in_subject = 0;
757                 return;
758         }
759
760         if( machine->in_thread && strcmp( (const char*) name, "thread" ) == 0 ) {
761                 machine->in_thread = 0;
762                 return;
763         }
764
765         if( machine->in_iq && strcmp( (const char*) name, "iq" ) == 0 ) {
766                 machine->in_iq = 0;
767                 if( ses->message_error_code > 0 ) {
768                         if( 401 == ses->message_error_code )
769                                 osrfLogWarning( OSRF_LOG_MARK, "Error 401 in IQ packet: not authorized" );
770                         else
771                                 osrfLogWarning( OSRF_LOG_MARK, "Error in IQ packet: code %d",
772                                                 ses->message_error_code );
773                 }
774                 reset_session_buffers( session );
775                 return;
776         }
777
778         if( machine->in_presence && strcmp( (const char*) name, "presence" ) == 0 ) {
779                 machine->in_presence = 0;
780                 /*
781                 if( ses->presence_callback ) {
782                         // call the callback with the status, etc.
783                 }
784                 */
785                 reset_session_buffers( session );
786                 return;
787         }
788
789         if( machine->in_status && strcmp( (const char*) name, "status" ) == 0 ) {
790                 machine->in_status = 0;
791                 return;
792         }
793
794         if( machine->in_message_error && strcmp( (const char*) name, "error" ) == 0 ) {
795                 machine->in_message_error = 0;
796                 return;
797         }
798
799         if( machine->in_error && strcmp( (const char*) name, "stream:error" ) == 0 ) {
800                 machine->in_error = 0;
801                 return;
802         }
803 }
804
805 /**
806         @brief Clear all the buffers of a transport_session.
807         @param ses Pointer to the transport_session whose buffers are to be cleared.
808 */
809 static void reset_session_buffers( transport_session* ses ) {
810         OSRF_BUFFER_RESET( ses->body_buffer );
811         OSRF_BUFFER_RESET( ses->subject_buffer );
812         OSRF_BUFFER_RESET( ses->thread_buffer );
813         OSRF_BUFFER_RESET( ses->from_buffer );
814         OSRF_BUFFER_RESET( ses->recipient_buffer );
815         OSRF_BUFFER_RESET( ses->router_from_buffer );
816         OSRF_BUFFER_RESET( ses->osrf_xid_buffer );
817         OSRF_BUFFER_RESET( ses->router_to_buffer );
818         OSRF_BUFFER_RESET( ses->router_class_buffer );
819         OSRF_BUFFER_RESET( ses->router_command_buffer );
820         OSRF_BUFFER_RESET( ses->message_error_type );
821         OSRF_BUFFER_RESET( ses->session_id );
822         OSRF_BUFFER_RESET( ses->status_buffer );
823 }
824
825 // ------------------------------------------------------------------
826 // takes data out of the body of the message and pushes it into
827 // the appropriate buffer
828 // ------------------------------------------------------------------
829 /**
830         @brief Copy XML text (outside of tags) into the appropriate buffer.
831         @param session Pointer to the transport_session.
832         @param ch Pointer to the text to be copied.
833         @param len How many characters to be copied.
834
835         The XML parser calls this as a callback when it finds text outside of a tag,  We check
836         the state machine to figure out what kind of text it is, and then append it to the
837         corresponding buffer.
838 */
839 static void characterHandler(
840                 void *session, const xmlChar *ch, int len) {
841
842         const char* p = (const char*) ch;
843
844         transport_session* ses = (transport_session*) session;
845         if( ! ses ) { return; }
846
847         jabber_machine* machine = ses->state_machine;
848
849         /* set the various message parts */
850         if( machine->in_message ) {
851
852                 if( machine->in_message_body ) {
853                         buffer_add_n( ses->body_buffer, p, len );
854                 }
855
856                 if( machine->in_subject ) {
857                         buffer_add_n( ses->subject_buffer, p, len );
858                 }
859
860                 if( machine->in_thread ) {
861                         buffer_add_n( ses->thread_buffer, p, len );
862                 }
863         }
864
865         /* set the presence status */
866         if( machine->in_presence && ses->state_machine->in_status ) {
867                 buffer_add_n( ses->status_buffer, p, len );
868         }
869
870         if( machine->in_error ) {
871                 char msg[ len + 1 ];
872                 strncpy( msg, p, len );
873                 msg[ len ] = '\0';
874                 osrfLogWarning( OSRF_LOG_MARK,
875                         "Text of error message received from Jabber: %s", msg );
876         }
877 }
878
879 /**
880         @brief Log a warning from the XML parser.
881         @param session Pointer to a transport_session, cast to a void pointer (not used).
882         @param msg Pointer to a printf-style format string.  Subsequent messages, if any, are
883                 formatted and inserted into the expanded string.
884
885         The XML parser calls this function when it wants to warn about something in the XML.
886 */
887 static void  parseWarningHandler( void *session, const char* msg, ... ) {
888         VA_LIST_TO_STRING(msg);
889         osrfLogWarning( OSRF_LOG_MARK, VA_BUF );
890 }
891
892 /**
893         @brief Log an error from the XML parser.
894         @param session Pointer to a transport_session, cast to a void pointer (not used).
895         @param msg Pointer to a printf-style format string.  Subsequent messages, if any, are
896                 formatted and inserted into the expanded string.
897
898         The XML parser calls this function when it finds an error in the XML.
899 */
900 static void  parseErrorHandler( void *session, const char* msg, ... ){
901         VA_LIST_TO_STRING(msg);
902         osrfLogError( OSRF_LOG_MARK, VA_BUF );
903 }
904
905 /**
906         @brief Disconnect from Jabber, and close the socket.
907         @param session Pointer to the transport_session to be disconnected.
908         @return 0 in all cases.
909 */
910 int session_disconnect( transport_session* session ) {
911         if( session && session->sock_id != 0 ) {
912                 socket_send(session->sock_id, "</stream:stream>");
913                 socket_disconnect(session->sock_mgr, session->sock_id);
914                 session->sock_id = 0;
915         }
916         return 0;
917 }
918