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