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