1. Added an osrfHashIterator as a member of osrfRouter, so that
[OpenSRF.git] / src / router / osrf_router.c
1 #include "osrf_router.h"
2
3 /**
4         @file osrf_router.c
5         @brief Implementation of osrfRouter.
6
7         The router opens multiple Jabber sessions for the same username and domain, one for
8         each server class.  The Jabber IDs for these sessions are distinguished by the use of
9         the class names as Jabber resource names.
10
11         For each server class there may be multiple server nodes.
12 */
13
14 /* a router maintains a list of server classes */
15
16 /**
17         @brief Collection of server classes, with connection parameters for Jabber.
18  */
19 struct osrfRouterStruct {
20
21         /** 
22                 @brief Hash store of server classes.
23         
24                 For each entry, the key is the class name, and the corresponding datum is an
25                 osrfRouterClass.
26         */
27         osrfHash* classes;
28         osrfHashIterator* class_itr;  /**< For traversing the list of classes */
29         char* domain;         /**< Domain name of Jabber server. */
30         char* name;           /**< Router's username for the Jabber logon. */
31         char* resource;       /**< Router's resource name for the Jabber logon. */
32         char* password;       /**< Router's password for the Jabber logon. */
33         int port;             /**< Jabber's port number. */
34         sig_atomic_t stop;    /**< To be set by signal handler to interrupt main loop */
35
36         /** Array of client domains that we allow to send requests through us. */
37         osrfStringArray* trustedClients;
38         /** Array of server domains that we allow to register, etc. with us. */
39         osrfStringArray* trustedServers;
40
41         transport_client* connection;
42 };
43
44 /**
45         @brief Maintains a set of server nodes belonging to the same class.
46 */
47 struct _osrfRouterClassStruct {
48         osrfRouter* router;         /**< The osrfRouter that owns this osrfRouterClass. */
49         osrfHashIterator* itr;      /**< Iterator for set of osrfRouterNodes. */
50         /**
51                 @brief Hash store of server nodes.
52
53                 The key of each entry is a node name, and the associated data is an osrfRouterNode.
54                 We install a callback for freeing the entries.
55         */
56         osrfHash* nodes;
57         /** The transport_client used for communicating with this server. */
58         transport_client* connection;
59 };
60 typedef struct _osrfRouterClassStruct osrfRouterClass;
61
62 /**
63         @brief Represents a link to a single server's inbound connection.
64 */
65 struct _osrfRouterNodeStruct {
66         char* remoteId;     /**< Send message to me via this login. */
67         int count;          /**< How many message have been sent to this node. */
68         transport_message* lastMessage;
69 };
70 typedef struct _osrfRouterNodeStruct osrfRouterNode;
71
72 static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* classname );
73 static void osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId );
74 static void osrfRouterHandleCommand( osrfRouter* router, transport_message* msg );
75 static int osrfRouterClassHandleMessage( osrfRouter* router,
76                 osrfRouterClass* rclass, transport_message* msg );
77 static void osrfRouterRemoveClass( osrfRouter* router, const char* classname );
78 static int osrfRouterClassRemoveNode( osrfRouter* router, const char* classname,
79                 const char* remoteId );
80 static void osrfRouterClassFree( char* classname, void* rclass );
81 static void osrfRouterNodeFree( char* remoteId, void* node );
82 static osrfRouterClass* osrfRouterFindClass( osrfRouter* router, const char* classname );
83 static osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass,
84                 const char* remoteId );
85 static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set );
86 static void osrfRouterHandleIncoming( osrfRouter* router );
87 static int osrfRouterClassHandleIncoming( osrfRouter* router,
88                 const char* classname,  osrfRouterClass* class );
89 static transport_message* osrfRouterClassHandleBounce( osrfRouter* router,
90                 const char* classname, osrfRouterClass* rclass, transport_message* msg );
91 static void osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg );
92 static int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg,
93                 osrfMessage* omsg );
94 static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg,
95                 osrfMessage* omsg );
96 static int osrfRouterHandleAppResponse( osrfRouter* router,
97                 transport_message* msg, osrfMessage* omsg, const jsonObject* response );
98 static int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* msg,
99                 osrfMessage* omsg );
100
101 #define ROUTER_REGISTER "register"
102 #define ROUTER_UNREGISTER "unregister"
103
104 #define ROUTER_REQUEST_CLASS_LIST "opensrf.router.info.class.list"
105 #define ROUTER_REQUEST_STATS_NODE_FULL "opensrf.router.info.stats.class.node.all"
106 #define ROUTER_REQUEST_STATS_CLASS_FULL "opensrf.router.info.stats.class.all"
107 #define ROUTER_REQUEST_STATS_CLASS "opensrf.router.info.stats.class"
108 #define ROUTER_REQUEST_STATS_CLASS_SUMMARY "opensrf.router.info.stats.class.summary"
109
110 /**
111         @brief Stop the otherwise infinite main loop of the router.
112         @param router Pointer to the osrfRouter to be stopped.
113
114         To be called by a signal handler.
115 */
116 void router_stop( osrfRouter* router )
117 {
118         if( router )
119                 router->stop = 1;
120 }
121
122 /**
123         @brief Allocate and initialize a new osrfRouter.
124         @param domain Domain name of Jabber server
125         @param name Router's username for the Jabber logon.
126         @param resource Router's resource name for the Jabber logon.
127         @param password Router's password for the Jabber logon.
128         @param port Jabber's port number.
129         @param trustedClients Array of client domains that we allow to send requests through us.
130         @param trustedServers Array of server domains that we allow to register, etc. with us.
131         @return Pointer to the newly allocated osrfRouter.
132
133         Don't connect to Jabber yet.  We'll do that later, upon a call to osrfRouterConnect().
134
135         The calling code is responsible for freeing the osrfRouter by calling osrfRouterFree().
136 */
137 osrfRouter* osrfNewRouter(
138                 const char* domain, const char* name,
139                 const char* resource, const char* password, int port,
140                 osrfStringArray* trustedClients, osrfStringArray* trustedServers ) {
141
142         if(!( domain && name && resource && password && port && trustedClients && trustedServers ))
143                 return NULL;
144
145         osrfRouter* router     = safe_malloc(sizeof(osrfRouter));
146         router->domain         = strdup(domain);
147         router->name           = strdup(name);
148         router->password       = strdup(password);
149         router->resource       = strdup(resource);
150         router->port           = port;
151         router->stop           = 0;
152
153         router->trustedClients = trustedClients;
154         router->trustedServers = trustedServers;
155
156
157         router->classes = osrfNewHash();
158         osrfHashSetCallback(router->classes, &osrfRouterClassFree);
159         router->class_itr = osrfNewHashIterator( router->classes );
160
161         // Prepare to connect to Jabber, as a non-component, over TCP (not UNIX domain).
162         router->connection = client_init( domain, port, NULL, 0 );
163
164         return router;
165 }
166
167 /**
168         @brief Connect to Jabber.
169         @param router Pointer to the osrfRouter to connect to Jabber
170         @return 0 if successful, or -1 on error.
171
172         Allow up to 10 seconds for the logon to succeed.
173
174         We connect over TCP (not over a UNIX domain), as a non-component.
175 */
176 int osrfRouterConnect( osrfRouter* router ) {
177         if(!router) return -1;
178         int ret = client_connect( router->connection, router->name,
179                         router->password, router->resource, 10, AUTH_DIGEST );
180         if( ret == 0 ) return -1;
181         return 0;
182 }
183
184 /**
185         @brief Enter endless loop to receive and respond to input.
186         @param router Pointer to the osrfRouter that's looping.
187         @return 
188
189         On each iteration: wait for incoming messages to arrive on any of our sockets -- i.e.
190         either the top level socket belong to the router or any of the lower level sockets
191         belonging to the classes.  React to the incoming activity as needed.
192
193         We don't exit the loop until we receive a signal to stop, or until we encounter an error.
194 */
195 void osrfRouterRun( osrfRouter* router ) {
196         if(!(router && router->classes)) return;
197
198         int routerfd = client_sock_fd( router->connection );
199         int selectret = 0;
200
201         // Loop until a signal handler sets router->stop
202         while( ! router->stop ) {
203
204                 fd_set set;
205                 int maxfd = _osrfRouterFillFDSet( router, &set );
206                 int numhandled = 0;
207
208                 if( (selectret = select(maxfd + 1, &set, NULL, NULL, NULL)) < 0 ) {
209                         if( EINTR == errno ) {
210                                 if( router->stop ) {
211                                         osrfLogWarning( OSRF_LOG_MARK, "Top level select call interrupted by signal" );
212                                         break;
213                                 }
214                                 else
215                                         continue;    // Irrelevant signal; ignore it
216                         } else {
217                                 osrfLogWarning( OSRF_LOG_MARK, "Top level select call failed with errno %d: %s",
218                                                 errno, strerror( errno ) );
219                                 break;
220                         }
221                 }
222
223                 /* see if there is a top level router message */
224
225                 if( FD_ISSET(routerfd, &set) ) {
226                         osrfLogDebug( OSRF_LOG_MARK, "Top router socket is active: %d", routerfd );
227                         numhandled++;
228                         osrfRouterHandleIncoming( router );
229                 }
230
231                 /* now check each of the connected classes and see if they have data to route */
232                 while( numhandled < selectret ) {
233
234                         osrfRouterClass* class;
235                         osrfHashIterator* itr = router->class_itr;  // remove a layer of indirection
236                         osrfHashIteratorReset( itr );
237
238                         while( (class = osrfHashIteratorNext(itr)) ) {
239
240                                 const char* classname = osrfHashIteratorKey(itr);
241
242                                 if( classname ) {
243
244                                         osrfLogDebug( OSRF_LOG_MARK, "Checking %s for activity...", classname );
245
246                                         int sockfd = client_sock_fd( class->connection );
247                                         if(FD_ISSET( sockfd, &set )) {
248                                                 osrfLogDebug( OSRF_LOG_MARK, "Socket is active: %d", sockfd );
249                                                 numhandled++;
250                                                 osrfRouterClassHandleIncoming( router, classname, class );
251                                         }
252                                 }
253                         } // end while
254                 } // end while
255         } // end while
256 }
257
258
259 /**
260         @brief Handle incoming requests to the router.
261         @param router Pointer to the osrfRouter.
262
263         Read all available input messages from the top-level transport_client.  For each one:
264         if the domain of the sender's Jabber id is on the list of approved domains, pass the
265         message to osrfRouterHandleCommand() (if there's a message) or osrfRouterHandleAppRequest()
266         (if there isn't).  If the domain is @em not on the approved list, log a warning and
267         discard the message.
268 */
269 static void osrfRouterHandleIncoming( osrfRouter* router ) {
270         if(!router) return;
271
272         transport_message* msg = NULL;
273
274         while( (msg = client_recv( router->connection, 0 )) ) {  // for each message
275
276                 if( msg->sender ) {
277
278                         osrfLogDebug(OSRF_LOG_MARK,
279                                 "osrfRouterHandleIncoming(): investigating message from %s", msg->sender);
280
281                         /* if the sender is not on a trusted domain, drop the message */
282                         int len = strlen(msg->sender) + 1;
283                         char domain[len];
284                         jid_get_domain( msg->sender, domain, len - 1 );
285
286                         if(osrfStringArrayContains( router->trustedServers, domain)) {
287
288                                 // If there's a command, obey it.  Otherwise, treat
289                                 // the message as an app session level request.
290                                 if( msg->router_command && *msg->router_command )
291                                         osrfRouterHandleCommand( router, msg );
292                                 else
293                                         osrfRouterHandleAppRequest( router, msg );
294                         }
295                         else
296                                 osrfLogWarning( OSRF_LOG_MARK, 
297                                                 "Received message from un-trusted server domain %s", msg->sender);
298                 }
299
300                 message_free(msg);
301         }
302 }
303
304 /**
305         @brief Handle incoming requests to a router class.
306         @param router Pointer to the osrfRouter.
307         @param classname Class name.
308         @param class Pointer to an osrfRouterClass.
309
310         Make sure sender is a trusted client.
311 */
312 static int osrfRouterClassHandleIncoming( osrfRouter* router, const char* classname,
313                 osrfRouterClass* class ) {
314         if(!(router && class)) return -1;
315
316         transport_message* msg;
317         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleIncoming()");
318
319         while( (msg = client_recv( class->connection, 0 )) ) {
320
321                 osrfLogSetXid(msg->osrf_xid);
322
323                 if( msg->sender ) {
324
325                         osrfLogDebug(OSRF_LOG_MARK,
326                                 "osrfRouterClassHandleIncoming(): investigating message from %s", msg->sender);
327
328                         /* if the client is not from a trusted domain, drop the message */
329                         int len = strlen(msg->sender) + 1;
330                         char domain[len];
331                         memset(domain, 0, sizeof(domain));
332                         jid_get_domain( msg->sender, domain, len - 1 );
333
334                         if(osrfStringArrayContains( router->trustedClients, domain)) {
335
336                                 transport_message* bouncedMessage = NULL;
337                                 if( msg->is_error )  {
338
339                                         /* handle bounced message */
340                                         if( !(bouncedMessage = osrfRouterClassHandleBounce( router, classname,
341                                                         class, msg )) )
342                                                 return -1; /* we have no one to send the requested message to */
343
344                                         message_free( msg );
345                                         msg = bouncedMessage;
346                                 }
347                                 osrfRouterClassHandleMessage( router, class, msg );
348
349                         } else {
350                                 osrfLogWarning( OSRF_LOG_MARK, 
351                                                 "Received client message from untrusted client domain %s", domain );
352                         }
353                 }
354
355                 osrfLogClearXid();
356                 message_free( msg );
357         }
358
359         return 0;
360 }
361
362 /**
363         @brief Handle a top level router command.
364         @param router Pointer to the osrfRouter.
365         @param msg Pointer to the transport_message to be handled.
366
367         Currently supported commands:
368         - "register" -- Add a server class and/or a server node to our lists.
369         - "unregister" -- Remove a server class (and any associated nodes) from our list.
370 */
371 static void osrfRouterHandleCommand( osrfRouter* router, transport_message* msg ) {
372         if(!(router && msg && msg->router_class)) return;
373
374         if( !strcmp( msg->router_command, ROUTER_REGISTER ) ) {
375
376                 osrfLogInfo( OSRF_LOG_MARK, "Registering class %s", msg->router_class );
377
378                 // Add the server class to the list, if it isn't already there
379                 osrfRouterClass* class = osrfRouterFindClass( router, msg->router_class );
380                 if(!class)
381                         class = osrfRouterAddClass( router, msg->router_class );
382
383                 // Add the node to the osrfRouterClass's list, if it isn't already there
384                 if(class && ! osrfRouterClassFindNode( class, msg->sender ) )
385                         osrfRouterClassAddNode( class, msg->sender );
386
387         } else if( !strcmp( msg->router_command, ROUTER_UNREGISTER ) ) {
388
389                 if( msg->router_class && *msg->router_class ) {
390                         osrfLogInfo( OSRF_LOG_MARK, "Unregistering router class %s", msg->router_class );
391                         osrfRouterClassRemoveNode( router, msg->router_class, msg->sender );
392                 }
393         }
394 }
395
396
397 /**
398         @brief Adds an osrfRouterClass to a router, and open a connection for it.
399         @param router Pointer to the osrfRouter.
400         @param classname The name of the class this node handles.
401         @return A pointer to the new osrfRouterClass, or NULL upon error.
402
403         Open a Jabber session to be used for this server class.  The Jabber ID incorporates the
404         class name as the resource name.
405 */
406 static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* classname ) {
407         if(!(router && router->classes && classname)) return NULL;
408
409         osrfRouterClass* class = safe_malloc(sizeof(osrfRouterClass));
410         class->nodes = osrfNewHash();
411         class->itr = osrfNewHashIterator(class->nodes);
412         osrfHashSetCallback(class->nodes, &osrfRouterNodeFree);
413         class->router = router;
414
415         class->connection = client_init( router->domain, router->port, NULL, 0 );
416
417         if(!client_connect( class->connection, router->name,
418                         router->password, classname, 10, AUTH_DIGEST ) ) {
419                 // Cast away the constness of classname.  Though ugly, this
420                 // cast is benign because osrfRouterClassFree doesn't actually
421                 // write through the pointer.  We can't readily change its
422                 // signature because it is used for a function pointer, and
423                 // we would have to change other signatures the same way.
424                 osrfRouterClassFree( (char *) classname, class );
425                 return NULL;
426         }
427
428         osrfHashSet( router->classes, class, classname );
429         return class;
430 }
431
432
433 /**
434         @brief Add a new server node to an osrfRouterClass.
435         @param rclass Pointer to the osrfRouterClass to add the node to.
436         @param remoteId The remote login of the osrfRouterNode.
437 */
438 static void osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId ) {
439         if(!(rclass && rclass->nodes && remoteId)) return;
440
441         osrfLogInfo( OSRF_LOG_MARK, "Adding router node for remote id %s", remoteId );
442
443         osrfRouterNode* node = safe_malloc(sizeof(osrfRouterNode));
444         node->count = 0;
445         node->lastMessage = NULL;
446         node->remoteId = strdup(remoteId);
447
448         osrfHashSet( rclass->nodes, node, remoteId );
449 }
450
451 /* copy off the lastMessage, remove the offending node, send error if it's tht last node
452         ? return NULL if it's the last node ?
453 */
454
455 /* handles case where router node is not longer reachable.  copies over the
456         data from the last sent message and returns a newly crafted suitable for treating
457         as a newly inconing message.  Removes the dead node and If there are no more
458         nodes to send the new message to, returns NULL.
459 */
460 static transport_message* osrfRouterClassHandleBounce( osrfRouter* router,
461                 const char* classname, osrfRouterClass* rclass, transport_message* msg ) {
462
463         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleBounce()");
464
465         osrfLogInfo( OSRF_LOG_MARK, "Received network layer error message from %s", msg->sender );
466         osrfRouterNode* node = osrfRouterClassFindNode( rclass, msg->sender );
467         transport_message* lastSent = NULL;
468
469         if( node && osrfHashGetCount(rclass->nodes) == 1 ) { /* the last node is dead */
470
471                 if( node->lastMessage ) {
472                         osrfLogWarning( OSRF_LOG_MARK,
473                                         "We lost the last node in the class, responding with error and removing...");
474
475                         transport_message* error = message_init(
476                                 node->lastMessage->body, node->lastMessage->subject,
477                                 node->lastMessage->thread, node->lastMessage->router_from,
478                                 node->lastMessage->recipient );
479                         message_set_osrf_xid(error, node->lastMessage->osrf_xid);
480                         set_msg_error( error, "cancel", 501 );
481
482                         /* send the error message back to the original sender */
483                         client_send_message( rclass->connection, error );
484                         message_free( error );
485                 }
486
487                 return NULL;
488
489         } else {
490
491                 if( node ) {
492                         if( node->lastMessage ) {
493                                 osrfLogDebug( OSRF_LOG_MARK, "Cloning lastMessage so next node can send it");
494                                 lastSent = message_init( node->lastMessage->body,
495                                         node->lastMessage->subject, node->lastMessage->thread, "", node->lastMessage->router_from );
496                                 message_set_router_info( lastSent, node->lastMessage->router_from, NULL, NULL, NULL, 0 );
497                         message_set_osrf_xid( lastSent, node->lastMessage->osrf_xid );
498                         }
499                 } else {
500
501                         osrfLogInfo(OSRF_LOG_MARK, "network error occurred after we removed the class.. ignoring");
502                         return NULL;
503                 }
504         }
505
506         /* remove the dead node */
507         osrfRouterClassRemoveNode( router, classname, msg->sender);
508         return lastSent;
509 }
510
511
512 /*
513         Handles class level requests
514         If we get a regular message, we send it to the next node in the list of nodes
515         if we get an error, it's a bounce back from a previous attempt.  We take the
516         body and thread from the last sent on the node that had the bounced message
517         and propogate them on to the new message being sent
518         @return 0 on success
519 */
520 static int osrfRouterClassHandleMessage(
521                 osrfRouter* router, osrfRouterClass* rclass, transport_message* msg ) {
522         if(!(router && rclass && msg)) return -1;
523
524         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleMessage()");
525
526         osrfRouterNode* node = osrfHashIteratorNext( rclass->itr );
527         if(!node) {
528                 osrfHashIteratorReset(rclass->itr);
529                 node = osrfHashIteratorNext( rclass->itr );
530         }
531
532         if(node) {
533
534                 transport_message* new_msg= message_init( msg->body,
535                                 msg->subject, msg->thread, node->remoteId, msg->sender );
536                 message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 );
537                 message_set_osrf_xid( new_msg, msg->osrf_xid );
538
539                 osrfLogInfo( OSRF_LOG_MARK,  "Routing message:\nfrom: [%s]\nto: [%s]",
540                                 new_msg->router_from, new_msg->recipient );
541
542                 message_free( node->lastMessage );
543                 node->lastMessage = new_msg;
544
545                 if ( client_send_message( rclass->connection, new_msg ) == 0 )
546                         node->count++;
547
548                 else {
549                         message_prepare_xml(new_msg);
550                         osrfLogWarning( OSRF_LOG_MARK, "Error sending message from %s to %s\n%s",
551                                         new_msg->sender, new_msg->recipient, new_msg->msg_xml );
552                 }
553
554         }
555
556         return 0;
557 }
558
559
560 /**
561         @brief Remove a given osrfRouterClass from an osrfRouter
562         @param router Pointer to the osrfRouter.
563         @param classname The name of the class to be removed.
564
565         A callback function, installed in the osrfHash, frees the osrfRouterClass and any
566         associated nodes.
567 */
568 static void osrfRouterRemoveClass( osrfRouter* router, const char* classname ) {
569         if( router && router->classes && classname ) {
570                 osrfLogInfo( OSRF_LOG_MARK, "Removing router class %s", classname );
571                 osrfHashRemove( router->classes, classname );
572         }
573 }
574
575
576 /*
577         Removes the given node from the class.  Also, if this is that last node in the set,
578         removes the class from the router
579         @return 0 on successful removal with no class removal
580         @return 1 on successful remove with class removal
581         @return -1 error on removal
582 */
583 static int osrfRouterClassRemoveNode(
584                 osrfRouter* router, const char* classname, const char* remoteId ) {
585
586         if(!(router && router->classes && classname && remoteId)) return 0;
587
588         osrfLogInfo( OSRF_LOG_MARK, "Removing router node %s", remoteId );
589
590         osrfRouterClass* class = osrfRouterFindClass( router, classname );
591
592         if( class ) {
593
594                 osrfHashRemove( class->nodes, remoteId );
595                 if( osrfHashGetCount(class->nodes) == 0 ) {
596                         osrfRouterRemoveClass( router, classname );
597                         return 1;
598                 }
599
600                 return 0;
601         }
602
603         return -1;
604 }
605
606
607 /**
608         @brief Free a router class object.
609         @param classname Class name.
610         @param c Pointer to the osrfRouterClass, cast to a void pointer.
611
612         This function is designated to the osrfHash as a callback.
613 */
614 static void osrfRouterClassFree( char* classname, void* c ) {
615         if(!(classname && c)) return;
616         osrfRouterClass* rclass = (osrfRouterClass*) c;
617         client_disconnect( rclass->connection );
618         client_free( rclass->connection );
619
620         osrfHashIteratorReset( rclass->itr );
621         osrfRouterNode* node;
622
623         while( (node = osrfHashIteratorNext(rclass->itr)) )
624                 osrfHashRemove( rclass->nodes, node->remoteId );
625
626         osrfHashIteratorFree(rclass->itr);
627         osrfHashFree(rclass->nodes);
628
629         free(rclass);
630 }
631
632 /**
633         @brief Free an osrfRouterNode.
634         @param remoteId Name of router (not used).
635         @param n Pointer to the osrfRouterNode to be freed, cast to a void pointer.
636
637         This is a callback installed in an osrfHash (the nodes member of an osrfRouterClass).
638 */
639 static void osrfRouterNodeFree( char* remoteId, void* n ) {
640         if(!n) return;
641         osrfRouterNode* node = (osrfRouterNode*) n;
642         free(node->remoteId);
643         message_free(node->lastMessage);
644         free(node);
645 }
646
647
648 void osrfRouterFree( osrfRouter* router ) {
649         if(!router) return;
650
651         osrfHashIteratorFree( router->class_itr);
652         osrfHashFree(router->classes);
653         free(router->domain);
654         free(router->name);
655         free(router->resource);
656         free(router->password);
657
658         osrfStringArrayFree( router->trustedClients );
659         osrfStringArrayFree( router->trustedServers );
660
661         client_free( router->connection );
662         free(router);
663 }
664
665
666
667 /*
668         Finds the class associated with the given class name in the list of classes
669 */
670 static osrfRouterClass* osrfRouterFindClass( osrfRouter* router, const char* classname ) {
671         if(!( router && router->classes && classname )) return NULL;
672         return (osrfRouterClass*) osrfHashGet( router->classes, classname );
673 }
674
675
676 /*
677         Finds the router node within this class with the given remote id
678 */
679 static osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass,
680                 const char* remoteId ) {
681         if(!(rclass && remoteId))  return NULL;
682         return (osrfRouterNode*) osrfHashGet( rclass->nodes, remoteId );
683 }
684
685
686 /*
687         Clears and populates the provided fd_set* with file descriptors
688         from the router's top level connection as well as each of the
689         router class connections
690         @return The largest file descriptor found in the filling process
691 */
692 /**
693         @brief Fill an fd_set with all the sockets owned by the osrfRouter.
694         @param router Pointer to the osrfRouter whose sockets are to be used.
695         @param set Pointer to the fd_set that is to be filled.
696         @return The largest file descriptor loaded into the fd_set; or -1 upon error.
697
698         There's one socket for the osrfRouter as a whole, and one for each osrfRouterClass
699         that belongs to it.  We load them all.
700 */
701 static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set ) {
702         if(!(router && router->classes && set)) return -1;
703
704         FD_ZERO(set);
705         int maxfd = client_sock_fd( router->connection );
706         FD_SET(maxfd, set);
707
708         int sockid;
709
710         osrfRouterClass* class = NULL;
711         osrfHashIterator* itr = osrfNewHashIterator(router->classes);
712
713         while( (class = osrfHashIteratorNext(itr)) ) {
714                 const char* classname = osrfHashIteratorKey(itr);
715
716                 if( classname && (class = osrfRouterFindClass( router, classname )) ) {
717                         sockid = client_sock_fd( class->connection );
718
719                         if( osrfUtilsCheckFileDescriptor( sockid ) ) {
720
721                                 osrfLogWarning(OSRF_LOG_MARK,
722                                         "Removing router class '%s' because of a bad top-level file descriptor [%d]",
723                                         classname, sockid );
724                                 osrfRouterRemoveClass( router, classname );
725
726                         } else {
727                                 if( sockid > maxfd ) maxfd = sockid;
728                                 FD_SET(sockid, set);
729                         }
730                 }
731         }
732
733         osrfHashIteratorFree(itr);
734         return maxfd;
735 }
736
737 /*
738         handles messages that don't have a 'router_command' set.  They are assumed to
739         be app request messages
740 */
741 static void osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg ) {
742
743         int T = 32;
744         osrfMessage* arr[T];
745         memset(arr, 0, sizeof(arr));
746
747         int num_msgs = osrf_message_deserialize( msg->body, arr, T );
748         osrfMessage* omsg = NULL;
749
750         int i;
751         for( i = 0; i != num_msgs; i++ ) {
752
753                 if( !(omsg = arr[i]) ) continue;
754
755                 switch( omsg->m_type ) {
756
757                         case CONNECT:
758                                 osrfRouterRespondConnect( router, msg, omsg );
759                                 break;
760
761                         case REQUEST:
762                                 osrfRouterProcessAppRequest( router, msg, omsg );
763                                 break;
764
765                         default: break;
766                 }
767
768                 osrfMessageFree( omsg );
769         }
770
771         return;
772 }
773
774 static int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg,
775                 osrfMessage* omsg ) {
776         if(!(router && msg && omsg)) return -1;
777
778         osrfMessage* success = osrf_message_init( STATUS, omsg->thread_trace, omsg->protocol );
779
780         osrfLogDebug( OSRF_LOG_MARK, "router received a CONNECT message from %s", msg->sender );
781
782         osrf_message_set_status_info(
783                 success, "osrfConnectStatus", "Connection Successful", OSRF_STATUS_OK );
784
785         char* data = osrf_message_serialize(success);
786
787         transport_message* return_m = message_init(
788                 data, "", msg->thread, msg->sender, "" );
789
790         client_send_message(router->connection, return_m);
791
792         free(data);
793         osrfMessageFree(success);
794         message_free(return_m);
795
796         return 0;
797 }
798
799
800
801 static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg,
802                 osrfMessage* omsg ) {
803
804         if(!(router && msg && omsg && omsg->method_name)) return -1;
805
806         osrfLogInfo( OSRF_LOG_MARK, "Router received app request: %s", omsg->method_name );
807
808         jsonObject* jresponse = NULL;
809         if(!strcmp( omsg->method_name, ROUTER_REQUEST_CLASS_LIST )) {
810
811                 int i;
812                 jresponse = jsonNewObjectType(JSON_ARRAY);
813
814                 osrfStringArray* keys = osrfHashKeys( router->classes );
815                 for( i = 0; i != keys->size; i++ )
816                         jsonObjectPush( jresponse, jsonNewObject(osrfStringArrayGetString( keys, i )) );
817                 osrfStringArrayFree(keys);
818
819
820         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS_SUMMARY )) {
821
822                 osrfRouterClass* class;
823                 osrfRouterNode* node;
824                 int count = 0;
825
826                 char* classname = jsonObjectToSimpleString( jsonObjectGetIndex( omsg->_params, 0 ) );
827
828                 if (!classname)
829                         return -1;
830
831                 class = osrfHashGet(router->classes, classname);
832                 free(classname);
833
834                 osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
835                 while( (node = osrfHashIteratorNext(node_itr)) ) {
836                         count += node->count;
837                         //jsonObjectSetKey( class_res, node->remoteId, jsonNewNumberObject( (double) node->count ) );
838                 }
839                 osrfHashIteratorFree(node_itr);
840
841                 jresponse = jsonNewNumberObject( (double) count );
842
843         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS )) {
844
845                 osrfRouterClass* class;
846                 osrfRouterNode* node;
847
848                 char* classname = jsonObjectToSimpleString( jsonObjectGetIndex( omsg->_params, 0 ) );
849
850                 if (!classname)
851                         return -1;
852
853                 jresponse = jsonNewObjectType(JSON_HASH);
854                 class = osrfHashGet(router->classes, classname);
855                 free(classname);
856
857                 osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
858                 while( (node = osrfHashIteratorNext(node_itr)) ) {
859                         jsonObjectSetKey( jresponse, node->remoteId,
860                                         jsonNewNumberObject( (double) node->count ) );
861                 }
862                 osrfHashIteratorFree(node_itr);
863
864         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS_FULL )) {
865
866                 osrfRouterClass* class;
867                 osrfRouterNode* node;
868                 jresponse = jsonNewObjectType(JSON_HASH);
869
870                 osrfHashIterator* class_itr = osrfNewHashIterator(router->classes);
871                 while( (class = osrfHashIteratorNext(class_itr)) ) {
872
873                         jsonObject* class_res = jsonNewObjectType(JSON_HASH);
874                         const char* classname = osrfHashIteratorKey(class_itr);
875
876                         osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
877                         while( (node = osrfHashIteratorNext(node_itr)) ) {
878                                 jsonObjectSetKey( class_res, node->remoteId,
879                                                 jsonNewNumberObject( (double) node->count ) );
880                         }
881                         osrfHashIteratorFree(node_itr);
882
883                         jsonObjectSetKey( jresponse, classname, class_res );
884                 }
885
886                 osrfHashIteratorFree(class_itr);
887
888         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_NODE_FULL )) {
889
890                 osrfRouterClass* class;
891                 osrfRouterNode* node;
892                 int count;
893                 jresponse = jsonNewObjectType(JSON_HASH);
894
895                 osrfHashIterator* class_itr = osrfNewHashIterator(router->classes);
896                 while( (class = osrfHashIteratorNext(class_itr)) ) {
897
898                         count = 0;
899                         const char* classname = osrfHashIteratorKey(class_itr);
900
901                         osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
902                         while( (node = osrfHashIteratorNext(node_itr)) ) {
903                                 count += node->count;
904                         }
905                         osrfHashIteratorFree(node_itr);
906
907                         jsonObjectSetKey( jresponse, classname, jsonNewNumberObject( (double) count ) );
908                 }
909
910                 osrfHashIteratorFree(class_itr);
911
912         } else {
913
914                 return osrfRouterHandleMethodNFound( router, msg, omsg );
915         }
916
917
918         osrfRouterHandleAppResponse( router, msg, omsg, jresponse );
919         jsonObjectFree(jresponse);
920
921         return 0;
922
923 }
924
925
926 static int osrfRouterHandleMethodNFound(
927                 osrfRouter* router, transport_message* msg, osrfMessage* omsg ) {
928
929         osrfMessage* err = osrf_message_init( STATUS, omsg->thread_trace, 1);
930                 osrf_message_set_status_info( err,
931                                 "osrfMethodException", "Router method not found", OSRF_STATUS_NOTFOUND );
932
933                 char* data =  osrf_message_serialize(err);
934
935                 transport_message* tresponse = message_init(
936                                 data, "", msg->thread, msg->sender, msg->recipient );
937
938                 client_send_message(router->connection, tresponse );
939
940                 free(data);
941                 osrfMessageFree( err );
942                 message_free(tresponse);
943                 return 0;
944 }
945
946
947 static int osrfRouterHandleAppResponse( osrfRouter* router,
948         transport_message* msg, osrfMessage* omsg, const jsonObject* response ) {
949
950         if( response ) { /* send the response message */
951
952                 osrfMessage* oresponse = osrf_message_init(
953                                 RESULT, omsg->thread_trace, omsg->protocol );
954
955                 char* json = jsonObjectToJSON(response);
956                 osrf_message_set_result_content( oresponse, json);
957
958                 char* data =  osrf_message_serialize(oresponse);
959                 osrfLogDebug( OSRF_LOG_MARK,  "Responding to client app request with data: \n%s\n", data );
960
961                 transport_message* tresponse = message_init(
962                                 data, "", msg->thread, msg->sender, msg->recipient );
963
964                 client_send_message(router->connection, tresponse );
965
966                 osrfMessageFree(oresponse);
967                 message_free(tresponse);
968                 free(json);
969                 free(data);
970         }
971
972         /* now send the 'request complete' message */
973         osrfMessage* status = osrf_message_init( STATUS, omsg->thread_trace, 1);
974         osrf_message_set_status_info( status, "osrfConnectStatus", "Request Complete",
975                         OSRF_STATUS_COMPLETE );
976
977         char* statusdata = osrf_message_serialize(status);
978
979         transport_message* sresponse = message_init(
980                         statusdata, "", msg->thread, msg->sender, msg->recipient );
981         client_send_message(router->connection, sresponse );
982
983         free(statusdata);
984         osrfMessageFree(status);
985         message_free(sresponse);
986
987         return 0;
988 }
989
990
991
992