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