move jabber_state_machine_struct into header to keep 'make check' happy
[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                 session->state_machine->connected = 0;
289         }
290         return ret;
291 }
292
293 /**
294         @brief Convert a transport_message to XML and send it to Jabber.
295         @param session Pointer to the transport_session.
296         @param msg Pointer to a transport_message enclosing the message.
297         @return 0 if successful, or -1 upon error.
298 */
299 int session_send_msg(
300                 transport_session* session, transport_message* msg ) {
301
302         if( ! session ) { return -1; }
303
304         if( ! session->state_machine->connected ) {
305                 osrfLogWarning(OSRF_LOG_MARK, "State machine is not connected in send_msg()");
306                 return -1;
307         }
308
309         message_prepare_xml( msg );
310         return socket_send( session->sock_id, msg->msg_xml );
311
312 }
313
314
315 /**
316         @brief Connect to the Jabber server as a client and open a Jabber session.
317         @param session Pointer to a transport_session.
318         @param username Jabber user name.
319         @param password Jabber password.
320         @param resource name of Jabber resource.
321         @param connect_timeout Timeout interval, in seconds, for receiving data (see notes).
322         @param auth_type An enum: either AUTH_PLAIN or AUTH_DIGEST (see notes).
323         @return 1 if successful, or 0 upon error.
324
325         If @a connect_timeout is -1, wait indefinitely for the Jabber server to respond.  If
326         @a connect_timeout is zero, don't wait at all.  If @a timeout is positive, wait that
327         number of seconds before timing out.  If @a connect_timeout has a negative value other
328         than -1, the results are not well defined.
329
330         The value of @a connect_timeout applies to each of two stages in the logon procedure.
331         Hence the logon may take up to twice the amount of time indicated.
332
333         If we connect as a Jabber component, we send the password as an SHA1 hash.  Otherwise
334         we look at the @a auth_type.  If it's AUTH_PLAIN, we send the password as plaintext; if
335         it's AUTH_DIGEST, we send it as a hash.
336
337         At this writing, we only use AUTH_DIGEST.
338 */
339 int session_connect( transport_session* session,
340                 const char* username, const char* password,
341                 const char* resource, int connect_timeout, enum TRANSPORT_AUTH_TYPE auth_type ) {
342
343         // Sanity checks
344         if( ! session ) {
345                 osrfLogWarning(OSRF_LOG_MARK, "session is null in session_connect()" );
346                 return 0;
347         }
348
349         if( session->sock_id != 0 ) {
350                 osrfLogWarning(OSRF_LOG_MARK, "transport session is already open, on socket %d",
351                         session->sock_id );
352                 return 0;
353         }
354
355         // Open a client socket connecting to the Jabber server
356         if(session->port > 0) {   // use TCP
357                 session->sock_id = socket_open_tcp_client(
358                                 session->sock_mgr, session->port, session->server );
359                 if( session->sock_id <= 0 ) {
360                         session->sock_id = 0;
361                         return 0;
362                 }
363         } else if(session->unix_path != NULL) {  // use UNIX domain
364                 session->sock_id = socket_open_unix_client( session->sock_mgr, session->unix_path );
365                 if( session->sock_id <= 0 ) {
366                         session->sock_id = 0;
367                         return 0;
368                 }
369         }
370         else {
371                 osrfLogWarning( OSRF_LOG_MARK, "Can't open session: no port or unix path" );
372                 return 0;
373         }
374
375         const char* server = session->server;
376         int size1 = 0;
377         int size2 = 0;
378
379         /*
380         We establish the session in two stages.
381
382         First we establish an XMPP stream with the Jabber server by sending an opening tag of
383         stream:stream.  This is not a complete XML document.  We don't send the corresponding
384         closing tag until we close the session.
385
386         If the Jabber server responds by sending an opening stream:stream tag of its own, we can
387         proceed to the second stage by sending a second stanza to log in.  This stanza is an XML
388         element with the tag <handshake> (if we're a Jabber component) or <iq> (if we're not),
389         enclosing the username, password, and resource.
390
391         If all goes well, the Jabber server responds with a <handshake> or <iq> stanza of its own,
392         and we're logged in.
393
394         If authentication fails, the Jabber server returns a <stream:error> (if we used a <handshake>
395         or an <iq> of type "error" (if we used an <iq>).
396         */
397         if( session->component ) {
398
399                 /* the first Jabber connect stanza */
400                 char our_hostname[HOST_NAME_MAX + 1] = "";
401                 gethostname(our_hostname, sizeof(our_hostname) );
402                 our_hostname[HOST_NAME_MAX] = '\0';
403                 size1 = 150 + strlen( username ) + strlen( our_hostname );
404                 char stanza1[ size1 ];
405                 snprintf( stanza1, sizeof(stanza1),
406                                 "<stream:stream version='1.0' xmlns:stream='http://etherx.jabber.org/streams' "
407                                 "xmlns='jabber:component:accept' to='%s' from='%s' xml:lang='en'>",
408                                 username, our_hostname );
409
410                 /* send the first stanze */
411                 session->state_machine->connecting = CONNECTING_1;
412
413                 if( socket_send( session->sock_id, stanza1 ) ) {
414                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
415                         socket_disconnect( session->sock_mgr, session->sock_id );
416                         session->sock_id = 0;
417                         return 0;
418                 }
419
420                 /* wait for reply */
421                 socket_wait(session->sock_mgr, connect_timeout, session->sock_id);
422
423                 /* server acknowledges our existence, now see if we can login */
424                 if( session->state_machine->connecting == CONNECTING_2 ) {
425
426                         int ss = buffer_length( session->session_id ) + strlen( password ) + 5;
427                         char hashstuff[ss];
428                         snprintf( hashstuff, sizeof(hashstuff), "%s%s",
429                                         OSRF_BUFFER_C_STR( session->session_id ), password );
430
431                         char* hash = shahash( hashstuff );
432                         size2 = 100 + strlen( hash );
433                         char stanza2[ size2 ];
434                         snprintf( stanza2, sizeof(stanza2), "<handshake>%s</handshake>", hash );
435
436                         if( socket_send( session->sock_id, stanza2 )  ) {
437                                 osrfLogWarning(OSRF_LOG_MARK, "error sending");
438                                 socket_disconnect( session->sock_mgr, session->sock_id );
439                                 session->sock_id = 0;
440                                 return 0;
441                         }
442                 }
443
444         } else { /* we're not a component */
445
446                 /* the first Jabber connect stanza */
447                 size1 = 100 + strlen( server );
448                 char stanza1[ size1 ];
449                 snprintf( stanza1, sizeof(stanza1),
450                                 "<stream:stream to='%s' xmlns='jabber:client' "
451                                 "xmlns:stream='http://etherx.jabber.org/streams'>",
452                         server );
453
454                 /* send the first stanze */
455                 session->state_machine->connecting = CONNECTING_1;
456                 if( socket_send( session->sock_id, stanza1 ) ) {
457                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
458                         socket_disconnect( session->sock_mgr, session->sock_id );
459                         session->sock_id = 0;
460                         return 0;
461                 }
462
463
464                 /* wait for reply */
465                 socket_wait( session->sock_mgr, connect_timeout, session->sock_id ); /* make the timeout smarter XXX */
466
467                 if( auth_type == AUTH_PLAIN ) {
468
469                         /* the second jabber connect stanza including login info*/
470                         size2 = 150 + strlen( username ) + strlen( password ) + strlen( resource );
471                         char stanza2[ size2 ];
472                         snprintf( stanza2, sizeof(stanza2),
473                                         "<iq id='123456789' type='set'><query xmlns='jabber:iq:auth'>"
474                                         "<username>%s</username><password>%s</password><resource>%s</resource></query></iq>",
475                                         username, password, resource );
476
477                         /* server acknowledges our existence, now see if we can login */
478                         if( session->state_machine->connecting == CONNECTING_2 ) {
479                                 if( socket_send( session->sock_id, stanza2 )  ) {
480                                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
481                                         socket_disconnect( session->sock_mgr, session->sock_id );
482                                         session->sock_id = 0;
483                                         return 0;
484                                 }
485                         }
486
487                 } else if( auth_type == AUTH_DIGEST ) {
488
489                         int ss = buffer_length( session->session_id ) + strlen( password ) + 5;
490                         char hashstuff[ss];
491                         snprintf( hashstuff, sizeof(hashstuff), "%s%s", OSRF_BUFFER_C_STR( session->session_id ), password );
492
493                         char* hash = shahash( hashstuff );
494
495                         /* the second jabber connect stanza including login info */
496                         size2 = 150 + strlen( username ) + strlen( hash ) + strlen(resource);
497                         char stanza2[ size2 ];
498                         snprintf( stanza2, sizeof(stanza2),
499                                         "<iq id='123456789' type='set'><query xmlns='jabber:iq:auth'>"
500                                         "<username>%s</username><digest>%s</digest><resource>%s</resource></query></iq>",
501                                         username, hash, resource );
502
503                         /* server acknowledges our existence, now see if we can login */
504                         if( session->state_machine->connecting == CONNECTING_2 ) {
505                                 if( socket_send( session->sock_id, stanza2 )  ) {
506                                         osrfLogWarning(OSRF_LOG_MARK, "error sending");
507                                         socket_disconnect( session->sock_mgr, session->sock_id );
508                                         session->sock_id = 0;
509                                         return 0;
510                                 }
511                         }
512
513                 } else {
514                         osrfLogWarning(OSRF_LOG_MARK, "Invalid auth_type parameter: %d",
515                                         (int) auth_type );
516                         socket_disconnect( session->sock_mgr, session->sock_id );
517                         session->sock_id = 0;
518                         return 0;
519                 }
520
521         } // not component
522
523
524         /* wait for reply to login request */
525         socket_wait( session->sock_mgr, connect_timeout, session->sock_id );
526
527         if( session->state_machine->connected ) {
528                 /* yar! */
529                 return 1;
530         } else {
531                 socket_disconnect( session->sock_mgr, session->sock_id );
532                 session->sock_id = 0;
533                 return 0;
534         }
535 }
536
537 /**
538         @brief Callback function: push a buffer of XML into an XML parser.
539         @param blob Void pointer pointing to the transport_session.
540         @param mgr Pointer to the socket_manager (not used).
541         @param sockid Socket file descriptor (not used)
542         @param data Pointer to a buffer of received data, as a nul-terminated string.
543         @param parent Not applicable.
544
545         The socket_manager calls this function when it reads a buffer's worth of data from
546         the Jabber socket.  The XML parser calls other callback functions when it sees various
547         features of the XML.
548 */
549 static void grab_incoming(void* blob, socket_manager* mgr, int sockid, char* data, int parent) {
550         transport_session* ses = (transport_session*) blob;
551         if( ! ses ) { return; }
552         xmlParseChunk(ses->parser_ctxt, data, strlen(data), 0);
553 }
554
555
556 /**
557         @brief Respond to the beginning of an XML element.
558         @param session Pointer to the transport_session, cast to a void pointer.
559         @param name Name of the XML element.
560         @param atts Pointer to a ragged array containing attributes and values.
561
562         The XML parser calls this when it sees the beginning of an XML element.  We note what
563         element it is by setting the corresponding switch in the state machine, and grab whatever
564         attributes we expect to find.
565 */
566 static void startElementHandler(
567         void *session, const xmlChar *name, const xmlChar **atts) {
568
569         transport_session* ses = (transport_session*) session;
570         if( ! ses ) { return; }
571
572
573         if( strcmp( (char*) name, "message" ) == 0 ) {
574                 ses->state_machine->in_message = 1;
575                 buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) );
576                 buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) );
577                 buffer_add( ses->router_from_buffer, get_xml_attr( atts, "router_from" ) );
578                 buffer_add( ses->osrf_xid_buffer, get_xml_attr( atts, "osrf_xid" ) );
579                 buffer_add( ses->router_to_buffer, get_xml_attr( atts, "router_to" ) );
580                 buffer_add( ses->router_class_buffer, get_xml_attr( atts, "router_class" ) );
581                 buffer_add( ses->router_command_buffer, get_xml_attr( atts, "router_command" ) );
582                 const char* broadcast = get_xml_attr( atts, "broadcast" );
583                 if( broadcast )
584                         ses->router_broadcast = atoi( broadcast );
585
586                 return;
587         }
588
589         if( ses->state_machine->in_message ) {
590
591                 if( strcmp( (char*) name, "body" ) == 0 ) {
592                         ses->state_machine->in_message_body = 1;
593                         return;
594                 }
595
596                 if( strcmp( (char*) name, "subject" ) == 0 ) {
597                         ses->state_machine->in_subject = 1;
598                         return;
599                 }
600
601                 if( strcmp( (char*) name, "thread" ) == 0 ) {
602                         ses->state_machine->in_thread = 1;
603                         return;
604                 }
605
606         }
607
608         if( strcmp( (char*) name, "presence" ) == 0 ) {
609                 ses->state_machine->in_presence = 1;
610                 buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) );
611                 buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) );
612                 return;
613         }
614
615         if( strcmp( (char*) name, "status" ) == 0 ) {
616                 ses->state_machine->in_status = 1;
617                 return;
618         }
619
620
621         if( strcmp( (char*) name, "stream:error" ) == 0 ) {
622                 ses->state_machine->in_error = 1;
623                 ses->state_machine->connected = 0;
624                 osrfLogWarning(  OSRF_LOG_MARK, "Received <stream:error> message from Jabber server" );
625                 return;
626         }
627
628
629         /* first server response from a connect attempt */
630         if( strcmp( (char*) name, "stream:stream" ) == 0 ) {
631                 if( ses->state_machine->connecting == CONNECTING_1 ) {
632                         ses->state_machine->connecting = CONNECTING_2;
633                         buffer_add( ses->session_id, get_xml_attr(atts, "id") );
634                 }
635                 return;
636         }
637
638         if( strcmp( (char*) name, "handshake" ) == 0 ) {
639                 ses->state_machine->connected = 1;
640                 ses->state_machine->connecting = 0;
641                 return;
642         }
643
644
645         if( strcmp( (char*) name, "error" ) == 0 ) {
646                 ses->state_machine->in_message_error = 1;
647                 buffer_add( ses->message_error_type, get_xml_attr( atts, "type" ) );
648                 ses->message_error_code = atoi( get_xml_attr( atts, "code" ) );
649                 osrfLogInfo( OSRF_LOG_MARK, "Received <error> message with type %s and code %d",
650                         OSRF_BUFFER_C_STR( ses->message_error_type ), ses->message_error_code );
651                 return;
652         }
653
654         if( strcmp( (char*) name, "iq" ) == 0 ) {
655                 ses->state_machine->in_iq = 1;
656
657                 const char* type = get_xml_attr(atts, "type");
658
659                 if( strcmp( type, "result") == 0
660                                 && ses->state_machine->connecting == CONNECTING_2 ) {
661                         ses->state_machine->connected = 1;
662                         ses->state_machine->connecting = 0;
663                         return;
664                 }
665
666                 if( strcmp( type, "error") == 0 ) {
667                         osrfLogWarning( OSRF_LOG_MARK,  "Error connecting to jabber" );
668                         return;
669                 }
670         }
671 }
672
673 /**
674         @brief Return the value of a given XML attribute.
675         @param atts Pointer to a NULL terminated array of strings.
676         @param attr_name Name of the attribute you're looking for.
677         @return The value of the attribute if found, or NULL if not.
678
679         In the array to which @a atts points, the zeroth entry is an attribute name, and the
680         one after that is its value.  Subsequent entries alternate between names and values.
681         The last entry is NULL to terminate the list.
682 */
683 static const char* get_xml_attr( const xmlChar** atts, const char* attr_name ) {
684         int i;
685         if (atts != NULL) {
686                 for(i = 0;(atts[i] != NULL);i++) {
687                         if( strcmp( (const char*) atts[i++], attr_name ) == 0 ) {
688                                 if( atts[i] != NULL ) {
689                                         return (const char*) atts[i];
690                                 }
691                         }
692                 }
693         }
694         return NULL;
695 }
696
697
698 /**
699         @brief React to the closing of an XML tag.
700         @param session Pointer to a transport_session, cast to a void pointer.
701         @param name Pointer to the name of the tag that is closing.
702
703         See what kind of tag is closing, and respond accordingly.
704 */
705 static void endElementHandler( void *session, const xmlChar *name) {
706         transport_session* ses = (transport_session*) session;
707         if( ! ses ) { return; }
708
709         // Bypass a level of indirection, since we'll examine the machine repeatedly:
710         jabber_machine* machine = ses->state_machine;
711
712         if( machine->in_message && strcmp( (char*) name, "message" ) == 0 ) {
713
714                 /* pass off the message info the callback */
715                 if( ses->message_callback ) {
716
717                         transport_message* msg =  message_init(
718                                 OSRF_BUFFER_C_STR( ses->body_buffer ),
719                                 OSRF_BUFFER_C_STR( ses->subject_buffer ),
720                                 OSRF_BUFFER_C_STR( ses->thread_buffer ),
721                                 OSRF_BUFFER_C_STR( ses->recipient_buffer ),
722                                 OSRF_BUFFER_C_STR( ses->from_buffer ) );
723
724                         message_set_router_info( msg,
725                                 ses->router_from_buffer->buf,
726                                 ses->router_to_buffer->buf,
727                                 ses->router_class_buffer->buf,
728                                 ses->router_command_buffer->buf,
729                                 ses->router_broadcast );
730
731                         message_set_osrf_xid( msg, ses->osrf_xid_buffer->buf );
732
733                         if( ses->message_error_type->n_used > 0 ) {
734                                 set_msg_error( msg, ses->message_error_type->buf, ses->message_error_code );
735                         }
736
737                         if( msg == NULL ) { return; }
738                         ses->message_callback( ses->user_data, msg );
739                 }
740
741                 machine->in_message = 0;
742                 reset_session_buffers( session );
743                 return;
744         }
745
746         if( machine->in_message_body && strcmp( (const char*) name, "body" ) == 0 ) {
747                 machine->in_message_body = 0;
748                 return;
749         }
750
751         if( machine->in_subject && strcmp( (const char*) name, "subject" ) == 0 ) {
752                 machine->in_subject = 0;
753                 return;
754         }
755
756         if( machine->in_thread && strcmp( (const char*) name, "thread" ) == 0 ) {
757                 machine->in_thread = 0;
758                 return;
759         }
760
761         if( machine->in_iq && strcmp( (const char*) name, "iq" ) == 0 ) {
762                 machine->in_iq = 0;
763                 if( ses->message_error_code > 0 ) {
764                         if( 401 == ses->message_error_code )
765                                 osrfLogWarning( OSRF_LOG_MARK, "Error 401 in IQ packet: not authorized" );
766                         else
767                                 osrfLogWarning( OSRF_LOG_MARK, "Error in IQ packet: code %d",
768                                                 ses->message_error_code );
769                 }
770                 reset_session_buffers( session );
771                 return;
772         }
773
774         if( machine->in_presence && strcmp( (const char*) name, "presence" ) == 0 ) {
775                 machine->in_presence = 0;
776                 /*
777                 if( ses->presence_callback ) {
778                         // call the callback with the status, etc.
779                 }
780                 */
781                 reset_session_buffers( session );
782                 return;
783         }
784
785         if( machine->in_status && strcmp( (const char*) name, "status" ) == 0 ) {
786                 machine->in_status = 0;
787                 return;
788         }
789
790         if( machine->in_message_error && strcmp( (const char*) name, "error" ) == 0 ) {
791                 machine->in_message_error = 0;
792                 return;
793         }
794
795         if( machine->in_error && strcmp( (const char*) name, "stream:error" ) == 0 ) {
796                 machine->in_error = 0;
797                 return;
798         }
799 }
800
801 /**
802         @brief Clear all the buffers of a transport_session.
803         @param ses Pointer to the transport_session whose buffers are to be cleared.
804 */
805 static void reset_session_buffers( transport_session* ses ) {
806         OSRF_BUFFER_RESET( ses->body_buffer );
807         OSRF_BUFFER_RESET( ses->subject_buffer );
808         OSRF_BUFFER_RESET( ses->thread_buffer );
809         OSRF_BUFFER_RESET( ses->from_buffer );
810         OSRF_BUFFER_RESET( ses->recipient_buffer );
811         OSRF_BUFFER_RESET( ses->router_from_buffer );
812         OSRF_BUFFER_RESET( ses->osrf_xid_buffer );
813         OSRF_BUFFER_RESET( ses->router_to_buffer );
814         OSRF_BUFFER_RESET( ses->router_class_buffer );
815         OSRF_BUFFER_RESET( ses->router_command_buffer );
816         OSRF_BUFFER_RESET( ses->message_error_type );
817         OSRF_BUFFER_RESET( ses->session_id );
818         OSRF_BUFFER_RESET( ses->status_buffer );
819 }
820
821 // ------------------------------------------------------------------
822 // takes data out of the body of the message and pushes it into
823 // the appropriate buffer
824 // ------------------------------------------------------------------
825 /**
826         @brief Copy XML text (outside of tags) into the appropriate buffer.
827         @param session Pointer to the transport_session.
828         @param ch Pointer to the text to be copied.
829         @param len How many characters to be copied.
830
831         The XML parser calls this as a callback when it finds text outside of a tag,  We check
832         the state machine to figure out what kind of text it is, and then append it to the
833         corresponding buffer.
834 */
835 static void characterHandler(
836                 void *session, const xmlChar *ch, int len) {
837
838         const char* p = (const char*) ch;
839
840         transport_session* ses = (transport_session*) session;
841         if( ! ses ) { return; }
842
843         jabber_machine* machine = ses->state_machine;
844
845         /* set the various message parts */
846         if( machine->in_message ) {
847
848                 if( machine->in_message_body ) {
849                         buffer_add_n( ses->body_buffer, p, len );
850                 }
851
852                 if( machine->in_subject ) {
853                         buffer_add_n( ses->subject_buffer, p, len );
854                 }
855
856                 if( machine->in_thread ) {
857                         buffer_add_n( ses->thread_buffer, p, len );
858                 }
859         }
860
861         /* set the presence status */
862         if( machine->in_presence && ses->state_machine->in_status ) {
863                 buffer_add_n( ses->status_buffer, p, len );
864         }
865
866         if( machine->in_error ) {
867                 char msg[ len + 1 ];
868                 strncpy( msg, p, len );
869                 msg[ len ] = '\0';
870                 osrfLogWarning( OSRF_LOG_MARK,
871                         "Text of error message received from Jabber: %s", msg );
872         }
873 }
874
875 /**
876         @brief Log a warning from the XML parser.
877         @param session Pointer to a transport_session, cast to a void pointer (not used).
878         @param msg Pointer to a printf-style format string.  Subsequent messages, if any, are
879                 formatted and inserted into the expanded string.
880
881         The XML parser calls this function when it wants to warn about something in the XML.
882 */
883 static void  parseWarningHandler( void *session, const char* msg, ... ) {
884         VA_LIST_TO_STRING(msg);
885         osrfLogWarning( OSRF_LOG_MARK, VA_BUF );
886 }
887
888 /**
889         @brief Log an error from the XML parser.
890         @param session Pointer to a transport_session, cast to a void pointer (not used).
891         @param msg Pointer to a printf-style format string.  Subsequent messages, if any, are
892                 formatted and inserted into the expanded string.
893
894         The XML parser calls this function when it finds an error in the XML.
895 */
896 static void  parseErrorHandler( void *session, const char* msg, ... ){
897         VA_LIST_TO_STRING(msg);
898         osrfLogError( OSRF_LOG_MARK, VA_BUF );
899 }
900
901 /**
902         @brief Disconnect from Jabber, and close the socket.
903         @param session Pointer to the transport_session to be disconnected.
904         @return 0 in all cases.
905 */
906 int session_disconnect( transport_session* session ) {
907         if( session && session->sock_id != 0 ) {
908                 socket_send(session->sock_id, "</stream:stream>");
909                 socket_disconnect(session->sock_mgr, session->sock_id);
910                 session->sock_id = 0;
911         }
912         return 0;
913 }
914