src/router/osrf_router.c

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