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 void 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 void 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
 207                 // Wait indefinitely for an incoming message
 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                 if( FD_ISSET(routerfd, &set) ) {
 225                         osrfLogDebug( OSRF_LOG_MARK, "Top router socket is active: %d", routerfd );
 226                         osrfRouterHandleIncoming( router );
 227                 }
 228
 229                 /* Check each of the connected classes and see if they have data to route */
 230                 osrfRouterClass* class;
 231                 osrfHashIterator* itr = router->class_itr;  // remove a layer of indirection
 232                 osrfHashIteratorReset( itr );
 233
 234                 while( (class = osrfHashIteratorNext(itr)) ) {   // for each class
 235
 236                         const char* classname = osrfHashIteratorKey(itr);
 237
 238                         if( classname ) {
 239
 240                                 osrfLogDebug( OSRF_LOG_MARK, "Checking %s for activity...", classname );
 241
 242                                 int sockfd = client_sock_fd( class->connection );
 243                                 if(FD_ISSET( sockfd, &set )) {
 244                                         osrfLogDebug( OSRF_LOG_MARK, "Socket is active: %d", sockfd );
 245                                         osrfRouterClassHandleIncoming( router, classname, class );
 246                                 }
 247                         }
 248                 } // end while
 249         } // end while
 250 }
 251
 252
 253 /**
 254         @brief Handle incoming requests to the router.
 255         @param router Pointer to the osrfRouter.
 256
 257         Read all available input messages from the top-level transport_client.  For each one:
 258         if the domain of the sender's Jabber id is on the list of approved domains, pass the
 259         message to osrfRouterHandleCommand() (if there's a message) or osrfRouterHandleAppRequest()
 260         (if there isn't).  If the domain is @em not on the approved list, log a warning and
 261         discard the message.
 262 */
 263 static void osrfRouterHandleIncoming( osrfRouter* router ) {
 264         if(!router) return;
 265
 266         transport_message* msg = NULL;
 267
 268         while( (msg = client_recv( router->connection, 0 )) ) {  // for each message
 269
 270                 if( msg->sender ) {
 271
 272                         osrfLogDebug(OSRF_LOG_MARK,
 273                                 "osrfRouterHandleIncoming(): investigating message from %s", msg->sender);
 274
 275                         /* if the server is not on a trusted domain, drop the message */
 276                         int len = strlen(msg->sender) + 1;
 277                         char domain[len];
 278                         jid_get_domain( msg->sender, domain, len - 1 );
 279
 280                         if(osrfStringArrayContains( router->trustedServers, domain)) {
 281
 282                                 // If there's a command, obey it.  Otherwise, treat
 283                                 // the message as an app session level request.
 284                                 if( msg->router_command && *msg->router_command )
 285                                         osrfRouterHandleCommand( router, msg );
 286                                 else
 287                                         osrfRouterHandleAppRequest( router, msg );
 288                         }
 289                         else
 290                                 osrfLogWarning( OSRF_LOG_MARK,
 291                                                 "Received message from un-trusted server domain %s", msg->sender);
 292                 }
 293
 294                 message_free(msg);
 295         }
 296 }
 297
 298 /**
 299         @brief Handle all available incoming messages for a router class.
 300         @param router Pointer to the osrfRouter.
 301         @param classname Class name.
 302         @param class Pointer to the osrfRouterClass.
 303
 304         For each message: if the sender is on a trusted domain, process the message.
 305 */
 306 static void osrfRouterClassHandleIncoming( osrfRouter* router, const char* classname,
 307                 osrfRouterClass* class ) {
 308         if(!(router && class)) return;
 309
 310         transport_message* msg;
 311         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleIncoming()");
 312
 313         // For each incoming message for this class:
 314         while( (msg = client_recv( class->connection, 0 )) ) {
 315
 316                 // Save the transaction id so that we can incorporate it
 317                 // into any relevant messages
 318                 osrfLogSetXid(msg->osrf_xid);
 319
 320                 if( msg->sender ) {
 321
 322                         osrfLogDebug(OSRF_LOG_MARK,
 323                                 "osrfRouterClassHandleIncoming(): investigating message from %s", msg->sender);
 324
 325                         /* if the client is not from a trusted domain, drop the message */
 326                         int len = strlen(msg->sender) + 1;
 327                         char domain[len];
 328                         jid_get_domain( msg->sender, domain, len - 1 );
 329
 330                         if(osrfStringArrayContains( router->trustedClients, domain )) {
 331
 332                                 if( msg->is_error )  {
 333
 334                                         transport_message* bouncedMessage = osrfRouterClassHandleBounce(
 335                                                         router, classname, class, msg );
 336                                         /* handle bounced message */
 337                                         if( !bouncedMessage ) {
 338                                                 /* we have no one to send the requested message to */
 339                                                 message_free( msg );
 340                                                 osrfLogClearXid();
 341                                                 continue;
 342                                         }
 343                                         osrfRouterClassHandleMessage( router, class, bouncedMessage );
 344                                         message_free( bouncedMessage );
 345                                 } else
 346                                         osrfRouterClassHandleMessage( router, class, msg );
 347
 348                         } else {
 349                                 osrfLogWarning( OSRF_LOG_MARK,
 350                                                 "Received client message from untrusted client domain %s", domain );
 351                         }
 352                 }
 353
 354                 message_free( msg );
 355                 osrfLogClearXid();  // We're done with this transaction id
 356         }
 357 }
 358
 359 /**
 360         @brief Handle a top level router command.
 361         @param router Pointer to the osrfRouter.
 362         @param msg Pointer to the transport_message to be handled.
 363
 364         Currently supported commands:
 365         - "register" -- Add a server class and/or a server node to our lists.
 366         - "unregister" -- Remove a node from a class, and the class as well if no nodes are
 367         left for it.
 368 */
 369 static void osrfRouterHandleCommand( osrfRouter* router, transport_message* msg ) {
 370         if(!(router && msg && msg->router_class)) return;
 371
 372         if( !strcmp( msg->router_command, ROUTER_REGISTER ) ) {
 373
 374                 osrfLogInfo( OSRF_LOG_MARK, "Registering class %s", msg->router_class );
 375
 376                 // Add the server class to the list, if it isn't already there
 377                 osrfRouterClass* class = osrfRouterFindClass( router, msg->router_class );
 378                 if(!class)
 379                         class = osrfRouterAddClass( router, msg->router_class );
 380
 381                 // Add the node to the osrfRouterClass's list, if it isn't already there
 382                 if(class && ! osrfRouterClassFindNode( class, msg->sender ) )
 383                         osrfRouterClassAddNode( class, msg->sender );
 384
 385         } else if( !strcmp( msg->router_command, ROUTER_UNREGISTER ) ) {
 386
 387                 if( msg->router_class && *msg->router_class ) {
 388                         osrfLogInfo( OSRF_LOG_MARK, "Unregistering router class %s", msg->router_class );
 389                         osrfRouterClassRemoveNode( router, msg->router_class, msg->sender );
 390                 }
 391         }
 392 }
 393
 394
 395 /**
 396         @brief Adds an osrfRouterClass to a router, and open a connection for it.
 397         @param router Pointer to the osrfRouter.
 398         @param classname The name of the class this node handles.
 399         @return A pointer to the new osrfRouterClass, or NULL upon error.
 400
 401         Open a Jabber session to be used for this server class.  The Jabber ID incorporates the
 402         class name as the resource name.
 403 */
 404 static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* classname ) {
 405         if(!(router && router->classes && classname)) return NULL;
 406
 407         osrfRouterClass* class = safe_malloc(sizeof(osrfRouterClass));
 408         class->nodes = osrfNewHash();
 409         class->itr = osrfNewHashIterator(class->nodes);
 410         osrfHashSetCallback(class->nodes, &osrfRouterNodeFree);
 411         class->router = router;
 412
 413         class->connection = client_init( router->domain, router->port, NULL, 0 );
 414
 415         if(!client_connect( class->connection, router->name,
 416                         router->password, classname, 10, AUTH_DIGEST ) ) {
 417                 // Cast away the constness of classname.  Though ugly, this
 418                 // cast is benign because osrfRouterClassFree doesn't actually
 419                 // write through the pointer.  We can't readily change its
 420                 // signature because it is used for a function pointer, and
 421                 // we would have to change other signatures the same way.
 422                 osrfRouterClassFree( (char *) classname, class );
 423                 return NULL;
 424         }
 425
 426         osrfHashSet( router->classes, class, classname );
 427         return class;
 428 }
 429
 430
 431 /**
 432         @brief Add a new server node to an osrfRouterClass.
 433         @param rclass Pointer to the osrfRouterClass to add the node to.
 434         @param remoteId The remote login of the osrfRouterNode.
 435 */
 436 static void osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId ) {
 437         if(!(rclass && rclass->nodes && remoteId)) return;
 438
 439         osrfLogInfo( OSRF_LOG_MARK, "Adding router node for remote id %s", remoteId );
 440
 441         osrfRouterNode* node = safe_malloc(sizeof(osrfRouterNode));
 442         node->count = 0;
 443         node->lastMessage = NULL;
 444         node->remoteId = strdup(remoteId);
 445
 446         osrfHashSet( rclass->nodes, node, remoteId );
 447 }
 448
 449 /* copy off the lastMessage, remove the offending node, send error if it's the last node
 450         ? return NULL if it's the last node ?
 451 */
 452
 453 /* handles case where router node is not longer reachable.  copies over the
 454         data from the last sent message and returns a newly crafted suitable for treating
 455         as a newly inconing message.  Removes the dead node and If there are no more
 456         nodes to send the new message to, returns NULL.
 457 */
 458 /**
 459         @brief Handle an input message representing a Jabber error stanza.
 460         @param router Pointer to the current osrfRouter.
 461         @param classname Name of the class to which the error stanza was sent.
 462         @param rclass Pointer to the osrfRouterClass to which the error stanza was sent.
 463         @param msg Pointer to the transport_message representing the error stanza.
 464         @return Pointer to a newly allocated transport_message; or NULL (see remarks).
 465
 466         The presumption is that the relevant node is dead.  If another node is available for
 467         the same class, then remove the dead one, create a clone of the message to be sent
 468         elsewhere, and return a pointer to it.  If there is no other node for the same class,
 469         send a cancel message back to Jabber, and return NULL.  If we can't even do that because
 470         the entire class is dead, log a message to that effect and return NULL.
 471 */
 472 static transport_message* osrfRouterClassHandleBounce( osrfRouter* router,
 473                 const char* classname, osrfRouterClass* rclass, transport_message* msg ) {
 474
 475         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleBounce()");
 476
 477         osrfLogInfo( OSRF_LOG_MARK, "Received network layer error message from %s", msg->sender );
 478         osrfRouterNode* node = osrfRouterClassFindNode( rclass, msg->sender );
 479         if( ! node ) {
 480                 osrfLogInfo( OSRF_LOG_MARK,
 481                         "network error occurred after we removed the class.. ignoring");
 482                 return NULL;
 483         }
 484
 485         if( osrfHashGetCount(rclass->nodes) == 1 ) { /* the last node is dead */
 486
 487                 if( node->lastMessage ) {
 488                         osrfLogWarning( OSRF_LOG_MARK,
 489                                         "We lost the last node in the class, responding with error and removing...");
 490
 491                         transport_message* error = message_init(
 492                                 node->lastMessage->body, node->lastMessage->subject,
 493                                 node->lastMessage->thread, node->lastMessage->router_from,
 494                                 node->lastMessage->recipient );
 495                         message_set_osrf_xid(error, node->lastMessage->osrf_xid);
 496                         set_msg_error( error, "cancel", 501 );
 497
 498                         /* send the error message back to the original sender */
 499                         client_send_message( rclass->connection, error );
 500                         message_free( error );
 501                 }
 502
 503                 /* remove the dead node */
 504                 osrfRouterClassRemoveNode( router, classname, msg->sender);
 505                 return NULL;
 506
 507         } else {
 508
 509                 transport_message* lastSent = NULL;
 510
 511                 if( node->lastMessage ) {
 512                         osrfLogDebug( OSRF_LOG_MARK, "Cloning lastMessage so next node can send it");
 513                         lastSent = message_init( node->lastMessage->body,
 514                                 node->lastMessage->subject, node->lastMessage->thread, "",
 515                                 node->lastMessage->router_from );
 516                         message_set_router_info( lastSent, node->lastMessage->router_from,
 517                                 NULL, NULL, NULL, 0 );
 518                         message_set_osrf_xid( lastSent, node->lastMessage->osrf_xid );
 519                 }
 520
 521                 /* remove the dead node */
 522                 osrfRouterClassRemoveNode( router, classname, msg->sender);
 523                 return lastSent;
 524         }
 525 }
 526
 527
 528 /*
 529         Handles class level requests
 530         If we get a regular message, we send it to the next node in the list of nodes
 531         if we get an error, it's a bounce back from a previous attempt.  We take the
 532         body and thread from the last sent on the node that had the bounced message
 533         and propogate them on to the new message being sent
 534         @return 0 on success
 535 */
 536 static void osrfRouterClassHandleMessage(
 537                 osrfRouter* router, osrfRouterClass* rclass, transport_message* msg ) {
 538         if(!(router && rclass && msg)) return;
 539
 540         osrfLogDebug( OSRF_LOG_MARK, "osrfRouterClassHandleMessage()");
 541
 542         osrfRouterNode* node = osrfHashIteratorNext( rclass->itr );
 543         if(!node) {
 544                 osrfHashIteratorReset(rclass->itr);
 545                 node = osrfHashIteratorNext( rclass->itr );
 546         }
 547
 548         if(node) {
 549
 550                 transport_message* new_msg= message_init( msg->body,
 551                                 msg->subject, msg->thread, node->remoteId, msg->sender );
 552                 message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 );
 553                 message_set_osrf_xid( new_msg, msg->osrf_xid );
 554
 555                 osrfLogInfo( OSRF_LOG_MARK,  "Routing message:\nfrom: [%s]\nto: [%s]",
 556                                 new_msg->router_from, new_msg->recipient );
 557
 558                 message_free( node->lastMessage );
 559                 node->lastMessage = new_msg;
 560
 561                 if ( client_send_message( rclass->connection, new_msg ) == 0 )
 562                         node->count++;
 563
 564                 else {
 565                         message_prepare_xml(new_msg);
 566                         osrfLogWarning( OSRF_LOG_MARK, "Error sending message from %s to %s\n%s",
 567                                         new_msg->sender, new_msg->recipient, new_msg->msg_xml );
 568                 }
 569
 570         }
 571 }
 572
 573
 574 /**
 575         @brief Remove a given osrfRouterClass from an osrfRouter
 576         @param router Pointer to the osrfRouter.
 577         @param classname The name of the class to be removed.
 578
 579         A callback function, installed in the osrfHash, frees the osrfRouterClass and any
 580         associated nodes.
 581 */
 582 static void osrfRouterRemoveClass( osrfRouter* router, const char* classname ) {
 583         if( router && router->classes && classname ) {
 584                 osrfLogInfo( OSRF_LOG_MARK, "Removing router class %s", classname );
 585                 osrfHashRemove( router->classes, classname );
 586         }
 587 }
 588
 589
 590 /*
 591         Removes the given node from the class.  Also, if this is that last node in the set,
 592         removes the class from the router
 593         @return 0 on successful removal with no class removal
 594         @return 1 on successful remove with class removal
 595         @return -1 error on removal
 596 */
 597 static int osrfRouterClassRemoveNode(
 598                 osrfRouter* router, const char* classname, const char* remoteId ) {
 599
 600         if(!(router && router->classes && classname && remoteId)) return 0;
 601
 602         osrfLogInfo( OSRF_LOG_MARK, "Removing router node %s", remoteId );
 603
 604         osrfRouterClass* class = osrfRouterFindClass( router, classname );
 605
 606         if( class ) {
 607
 608                 osrfHashRemove( class->nodes, remoteId );
 609                 if( osrfHashGetCount(class->nodes) == 0 ) {
 610                         osrfRouterRemoveClass( router, classname );
 611                         return 1;
 612                 }
 613
 614                 return 0;
 615         }
 616
 617         return -1;
 618 }
 619
 620
 621 /**
 622         @brief Free a router class object.
 623         @param classname Class name.
 624         @param c Pointer to the osrfRouterClass, cast to a void pointer.
 625
 626         This function is designated to the osrfHash as a callback.
 627 */
 628 static void osrfRouterClassFree( char* classname, void* c ) {
 629         if(!(classname && c)) return;
 630         osrfRouterClass* rclass = (osrfRouterClass*) c;
 631         client_disconnect( rclass->connection );
 632         client_free( rclass->connection );
 633
 634         osrfHashIteratorReset( rclass->itr );
 635         osrfRouterNode* node;
 636
 637         while( (node = osrfHashIteratorNext(rclass->itr)) )
 638                 osrfHashRemove( rclass->nodes, node->remoteId );
 639
 640         osrfHashIteratorFree(rclass->itr);
 641         osrfHashFree(rclass->nodes);
 642
 643         free(rclass);
 644 }
 645
 646 /**
 647         @brief Free an osrfRouterNode.
 648         @param remoteId Name of router (not used).
 649         @param n Pointer to the osrfRouterNode to be freed, cast to a void pointer.
 650
 651         This is a callback installed in an osrfHash (the nodes member of an osrfRouterClass).
 652 */
 653 static void osrfRouterNodeFree( char* remoteId, void* n ) {
 654         if(!n) return;
 655         osrfRouterNode* node = (osrfRouterNode*) n;
 656         free(node->remoteId);
 657         message_free(node->lastMessage);
 658         free(node);
 659 }
 660
 661
 662 void osrfRouterFree( osrfRouter* router ) {
 663         if(!router) return;
 664
 665         osrfHashIteratorFree( router->class_itr);
 666         osrfHashFree(router->classes);
 667         free(router->domain);
 668         free(router->name);
 669         free(router->resource);
 670         free(router->password);
 671
 672         osrfStringArrayFree( router->trustedClients );
 673         osrfStringArrayFree( router->trustedServers );
 674
 675         client_free( router->connection );
 676         free(router);
 677 }
 678
 679
 680
 681 /*
 682         Finds the class associated with the given class name in the list of classes
 683 */
 684 static osrfRouterClass* osrfRouterFindClass( osrfRouter* router, const char* classname ) {
 685         if(!( router && router->classes && classname )) return NULL;
 686         return (osrfRouterClass*) osrfHashGet( router->classes, classname );
 687 }
 688
 689
 690 /*
 691         Finds the router node within this class with the given remote id
 692 */
 693 static osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass,
 694                 const char* remoteId ) {
 695         if(!(rclass && remoteId))  return NULL;
 696         return (osrfRouterNode*) osrfHashGet( rclass->nodes, remoteId );
 697 }
 698
 699
 700 /*
 701         Clears and populates the provided fd_set* with file descriptors
 702         from the router's top level connection as well as each of the
 703         router class connections
 704         @return The largest file descriptor found in the filling process
 705 */
 706 /**
 707         @brief Fill an fd_set with all the sockets owned by the osrfRouter.
 708         @param router Pointer to the osrfRouter whose sockets are to be used.
 709         @param set Pointer to the fd_set that is to be filled.
 710         @return The largest file descriptor loaded into the fd_set; or -1 upon error.
 711
 712         There's one socket for the osrfRouter as a whole, and one for each osrfRouterClass
 713         that belongs to it.  We load them all.
 714 */
 715 static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set ) {
 716         if(!(router && router->classes && set)) return -1;
 717
 718         FD_ZERO(set);
 719         int maxfd = client_sock_fd( router->connection );
 720         FD_SET(maxfd, set);
 721
 722         int sockid;
 723
 724         osrfRouterClass* class = NULL;
 725         osrfHashIterator* itr = router->class_itr;
 726         osrfHashIteratorReset( itr );
 727
 728         while( (class = osrfHashIteratorNext(itr)) ) {
 729                 const char* classname = osrfHashIteratorKey(itr);
 730
 731                 if( classname && (class = osrfRouterFindClass( router, classname )) ) {
 732                         sockid = client_sock_fd( class->connection );
 733
 734                         if( osrfUtilsCheckFileDescriptor( sockid ) ) {
 735
 736                                 osrfLogWarning(OSRF_LOG_MARK,
 737                                         "Removing router class '%s' because of a bad top-level file descriptor [%d]",
 738                                         classname, sockid );
 739                                 osrfRouterRemoveClass( router, classname );
 740
 741                         } else {
 742                                 if( sockid > maxfd ) maxfd = sockid;
 743                                 FD_SET(sockid, set);
 744                         }
 745                 }
 746         }
 747
 748         return maxfd;
 749 }
 750
 751 /*
 752         handles messages that don't have a 'router_command' set.  They are assumed to
 753         be app request messages
 754 */
 755 static void osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg ) {
 756
 757         int T = 32;
 758         osrfMessage* arr[T];
 759         memset(arr, 0, sizeof(arr));
 760
 761         int num_msgs = osrf_message_deserialize( msg->body, arr, T );
 762         osrfMessage* omsg = NULL;
 763
 764         int i;
 765         for( i = 0; i != num_msgs; i++ ) {
 766
 767                 if( !(omsg = arr[i]) ) continue;
 768
 769                 switch( omsg->m_type ) {
 770
 771                         case CONNECT:
 772                                 osrfRouterRespondConnect( router, msg, omsg );
 773                                 break;
 774
 775                         case REQUEST:
 776                                 osrfRouterProcessAppRequest( router, msg, omsg );
 777                                 break;
 778
 779                         default: break;
 780                 }
 781
 782                 osrfMessageFree( omsg );
 783         }
 784
 785         return;
 786 }
 787
 788 static int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg,
 789                 osrfMessage* omsg ) {
 790         if(!(router && msg && omsg)) return -1;
 791
 792         osrfMessage* success = osrf_message_init( STATUS, omsg->thread_trace, omsg->protocol );
 793
 794         osrfLogDebug( OSRF_LOG_MARK, "router received a CONNECT message from %s", msg->sender );
 795
 796         osrf_message_set_status_info(
 797                 success, "osrfConnectStatus", "Connection Successful", OSRF_STATUS_OK );
 798
 799         char* data = osrf_message_serialize(success);
 800
 801         transport_message* return_m = message_init(
 802                 data, "", msg->thread, msg->sender, "" );
 803
 804         client_send_message(router->connection, return_m);
 805
 806         free(data);
 807         osrfMessageFree(success);
 808         message_free(return_m);
 809
 810         return 0;
 811 }
 812
 813
 814
 815 static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg,
 816                 osrfMessage* omsg ) {
 817
 818         if(!(router && msg && omsg && omsg->method_name)) return -1;
 819
 820         osrfLogInfo( OSRF_LOG_MARK, "Router received app request: %s", omsg->method_name );
 821
 822         jsonObject* jresponse = NULL;
 823         if(!strcmp( omsg->method_name, ROUTER_REQUEST_CLASS_LIST )) {
 824
 825                 int i;
 826                 jresponse = jsonNewObjectType(JSON_ARRAY);
 827
 828                 osrfStringArray* keys = osrfHashKeys( router->classes );
 829                 for( i = 0; i != keys->size; i++ )
 830                         jsonObjectPush( jresponse, jsonNewObject(osrfStringArrayGetString( keys, i )) );
 831                 osrfStringArrayFree(keys);
 832
 833
 834         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS_SUMMARY )) {
 835
 836                 osrfRouterClass* class;
 837                 osrfRouterNode* node;
 838                 int count = 0;
 839
 840                 char* classname = jsonObjectToSimpleString( jsonObjectGetIndex( omsg->_params, 0 ) );
 841
 842                 if (!classname)
 843                         return -1;
 844
 845                 class = osrfHashGet(router->classes, classname);
 846                 free(classname);
 847
 848                 osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
 849                 while( (node = osrfHashIteratorNext(node_itr)) ) {
 850                         count += node->count;
 851                         //jsonObjectSetKey( class_res, node->remoteId, jsonNewNumberObject( (double) node->count ) );
 852                 }
 853                 osrfHashIteratorFree(node_itr);
 854
 855                 jresponse = jsonNewNumberObject( (double) count );
 856
 857         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS )) {
 858
 859                 osrfRouterClass* class;
 860                 osrfRouterNode* node;
 861
 862                 char* classname = jsonObjectToSimpleString( jsonObjectGetIndex( omsg->_params, 0 ) );
 863
 864                 if (!classname)
 865                         return -1;
 866
 867                 jresponse = jsonNewObjectType(JSON_HASH);
 868                 class = osrfHashGet(router->classes, classname);
 869                 free(classname);
 870
 871                 osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
 872                 while( (node = osrfHashIteratorNext(node_itr)) ) {
 873                         jsonObjectSetKey( jresponse, node->remoteId,
 874                                         jsonNewNumberObject( (double) node->count ) );
 875                 }
 876                 osrfHashIteratorFree(node_itr);
 877
 878         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_CLASS_FULL )) {
 879
 880                 osrfRouterClass* class;
 881                 osrfRouterNode* node;
 882                 jresponse = jsonNewObjectType(JSON_HASH);
 883
 884                 osrfHashIterator* class_itr = osrfNewHashIterator(router->classes);
 885                 while( (class = osrfHashIteratorNext(class_itr)) ) {
 886
 887                         jsonObject* class_res = jsonNewObjectType(JSON_HASH);
 888                         const char* classname = osrfHashIteratorKey(class_itr);
 889
 890                         osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
 891                         while( (node = osrfHashIteratorNext(node_itr)) ) {
 892                                 jsonObjectSetKey( class_res, node->remoteId,
 893                                                 jsonNewNumberObject( (double) node->count ) );
 894                         }
 895                         osrfHashIteratorFree(node_itr);
 896
 897                         jsonObjectSetKey( jresponse, classname, class_res );
 898                 }
 899
 900                 osrfHashIteratorFree(class_itr);
 901
 902         } else if(!strcmp( omsg->method_name, ROUTER_REQUEST_STATS_NODE_FULL )) {
 903
 904                 osrfRouterClass* class;
 905                 osrfRouterNode* node;
 906                 int count;
 907                 jresponse = jsonNewObjectType(JSON_HASH);
 908
 909                 osrfHashIterator* class_itr = osrfNewHashIterator(router->classes);
 910                 while( (class = osrfHashIteratorNext(class_itr)) ) {
 911
 912                         count = 0;
 913                         const char* classname = osrfHashIteratorKey(class_itr);
 914
 915                         osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes);
 916                         while( (node = osrfHashIteratorNext(node_itr)) ) {
 917                                 count += node->count;
 918                         }
 919                         osrfHashIteratorFree(node_itr);
 920
 921                         jsonObjectSetKey( jresponse, classname, jsonNewNumberObject( (double) count ) );
 922                 }
 923
 924                 osrfHashIteratorFree(class_itr);
 925
 926         } else {
 927
 928                 return osrfRouterHandleMethodNFound( router, msg, omsg );
 929         }
 930
 931
 932         osrfRouterHandleAppResponse( router, msg, omsg, jresponse );
 933         jsonObjectFree(jresponse);
 934
 935         return 0;
 936
 937 }
 938
 939
 940 static int osrfRouterHandleMethodNFound(
 941                 osrfRouter* router, transport_message* msg, osrfMessage* omsg ) {
 942
 943         osrfMessage* err = osrf_message_init( STATUS, omsg->thread_trace, 1);
 944                 osrf_message_set_status_info( err,
 945                                 "osrfMethodException", "Router method not found", OSRF_STATUS_NOTFOUND );
 946
 947                 char* data =  osrf_message_serialize(err);
 948
 949                 transport_message* tresponse = message_init(
 950                                 data, "", msg->thread, msg->sender, msg->recipient );
 951
 952                 client_send_message(router->connection, tresponse );
 953
 954                 free(data);
 955                 osrfMessageFree( err );
 956                 message_free(tresponse);
 957                 return 0;
 958 }
 959
 960
 961 static int osrfRouterHandleAppResponse( osrfRouter* router,
 962         transport_message* msg, osrfMessage* omsg, const jsonObject* response ) {
 963
 964         if( response ) { /* send the response message */
 965
 966                 osrfMessage* oresponse = osrf_message_init(
 967                                 RESULT, omsg->thread_trace, omsg->protocol );
 968
 969                 char* json = jsonObjectToJSON(response);
 970                 osrf_message_set_result_content( oresponse, json);
 971
 972                 char* data =  osrf_message_serialize(oresponse);
 973                 osrfLogDebug( OSRF_LOG_MARK,  "Responding to client app request with data: \n%s\n", data );
 974
 975                 transport_message* tresponse = message_init(
 976                                 data, "", msg->thread, msg->sender, msg->recipient );
 977
 978                 client_send_message(router->connection, tresponse );
 979
 980                 osrfMessageFree(oresponse);
 981                 message_free(tresponse);
 982                 free(json);
 983                 free(data);
 984         }
 985
 986         /* now send the 'request complete' message */
 987         osrfMessage* status = osrf_message_init( STATUS, omsg->thread_trace, 1);
 988         osrf_message_set_status_info( status, "osrfConnectStatus", "Request Complete",
 989                         OSRF_STATUS_COMPLETE );
 990
 991         char* statusdata = osrf_message_serialize(status);
 992
 993         transport_message* sresponse = message_init(
 994                         statusdata, "", msg->thread, msg->sender, msg->recipient );
 995         client_send_message(router->connection, sresponse );
 996
 997         free(statusdata);
 998         osrfMessageFree(status);
 999         message_free(sresponse);
1000
1001         return 0;
1002 }
1003
1004
1005
1006