src/router/router.c

   1 #include "router.h"
   2 #include <sys/types.h>
   3 #include <signal.h>
   4
   5 #define ROUTER_MAX_MSGS_PER_PACKET 12
   6 char* router_resource;
   7 transport_router_registrar* routt;
   8 void _build_trusted_sites( transport_router_registrar* router );
   9
  10
  11 void sig_hup_handler( int a ) {
  12         router_registrar_free( routt );
  13         config_reader_free();
  14         log_free();
  15         free( router_resource );
  16         exit(0);
  17 }
  18
  19
  20 int main( int argc, char* argv[] ) {
  21
  22         if( argc < 2 ) {
  23                 fatal_handler( "Usage: %s <path_to_config_file>", argv[0] );
  24                 exit(0);
  25         }
  26
  27         config_reader_init( "opensrf.router", argv[1] );
  28         if( conf_reader == NULL ) fatal_handler( "main(): Config is NULL" );
  29
  30         /* laod the config options */
  31         char* server                    = config_value("opensrf.router", "//router/transport/server");
  32         char* port                              = config_value("opensrf.router", "//router/transport/port");
  33         char* username                  = config_value("opensrf.router", "//router/transport/username");
  34         char* password                  = config_value("opensrf.router", "//router/transport/password");
  35         router_resource         = config_value("opensrf.router", "//router/transport/resource");
  36         char* con_timeout               = config_value("opensrf.router", "//router/transport/connect_timeout" );
  37         char* max_retries               = config_value("opensrf.router", "//router/transport/max_reconnect_attempts" );
  38         char* component         = config_value("opensrf.router", "//router/component" );
  39
  40
  41         /* set up the logger */
  42         char* level = config_value("opensrf.router","//log/level");
  43         char* log_file = config_value("opensrf.router","//log/file");
  44         int llevel = atoi(level);
  45         fprintf(stderr, "Level %d; file %s\n", llevel, log_file );
  46
  47         if(!log_init( llevel, log_file ))
  48                 fprintf(stderr, "Unable to init logging, going to stderr...\n" );
  49
  50
  51         free(level);
  52         free(log_file);
  53
  54         fprintf(stderr, "Router connecting as \nserver: %s \nport: %s \nuser:%s \nresource:%s\n",
  55                         server, port, username, router_resource );
  56
  57         int iport                       = atoi( port );
  58         int con_itimeout        = atoi( con_timeout );
  59         int max_retries_        = atoi(max_retries);
  60         int icomponent = 0;
  61         if(component)
  62                 icomponent = atoi(component);
  63
  64         if( iport < 1 ) {
  65                 fatal_handler( "Port is negative or 0" );
  66                 return 99;
  67         }
  68
  69
  70         /* build the router_registrar */
  71         transport_router_registrar* router_registrar =
  72                 router_registrar_init( server, iport, username, password, router_resource, 0, con_itimeout, icomponent );
  73
  74         routt = router_registrar;
  75
  76         free(server);
  77         free(port);
  78         free(username);
  79         free(password);
  80         free(con_timeout);
  81         free(max_retries);
  82
  83         signal(SIGHUP,sig_hup_handler);
  84
  85
  86         int counter = 0;
  87         /* wait for incoming... */
  88         while( ++counter <= max_retries_ ) {
  89
  90                 /* connect to jabber */
  91                 if( router_registrar_connect( router_registrar ) )  {
  92                         info_handler( "Connected..." );
  93                         fprintf(stderr, "- Connected -\n");
  94                         counter = 0;
  95                         listen_loop( router_registrar );
  96                 } else
  97                         fatal_handler( "Could not connect to Jabber Server" );
  98
  99                 /* this should never happen */
 100                 warning_handler( "Jabber server probably went away, attempting reconnect" );
 101
 102                 sleep(5);
 103         }
 104
 105
 106         router_registrar_free( router_registrar );
 107         config_reader_free();
 108         return 1;
 109
 110 }
 111
 112 transport_router_registrar* router_registrar_init( char* server,
 113                 int port, char* username, char* password,
 114                 char* resource, int client_timeout, int con_timeout, int component ) {
 115
 116         if( server == NULL ) { return NULL; }
 117
 118         /* allocate a new router_registrar object */
 119         size_t size = sizeof( transport_router_registrar );
 120         transport_router_registrar* router_registrar = (transport_router_registrar*) safe_malloc( size );
 121
 122         router_registrar->client_timeout        = client_timeout;
 123         router_registrar->jabber = jabber_connect_init( server, port, username, password, resource, con_timeout, component );
 124         _build_trusted_sites( router_registrar );
 125         info_handler( "Trusted stuff %s, %s, %s", router_registrar->trusted_servers[0],
 126                 router_registrar->trusted_clients[0], router_registrar->trusted_clients[1] );
 127         return router_registrar;
 128
 129 }
 130
 131 void _build_trusted_sites( transport_router_registrar* router ) {
 132
 133         router->trusted_servers = (char**) safe_malloc(sizeof(char**));
 134         router->trusted_clients = (char**) safe_malloc(sizeof(char**));
 135
 136         *(router->trusted_servers) = (char*) safe_malloc(ROUTER_MAX_TRUSTED);
 137         *(router->trusted_clients) = (char*) safe_malloc(ROUTER_MAX_TRUSTED);
 138
 139         int i = 0;
 140         while( ++i ) {
 141                 char* server = config_value("opensrf.router","//router/trusted_domains/server%d", i );
 142                 if(server == NULL)
 143                         break;
 144
 145                 router->trusted_servers[i-1] = server;
 146         }
 147
 148         i = 0;
 149         while( ++i ) {
 150                 char* client = config_value( "opensrf.router","//router/trusted_domains/client%d", i );
 151                 if(client == NULL)
 152                         break;
 153                 router->trusted_clients[i-1] = client;
 154         }
 155
 156         if( router->trusted_servers[0] == NULL ||
 157                         router->trusted_clients[0] == NULL )
 158
 159                 fatal_handler( "You must specify at least one trusted server and client in the config file");
 160 }
 161
 162
 163 jabber_connect* jabber_connect_init( char* server,
 164                 int port, char* username, char* password, char* resource, int connect_timeout, int component ) {
 165
 166         size_t len = sizeof(jabber_connect);
 167         jabber_connect* jabber = (jabber_connect*) safe_malloc( len );
 168
 169         jabber->port                            = port;
 170         jabber->connect_timeout = connect_timeout;
 171
 172         jabber->server                          = strdup(server);
 173         jabber->username                        = strdup(username);
 174         jabber->password                        = strdup(password);
 175         jabber->resource                        = strdup(resource);
 176
 177         if( jabber->server == NULL || jabber->username == NULL ||
 178                         jabber->password == NULL || jabber->resource == NULL ) {
 179                 fatal_handler( "jabber_init(): Out of Memory" );
 180                 return NULL;
 181         }
 182
 183         /* build the transport client */
 184         jabber->t_client = client_init( jabber->server, jabber->port, component );
 185
 186         return jabber;
 187 }
 188
 189 /* connect the router_registrar to jabber */
 190 int router_registrar_connect( transport_router_registrar* router ) {
 191         return j_connect( router->jabber );
 192 }
 193
 194 /* connect a jabber_connect object jabber */
 195 int j_connect( jabber_connect* jabber ) {
 196         if( jabber == NULL ) { return 0; }
 197         return client_connect( jabber->t_client,
 198                         jabber->username, jabber->password, jabber->resource,
 199                         jabber->connect_timeout, AUTH_DIGEST );
 200 }
 201
 202 int fill_fd_set( transport_router_registrar* router, fd_set* set ) {
 203
 204         int max_fd;
 205         FD_ZERO(set);
 206
 207         int router_fd = router->jabber->t_client->session->sock_obj->sock_fd;
 208         max_fd = router_fd;
 209         FD_SET( router_fd, set );
 210
 211         server_class_node* cur_node = router->server_class_list;
 212         while( cur_node != NULL ) {
 213                 int cur_class_fd = cur_node->jabber->t_client->session->sock_obj->sock_fd;
 214                 if( cur_class_fd > max_fd )
 215                         max_fd = cur_class_fd;
 216                 FD_SET( cur_class_fd, set );
 217                 cur_node = cur_node->next;
 218         }
 219
 220         FD_CLR( 0, set );
 221         return max_fd;
 222 }
 223
 224
 225 void listen_loop( transport_router_registrar* router ) {
 226
 227         if( router == NULL )
 228                 return;
 229
 230         int select_ret;
 231         int router_fd = router->jabber->t_client->session->sock_obj->sock_fd;
 232         transport_message* cur_msg;
 233
 234         while(1) {
 235
 236                 fd_set listen_set;
 237                 int max_fd = fill_fd_set( router, &listen_set );
 238
 239                 if( max_fd < 1 )
 240                         fatal_handler( "fill_fd_set return bogus max_fd: %d", max_fd );
 241
 242                 int num_handled = 0;
 243                 info_handler( "Going into select" );
 244
 245                 if( (select_ret=select(max_fd+ 1, &listen_set, NULL, NULL, NULL)) < 0 ) {
 246
 247                         warning_handler( "Select returned error %d", select_ret );
 248                         warning_handler( "Select Error %d on fd %d", errno );
 249                         perror( "Select Error" );
 250                         warning_handler( "Errors: EBADF %d, EINTR %d, EINVAL %d, ENOMEM %d",
 251                                         EBADF, EINTR, EINVAL, ENOMEM );
 252                         continue;
 253
 254                 } else {
 255
 256                         info_handler( "Select returned %d", select_ret );
 257
 258                         if( FD_ISSET( router_fd, &listen_set ) ) {
 259                                 cur_msg = client_recv( router->jabber->t_client, 1 );
 260
 261                                 /* We only process a message if we have some trusted servers and the current
 262                                         message came from one of those servers */
 263                                 if(router->trusted_servers && router->trusted_servers[0]) {
 264                                         int i = 0;
 265                                         int found = 0;
 266
 267                                         char server_buf[256];
 268                                         memset(server_buf,0,256);
 269                                         jid_get_domain( cur_msg->sender, server_buf );
 270                                         info_handler("Received top level message from %s", server_buf );
 271
 272                                         while(1) {
 273                                                 if(router->trusted_servers[i] == NULL)
 274                                                         break;
 275                                                 if(!strcmp(router->trusted_servers[i], server_buf)) {
 276                                                         found = 1;
 277                                                         break;
 278                                                 }
 279                                                 i++;
 280                                         }
 281                                         if(found)
 282                                                 router_registrar_handle_msg( router, cur_msg );
 283                                         else
 284                                                 warning_handler( "Received top level message from unpriveleged sender %s", cur_msg->sender );
 285                                 }
 286
 287                                 message_free( cur_msg );
 288                                 if( ++num_handled == select_ret )
 289                                         continue;
 290                         }
 291
 292                         /* cycle through the children and find any whose fd's are ready for reading */
 293                         server_class_node* cur_node = router->server_class_list;
 294                         while( cur_node != NULL ) {
 295                                 debug_handler( "Checking File Descriptor" );
 296                                 int cur_fd = cur_node->jabber->t_client->session->sock_obj->sock_fd;
 297
 298                                 if( FD_ISSET(cur_fd, &listen_set) ) {
 299                                         ++num_handled;
 300                                         FD_CLR(cur_fd,&listen_set);
 301
 302                                         cur_msg = client_recv( cur_node->jabber->t_client, 1 );
 303                                         info_handler( "%s received from %s", cur_node->server_class, cur_msg->sender );
 304                                         int handle_ret = server_class_handle_msg( router, cur_node, cur_msg );
 305
 306                                         if( handle_ret == -1 ) {
 307                                                 warning_handler( "server_class_handle_msg() returned -1" );
 308                                                 cur_node = router->server_class_list; /*start over*/
 309                                                 continue;
 310
 311                                         } else if( handle_ret == 0 ) {
 312                                                 /* delete and continue */
 313                                                 warning_handler( "server_class_handle_msg() returned 0" );
 314                                                 //server_class_node* tmp_node = cur_node->next;
 315                                                 remove_server_class( router, cur_node );
 316                                                 debug_handler( "Removed Server Class" );
 317                                                 cur_node = router->server_class_list; /*start over*/
 318                                                 //cur_node = tmp_node;
 319                                                 continue;
 320                                         }
 321
 322                                         info_handler( "%s handled message successfully", cur_node->server_class );
 323                                         /* dont free message here */
 324                                         if( num_handled == select_ret )
 325                                                 break;
 326                                 }
 327                                 if( num_handled == select_ret )
 328                                         break;
 329                                 cur_node = cur_node->next;
 330
 331                         } /* cycling through the server_class list */
 332
 333                 } /* no select errors */
 334         }
 335 }
 336
 337
 338 /* determine where to route top level messages */
 339 int router_registrar_handle_msg( transport_router_registrar* router_registrar, transport_message* msg ) {
 340
 341         info_handler( "Received class: %s : command %s ", msg->router_class, msg->router_command );
 342
 343         if( router_registrar == NULL || msg == NULL ) { return 0; }
 344
 345         if( msg->router_command == NULL || !strcmp(msg->router_command,"") ) {
 346                 return router_registrar_handle_app_request( router_registrar, msg );
 347         }
 348
 349         // user issued a ruoter query
 350         /* a query command has router_command="query" and the actual query type
 351                 is the content of the message */
 352         if( !strcmp(msg->router_command,"query")) {
 353                 info_handler( "Router received query command" );
 354
 355                 // user issues a servers query
 356                 if( !strcmp(msg->body, "servers")) {
 357
 358                         info_handler( "Router received servers query command" );
 359                         router_return_server_info( router_registrar, msg );
 360                         return 1;
 361                 }
 362         }
 363
 364
 365         info_handler("Looking for server_class_node %s...",msg->router_class);
 366         server_class_node* active_class_node = find_server_class( router_registrar, msg->router_class );
 367
 368         if( active_class_node == NULL ) {
 369                 info_handler("Could not find server_class_node %s, creating one.",msg->router_class);
 370
 371                 /* there is no server_class for msg->router_class so we build it here */
 372                 if( strcmp( msg->router_command, "register") == 0 ) {
 373
 374                         info_handler("Adding server_class_node for %s",msg->router_class);
 375                         active_class_node =
 376                                 init_server_class( router_registrar, msg->sender, msg->router_class );
 377
 378                         if( active_class_node == NULL ) {
 379                                 fatal_handler( "router_listen(): active_class_node == NULL for %s", msg->sender );
 380                                 return 0;
 381                         }
 382
 383                         if (router_registrar->server_class_list != NULL) {
 384                                 active_class_node->next = router_registrar->server_class_list;
 385                                 router_registrar->server_class_list->prev = active_class_node;
 386                         }
 387                         router_registrar->server_class_list = active_class_node;
 388
 389                         //spawn_server_class( (void*) active_class_node );
 390
 391                 } else {
 392                         warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
 393                                 msg->router_command, msg->router_class );
 394                 }
 395
 396         } else if( strcmp( msg->router_command, "register") == 0 ) {
 397                 /* there is a server_class for msg->router_class so we
 398                         need to either add a new server_node or update the existing one */
 399
 400
 401                 server_node* s_node = find_server_node( active_class_node, msg->sender );
 402
 403                 if( s_node != NULL ) {
 404                         s_node->available = 1;
 405                         s_node->upd_time = time(NULL);
 406                         info_handler( "Found matching registered server: %s. Updating.",
 407                                         s_node->remote_id );
 408                 } else {
 409                         s_node = init_server_node( msg->sender );
 410
 411                         info_handler( "Adding server_node for: %s.", s_node->remote_id );
 412
 413                         if (s_node == NULL ) {
 414                                 warning_handler( " Could not create new xerver_node for %s.",
 415                                         msg->sender );
 416                                 return 0;
 417                         }
 418
 419                         s_node->next = active_class_node->current_server_node->next;
 420                         s_node->prev = active_class_node->current_server_node;
 421
 422                         active_class_node->current_server_node->next->prev = s_node;
 423                         active_class_node->current_server_node->next = s_node;
 424                 }
 425
 426
 427         } else if( strcmp( msg->router_command, "unregister") == 0 ) {
 428
 429                 if( ! unregister_server_node( active_class_node, msg->sender ) ) {
 430                         remove_server_class( router_registrar, active_class_node );
 431                         debug_handler( "Removed server class after final unregister");
 432                 }
 433
 434         } else {
 435                 warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
 436                         msg->router_command, msg->router_class );
 437         }
 438
 439         return 1;
 440 }
 441
 442
 443 /* removes a server class node from the top level router_registrar */
 444 int unregister_server_node( server_class_node* active_class_node, char* remote_id ) {
 445
 446         server_node* d_node = find_server_node( active_class_node, remote_id );
 447
 448         if ( d_node != NULL ) {
 449
 450                 info_handler( "Removing server_node for: %s.", d_node->remote_id );
 451
 452                 if ( d_node->next == NULL ) {
 453                         warning_handler( "NEXT is NULL in ring [%s] -- "
 454                                 "THIS SHOULD NEVER HAPPEN",
 455                                 d_node->remote_id );
 456
 457                 }
 458
 459                 if ( d_node->prev == NULL ) {
 460                         warning_handler( "PREV is NULL in a ring [%s] -- "
 461                                 "THIS SHOULD NEVER HAPPEN",
 462                                 d_node->remote_id );
 463
 464                 }
 465
 466                 if ( d_node->next == d_node && d_node->prev == d_node) {
 467                         info_handler( "Last node, setting ring to NULL: %s.",
 468                                 d_node->remote_id );
 469
 470                         active_class_node->current_server_node = NULL;
 471
 472                         server_node_free( d_node );
 473                         return 0;
 474
 475                 } else {
 476                         info_handler( "Nodes remain, splicing: %s, %s",
 477                                 d_node->prev->remote_id,
 478                                 d_node->next->remote_id);
 479
 480                 info_handler( "d_node => %x, next => %x, prev => %x",
 481                                         d_node, d_node->next, d_node->prev );
 482
 483
 484                         d_node->prev->next = d_node->next;
 485                         d_node->next->prev = d_node->prev;
 486
 487                         info_handler( "prev => %x, prev->next => %x, prev->prev => %x",
 488                                 d_node->prev, d_node->prev->next, d_node->prev->prev );
 489
 490                         info_handler( "next => %x, next->next => %x, next->prev => %x",
 491                                 d_node->next, d_node->next->next, d_node->next->prev );
 492
 493                         if (active_class_node->current_server_node == d_node)
 494                                 active_class_node->current_server_node = d_node->next;
 495
 496
 497                         server_node_free( d_node );
 498                 }
 499         }
 500
 501         return 1;
 502 }
 503
 504 server_node * find_server_node ( server_class_node * class, const char * remote_id ) {
 505
 506         if ( class == NULL ) {
 507                 warning_handler(" find_server_node(): bad arg!");
 508                 return NULL;
 509         }
 510
 511         server_node * start_node = class->current_server_node;
 512         server_node * node = class->current_server_node;
 513
 514         do {
 515                 if (node == NULL)
 516                         return NULL;
 517
 518                 if ( strcmp(node->remote_id, remote_id) == 0 )
 519                         return node;
 520
 521                 node = node->next;
 522
 523         } while ( node != start_node );
 524
 525         return NULL;
 526 }
 527
 528 /* if we return -1, then we just deleted the server_class you were looking for
 529         if we return 0, then some other error has occured
 530         we return 1 otherwise */
 531 int remove_server_class( transport_router_registrar* router, server_class_node* class ) {
 532         if( class == NULL )
 533                 return 0;
 534
 535         transport_message * msg = NULL;
 536         while ( (msg = client_recv(class->jabber->t_client, 0)) != NULL ) {
 537                 debug_handler( "Looping on messages to dead class" );
 538                 if( server_class_handle_msg(router, class, msg) < 0 ) {
 539                   debug_handler( "This class was freed by a recursive call, exiting 'remove_server_class'");
 540                   //message_free(msg); - this will be freed by server_class_handle_msg
 541                   debug_handler( "Message Freed");
 542                   return -1;
 543                 }
 544                 message_free(msg);
 545         }
 546
 547
 548         free( class->server_class );
 549         class->server_class = NULL;
 550
 551         find_server_class( router, router_resource ); /* find deletes for us */
 552         debug_handler( "Successfuly called 'find_server_class' on class to delete" );
 553
 554         if( router->server_class_list == NULL )
 555                 return 0;
 556         return 1;
 557 }
 558
 559 server_class_node * find_server_class ( transport_router_registrar * router, const char * class_id ) {
 560
 561         if ( router == NULL ) {
 562                 warning_handler(" find_server_class(): bad arg!");
 563                 return NULL;
 564         }
 565
 566         info_handler( "Finding server class for %s", class_id );
 567         server_class_node * class = router->server_class_list;
 568         server_class_node * dead_class = NULL;
 569
 570         while ( class != NULL ) {
 571
 572                 if ( class->server_class == NULL ) {
 573                         info_handler( "Found an empty server class" );
 574
 575                         if ( class->prev != NULL ) {
 576                                 class->prev->next = class->next;
 577                                 if( class->next != NULL ) {
 578                                         class->next->prev = class->prev;
 579                                 }
 580
 581                         } else {
 582                                 info_handler( "Empty class is the first on the list" );
 583                                 if( class->next != NULL )
 584                                         router->server_class_list = class->next;
 585
 586                                 else { /* we're the last class node in the class node list */
 587                                         info_handler( "Empty class is the last on the list" );
 588                                         server_class_node_free( router->server_class_list );
 589                                         router->server_class_list = NULL;
 590                                         break;
 591                                 }
 592
 593                         }
 594
 595                         dead_class = class;
 596                         class = class->next;
 597
 598                         info_handler( "Tossing our dead class" );
 599                         server_class_node_free( dead_class );
 600
 601                         if ( class == NULL )
 602                                 return NULL;
 603                 }
 604
 605                 if ( strcmp(class->server_class, class_id) == 0 )
 606                         return class;
 607                 info_handler( "%s != %s", class->server_class, class_id );
 608
 609                 class = class->next;
 610         }
 611
 612         debug_handler( "Returning NULL from find_server_class()" );
 613         return NULL;
 614 }
 615
 616 /* builds a new server class and connects to the jabber server with the new resource */
 617 server_class_node* init_server_class(
 618                 transport_router_registrar* router, char* remote_id, char* server_class ) {
 619
 620         size_t len = sizeof( server_class_node );
 621         server_class_node* node = (server_class_node*) safe_malloc( len );
 622
 623         node->jabber = jabber_connect_init( router->jabber->server,
 624                         router->jabber->port, router->jabber->username,
 625                         router->jabber->password, server_class, router->jabber->connect_timeout, router->component );
 626
 627
 628
 629         node->server_class = strdup( server_class );
 630         if( server_class == NULL ) {
 631                 fatal_handler( "imit_server_class(): out of memory for %s", server_class );
 632                 return NULL;
 633         }
 634
 635         info_handler( "Received class to init_server_class: %s", server_class );
 636         node->current_server_node = init_server_node( remote_id );
 637         if( node->current_server_node == NULL ) {
 638                 fatal_handler( "init_server_class(): NULL server_node for %s", remote_id );
 639                 return NULL;
 640         }
 641
 642
 643         if( ! j_connect( node->jabber ) ) {
 644                 fatal_handler( "Unable to init server class %s", node->server_class );
 645                 return NULL;
 646         }
 647
 648         info_handler( "Jabber address in init for %s : address %x : username %s : resource %s",
 649                         node->server_class, node->jabber->t_client->session->sock_obj->sock_fd,
 650                         node->jabber->username,  node->jabber->resource );
 651
 652         return node;
 653
 654 }
 655
 656 /* builds a new server_node to be added to the ring of server_nodes */
 657 server_node* init_server_node(  char* remote_id ) {
 658
 659         info_handler( "Initing server node for %s", remote_id );
 660         server_node* current_server_node;
 661         size_t size = sizeof( server_node);
 662         current_server_node = (server_node*) safe_malloc( size );
 663
 664         current_server_node->remote_id = strdup(remote_id);
 665         if( current_server_node->remote_id == NULL ) {
 666                 fatal_handler("init_server_class(): Out of Memory for %s", remote_id );
 667                 return NULL;
 668         }
 669
 670         current_server_node->reg_time = time(NULL);
 671         current_server_node->available = 1;
 672         current_server_node->next = current_server_node;
 673         current_server_node->prev = current_server_node;
 674
 675
 676         return current_server_node;
 677
 678 }
 679
 680 int  server_class_handle_msg( transport_router_registrar* router,
 681                 server_class_node* s_node, transport_message* msg ) {
 682
 683         if( s_node->current_server_node == NULL ) {
 684                 /* return error to client ??!*/
 685                 /* WE have no one to send the message to */
 686                 warning_handler( "We no longer have any servers for %s : "
 687                                 "no one to send the message to. Sending error message to %s", s_node->server_class, msg->sender );
 688                 free( msg->recipient );
 689
 690                 char* rec = strdup( msg->sender );
 691                 if( rec == NULL ) {
 692                         fatal_handler( "class msg_handler: out of memory");
 693                         return 0;
 694                 }
 695
 696                 info_handler( "Building error message to return for %s", s_node->server_class);
 697                 msg->recipient = rec;
 698                 set_msg_error(msg, "cancel", 501);
 699
 700                 client_send_message( s_node->jabber->t_client, msg );
 701                 message_free( msg );
 702
 703                 remove_server_class( router, s_node );
 704                 debug_handler( "Successfully removed server class" );
 705
 706                 return -1;
 707         }
 708
 709         info_handler( "[%s] Received \nfrom: %s \nto: %s",
 710                         s_node->server_class, msg->sender, msg->recipient );
 711
 712         if( msg->is_error ) {
 713                 warning_handler( "We've received an error message type: %s : code: %d",
 714                                 msg->error_type, msg->error_code );
 715
 716                 if( strcmp( msg->error_type, "cancel" ) == 0 ) {
 717                         warning_handler( "Looks like we've lost a server!" );
 718                         server_node* dead_node = find_server_node( s_node, msg->sender );
 719
 720                         if( dead_node != NULL ) {
 721                                 //message_free( msg );
 722                                 transport_message* tmp = dead_node->last_sent;
 723
 724                                 /* copy over last sent, it will be freed in the unregister function */
 725                                 transport_message* tmp2 = message_init( tmp->body, tmp->subject, tmp->thread,
 726                                                 tmp->recipient, tmp->sender );
 727
 728                                 message_set_router_info( tmp2, tmp->router_from,
 729                                                 tmp->router_to, tmp->router_class, tmp->router_command, tmp->broadcast );
 730
 731                                 if( ! unregister_server_node( s_node, dead_node->remote_id ) ) {
 732                                         /* WE have no one to send the message to */
 733                                         warning_handler( "We no longer have any servers for %s : "
 734                                                         "no one to send the message to.", s_node->server_class );
 735                                         free( msg->recipient );
 736
 737                                         char* rec = strdup( msg->router_from );
 738                                         if( rec == NULL ) {
 739                                                 fatal_handler( "class msg_handler: out of memory");
 740                                                 return 0;
 741                                         }
 742
 743                                         info_handler( "Building error message to return for %s", s_node->server_class);
 744                                         msg->recipient = rec;
 745                                         client_send_message( s_node->jabber->t_client, msg );
 746                                         message_free( tmp2 );
 747                                         message_free( msg );
 748                                         return 0;
 749
 750                                 } else {
 751                                         msg = tmp2;
 752                                 }
 753                         }
 754                 }
 755         }
 756
 757
 758         server_node* c_node = s_node->current_server_node->next;
 759
 760         /* not implemented yet */
 761         while( ! c_node->available ) {
 762                 if( c_node == s_node->current_server_node ) {
 763                         warning_handler("No server_node's are available for %s", s_node->server_class );
 764                         /* XXX send error message to client */
 765                         return 0;
 766                 }
 767                 c_node = c_node->next;
 768         }
 769         s_node->current_server_node = c_node;
 770
 771         transport_message * new_msg =
 772                 message_init(   msg->body, msg->subject, msg->thread,
 773                                 s_node->current_server_node->remote_id, msg->sender );
 774
 775         message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 );
 776
 777         info_handler( "[%s] Routing message from [%s]\nto [%s]", s_node->server_class, msg->sender, new_msg->recipient );
 778         //info_handler( "New Message Details: sender:%s recipient: %s \nbody: %s",
 779         //              new_msg->sender, new_msg->recipient, new_msg->body );
 780
 781         message_free( s_node->current_server_node->last_sent );
 782         s_node->current_server_node->last_sent = msg;
 783
 784         if ( new_msg != NULL && client_send_message( s_node->jabber->t_client, new_msg ) ) {
 785                 s_node->current_server_node->serve_count++;
 786                 s_node->current_server_node->la_time = time(NULL);
 787                 message_free( new_msg ); // XXX
 788                 return 1;
 789         }
 790         message_free( new_msg ); // XXX
 791
 792         return 0;
 793 }
 794
 795
 796 int router_return_server_info(
 797                 transport_router_registrar* router, transport_message* msg ) {
 798
 799         server_class_node* cur_class = router->server_class_list;
 800         growing_buffer* buffer = buffer_init(1024);
 801
 802         while( cur_class != NULL ) {
 803
 804                 server_node* start_node = cur_class->current_server_node;
 805                 server_node* cur_node = start_node;
 806                 if( cur_node == NULL ) continue;
 807
 808                 do {
 809
 810                         char tbuf[124];
 811                         memset(tbuf,0,124);
 812                         sprintf( tbuf, "%d", (int)cur_node->reg_time );
 813                         buffer_add( buffer, tbuf );
 814                         buffer_add( buffer, " | ");
 815
 816                         memset(tbuf,0,124);
 817                         sprintf( tbuf, "%d", (int)cur_node->upd_time );
 818                         buffer_add( buffer, tbuf );
 819                         buffer_add( buffer, " | ");
 820
 821                         memset(tbuf,0,124);
 822                         sprintf( tbuf, "%d", (int)cur_node->la_time );
 823                         buffer_add( buffer, tbuf );
 824                         buffer_add( buffer, " | ");
 825
 826
 827                         char sbuf[64];
 828                         memset(sbuf,0,64);
 829                         sprintf(sbuf,"%d",cur_node->serve_count);
 830
 831                         buffer_add( buffer, "#" );
 832                         buffer_add( buffer, sbuf );
 833                         buffer_add( buffer, " | ");
 834
 835                         buffer_add( buffer, cur_class->server_class );
 836                         buffer_add( buffer, " | ");
 837
 838                         buffer_add( buffer, cur_node->remote_id );
 839
 840                         buffer_add( buffer, "\n" );
 841                         cur_node = cur_node->next;
 842
 843                 } while( cur_node != start_node );
 844
 845                 cur_class = cur_class->next;
 846
 847         }
 848
 849         info_handler( "Router returning servers query command: %s", buffer->buf );
 850
 851         transport_message* new_msg;
 852
 853         if( buffer->buf == NULL || strlen(buffer->buf) == 0 )
 854                 new_msg = message_init( "0", NULL, NULL, msg->sender, NULL );
 855         else
 856                 new_msg = message_init( buffer->buf, NULL, NULL, msg->sender, NULL );
 857
 858         client_send_message( router->jabber->t_client, new_msg );
 859         message_free( new_msg );
 860
 861         return 1;
 862
 863 }
 864
 865 int router_registrar_handle_app_request(
 866                 transport_router_registrar* router, transport_message* msg ) {
 867
 868         osrf_message* arr[ROUTER_MAX_MSGS_PER_PACKET];
 869         memset(arr, 0, ROUTER_MAX_MSGS_PER_PACKET );
 870         int num_msgs = osrf_message_from_xml( msg->body, arr );
 871
 872         int i;
 873         for( i = 0; i != num_msgs; i++ ) {
 874
 875                 osrf_message* omsg = arr[i];
 876                 osrf_message* success = NULL;
 877                 osrf_message** result = NULL;
 878                 int num_responses;
 879
 880                 char* newxml =  osrf_message_to_xml(omsg);
 881                 debug_handler( "Received potential app request from client:\n%s\n", newxml );
 882                 free(newxml);
 883
 884                 if(omsg->m_type == CONNECT) {
 885
 886                         success = osrf_message_init(
 887                                         STATUS, omsg->thread_trace, omsg->protocol );
 888
 889                         osrf_message_set_status_info(
 890                                         success, "oilsConnectStatus", "Connection Successful", OSRF_STATUS_OK );
 891
 892                 } else if( omsg->m_type == REQUEST ) {
 893
 894                         result = router_registrar_process_app_request( router, omsg, &num_responses );
 895
 896                 } else if(omsg->m_type == DISCONNECT) {
 897                         success = NULL;
 898
 899                 } else {
 900
 901                         success = osrf_message_init(
 902                                         STATUS, omsg->thread_trace, omsg->protocol );
 903                         osrf_message_set_status_info(
 904                                         success, "oilsMethodException", "Method Not Found", OSRF_STATUS_NOTFOUND );
 905                 }
 906
 907
 908                 /* now send our new message back */
 909                 if(success) {
 910
 911                         char* xml =  osrf_message_to_xml(success);
 912                         debug_handler( "Sending XML to client app request:\n%s\n", xml );
 913                         transport_message* return_m = message_init(
 914                                 xml, "", msg->thread, msg->sender, "" );
 915
 916
 917                         client_send_message(router->jabber->t_client, return_m);
 918
 919                         free(xml);
 920                         osrf_message_free(success);
 921                 } else if(result) {
 922                         int i;
 923
 924                         for(i=0; i!= num_responses; i++){
 925                                 char* xml =  osrf_message_to_xml(result[i]);
 926                                 debug_handler( "Sending XML to client app request:\n%s\n", xml );
 927                                 transport_message* return_m = message_init(
 928                                         xml, "", msg->thread, msg->sender, "" );
 929
 930
 931                                 client_send_message(router->jabber->t_client, return_m);
 932
 933                                 free(xml);
 934                                 osrf_message_free(result[i]);
 935                         }
 936
 937                         osrf_message* complete = osrf_message_init(
 938                                 STATUS, result[i-1]->thread_trace, result[i-1]->protocol );
 939                         osrf_message_set_status_info( complete,
 940                                         "oilsConnectStatus", "Request Complete", OSRF_STATUS_COMPLETE );
 941                         char* complete_xml = osrf_message_to_xml(complete);
 942                         transport_message* complete_m = message_init(
 943                                         complete_xml, "", msg->thread, msg->sender, "" );
 944                         client_send_message(router->jabber->t_client, complete_m);
 945                         free(complete_xml);
 946                         osrf_message_free(complete);
 947                         free(result);
 948
 949                 }
 950
 951         }
 952
 953         return 1;
 954
 955 }
 956
 957
 958
 959 osrf_message** router_registrar_process_app_request(
 960                 transport_router_registrar* router, osrf_message* omsg, int* num_responses ) {
 961
 962
 963         if( omsg->method_name == NULL )
 964                 return NULL;
 965
 966         osrf_message** result_array = NULL;
 967
 968
 969         debug_handler( "Received method from client: %s", omsg->method_name );
 970
 971         if(!strcmp(omsg->method_name,"opensrf.router.info.class.list")) {
 972
 973                 json* result_content = NULL;
 974
 975                 debug_handler("Processing opensrf.router.info.class.list request");
 976
 977                 result_content = json_object_new_array();
 978                 server_class_node* cur_class = router->server_class_list;
 979                 while( cur_class != NULL ) {
 980
 981                         debug_handler("Adding %s to request list", cur_class->server_class);
 982
 983                         json_object_array_add(
 984                                         result_content, json_object_new_string(cur_class->server_class));
 985                         cur_class = cur_class->next;
 986                 }
 987                 result_array = safe_malloc(sizeof(osrf_message*));
 988                 *num_responses = 1;
 989
 990                 result_array[0] = osrf_message_init(
 991                         RESULT, omsg->thread_trace, omsg->protocol );
 992                 osrf_message_set_result_content( result_array[0],
 993                                 json_object_to_json_string(result_content) );
 994                 json_object_put(result_content);
 995
 996
 997         } else if(!strcmp(omsg->method_name,"opensrf.router.info.stats")) {
 998
 999                 /* we have a server_class array which holds an array of node_objects.
1000                         each node_object contains an array of stats
1001                         */
1002
1003                 debug_handler("Processing opensrf.router.info.stats request");
1004
1005                 json* result_content = NULL;
1006                 result_content = json_object_new_object();
1007                 server_class_node* cur_class = router->server_class_list;
1008
1009                 while( cur_class != NULL ) {
1010
1011                         server_node* start_node = cur_class->current_server_node;
1012                         server_node* cur_node = start_node;
1013                         if( cur_node == NULL ) continue;
1014
1015                         json* server_object = json_object_new_object();
1016
1017                         do {
1018
1019                                 json* node_stats_array = json_object_new_array();
1020
1021                                 json* json_reg_time = json_object_new_object();
1022                                 json_object_object_add( json_reg_time, "reg_time",
1023                                                 json_object_new_int((int)cur_node->reg_time));
1024                                 json_object_array_add(  node_stats_array, json_reg_time );
1025
1026                                 json* json_upd_time = json_object_new_object();
1027                                 json_object_object_add( json_upd_time, "upd_time",
1028                                                 json_object_new_int((int)cur_node->upd_time));
1029                                 json_object_array_add( node_stats_array, json_upd_time );
1030
1031                                 json* json_la_time = json_object_new_object();
1032                                 json_object_object_add( json_la_time, "la_time",
1033                                                 json_object_new_int((int)cur_node->la_time));
1034                                 json_object_array_add( node_stats_array, json_la_time );
1035
1036                                 json* json_serve_count = json_object_new_object();
1037                                 json_object_object_add( json_serve_count, "serve_count",
1038                                                 json_object_new_int((int)cur_node->serve_count));
1039                                 json_object_array_add( node_stats_array, json_serve_count );
1040
1041                                 json_object_object_add( server_object, cur_node->remote_id, node_stats_array );
1042
1043                                 cur_node = cur_node->next;
1044
1045                         } while( cur_node != start_node );
1046
1047                         json_object_object_add(
1048                                         result_content, cur_class->server_class, server_object );
1049
1050                         cur_class = cur_class->next;
1051
1052
1053                 }
1054
1055                 result_array = safe_malloc(sizeof(osrf_message*));
1056                 *num_responses = 1;
1057
1058                 result_array[0] = osrf_message_init(
1059                         RESULT, omsg->thread_trace, omsg->protocol );
1060                 osrf_message_set_result_content( result_array[0],
1061                                 json_object_to_json_string(result_content) );
1062                 json_object_put(result_content);
1063
1064
1065         } else if(!strcmp(omsg->method_name,"opensrf.system.method.all")) {
1066
1067                 json* content = json_object_new_object();
1068                 json_object_object_add(content, "api_level", json_object_new_string("1"));
1069                 json_object_object_add(content, "api_name", json_object_new_string("opensrf.router.info.class.list"));
1070                 json_object_object_add(content, "server_class", json_object_new_string("router"));
1071                 json_object_object_add(content, "stream", json_object_new_string("0"));
1072
1073                 json* content2 = json_object_new_object();
1074                 json_object_object_add(content2, "api_level", json_object_new_string("1"));
1075                 json_object_object_add(content2, "api_name", json_object_new_string("opensrf.router.info.stats"));
1076                 json_object_object_add(content2, "server_class", json_object_new_string("router"));
1077                 json_object_object_add(content2, "stream", json_object_new_string("0"));
1078
1079                 json* content3 = json_object_new_object();
1080                 json_object_object_add(content3, "api_level", json_object_new_string("1"));
1081                 json_object_object_add(content3, "api_name", json_object_new_string("opensrf.system.method.all"));
1082                 json_object_object_add(content3, "server_class", json_object_new_string("router"));
1083                 json_object_object_add(content3, "stream", json_object_new_string("1"));
1084
1085                 result_array = safe_malloc(3*sizeof(osrf_message*));
1086                 *num_responses = 3;
1087
1088                 result_array[0] = osrf_message_init(
1089                         RESULT, omsg->thread_trace, omsg->protocol );
1090                 osrf_message_set_result_content( result_array[0], json_object_to_json_string(content) );
1091                 json_object_put(content);
1092
1093                 result_array[1] = osrf_message_init(
1094                         RESULT, omsg->thread_trace, omsg->protocol );
1095                 osrf_message_set_result_content( result_array[1], json_object_to_json_string(content2) );
1096                 json_object_put(content2);
1097
1098                 result_array[2] = osrf_message_init(
1099                         RESULT, omsg->thread_trace, omsg->protocol );
1100                 osrf_message_set_result_content( result_array[1], json_object_to_json_string(content3) );
1101                 json_object_put(content3);
1102
1103
1104         }
1105
1106
1107         if( result_array == NULL || result_array[0] == NULL )
1108                 return NULL;
1109
1110         return result_array;
1111 }
1112
1113
1114
1115
1116 int router_registrar_free( transport_router_registrar* router_registrar ) {
1117         if( router_registrar == NULL ) return 0;
1118         jabber_connect_free( router_registrar->jabber );
1119
1120         /* free the server_class list XXX */
1121         while( router_registrar->server_class_list != NULL ) {
1122                 remove_server_class(router_registrar, router_registrar->server_class_list);
1123                 debug_handler( "Removed server classes in registrar free");
1124         }
1125
1126         transport_router_registrar* router = router_registrar;
1127
1128         int i = 0;
1129
1130         while(1) {
1131
1132                 if( router->trusted_servers[i] == NULL &&
1133                                 router->trusted_clients[i] == NULL )
1134                         break;
1135
1136                 if(router->trusted_servers[i] != NULL)
1137                         free(router->trusted_servers[i]);
1138                 if(router->trusted_clients[i] != NULL)
1139                         free(router->trusted_clients[i]);
1140                 i++;
1141         }
1142
1143         free( router_registrar );
1144
1145
1146
1147         return 1;
1148 }
1149
1150
1151 int server_class_node_free( server_class_node* node ) {
1152         if( node == NULL ) { return 0; }
1153         if( node->server_class != NULL )
1154                 free( node->server_class );
1155
1156         jabber_connect_free( node->jabber );
1157
1158         /* just in case, free the list */
1159         while( node->current_server_node != NULL ) {
1160                 unregister_server_node( node, node->current_server_node->remote_id );
1161         }
1162         free( node );
1163         return 1;
1164 }
1165
1166 int server_node_free( server_node* node ) {
1167         if( node == NULL ) { return 0; }
1168         message_free( node->last_sent );
1169         free( node->remote_id );
1170         free( node );
1171         return 1;
1172 }
1173
1174 int jabber_connect_free( jabber_connect* jabber ) {
1175         if( jabber == NULL ) { return 0; }
1176         client_free( jabber->t_client );
1177         free( jabber->username );
1178         free( jabber->password );
1179         free( jabber->resource );
1180         free( jabber->server );
1181         free( jabber );
1182         return 1;
1183 }
1184
1185