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 <opensrf/transport_message.h>
8 #include <opensrf/utils.h>
9 #include <opensrf/log.h>
10 #include <opensrf/socket_bundle.h>
15 #include <libxml/globals.h>
16 #include <libxml/xmlerror.h>
17 #include <libxml/parser.h>
18 #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
19 #include <libxml/tree.h>
20 #include <libxml/debugXML.h>
21 #include <libxml/xmlmemory.h>
23 #ifndef TRANSPORT_SESSION_H
24 #define TRANSPORT_SESSION_H
26 #define CONNECTING_1 1 /* just starting the connection to Jabber */
27 #define CONNECTING_2 2 /* First <stream> packet sent and <stream> packet received from server */
29 /* Note. these are growing buffers, so all that's necessary is a sane starting point */
30 #define JABBER_BODY_BUFSIZE 4096
31 #define JABBER_SUBJECT_BUFSIZE 64
32 #define JABBER_THREAD_BUFSIZE 64
33 #define JABBER_JID_BUFSIZE 64
34 #define JABBER_STATUS_BUFSIZE 16
36 // ---------------------------------------------------------------------------------
37 // Takes data from the socket handler and pushes it directly into the push parser
38 // ---------------------------------------------------------------------------------
39 //void grab_incoming( void * session, char* data );
40 void grab_incoming(void* blob, socket_manager* mgr, int sockid, char* data, int parent);
42 // ---------------------------------------------------------------------------------
43 // Callback for handling the startElement event. Much of the jabber logic occurs
44 // in this and the characterHandler callbacks.
45 // Here we check for the various top level jabber elements: body, iq, etc.
46 // ---------------------------------------------------------------------------------
47 void startElementHandler(
48 void *session, const xmlChar *name, const xmlChar **atts);
50 // ---------------------------------------------------------------------------------
51 // Callback for handling the endElement event. Updates the Jabber state machine
52 // to let us know the element is over.
53 // ---------------------------------------------------------------------------------
54 void endElementHandler( void *session, const xmlChar *name);
56 // ---------------------------------------------------------------------------------
57 // This is where we extract XML text content. In particular, this is useful for
58 // extracting Jabber message bodies.
59 // ---------------------------------------------------------------------------------
60 void characterHandler(
61 void *session, const xmlChar *ch, int len);
63 void parseWarningHandler( void *session, const char* msg, ... );
64 void parseErrorHandler( void *session, const char* msg, ... );
66 // ---------------------------------------------------------------------------------
67 // Tells the SAX parser which functions will be used as event callbacks
68 // ---------------------------------------------------------------------------------
69 static xmlSAXHandler SAXHandlerStruct = {
70 NULL, /* internalSubset */
71 NULL, /* isStandalone */
72 NULL, /* hasInternalSubset */
73 NULL, /* hasExternalSubset */
74 NULL, /* resolveEntity */
76 NULL, /* entityDecl */
77 NULL, /* notationDecl */
78 NULL, /* attributeDecl */
79 NULL, /* elementDecl */
80 NULL, /* unparsedEntityDecl */
81 NULL, /* setDocumentLocator */
82 NULL, /* startDocument */
83 NULL, /* endDocument */
84 startElementHandler, /* startElement */
85 endElementHandler, /* endElement */
87 characterHandler, /* characters */
88 NULL, /* ignorableWhitespace */
89 NULL, /* processingInstruction */
91 parseWarningHandler, /* xmlParserWarning */
92 parseErrorHandler, /* xmlParserError */
93 NULL, /* xmlParserFatalError : unused */
94 NULL, /* getParameterEntity */
95 NULL, /* cdataBlock; */
96 NULL, /* externalSubset; */
99 NULL, /* startElementNs */
100 NULL, /* endElementNs */
101 NULL /* xmlStructuredErrorFunc */
104 // ---------------------------------------------------------------------------------
105 // Our SAX handler pointer.
106 // ---------------------------------------------------------------------------------
107 static const xmlSAXHandlerPtr SAXHandler = &SAXHandlerStruct;
109 // ---------------------------------------------------------------------------------
110 // Jabber state machine. This is how we know where we are in the Jabber
112 // ---------------------------------------------------------------------------------
113 struct jabber_state_machine_struct {
121 int in_message_error;
126 typedef struct jabber_state_machine_struct jabber_machine;
129 enum TRANSPORT_AUTH_TYPE { AUTH_PLAIN, AUTH_DIGEST };
131 // ---------------------------------------------------------------------------------
132 // Transport session. This maintains all the various parts of a session
133 // ---------------------------------------------------------------------------------
134 struct transport_session_struct {
136 /* our socket connection */
137 //transport_socket* sock_obj;
138 socket_manager* sock_mgr;
140 /* our Jabber state machine */
141 jabber_machine* state_machine;
142 /* our SAX push parser context */
143 xmlParserCtxtPtr parser_ctxt;
145 /* our text buffers for holding text data */
146 growing_buffer* body_buffer;
147 growing_buffer* subject_buffer;
148 growing_buffer* thread_buffer;
149 growing_buffer* from_buffer;
150 growing_buffer* recipient_buffer;
151 growing_buffer* status_buffer;
152 growing_buffer* message_error_type;
153 growing_buffer* session_id;
154 int message_error_code;
156 /* for OILS extenstions */
157 growing_buffer* router_to_buffer;
158 growing_buffer* router_from_buffer;
159 growing_buffer* router_class_buffer;
160 growing_buffer* router_command_buffer;
161 growing_buffer* osrf_xid_buffer;
162 int router_broadcast;
164 /* this can be anything. It will show up in the
165 callbacks for your convenience. Otherwise, it's
174 int component; /* true if we're a component */
176 /* the Jabber message callback */
177 void (*message_callback) ( void* user_data, transport_message* msg );
178 //void (iq_callback) ( void* user_data, transport_iq_message* iq );
180 typedef struct transport_session_struct transport_session;
183 // ------------------------------------------------------------------
184 // Allocates and initializes the necessary transport session
186 // If port > 0, then this session uses TCP connection. Otherwise,
187 // if unix_path != NULL, it uses a UNIX domain socket.
188 // ------------------------------------------------------------------
189 transport_session* init_transport( const char* server, int port,
190 const char* unix_path, void* user_data, int component );
192 // ------------------------------------------------------------------
193 // Waits at most 'timeout' seconds for data to arrive from the
194 // TCP handler. A timeout of -1 means to wait indefinitely.
195 // ------------------------------------------------------------------
196 int session_wait( transport_session* session, int timeout );
198 // ---------------------------------------------------------------------------------
199 // Sends the given Jabber message
200 // ---------------------------------------------------------------------------------
201 int session_send_msg( transport_session* session, transport_message* msg );
203 // ---------------------------------------------------------------------------------
204 // Returns 1 if this session is connected to the jabber server. 0 otherwise
205 // ---------------------------------------------------------------------------------
206 int session_connected( transport_session* );
208 // ------------------------------------------------------------------
209 // Deallocates session memory
210 // ------------------------------------------------------------------
211 int session_free( transport_session* session );
213 // ------------------------------------------------------------------
214 // Connects to the Jabber server. Waits at most connect_timeout
215 // seconds before failing
216 // ------------------------------------------------------------------
217 int session_connect( transport_session* session,
218 const char* username, const char* password,
219 const char* resource, int connect_timeout,
220 enum TRANSPORT_AUTH_TYPE auth_type );
222 int session_disconnect( transport_session* session );
224 int reset_session_buffers( transport_session* session );