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