Fixed a bug in the chunking.
[OpenSRF.git] / src / jserver / osrf_chat.c
1 /*
2 Copyright (C) 2005  Georgia Public Library Service
3 Bill Erickson <billserickson@gmail.com>
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14 */
15
16 #include <string.h>
17 #include <stdio.h>
18 #include <time.h>
19
20 /* opensrf headers */
21 #include "opensrf/utils.h"
22 #include "opensrf/osrf_hash.h"
23 #include "opensrf/osrf_list.h"
24 #include "opensrf/log.h"
25 #include "opensrf/xml_utils.h"
26 #include "opensrf/socket_bundle.h"
27 #include "opensrf/sha.h"
28 #include "opensrf/transport_message.h"
29
30 /* libxml2 headers */
31 #include <libxml/parser.h>
32 #include <libxml/tree.h>
33 #include <libxml/globals.h>
34 #include <libxml/xmlerror.h>
35
36 #include "osrf_chat.h"
37
38 /* client to server XML */
39 #define OSRF_CHAT_START_STREAM "<?xml version='1.0'?><stream:stream "\
40         "xmlns:stream='http://etherx.jabber.org/streams' xmlns='jabber:client' "\
41         "from='%s' version='1.0' id='%s'>"
42
43 #define OSRF_CHAT_PARSE_ERROR "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "\
44         "version='1.0'><stream:error xmlns:stream='http://etherx.jabber.org/streams'>"\
45         "<xml-not-well-formed xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>" \
46         "<text xmlns='urn:ietf:params:xml:ns:xmpp-streams'>syntax " \
47         "error</text></stream:error></stream:stream>"
48
49 #define OSRF_CHAT_LOGIN_OK "<iq xmlns='jabber:client' id='0123456789' type='result'/>"
50
51 #define OSRF_CHAT_NO_RECIPIENT "<message xmlns='jabber:client' type='error' from='%s' to='%s'>"\
52         "<error type='cancel' code='404'><item-not-found " \
53         "xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"\
54         "</error><body>NOT ADDING BODY</body></message>"
55
56 /* ---------------------------------------------------------------------------------- */
57 /* server to server XML */
58
59 // client to server init
60 #define OSRF_CHAT_S2S_INIT "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "\
61         "xmlns='jabber:server' xmlns:db='jabber:server:dialback'>"
62
63 // server to client challenge
64 #define OSRF_CHAT_S2S_CHALLENGE "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "\
65         "xmlns='jabber:server' id='%s' xmlns:db='jabber:server:dialback'>"
66
67 // client to server challenge response
68 #define OSRF_CHAT_S2S_RESPONSE "<db:result xmlns:db='jabber:server:dialback' to='%s' from='%s'>%s</db:result>"
69
70 // server to client verify
71 #define OSRF_CHAT_S2S_VERIFY_REQUEST \
72         "<db:verify xmlns:db='jabber:server:dialback' id='%s' from='%s' to='%s'>%s</db:verify>"
73
74 // client to server verify response
75 #define OSRF_CHAT_S2S_VERIFY_RESPONSE \
76         "<db:verify xmlns:db='jabber:server:dialback' type='valid' to='%s' from='%s' id='%s'/>"
77
78 //server to client final verification
79 #define OSRF_CHAT_S2S_VERIFY_FINAL \
80         "<db:result xmlns:db='jabber:server:dialback' type='valid' from='%s' to ='%s'/>"
81
82 /* c2s states */
83 #define OSRF_CHAT_STATE_NONE            0   /* blank node */
84 #define OSRF_CHAT_STATE_CONNECTING      1   /* we have received the opening stream */
85 #define OSRF_CHAT_STATE_CONNECTED       2   /* we have sent the OK/result message */
86
87 /* s2s states */
88 #define OSRF_CHAT_STATE_S2S_CHALLENGE        4   /* client : waiting for the challenge */
89 #define OSRF_CHAT_STATE_S2S_RESPONSE         5   /* server : waiting for the challenge response */
90 #define OSRF_CHAT_STATE_S2S_VERIFY           6   /* client : waiting for verify message */
91 #define OSRF_CHAT_STATE_S2S_VERIFY_RESPONSE  7   /* server : waiting for verify response */
92 #define OSRF_CHAT_STATE_S2S_VERIFY_FINAL     8   /* client : waiting for final verify response */
93
94 /* xml parser states */
95 #define OSRF_CHAT_STATE_INMESSAGE       1
96 #define OSRF_CHAT_STATE_INIQ            2
97 #define OSRF_CHAT_STATE_INUSERNAME      4
98 #define OSRF_CHAT_STATE_INRESOURCE      8
99 #define OSRF_CHAT_STATE_INS2SRESULT    16
100 #define OSRF_CHAT_STATE_INS2SVERIFY    32
101
102 struct osrfChatNodeStruct {
103
104         int sockid;         /* our socket id */
105         int type;           /* 0 for client, 1 for server */
106
107         /* for clients this is the full JID of the client that connected to this server.
108         for servers it's the domain (network id) of the server we're connected to */
109         char* remote;
110
111         int state;          /* for the various stages of connectivity and parsing */
112         int xmlstate;       /* what part of the message are we currently parsing */
113         int inparse;        /* true if we are currently parsing a chunk of XML.  If so, we can't free the node.
114                                we have to cache it and free it later */
115
116         char* to;           /* The JID where the current message is being routed */
117
118         char* domain;       /* the domain, resource, and username of our connecting entity. */
119         char* resource;     /* for s2s nodes, resource and username will be empty . */
120         char* username;
121
122         char* authkey;      /* when doing any auth negotiation, this is the auth seed hash */
123         osrfList* msgs;     /* if we're a server node we may have a pool of messages
124                                waiting to be delivered */
125
126         xmlParserCtxtPtr parserCtx;
127         xmlDocPtr msgDoc;
128         osrfChatServer* parent;
129 };
130
131 /*
132 struct __osrfChatS2SMessageStruct {
133         char* toAddr;
134         char* msgXML;
135 };
136 typedef struct __osrfChatS2SMessageStruct osrfChatS2SMessage;
137 */
138
139 struct osrfChatServerStruct {
140         osrfHash* nodeHash; /* sometimes we need hash (remote id) lookup,
141                                sometimes we need socket id lookup */
142         osrfList* nodeList;
143         osrfList* deadNodes;    /* collection of nodes to free when we get a chance */
144         socket_manager* mgr;
145         char* secret;           /* shared S2S secret */
146         char* domain;           /* the domain this server hosts */
147         int s2sport;
148         int port;
149 };
150
151 //static void osrfChatCacheS2SMessage( char* toAddr, char* msgXML, osrfChatNode* snode );
152
153 static osrfChatNode* osrfNewChatS2SNode( const char* domain, const char* remote );
154 static osrfChatNode* osrfNewChatNode( int sockid, const char* domain );
155 static void osrfChatNodeFree( void* node );
156
157 static void osrfChatHandleData( void* cs,
158                 socket_manager* mgr, int sockid, char* data, int parent_id );
159
160 /* removes dead nodes that have been cached due to mid-parse removals */
161 static void osrfChatCleanupClients( osrfChatServer* server );
162
163 static osrfChatNode* osrfChatAddNode( osrfChatServer* server, int sockid );
164 static void osrfChatRemoveNode( osrfChatServer* server, osrfChatNode* node );
165
166 /** pushes new data into the nodes parser */
167 static int osrfChatPushData( osrfChatServer* server, osrfChatNode* node, char* data );
168
169 static void osrfChatSocketClosed( void* blob, int sockid );
170
171 /**
172         Sends msgXML to the client with remote 'toAddr'.  If we have no connection
173         to 'toAddr' and the domain for 'toAddr' is different from our hosted domain
174         we attempt to send the message to the domain found in 'toAddr'.
175 */
176 static int osrfChatSend( osrfChatServer* cs, osrfChatNode* node, const char* toAddr,
177                                   const char* fromAddr, const char* msgXML );
178 static int osrfChatSendRaw( osrfChatNode* node, const char* xml );
179
180 static void osrfChatNodeFinish( osrfChatServer* server, osrfChatNode* node );
181
182 /* initializes the negotiation of a server to server connection */
183 static int osrfChatInitS2S( osrfChatServer* cs, const char* remote, const char* toAddr,
184                                          const char* msgXML );
185
186 static int osrfChatHandleNewConnection( osrfChatNode* node, const char* name,
187                 const xmlChar** atts );
188 static int osrfChatHandleConnecting( osrfChatNode* node, const char* name, const xmlChar** atts );
189 static int osrfChatHandleConnected( osrfChatNode* node, const char* name, const xmlChar** atts );
190 static int osrfChatHandleS2SChallenge( osrfChatNode* node, const char* name,
191                 const xmlChar** atts );
192 //static int osrfChatHandleS2SResponse( osrfChatNode* node, const char* name,
193 //      const xmlChar** atts );
194
195 static int osrfChatHandleS2SConnected( osrfChatNode* node, const char* nm, const xmlChar**atts );
196
197 static void osrfChatS2SMessageFree(void* n);
198
199 /* generates a random sha1 hex key */
200 static char* osrfChatMkAuthKey();
201
202 static void osrfChatStartStream( void* blob );
203 static void osrfChatStartElement( void* blob, const xmlChar *name, const xmlChar **atts );
204 static void osrfChatEndElement( void* blob, const xmlChar* name );
205 static void osrfChatHandleCharacter(void* blob, const xmlChar *ch, int len);
206 static void osrfChatParseError( void* blob, const char* msg, ... );
207
208 static xmlSAXHandler osrfChatSaxHandlerStruct = {
209         NULL,                       /* internalSubset */
210         NULL,                       /* isStandalone */
211         NULL,                       /* hasInternalSubset */
212         NULL,                       /* hasExternalSubset */
213         NULL,                       /* resolveEntity */
214         NULL,                       /* getEntity */
215         NULL,                       /* entityDecl */
216         NULL,                       /* notationDecl */
217         NULL,                       /* attributeDecl */
218         NULL,                       /* elementDecl */
219         NULL,                       /* unparsedEntityDecl */
220         NULL,                       /* setDocumentLocator */
221         osrfChatStartStream,        /* startDocument */
222         NULL,                       /* endDocument */
223         osrfChatStartElement,       /* startElement */
224         osrfChatEndElement,         /* endElement */
225         NULL,                       /* reference */
226         osrfChatHandleCharacter,    /* characters */
227         NULL,                       /* ignorableWhitespace */
228         NULL,                       /* processingInstruction */
229         NULL,                       /* comment */
230         osrfChatParseError,         /* xmlParserWarning */
231         osrfChatParseError,         /* xmlParserError */
232         NULL,                       /* xmlParserFatalError : unused */
233         NULL,                       /* getParameterEntity */
234         NULL,                       /* cdataBlock; */
235         NULL,                       /* externalSubset; */
236         1,
237         NULL,
238         NULL,                       /* startElementNs */
239         NULL,                       /* endElementNs */
240         NULL                        /* xmlStructuredErrorFunc */
241 };
242
243 static const xmlSAXHandlerPtr osrfChatSaxHandler = &osrfChatSaxHandlerStruct;
244
245 #ifndef HOST_NAME_MAX
246 #define HOST_NAME_MAX 256
247 #endif
248
249 static int osrfChatXMLErrorOcurred = 0;
250
251 /*  This is used by code in osrfChatPushData, but that code is
252         currently commented out.  Uncomment the next line if needed. */
253 //static int osrfChatClientSentDisconnect = 0;
254
255 /* shorter version of strcmp */
256 static int eq(const char* a, const char* b) {
257         return (a && b && !strcmp(a,b));
258 }
259 //#define eq(a,b) ((a && b && !strcmp(a,b)) ? 1 : 0)
260
261 /* gnarly debug function */
262 static void chatdbg( osrfChatServer* server ) {
263
264         if(!server) return;
265         return; /* heavy logging, should only be used in heavy debug mode */
266
267         growing_buffer* buf = buffer_init(256);
268
269         buffer_add(buf, "---------------------------------------------------------------------\n");
270
271         buffer_fadd(buf,
272                 "ChopChop Debug:\n"
273                 "Connections:           %lu\n"
274                 "Named nodes in hash:   %lu\n"
275                 "Domain:                %s\n"
276                 "Port:                  %d\n"
277                 "S2S Port:              %d\n"
278                 "-------------------------------------------------------\n",
279                 osrfListGetCount(server->nodeList), osrfHashGetCount(server->nodeHash),
280                 server->domain, server->port, server->s2sport );
281
282         osrfListIterator* itr = osrfNewListIterator(server->nodeList);
283         osrfChatNode* node;
284
285         while( (node = osrfListIteratorNext(itr)) ) {
286
287                 buffer_fadd( buf,
288                         "sockid:    %d\n"
289                         "Remote:    %s\n"
290                         "State:     %d\n"
291                         "XMLState:  %d\n"
292                         "In Parse:  %d\n"
293                         "to:        %s\n"
294                         "Resource:  %s\n"
295                         "Username:  %s\n"
296                         "Domain:    %s\n"
297                         "Authkey:   %s\n"
298                         "type:      %d\n"
299                         "-------------------------------------------------------\n",
300                         node->sockid, node->remote, node->state, node->xmlstate, node->inparse,
301                         node->to, node->resource, node->username, node->domain, node->authkey, node->type );
302         }
303
304         osrfLogDebug( OSRF_LOG_MARK, "DEBUG:\n%s", buf->buf );
305         buffer_free(buf);
306         osrfListIteratorFree(itr);
307 }
308
309 osrfChatServer* osrfNewChatServer( const char* domain, const char* secret, int s2sport ) {
310         if(!(domain && secret)) return NULL;
311
312         osrfChatServer* server = safe_malloc(sizeof(osrfChatServer));
313
314         server->nodeHash    = osrfNewHash();
315         server->nodeList    = osrfNewList();
316         server->deadNodes   = osrfNewList();
317         server->nodeList->freeItem = &osrfChatNodeFree;
318         server->domain      = strdup(domain);
319         server->secret      = strdup(secret);
320         server->s2sport     = s2sport;
321         server->port        = 0;
322
323         // Build socket manager
324         server->mgr = safe_malloc(sizeof(socket_manager));
325         server->mgr->data_received = &osrfChatHandleData;
326         server->mgr->socket = NULL;
327         server->mgr->blob = server;
328         server->mgr->on_socket_closed = &osrfChatSocketClosed;
329
330         return server;
331 }
332
333 static void osrfChatCleanupClients( osrfChatServer* server ) {
334         if(!server) return;
335         osrfListFree(server->deadNodes);
336         server->deadNodes = osrfNewList();
337 }
338
339
340
341 static osrfChatNode* osrfNewChatNode( int sockid, const char* domain ) {
342         if(sockid < 1 || !domain) return NULL;
343         osrfChatNode* node      = safe_malloc(sizeof(osrfChatNode));
344         node->sockid            = 0;
345         node->remote            = NULL;
346         node->state             = OSRF_CHAT_STATE_NONE;
347         node->xmlstate          = 0;
348         node->inparse           = 0;
349         node->msgs              = NULL; /* only s2s nodes cache messages */
350         node->parserCtx         = xmlCreatePushParserCtxt(osrfChatSaxHandler, node, "", 0, NULL);
351         node->msgDoc            = xmlNewDoc(BAD_CAST "1.0");
352         node->domain = strdup(domain);
353         xmlKeepBlanksDefault(0);
354         node->authkey           = NULL;
355         node->username          = NULL;
356         node->resource          = NULL;
357         node->to                = NULL;
358         node->type = 0;
359         node->parent            = NULL;
360         return node;
361 }
362
363
364 static osrfChatNode* osrfNewChatS2SNode( const char* domain, const char* remote ) {
365         if(!(domain && remote)) return NULL;
366         osrfChatNode* n = osrfNewChatNode( 1, domain );
367         n->state    = OSRF_CHAT_STATE_S2S_CHALLENGE;
368         n->sockid   = -1;
369         n->remote   = strdup(remote);
370         n->msgs     = osrfNewList();
371         n->msgs->freeItem = &osrfChatS2SMessageFree;
372         n->type     = 1;
373         return n;
374 }
375
376 void osrfChatS2SMessageFree(void* n) {
377          free(n);
378 }
379
380 static void osrfChatNodeFree( void* node ) {
381         if(!node) return;
382         osrfChatNode* n = (osrfChatNode*) node;
383
384         /* we can't free messages that are mid-parse because the
385                 we can't free the parser context */
386         if(n->inparse) {
387                 n->inparse = 0;
388                 osrfListPush(n->parent->deadNodes, n);
389                 return;
390         }
391
392         free(n->remote);
393         free(n->to);
394         free(n->username);
395         free(n->resource);
396         free(n->domain);
397         free(n->authkey);
398
399         osrfListFree(n->msgs);
400
401         if(n->parserCtx) {
402                 xmlFreeDoc(n->parserCtx->myDoc);
403                 xmlFreeParserCtxt(n->parserCtx);
404         }
405
406         xmlFreeDoc(n->msgDoc);
407         free(n);
408 }
409
410
411
412 int osrfChatServerConnect( osrfChatServer* cs, int port, int s2sport, char* listenAddr ) {
413         if(!(cs && port && listenAddr)) return -1;
414         cs->port = port;
415         cs->s2sport = s2sport;
416         if( socket_open_tcp_server(cs->mgr, port, listenAddr ) < 0 )
417                 return -1;
418         if( socket_open_tcp_server(cs->mgr, s2sport, listenAddr ) < 0 )
419                 return -1;
420         return 0;
421 }
422
423
424 int osrfChatServerWait( osrfChatServer* server ) {
425         if(!server) return -1;
426         while(1) {
427                 if(socket_wait_all(server->mgr, -1) < 0)
428                         osrfLogWarning( OSRF_LOG_MARK,  "jserver_wait(): socket_wait_all() returned error");
429         }
430         return -1;
431 }
432
433
434 void osrfChatServerFree(osrfChatServer* server ) {
435         if(!server) return;
436         osrfHashFree(server->nodeHash);
437         osrfListFree(server->nodeList);
438         osrfListFree(server->deadNodes);
439         socket_manager_free(server->mgr);
440         free(server->domain);
441         free(server->secret);
442
443         free(server);
444 }
445
446
447 static void osrfChatHandleData( void* cs,
448         socket_manager* mgr, int sockid, char* data, int parent_id ) {
449
450         if(!(cs && mgr && sockid && data)) return;
451
452         osrfChatServer* server = (osrfChatServer*) cs;
453
454         osrfChatNode* node = osrfListGetIndex( server->nodeList, sockid );
455
456         if(node)
457                 osrfLogDebug( OSRF_LOG_MARK, "Found node for sockid %d with state %d",
458                                 sockid, node->state );
459
460         if(!node) {
461                 osrfLogDebug( OSRF_LOG_MARK, "Adding new connection for sockid %d", sockid );
462                 node = osrfChatAddNode( server, sockid );
463         }
464
465         if(node) {
466                 if( (osrfChatPushData( server, node, data ) == -1) ) {
467                         osrfLogError( OSRF_LOG_MARK,
468                                         "Node at socket %d with remote address %s and destination %s, "
469                                         "received bad XML [%s], disconnecting...",
470                                         sockid, node->remote, node->to, data );
471                         osrfChatSendRaw(  node, OSRF_CHAT_PARSE_ERROR );
472                         osrfChatRemoveNode( server, node );
473                 }
474         }
475
476         osrfChatCleanupClients(server); /* clean up old dead clients */
477 }
478
479
480 static void osrfChatSocketClosed( void* blob, int sockid ) {
481         if(!blob) return;
482         osrfChatServer* server = (osrfChatServer*) blob;
483         osrfChatNode* node = osrfListGetIndex(server->nodeList, sockid);
484         osrfChatRemoveNode( server, node );
485 }
486
487 static osrfChatNode* osrfChatAddNode( osrfChatServer* server, int sockid ) {
488         if(!(server && sockid)) return NULL;
489         osrfChatNode* node = osrfNewChatNode(sockid, server->domain);
490         node->parent = server;
491         node->sockid = sockid;
492         osrfListSet( server->nodeList, node, sockid );
493         return node;
494 }
495
496 void osrfChatRemoveNode( osrfChatServer* server, osrfChatNode* node ) {
497         if(!(server && node)) return;
498         socket_disconnect(server->mgr, node->sockid);
499         if(node->remote)
500                 osrfHashRemove( server->nodeHash, node->remote );
501         osrfListRemove( server->nodeList, node->sockid ); /* this will free it */
502 }
503
504 static int osrfChatSendRaw( osrfChatNode* node, const char* msgXML ) {
505         if(!(node && msgXML)) return -1;
506         /* wait at most 3 second for this client to take our data */
507         return socket_send_timeout( node->sockid, msgXML, 3000000 );
508 }
509
510 static void osrfChatNodeFinish( osrfChatServer* server, osrfChatNode* node ) {
511         if(!(server && node)) return;
512         osrfChatSendRaw( node, "</stream:stream>");
513         osrfChatRemoveNode( server, node );
514 }
515
516
517 static int osrfChatSend( osrfChatServer* cs, osrfChatNode* node, const char* toAddr,
518                 const char* fromAddr, const char* msgXML ) {
519         if(!(cs && node && toAddr && msgXML)) return -1;
520
521         int l = strlen(toAddr);
522         char dombuf[l];
523         memset(dombuf, 0, sizeof(dombuf));
524         jid_get_domain( toAddr, dombuf, l );
525
526         if( eq( dombuf, cs->domain ) ) { /* this is to a user we host */
527
528                 osrfLogInfo( OSRF_LOG_MARK, "Sending message on local connection\nfrom: %s\nto: %s",
529                                 fromAddr, toAddr );
530                 osrfChatNode* tonode = osrfHashGet(cs->nodeHash, toAddr);
531                 if(tonode) {
532
533                         /* if we can't send to the recipient (recipient is gone or too busy,
534                          * we drop the recipient and inform the sender that the recipient
535                          * is no more */
536                         if( osrfChatSendRaw( tonode, msgXML ) < 0 ) {
537
538                                 osrfChatRemoveNode( cs, tonode );
539                                 char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
540
541                                 osrfLogError( OSRF_LOG_MARK, "Node failed to function. "
542                                                 "Responding to caller with error: %s", toAddr);
543
544                                 if( osrfChatSendRaw( node, xml ) < 0 ) {
545                                         osrfLogError(OSRF_LOG_MARK, "Sending node is now gone..removing");
546                                         osrfChatRemoveNode( cs, node );
547                                 }
548                                 free(xml);
549                         }
550
551                 } else {
552
553                         /* send an error message saying we don't have this connection */
554                         osrfLogInfo( OSRF_LOG_MARK, "We have no connection for %s", toAddr);
555                         char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
556                         if( osrfChatSendRaw( node, xml ) < 0 )
557                                 osrfChatRemoveNode( cs, node );
558                         free(xml);
559                 }
560
561         } else {
562
563                 osrfChatNode* tonode = osrfHashGet(cs->nodeHash, dombuf);
564                 if(tonode) {
565                         if( tonode->state == OSRF_CHAT_STATE_CONNECTED ) {
566                                 osrfLogDebug( OSRF_LOG_MARK, "Routing message to server %s", dombuf);
567
568                                 if( osrfChatSendRaw( tonode, msgXML ) < 0 ) {
569                                         osrfLogError( OSRF_LOG_MARK, "Node failed to function: %s", toAddr);
570                                         char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
571                                         if( osrfChatSendRaw( node, xml ) < 0 )
572                                                 osrfChatRemoveNode( cs, node );
573                                         free(xml);
574                                         osrfChatRemoveNode( cs, tonode );
575                                 }
576
577                         } else {
578                                 osrfLogInfo( OSRF_LOG_MARK,
579                                                 "Received s2s message and we're still trying to connect...caching");
580                                 osrfListPush( tonode->msgs, strdup(msgXML) );
581                         }
582
583                 } else {
584
585                         if( osrfChatInitS2S( cs, dombuf, toAddr, msgXML ) != 0 ) {
586                                 osrfLogWarning( OSRF_LOG_MARK,
587                                                 "We are unable to connect to remote server %s for recipient %s",
588                                                 dombuf, toAddr);
589                                 char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
590                                 osrfChatSendRaw( node, xml );
591                                 free(xml);
592                         }
593                 }
594         }
595
596         return 0;
597 }
598
599
600 /*
601 static void osrfChatCacheS2SMessage( char* toAddr, char* msgXML, osrfChatNode* snode ) {
602         if(!(toAddr && msgXML)) return;
603         osrfChatS2SMessage* msg = safe_malloc(sizeof(osrfChatS2SMessage));
604         msg->toAddr = strdup(toAddr);
605         msg->msgXML = strdup(msgXML);
606         osrfLogInfo( OSRF_LOG_MARK, "Pushing client message onto s2s queue waiting for connect... ");
607         osrfListPush( snode->msgs, msgXML );
608 }
609 */
610
611
612 static int osrfChatInitS2S( osrfChatServer* cs, const char* remote, const char* toAddr,
613                 const char* msgXML ) {
614         if(!(cs && remote && toAddr && msgXML)) return -1;
615
616         osrfLogInfo( OSRF_LOG_MARK, "Initing server2server connection to domain %s", remote );
617         osrfChatNode* snode = osrfNewChatS2SNode( cs->domain, remote );
618         snode->parent = cs;
619
620         /* try to connect to the remote site */
621         snode->sockid = socket_open_tcp_client(cs->mgr, cs->s2sport, remote);
622         if(snode->sockid < 1) {
623                 osrfLogWarning( OSRF_LOG_MARK, "Unable to connect to remote server at %s", remote );
624                 osrfChatNodeFree( snode );
625                 return -1;
626         }
627
628         /* store the message we were supposed to deliver until we're fully connected */
629         //osrfChatCacheS2SMessage( toAddr, msgXML, snode );
630         osrfListPush( snode->msgs, strdup(msgXML) );
631         osrfHashSet(cs->nodeHash, snode, remote );
632         osrfListSet(cs->nodeList, snode, snode->sockid );
633
634         /* send the initial s2s request */
635         osrfChatSendRaw( snode, OSRF_CHAT_S2S_INIT );
636
637         osrfLogDebug( OSRF_LOG_MARK, "Added new s2s node...");
638         chatdbg(cs);
639
640         return 0;
641 }
642
643
644 /* commence SAX handling code */
645
646 static int osrfChatPushData( osrfChatServer* server, osrfChatNode* node, char* data ) {
647         if(!(node && data)) return -1;
648
649         chatdbg(server);
650
651         osrfLogDebug( OSRF_LOG_MARK, "pushing data into xml parser for node %d with state %d:\n%s",
652                         node->sockid, node->state, data);
653         node->inparse = 1;
654         xmlParseChunk(node->parserCtx, data, strlen(data), 0);
655         node->inparse = 0;
656
657         if(osrfChatXMLErrorOcurred) {
658                 osrfChatXMLErrorOcurred = 0;
659                 return -1;
660         }
661
662         /* we can't do cleanup of the XML handlers while in the middle of a
663                 data push, so set flags in the data push and do the cleanup here */
664         /*
665         if(osrfChatClientSentDisconnect) {
666                 osrfChatClientSentDisconnect  = 0;
667                 osrfChatNodeFinish( server, node );
668         }
669         */
670
671         return 0;
672 }
673
674
675 static void osrfChatStartStream( void* blob ) {
676         osrfLogDebug( OSRF_LOG_MARK, "Starting new client stream...");
677 }
678
679
680 static void osrfChatStartElement( void* blob, const xmlChar *name, const xmlChar **atts ) {
681         if(!(blob && name)) return;
682         osrfChatNode* node = (osrfChatNode*) blob;
683
684         int status = -1;
685         char* nm = (char*) name;
686
687         osrfLogDebug( OSRF_LOG_MARK, "Starting element %s with namespace %s and node state %d",
688                                                  nm, xmlSaxAttr(atts, "xmlns"), node->state );
689
690         switch( node->state ) {
691
692                 case OSRF_CHAT_STATE_NONE:
693                         status = osrfChatHandleNewConnection( node, nm, atts );
694                         osrfLogDebug( OSRF_LOG_MARK, "After NewConnection we have state %d", node->state);
695                         break;
696
697                 case OSRF_CHAT_STATE_CONNECTING:
698                         status = osrfChatHandleConnecting( node, nm, atts );
699                         break;
700
701                 case OSRF_CHAT_STATE_CONNECTED:
702                         status = osrfChatHandleConnected( node, nm, atts );
703                         break;
704
705                 case OSRF_CHAT_STATE_S2S_CHALLENGE:
706                         status = osrfChatHandleS2SChallenge( node, nm, atts );
707                         break;
708
709                 case OSRF_CHAT_STATE_S2S_RESPONSE: /* server waiting for client response to challenge */
710                         if(eq(nm, "db:result")) {
711                                 const char* remote = xmlSaxAttr(atts, "from");
712                                 if(remote) {
713                                         if( node->remote) free( node->remote );
714                                         node->remote = strdup(remote); /* copy off the client's id */
715                                 }
716                                 status = 0;
717                                 node->xmlstate |= OSRF_CHAT_STATE_INS2SRESULT;
718                         } else
719                                 status = -1;
720                         break;
721
722                 case OSRF_CHAT_STATE_S2S_VERIFY:     /* client : waiting for server verify message */
723                         if(eq(nm, "db:verify")) {
724                                 const char* id = xmlSaxAttr( atts, "id" );
725                                 if(id) {
726                                         char* xml = va_list_to_string( OSRF_CHAT_S2S_VERIFY_RESPONSE,
727                                                         node->remote, node->domain, id );
728                                         osrfChatSendRaw( node, xml );
729                                         free(xml);
730                                         node->state = OSRF_CHAT_STATE_S2S_VERIFY_FINAL;
731                                         status = 0;
732                                 }
733                         }
734                         break;
735
736                 case OSRF_CHAT_STATE_S2S_VERIFY_RESPONSE:   /* server waiting for client verify response */
737                 case OSRF_CHAT_STATE_S2S_VERIFY_FINAL: /* client waitig for final verify */
738                         status = osrfChatHandleS2SConnected( node, nm, atts );
739                         break;
740
741         }
742
743         if(status != 0)
744                 osrfChatParseError( node, "We don't know how to handle the XML data received" );
745 }
746
747 #define CHAT_CHECK_VARS(x,y,z) if(!(x && y)) return -1; if(z) osrfLogDebug( OSRF_LOG_MARK, z);
748
749
750
751 int osrfChatHandleS2SConnected( osrfChatNode* node, const char* name, const xmlChar**atts ) {
752         CHAT_CHECK_VARS(node, name, "osrfChatHandleS2SConnected" );
753
754         int status = -1;
755
756         if(eq(name,"db:verify")) { /* server receives verify from client */
757                 char* xml = va_list_to_string(OSRF_CHAT_S2S_VERIFY_FINAL, node->domain, node->remote );
758                 osrfChatSendRaw(node, xml );
759                 free(xml);
760                 status = 0;
761         }
762
763         if(eq(name, "db:result")) {
764                 /* send all the messages that we have queued for this server */
765                 node->state = OSRF_CHAT_STATE_CONNECTED;
766                 osrfListIterator* itr = osrfNewListIterator(node->msgs);
767
768                 const char* xml;
769                 while( (xml = (char*) osrfListIteratorNext(itr)) ) {
770                         xmlDocPtr doc = xmlParseMemory(xml, strlen(xml));
771                         if(doc) {
772                                 char* from = (char*) xmlGetProp(xmlDocGetRootElement(doc), BAD_CAST "from");
773                                 char* to = (char*) xmlGetProp(xmlDocGetRootElement(doc), BAD_CAST "to");
774                                 osrfChatSend( node->parent, node, to, from, xml );
775                                 osrfLogDebug( OSRF_LOG_MARK, "Sending cached message from %s to %s", from, to);
776                                 xmlFree(to); xmlFree(from);
777                                 xmlFreeDoc(doc);
778                         }
779                 }
780
781                 osrfListIteratorFree(itr);
782                 osrfListFree(node->msgs);
783                 node->msgs = NULL;
784                 status = 0;
785         }
786
787         if(status == 0) {
788                 osrfLogInfo( OSRF_LOG_MARK, "Successfully made S2S connection to %s", node->remote );
789                 node->state = OSRF_CHAT_STATE_CONNECTED;
790                 node->xmlstate = 0;
791         }
792
793         return status;
794 }
795
796
797 /** check the namespace of the stream message to see if it's a server or client connection */
798 static int osrfChatHandleNewConnection( osrfChatNode* node, const char* name,
799                 const xmlChar** atts ) {
800         CHAT_CHECK_VARS(node, name, "osrfChatHandleNewConnection()");
801
802         if(!eq(name, "stream:stream"))
803                 return -1;
804
805         if( node->authkey ) free( node->authkey );
806         node->authkey = osrfChatMkAuthKey();
807         const char* ns = xmlSaxAttr(atts, "xmlns");
808         if(!ns)
809                 return -1;
810
811         if(eq(ns, "jabber:client")) { /* client connection */
812
813                 const char* domain = xmlSaxAttr( atts, "to" );
814                 if(!domain)
815                         return -1;
816
817                 if(!eq(domain, node->domain)) {
818                         osrfLogWarning( OSRF_LOG_MARK,
819                                 "Client attempting to connect to invalid domain %s. Our domain is %s",
820                                 domain, node->domain);
821                         return -1;
822                 }
823
824                 char* buf = va_list_to_string( OSRF_CHAT_START_STREAM, domain, node->authkey );
825                 node->state = OSRF_CHAT_STATE_CONNECTING;
826
827                 osrfLogDebug( OSRF_LOG_MARK,
828                                 "Server node %d setting state to OSRF_CHAT_STATE_CONNECTING[%d]",
829                                 node->sockid, node->state );
830
831                 osrfLogDebug( OSRF_LOG_MARK, "Server responding to connect message with\n%s\n", buf );
832                 osrfChatSendRaw( node, buf );
833                 free(buf);
834                 return 0;
835         }
836
837         /* server to server init */
838         if(eq(ns, "jabber:server")) { /* client connection */
839                 osrfLogInfo( OSRF_LOG_MARK,
840                                 "We received a new server 2 server connection, generating auth key...");
841                 char* xml = va_list_to_string( OSRF_CHAT_S2S_CHALLENGE, node->authkey );
842                 osrfChatSendRaw( node, xml );
843                 free(xml);
844                 node->state = OSRF_CHAT_STATE_S2S_RESPONSE; /* the next message should be the response */
845                 node->type = 1;
846                 return 0;
847         }
848
849         return -1;
850 }
851
852
853
854 char* osrfChatMkAuthKey() {
855         char hostname[HOST_NAME_MAX + 1] = "";
856         gethostname(hostname, sizeof(hostname) );
857         hostname[HOST_NAME_MAX] = '\0';
858         char keybuf[112];
859         snprintf(keybuf, sizeof(keybuf), "%d%ld%s", (int) time(NULL), (long) getpid(), hostname);
860         return strdup(shahash(keybuf));
861 }
862
863 static int osrfChatHandleConnecting( osrfChatNode* node, const char* name, const xmlChar** atts ) {
864         CHAT_CHECK_VARS(node, name, "osrfChatHandleConnecting()");
865         osrfLogDebug( OSRF_LOG_MARK, "Handling connect node %s", name );
866
867         if(eq(name, "iq"))
868                 node->xmlstate |= OSRF_CHAT_STATE_INIQ;
869         else if(eq(name,"username"))
870                 node->xmlstate |= OSRF_CHAT_STATE_INUSERNAME;
871         else if(eq(name,"resource"))
872                 node->xmlstate |= OSRF_CHAT_STATE_INRESOURCE;
873         return 0;
874 }
875
876 static int osrfChatHandleConnected( osrfChatNode* node, const char* name, const xmlChar** atts ) {
877         CHAT_CHECK_VARS(node, name, "osrfChatHandleConnected()");
878
879         if(eq(name,"message")) {
880
881                 /* drop the old message and start with a new one */
882                 xmlNodePtr root = xmlNewNode(NULL, BAD_CAST name);
883                 xmlAddAttrs(root, atts);
884                 xmlNodePtr oldRoot = xmlDocSetRootElement(node->msgDoc, root);
885                 free(node->to);
886
887                 const char* to = xmlSaxAttr(atts, "to");
888                 if(!to)
889                         to = "";
890
891                 node->to = strdup(to);
892                 if(oldRoot)
893                         xmlFreeNode(oldRoot);
894                 node->xmlstate = OSRF_CHAT_STATE_INMESSAGE;
895
896         } else {
897
898                 /* all non "message" nodes are simply added to the message */
899                 xmlNodePtr nodep = xmlNewNode(NULL, BAD_CAST name);
900                 xmlAddAttrs(nodep, atts);
901                 xmlAddChild(xmlDocGetRootElement(node->msgDoc), nodep);
902         }
903
904         return 0;
905 }
906
907 /* takes s2s secret, hashdomain, and the s2s auth token */
908 static char* osrfChatGenerateS2SKey(
909                 const char* secret, const char* hashdomain, const char* authtoken ) {
910         if(!(secret && hashdomain && authtoken)) return NULL;
911         osrfLogInfo( OSRF_LOG_MARK, "Generating s2s key with auth token: %s", authtoken );
912         char* a = shahash(secret);
913         osrfLogDebug( OSRF_LOG_MARK, "S2S secret hash: %s", a);
914         char* b = va_list_to_string("%s%s", a, hashdomain);
915         char* c = shahash(b);
916         osrfLogDebug( OSRF_LOG_MARK, "S2S intermediate hash: %s", c);
917         char* d = va_list_to_string("%s%s", c, authtoken);
918         char* e = strdup(shahash(d));
919         free(b); free(d);
920         return e;
921 }
922
923 static int osrfChatHandleS2SChallenge( osrfChatNode* node, const char* name,
924                 const xmlChar** atts ) {
925         CHAT_CHECK_VARS(node, name, "osrfChatHandleS2SChallenge()");
926
927 /* here we respond to the stream challenge */
928         if(eq(name, "stream:stream")) {
929                 const char* id = xmlSaxAttr(atts, "id");
930                 if(id) {
931                         /* we use our domain in the s2s challenge hash */
932                         char* d = osrfChatGenerateS2SKey(node->parent->secret, node->domain, id );
933                         char* e = va_list_to_string(OSRF_CHAT_S2S_RESPONSE, node->remote, node->domain, d );
934                         osrfLogInfo( OSRF_LOG_MARK, "Answering s2s challenge with key:  %s", e );
935                         osrfChatSendRaw( node, e );
936                         free(d); free(e);
937                         node->state = OSRF_CHAT_STATE_S2S_VERIFY;
938                         return 0;
939                 }
940         }
941
942         return -1;
943 }
944
945 /*
946 static int osrfChatHandleS2SResponse( osrfChatNode* node, const char* name,
947                 const xmlChar** atts ) {
948         CHAT_CHECK_VARS(node, name, "osrfChatHandleS2SResponse()");
949
950         if(eq(name, "db:result")) {
951                 node->xmlstate |= OSRF_CHAT_STATE_INS2SRESULT;
952                 return 0;
953         }
954
955         return -1;
956 }
957 */
958
959
960
961 static void osrfChatEndElement( void* blob, const xmlChar* name ) {
962         if(!(blob && name)) return;
963         osrfChatNode* node = (osrfChatNode*) blob;
964
965         char* nm = (char*) name;
966
967         if(eq(nm,"stream:stream")) {
968                 osrfChatNodeFinish( node->parent, node );
969                 return;
970         }
971
972         if( node->state == OSRF_CHAT_STATE_CONNECTED ) {
973                 if(eq(nm, "message")) {
974
975                         xmlNodePtr msg = xmlDocGetRootElement(node->msgDoc);
976                         if(msg && node->type == 0)
977                                 xmlSetProp(msg, BAD_CAST "from", BAD_CAST node->remote );
978                         char* string = xmlDocToString(node->msgDoc, 0 );
979
980                         char* from = (char*) xmlGetProp(msg, BAD_CAST "from");
981                         osrfLogDebug( OSRF_LOG_MARK,  "Routing message to %s\n%s\n", node->to, from, string );
982                         osrfChatSend( node->parent, node, node->to, from, string );
983                         xmlFree(from);
984                         free(string);
985                 }
986         }
987
988         if( node->state == OSRF_CHAT_STATE_CONNECTING ) {
989                 if( node->xmlstate & OSRF_CHAT_STATE_INIQ ) {
990
991                         if(eq(nm, "iq")) {
992                                 node->xmlstate &= ~OSRF_CHAT_STATE_INIQ;
993                                 if( node->remote )
994                                         free( node->remote );
995                                 node->remote = va_list_to_string(
996                                                 "%s@%s/%s", node->username, node->domain, node->resource );
997
998                                 osrfLogInfo( OSRF_LOG_MARK, "%s successfully logged in", node->remote );
999
1000                                 osrfLogDebug( OSRF_LOG_MARK, "Setting remote address to %s", node->remote );
1001                                 osrfChatSendRaw( node, OSRF_CHAT_LOGIN_OK );
1002                                 if(osrfHashGet( node->parent->nodeHash, node->remote ) ) {
1003                                         osrfLogWarning( OSRF_LOG_MARK,
1004                                                         "New node replaces existing node for remote id %s", node->remote);
1005                                         osrfHashRemove(node->parent->nodeHash, node->remote);
1006                                 }
1007                                 osrfHashSet( node->parent->nodeHash, node, node->remote );
1008                                 node->state = OSRF_CHAT_STATE_CONNECTED;
1009                         }
1010                 }
1011         }
1012 }
1013
1014
1015 static void osrfChatHandleCharacter( void* blob, const xmlChar *ch, int len) {
1016         if(!(blob && ch && len)) return;
1017         osrfChatNode* node = (osrfChatNode*) blob;
1018
1019         /*
1020         osrfLogDebug( OSRF_LOG_MARK, "Char Handler: state %d, xmlstate %d, chardata %s",
1021                         node->state, node->xmlstate, (char*) ch );
1022         */
1023
1024         if( node->state == OSRF_CHAT_STATE_CONNECTING ) {
1025                 if( node->xmlstate & OSRF_CHAT_STATE_INIQ ) {
1026
1027                         if( node->xmlstate & OSRF_CHAT_STATE_INUSERNAME ) {
1028                                 free(node->username);
1029                                 node->username = strndup((char*) ch, len);
1030                                 node->xmlstate &= ~OSRF_CHAT_STATE_INUSERNAME;
1031                         }
1032
1033                         if( node->xmlstate & OSRF_CHAT_STATE_INRESOURCE ) {
1034                                 free(node->resource);
1035                                 node->resource = strndup((char*) ch, len);
1036                                 node->xmlstate &= ~OSRF_CHAT_STATE_INRESOURCE;
1037                         }
1038                 }
1039
1040                 return;
1041         }
1042
1043         if( node->state == OSRF_CHAT_STATE_CONNECTED ) {
1044                 xmlNodePtr last = xmlGetLastChild(xmlDocGetRootElement(node->msgDoc));
1045                 xmlNodePtr txt = xmlNewTextLen(ch, len);
1046                 xmlAddChild(last, txt);
1047                 return;
1048         }
1049
1050         if( node->state == OSRF_CHAT_STATE_S2S_RESPONSE &&
1051                         (node->xmlstate & OSRF_CHAT_STATE_INS2SRESULT) ) {
1052
1053                 char* key = strndup((char*) ch, len);
1054                 osrfLogDebug( OSRF_LOG_MARK, "Got s2s key from %s : %s", node->remote, key );
1055                 char* e = osrfChatGenerateS2SKey(node->parent->secret, node->remote, node->authkey );
1056                 osrfLogInfo( OSRF_LOG_MARK,
1057                                 "\nReceived s2s key from server: %s\nKey should be: %s", key, e );
1058
1059                 if(eq(key, e)) {
1060                         char* msg = va_list_to_string(OSRF_CHAT_S2S_VERIFY_REQUEST,
1061                                         node->authkey, node->domain, node->remote, e );
1062                         osrfChatSendRaw(node, msg );
1063                         free(msg);
1064                         node->state = OSRF_CHAT_STATE_S2S_VERIFY_RESPONSE;
1065                         node->xmlstate = 0;
1066
1067                 } else {
1068                         osrfLogWarning( OSRF_LOG_MARK, "Server2Server keys do not match!");
1069                 }
1070
1071                 free( e );
1072                 free( key );
1073
1074                 /* do the hash dance again */
1075         }
1076 }
1077
1078
1079 static void osrfChatParseError( void* blob, const char* msg, ... ) {
1080
1081         osrfChatXMLErrorOcurred = 1;
1082 }