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