1 // ---------------------------------------------------------------------------------
2 // Manages the Jabber session. Data is taken from the TCP object and pushed into
3 // a SAX push parser as it arrives. When key Jabber documetn elements are met,
5 // ---------------------------------------------------------------------------------
6 #include "transport_socket.h"
7 #include "transport_message.h"
8 #include "generic_utils.h"
13 #include <libxml/globals.h>
14 #include <libxml/xmlerror.h>
15 #include <libxml/parser.h>
16 #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
17 #include <libxml/tree.h>
18 #include <libxml/debugXML.h>
19 #include <libxml/xmlmemory.h>
21 #ifndef TRANSPORT_SESSION_H
22 #define TRANSPORT_SESSION_H
24 #define CONNECTING_1 1 /* just starting the connection to Jabber */
25 #define CONNECTING_2 2 /* First <stream> packet sent and <stream> packet received from server */
27 /* Note. these are growing buffers, so all that's necessary is a sane starting point */
28 #define JABBER_BODY_BUFSIZE 4096
29 #define JABBER_SUBJECT_BUFSIZE 64
30 #define JABBER_THREAD_BUFSIZE 64
31 #define JABBER_JID_BUFSIZE 64
32 #define JABBER_STATUS_BUFSIZE 16
34 // ---------------------------------------------------------------------------------
35 // Takes data from the socket handler and pushes it directly into the push parser
36 // ---------------------------------------------------------------------------------
37 void grab_incoming( void * session, char* data );
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 void startElementHandler(
45 void *session, const xmlChar *name, const xmlChar **atts);
47 // ---------------------------------------------------------------------------------
48 // Callback for handling the endElement event. Updates the Jabber state machine
49 // to let us know the element is over.
50 // ---------------------------------------------------------------------------------
51 void endElementHandler( void *session, const xmlChar *name);
53 // ---------------------------------------------------------------------------------
54 // This is where we extract XML text content. In particular, this is useful for
55 // extracting Jabber message bodies.
56 // ---------------------------------------------------------------------------------
57 void characterHandler(
58 void *session, const xmlChar *ch, int len);
60 void parseWarningHandler( void *session, const char* msg, ... );
61 void parseErrorHandler( void *session, const char* msg, ... );
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 */
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 */
84 characterHandler, /* characters */
85 NULL, /* ignorableWhitespace */
86 NULL, /* processingInstruction */
88 parseWarningHandler, /* xmlParserWarning */
89 parseErrorHandler, /* xmlParserError */
90 NULL, /* xmlParserFatalError : unused */
91 NULL, /* getParameterEntity */
92 NULL, /* cdataBlock; */
93 NULL, /* externalSubset; */
96 NULL, /* startElementNs */
97 NULL, /* endElementNs */
98 NULL /* xmlStructuredErrorFunc */
101 // ---------------------------------------------------------------------------------
102 // Our SAX handler pointer.
103 // ---------------------------------------------------------------------------------
104 static const xmlSAXHandlerPtr SAXHandler = &SAXHandlerStruct;
106 // ---------------------------------------------------------------------------------
107 // Jabber state machine. This is how we know where we are in the Jabber
109 // ---------------------------------------------------------------------------------
110 struct jabber_state_machine_struct {
118 int in_message_error;
123 typedef struct jabber_state_machine_struct jabber_machine;
126 enum TRANSPORT_AUTH_TYPE { AUTH_PLAIN, AUTH_DIGEST };
128 // ---------------------------------------------------------------------------------
129 // Transport session. This maintains all the various parts of a session
130 // ---------------------------------------------------------------------------------
131 struct transport_session_struct {
133 /* our socket connection */
134 transport_socket* sock_obj;
135 /* our Jabber state machine */
136 jabber_machine* state_machine;
137 /* our SAX push parser context */
138 xmlParserCtxtPtr parser_ctxt;
140 /* our text buffers for holding text data */
141 growing_buffer* body_buffer;
142 growing_buffer* subject_buffer;
143 growing_buffer* thread_buffer;
144 growing_buffer* from_buffer;
145 growing_buffer* recipient_buffer;
146 growing_buffer* status_buffer;
147 growing_buffer* message_error_type;
148 growing_buffer* session_id;
149 int message_error_code;
151 /* for OILS extenstions */
152 growing_buffer* router_to_buffer;
153 growing_buffer* router_from_buffer;
154 growing_buffer* router_class_buffer;
155 growing_buffer* router_command_buffer;
156 int router_broadcast;
158 /* this can be anything. It will show up in the
159 callbacks for your convenience. Otherwise, it's
163 int component; /* true if we're a component */
165 /* the Jabber message callback */
166 void (*message_callback) ( void* user_data, transport_message* msg );
167 //void (iq_callback) ( void* user_data, transport_iq_message* iq );
169 typedef struct transport_session_struct transport_session;
172 // ------------------------------------------------------------------
173 // Allocates and initializes the necessary transport session
175 // ------------------------------------------------------------------
176 transport_session* init_transport( char* server, int port, void* user_data, int component );
178 // ------------------------------------------------------------------
179 // Returns the value of the given XML attribute
180 // The xmlChar** construct is commonly returned from SAX event
181 // handlers. Pass that in with the name of the attribute you want
183 // ------------------------------------------------------------------
184 char* get_xml_attr( const xmlChar** atts, char* attr_name );
186 // ------------------------------------------------------------------
187 // Waits at most 'timeout' seconds for data to arrive from the
188 // TCP handler. A timeout of -1 means to wait indefinitely.
189 // ------------------------------------------------------------------
190 int session_wait( transport_session* session, int timeout );
192 // ---------------------------------------------------------------------------------
193 // Sends the given Jabber message
194 // ---------------------------------------------------------------------------------
195 int session_send_msg( transport_session* session, transport_message* msg );
197 // ---------------------------------------------------------------------------------
198 // Returns 1 if this session is connected to the jabber server. 0 otherwise
199 // ---------------------------------------------------------------------------------
200 int session_connected( transport_session* );
202 // ------------------------------------------------------------------
203 // Deallocates session memory
204 // ------------------------------------------------------------------
205 int session_free( transport_session* session );
207 // ------------------------------------------------------------------
208 // Connects to the Jabber server. Waits at most connect_timeout
209 // seconds before failing
210 // ------------------------------------------------------------------
211 int session_connect( transport_session* session,
212 const char* username, const char* password,
213 const char* resource, int connect_timeout,
214 enum TRANSPORT_AUTH_TYPE auth_type );
216 int session_disconnect( transport_session* session );
218 int reset_session_buffers( transport_session* session );