5 #define ROUTER_MAX_MSGS_PER_PACKET 256
7 transport_router_registrar* routt;
8 void _build_trusted_sites( transport_router_registrar* router );
11 void sig_hup_handler( int a ) {
12 router_registrar_free( routt );
15 free( router_resource );
20 int main( int argc, char* argv[] ) {
23 fatal_handler( "Usage: %s <path_to_config_file>", argv[0] );
27 config_reader_init( "opensrf.router", argv[1] );
28 if( conf_reader == NULL ) fatal_handler( "main(): Config is NULL" );
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* unixpath = config_value("opensrf.router", "//router/transport/unixpath");
34 char* username = config_value("opensrf.router", "//router/transport/username");
35 char* password = config_value("opensrf.router", "//router/transport/password");
36 router_resource = config_value("opensrf.router", "//router/transport/resource");
37 char* con_timeout = config_value("opensrf.router", "//router/transport/connect_timeout" );
38 char* max_retries = config_value("opensrf.router", "//router/transport/max_reconnect_attempts" );
39 char* component = config_value("opensrf.router", "//router/component" );
42 /* set up the logger */
43 char* level = config_value("opensrf.router","//log/level");
44 char* log_file = config_value("opensrf.router","//log/file");
45 int llevel = atoi(level);
46 fprintf(stderr, "Level %d; file %s\n", llevel, log_file );
48 if(!log_init( llevel, log_file ))
49 fprintf(stderr, "Unable to init logging, going to stderr...\n" );
55 fprintf(stderr, "Router connecting as \nserver: %s \nport: %s \nunixpath: %s\nuser:%s \nresource:%s\n",
56 server, port, unixpath, username, router_resource );
59 if(port) iport = atoi( port );
61 int con_itimeout = atoi( con_timeout );
62 int max_retries_ = atoi(max_retries);
65 icomponent = atoi(component);
67 /* build the router_registrar */
68 transport_router_registrar* router_registrar =
69 router_registrar_init( server, iport, unixpath, username, password, router_resource, 0, con_itimeout, icomponent );
71 routt = router_registrar;
83 signal(SIGHUP,sig_hup_handler);
84 signal(SIGINT,sig_hup_handler);
85 signal(SIGTERM,sig_hup_handler);
89 /* wait for incoming... */
90 while( ++counter <= max_retries_ ) {
92 /* connect to jabber */
93 if( router_registrar_connect( router_registrar ) ) {
94 info_handler( "Connected..." );
95 fprintf(stderr, "- Connected -\n");
97 listen_loop( router_registrar );
99 fatal_handler( "Could not connect to Jabber Server" );
101 /* this should never happen */
102 warning_handler( "Jabber server probably went away, attempting reconnect" );
108 router_registrar_free( router_registrar );
109 config_reader_free();
114 transport_router_registrar* router_registrar_init( char* server,
115 int port, char* unixpath, char* username, char* password,
116 char* resource, int client_timeout, int con_timeout, int component ) {
118 if( server == NULL ) { return NULL; }
120 /* allocate a new router_registrar object */
121 size_t size = sizeof( transport_router_registrar );
122 transport_router_registrar* router_registrar = (transport_router_registrar*) safe_malloc( size );
124 router_registrar->client_timeout = client_timeout;
125 router_registrar->jabber = jabber_connect_init( server, port, unixpath, username, password, resource, con_timeout, component );
126 _build_trusted_sites( router_registrar );
127 info_handler( "Trusted stuff %s, %s, %s", router_registrar->trusted_servers[0],
128 router_registrar->trusted_clients[0], router_registrar->trusted_clients[1] );
129 return router_registrar;
133 void _build_trusted_sites( transport_router_registrar* router ) {
135 router->trusted_servers = (char**) safe_malloc(sizeof(char**));
136 router->trusted_clients = (char**) safe_malloc(sizeof(char**));
138 *(router->trusted_servers) = (char*) safe_malloc(ROUTER_MAX_TRUSTED);
139 *(router->trusted_clients) = (char*) safe_malloc(ROUTER_MAX_TRUSTED);
143 char* server = config_value("opensrf.router","//router/trusted_domains/server%d", i );
147 router->trusted_servers[i-1] = server;
152 char* client = config_value( "opensrf.router","//router/trusted_domains/client%d", i );
155 router->trusted_clients[i-1] = client;
158 if( router->trusted_servers[0] == NULL ||
159 router->trusted_clients[0] == NULL )
161 fatal_handler( "You must specify at least one trusted server and client in the config file");
165 jabber_connect* jabber_connect_init(
166 char* server, int port, char* unixpath, char* username,
167 char* password, char* resource, int connect_timeout, int component ) {
169 size_t len = sizeof(jabber_connect);
170 jabber_connect* jabber = (jabber_connect*) safe_malloc( len );
173 jabber->connect_timeout = connect_timeout;
174 jabber->unixpath = strdup(unixpath);
176 jabber->server = strdup(server);
177 jabber->username = strdup(username);
178 jabber->password = strdup(password);
179 jabber->resource = strdup(resource);
181 if( jabber->server == NULL || jabber->username == NULL ||
182 jabber->password == NULL || jabber->resource == NULL ) {
183 fatal_handler( "jabber_init(): Out of Memory" );
187 /* build the transport client */
188 jabber->t_client = client_init( jabber->server, jabber->port, unixpath, component );
193 /* connect the router_registrar to jabber */
194 int router_registrar_connect( transport_router_registrar* router ) {
195 return j_connect( router->jabber );
198 /* connect a jabber_connect object jabber */
199 int j_connect( jabber_connect* jabber ) {
200 if( jabber == NULL ) { return 0; }
201 return client_connect( jabber->t_client,
202 jabber->username, jabber->password, jabber->resource,
203 jabber->connect_timeout, AUTH_DIGEST );
206 int fill_fd_set( transport_router_registrar* router, fd_set* set ) {
211 int router_fd = router->jabber->t_client->session->sock_id;
213 FD_SET( router_fd, set );
215 server_class_node* cur_node = router->server_class_list;
216 while( cur_node != NULL ) {
217 int cur_class_fd = cur_node->jabber->t_client->session->sock_id;
218 if( cur_class_fd > max_fd )
219 max_fd = cur_class_fd;
220 FD_SET( cur_class_fd, set );
221 cur_node = cur_node->next;
229 void listen_loop( transport_router_registrar* router ) {
235 int router_fd = router->jabber->t_client->session->sock_id;
236 transport_message* cur_msg;
241 int max_fd = fill_fd_set( router, &listen_set );
244 fatal_handler( "fill_fd_set return bogus max_fd: %d", max_fd );
247 info_handler( "Router going into select() wait..." );
249 if( (select_ret=select(max_fd+ 1, &listen_set, NULL, NULL, NULL)) < 0 ) {
251 warning_handler( "Select returned error %d", select_ret );
252 warning_handler( "Select Error %d on fd %d", errno );
253 perror( "Select Error" );
254 warning_handler( "Errors: EBADF %d, EINTR %d, EINVAL %d, ENOMEM %d",
255 EBADF, EINTR, EINVAL, ENOMEM );
260 info_handler( "Select returned %d", select_ret );
262 if( FD_ISSET( router_fd, &listen_set ) ) {
263 cur_msg = client_recv( router->jabber->t_client, 1 );
265 /* We only process a message if we have some trusted servers and the current
266 message came from one of those servers */
269 if(router->trusted_servers && router->trusted_servers[0]) {
274 if( cur_msg->sender ) {
276 int len = strlen(cur_msg->sender) + 1; /* there's no way it could be that big, but... */
277 char server_buf[len];
278 memset(server_buf,0,len);
279 jid_get_domain( cur_msg->sender, server_buf );
280 info_handler("Received top level message from %s", server_buf );
283 if(router->trusted_servers[i] == NULL)
285 if(!strcmp(router->trusted_servers[i], server_buf)) {
294 router_registrar_handle_msg( router, cur_msg );
296 warning_handler( "Received top level message from unpriveleged sender %s", cur_msg->sender );
299 message_free( cur_msg );
302 if( ++num_handled == select_ret )
306 /* cycle through the children and find any whose fd's are ready for reading */
307 server_class_node* cur_node = router->server_class_list;
308 while( cur_node != NULL ) {
309 debug_handler( "Checking File Descriptor" );
310 int cur_fd = cur_node->jabber->t_client->session->sock_id;
312 debug_handler("Router checking file descriptor %d", cur_fd);
314 if( FD_ISSET(cur_fd, &listen_set) ) {
316 FD_CLR(cur_fd,&listen_set);
318 debug_handler("Router has data on file descriptor %d", cur_fd);
319 cur_msg = client_recv( cur_node->jabber->t_client, 1 );
323 info_handler( "%s received from %s", cur_node->server_class, cur_msg->sender );
324 int handle_ret = server_class_handle_msg( router, cur_node, cur_msg );
326 if( handle_ret == -1 ) {
327 warning_handler( "server_class_handle_msg() returned -1" );
328 cur_node = router->server_class_list; /*start over*/
331 } else if( handle_ret == 0 ) {
332 /* delete and continue */
333 warning_handler( "server_class_handle_msg() returned 0" );
334 remove_server_class( router, cur_node );
335 debug_handler( "Removed Server Class" );
336 cur_node = router->server_class_list; /*start over*/
340 info_handler( "%s handled message successfully", cur_node->server_class );
341 /* dont free message here */
342 if( num_handled == select_ret )
348 if( num_handled == select_ret )
351 cur_node = cur_node->next;
353 } /* cycling through the server_class list */
355 } /* no select errors */
360 /* determine where to route top level messages */
361 int router_registrar_handle_msg( transport_router_registrar* router_registrar, transport_message* msg ) {
363 info_handler( "Received class: %s : command %s ", msg->router_class, msg->router_command );
365 if( router_registrar == NULL || msg == NULL ) { return 0; }
367 if( msg->router_command == NULL || !strcmp(msg->router_command,"") ) {
368 return router_registrar_handle_app_request( router_registrar, msg );
371 // user issued a ruoter query
372 /* a query command has router_command="query" and the actual query type
373 is the content of the message */
374 if( !strcmp(msg->router_command,"query")) {
375 info_handler( "Router received query command" );
377 // user issues a servers query
378 if( !strcmp(msg->body, "servers")) {
380 info_handler( "Router received servers query command" );
381 router_return_server_info( router_registrar, msg );
387 info_handler("Looking for server_class_node %s...",msg->router_class);
388 server_class_node* active_class_node = find_server_class( router_registrar, msg->router_class );
390 if( active_class_node == NULL ) {
391 info_handler("Could not find server_class_node %s, creating one.",msg->router_class);
393 /* there is no server_class for msg->router_class so we build it here */
394 if( strcmp( msg->router_command, "register") == 0 ) {
396 info_handler("Adding server_class_node for %s",msg->router_class);
398 init_server_class( router_registrar, msg->sender, msg->router_class );
400 if( active_class_node == NULL ) {
401 fatal_handler( "router_listen(): active_class_node == NULL for %s", msg->sender );
405 if (router_registrar->server_class_list != NULL) {
406 active_class_node->next = router_registrar->server_class_list;
407 router_registrar->server_class_list->prev = active_class_node;
409 router_registrar->server_class_list = active_class_node;
411 //spawn_server_class( (void*) active_class_node );
414 warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
415 msg->router_command, msg->router_class );
418 } else if( strcmp( msg->router_command, "register") == 0 ) {
419 /* there is a server_class for msg->router_class so we
420 need to either add a new server_node or update the existing one */
423 server_node* s_node = find_server_node( active_class_node, msg->sender );
425 if( s_node != NULL ) {
426 s_node->available = 1;
427 s_node->upd_time = time(NULL);
428 info_handler( "Found matching registered server: %s. Updating.",
431 s_node = init_server_node( msg->sender );
433 info_handler( "Adding server_node for: %s.", s_node->remote_id );
435 if (s_node == NULL ) {
436 warning_handler( " Could not create new xerver_node for %s.",
441 s_node->next = active_class_node->current_server_node->next;
442 s_node->prev = active_class_node->current_server_node;
444 active_class_node->current_server_node->next->prev = s_node;
445 active_class_node->current_server_node->next = s_node;
449 } else if( strcmp( msg->router_command, "unregister") == 0 ) {
451 if( ! unregister_server_node( active_class_node, msg->sender ) ) {
452 remove_server_class( router_registrar, active_class_node );
453 debug_handler( "Removed server class after final unregister");
457 warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
458 msg->router_command, msg->router_class );
465 /* removes a server class node from the top level router_registrar */
466 int unregister_server_node( server_class_node* active_class_node, char* remote_id ) {
468 server_node* d_node = find_server_node( active_class_node, remote_id );
470 if ( d_node != NULL ) {
472 info_handler( "Removing server_node for: %s.", d_node->remote_id );
474 if ( d_node->next == NULL ) {
475 warning_handler( "NEXT is NULL in ring [%s] -- "
476 "THIS SHOULD NEVER HAPPEN",
481 if ( d_node->prev == NULL ) {
482 warning_handler( "PREV is NULL in a ring [%s] -- "
483 "THIS SHOULD NEVER HAPPEN",
488 if ( d_node->next == d_node && d_node->prev == d_node) {
489 info_handler( "Last node, setting ring to NULL: %s.",
492 active_class_node->current_server_node = NULL;
494 server_node_free( d_node );
498 info_handler( "Nodes remain, splicing: %s, %s",
499 d_node->prev->remote_id,
500 d_node->next->remote_id);
502 info_handler( "d_node => %x, next => %x, prev => %x",
503 d_node, d_node->next, d_node->prev );
506 d_node->prev->next = d_node->next;
507 d_node->next->prev = d_node->prev;
509 info_handler( "prev => %x, prev->next => %x, prev->prev => %x",
510 d_node->prev, d_node->prev->next, d_node->prev->prev );
512 info_handler( "next => %x, next->next => %x, next->prev => %x",
513 d_node->next, d_node->next->next, d_node->next->prev );
515 if (active_class_node->current_server_node == d_node)
516 active_class_node->current_server_node = d_node->next;
519 server_node_free( d_node );
526 server_node * find_server_node ( server_class_node * class, const char * remote_id ) {
528 if ( class == NULL ) {
529 warning_handler(" find_server_node(): bad arg!");
533 server_node * start_node = class->current_server_node;
534 server_node * node = class->current_server_node;
540 if ( strcmp(node->remote_id, remote_id) == 0 )
545 } while ( node != start_node );
550 /* if we return -1, then we just deleted the server_class you were looking for
551 if we return 0, then some other error has occured
552 we return 1 otherwise */
553 int remove_server_class( transport_router_registrar* router, server_class_node* class ) {
557 transport_message * msg = NULL;
558 while ( (msg = client_recv(class->jabber->t_client, 0)) != NULL ) {
559 debug_handler( "Looping on messages to dead class" );
560 if( server_class_handle_msg(router, class, msg) < 0 ) {
561 debug_handler( "This class was freed by a recursive call, exiting 'remove_server_class'");
562 //message_free(msg); - this will be freed by server_class_handle_msg
563 debug_handler( "Message Freed");
570 free( class->server_class );
571 class->server_class = NULL;
573 find_server_class( router, router_resource ); /* find deletes for us */
574 debug_handler( "Successfuly called 'find_server_class' on class to delete" );
576 if( router->server_class_list == NULL )
581 server_class_node * find_server_class ( transport_router_registrar * router, const char * class_id ) {
583 if ( router == NULL ) {
584 warning_handler(" find_server_class(): bad arg!");
588 info_handler( "Finding server class for %s", class_id );
589 server_class_node * class = router->server_class_list;
590 server_class_node * dead_class = NULL;
592 while ( class != NULL ) {
594 if ( class->server_class == NULL ) {
595 info_handler( "Found an empty server class" );
597 if ( class->prev != NULL ) {
598 class->prev->next = class->next;
599 if( class->next != NULL ) {
600 class->next->prev = class->prev;
604 info_handler( "Empty class is the first on the list" );
605 if( class->next != NULL )
606 router->server_class_list = class->next;
608 else { /* we're the last class node in the class node list */
609 info_handler( "Empty class is the last on the list" );
610 server_class_node_free( router->server_class_list );
611 router->server_class_list = NULL;
620 info_handler( "Tossing our dead class" );
621 server_class_node_free( dead_class );
627 if ( strcmp(class->server_class, class_id) == 0 )
629 info_handler( "%s != %s", class->server_class, class_id );
634 debug_handler( "Returning NULL from find_server_class()" );
638 /* builds a new server class and connects to the jabber server with the new resource */
639 server_class_node* init_server_class(
640 transport_router_registrar* router, char* remote_id, char* server_class ) {
642 size_t len = sizeof( server_class_node );
643 server_class_node* node = (server_class_node*) safe_malloc( len );
645 node->jabber = jabber_connect_init( router->jabber->server,
646 router->jabber->port, router->jabber->unixpath, router->jabber->username,
647 router->jabber->password, server_class, router->jabber->connect_timeout, router->component );
651 node->server_class = strdup( server_class );
652 if( server_class == NULL ) {
653 fatal_handler( "imit_server_class(): out of memory for %s", server_class );
657 info_handler( "Received class to init_server_class: %s", server_class );
658 node->current_server_node = init_server_node( remote_id );
659 if( node->current_server_node == NULL ) {
660 fatal_handler( "init_server_class(): NULL server_node for %s", remote_id );
665 if( ! j_connect( node->jabber ) ) {
666 fatal_handler( "Unable to init server class %s", node->server_class );
670 info_handler( "Jabber address in init for %s : address %x : username %s : resource %s",
671 node->server_class, node->jabber->t_client->session->sock_id,
672 node->jabber->username, node->jabber->resource );
678 /* builds a new server_node to be added to the ring of server_nodes */
679 server_node* init_server_node( char* remote_id ) {
681 info_handler( "Initing server node for %s", remote_id );
682 server_node* current_server_node;
683 size_t size = sizeof( server_node);
684 current_server_node = (server_node*) safe_malloc( size );
686 current_server_node->remote_id = strdup(remote_id);
687 if( current_server_node->remote_id == NULL ) {
688 fatal_handler("init_server_class(): Out of Memory for %s", remote_id );
692 current_server_node->reg_time = time(NULL);
693 current_server_node->available = 1;
694 current_server_node->next = current_server_node;
695 current_server_node->prev = current_server_node;
698 return current_server_node;
702 int server_class_handle_msg( transport_router_registrar* router,
703 server_class_node* s_node, transport_message* msg ) {
705 if( s_node->current_server_node == NULL ) {
706 /* return error to client ??!*/
707 /* WE have no one to send the message to */
708 warning_handler( "We no longer have any servers for %s : "
709 "no one to send the message to. Sending error message to %s", s_node->server_class, msg->sender );
710 free( msg->recipient );
712 char* rec = strdup( msg->sender );
714 fatal_handler( "class msg_handler: out of memory");
718 info_handler( "Building error message to return for %s", s_node->server_class);
719 msg->recipient = rec;
720 set_msg_error(msg, "cancel", 501);
722 client_send_message( s_node->jabber->t_client, msg );
725 remove_server_class( router, s_node );
726 debug_handler( "Successfully removed server class" );
731 info_handler( "[%s] Received \nfrom: %s \nto: %s",
732 s_node->server_class, msg->sender, msg->recipient );
734 if( msg->is_error ) {
735 warning_handler( "We've received an error message type: %s : code: %d",
736 msg->error_type, msg->error_code );
738 if( strcmp( msg->error_type, "cancel" ) == 0 ) {
739 warning_handler( "Looks like we've lost a server!" );
740 server_node* dead_node = find_server_node( s_node, msg->sender );
742 if( dead_node != NULL ) {
743 //message_free( msg );
744 transport_message* tmp = dead_node->last_sent;
746 /* copy over last sent, it will be freed in the unregister function */
747 transport_message* tmp2 = message_init( tmp->body, tmp->subject, tmp->thread,
748 tmp->recipient, tmp->sender );
750 message_set_router_info( tmp2, tmp->router_from,
751 tmp->router_to, tmp->router_class, tmp->router_command, tmp->broadcast );
753 if( ! unregister_server_node( s_node, dead_node->remote_id ) ) {
754 /* WE have no one to send the message to */
755 warning_handler( "We no longer have any servers for %s : "
756 "no one to send the message to.", s_node->server_class );
757 free( msg->recipient );
759 char* rec = strdup( msg->router_from );
761 fatal_handler( "class msg_handler: out of memory");
765 info_handler( "Building error message to return for %s", s_node->server_class);
766 msg->recipient = rec;
767 client_send_message( s_node->jabber->t_client, msg );
768 message_free( tmp2 );
780 server_node* c_node = s_node->current_server_node->next;
782 /* not implemented yet */
783 while( ! c_node->available ) {
784 if( c_node == s_node->current_server_node ) {
785 warning_handler("No server_node's are available for %s", s_node->server_class );
786 /* XXX send error message to client */
789 c_node = c_node->next;
791 s_node->current_server_node = c_node;
793 transport_message * new_msg =
794 message_init( msg->body, msg->subject, msg->thread,
795 s_node->current_server_node->remote_id, msg->sender );
797 message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 );
799 info_handler( "[%s] Routing message from [%s]\nto [%s]", s_node->server_class, msg->sender, new_msg->recipient );
800 //info_handler( "New Message Details: sender:%s recipient: %s \nbody: %s",
801 // new_msg->sender, new_msg->recipient, new_msg->body );
803 message_free( s_node->current_server_node->last_sent );
804 s_node->current_server_node->last_sent = msg;
806 if ( new_msg != NULL && client_send_message( s_node->jabber->t_client, new_msg ) ) {
807 s_node->current_server_node->serve_count++;
808 s_node->current_server_node->la_time = time(NULL);
809 message_free( new_msg ); // XXX
812 message_free( new_msg ); // XXX
818 int router_return_server_info(
819 transport_router_registrar* router, transport_message* msg ) {
821 server_class_node* cur_class = router->server_class_list;
822 growing_buffer* buffer = buffer_init(1024);
824 while( cur_class != NULL ) {
826 server_node* start_node = cur_class->current_server_node;
827 server_node* cur_node = start_node;
828 if( cur_node == NULL ) continue;
834 sprintf( tbuf, "%d", (int)cur_node->reg_time );
835 buffer_add( buffer, tbuf );
836 buffer_add( buffer, " | ");
839 sprintf( tbuf, "%d", (int)cur_node->upd_time );
840 buffer_add( buffer, tbuf );
841 buffer_add( buffer, " | ");
844 sprintf( tbuf, "%d", (int)cur_node->la_time );
845 buffer_add( buffer, tbuf );
846 buffer_add( buffer, " | ");
851 sprintf(sbuf,"%d",cur_node->serve_count);
853 buffer_add( buffer, "#" );
854 buffer_add( buffer, sbuf );
855 buffer_add( buffer, " | ");
857 buffer_add( buffer, cur_class->server_class );
858 buffer_add( buffer, " | ");
860 buffer_add( buffer, cur_node->remote_id );
862 buffer_add( buffer, "\n" );
863 cur_node = cur_node->next;
865 } while( cur_node != start_node );
867 cur_class = cur_class->next;
871 info_handler( "Router returning servers query command: %s", buffer->buf );
873 transport_message* new_msg;
875 if( buffer->buf == NULL || strlen(buffer->buf) == 0 )
876 new_msg = message_init( "0", NULL, NULL, msg->sender, NULL );
878 new_msg = message_init( buffer->buf, NULL, NULL, msg->sender, NULL );
880 client_send_message( router->jabber->t_client, new_msg );
881 message_free( new_msg );
887 int router_registrar_handle_app_request(
888 transport_router_registrar* router, transport_message* msg ) {
890 osrf_message* arr[ROUTER_MAX_MSGS_PER_PACKET];
891 memset(arr, 0, ROUTER_MAX_MSGS_PER_PACKET );
892 //int num_msgs = osrf_message_from_xml( msg->body, arr );
893 int num_msgs = osrf_message_deserialize( msg->body, arr, ROUTER_MAX_MSGS_PER_PACKET );
896 for( i = 0; i != num_msgs; i++ ) {
898 osrf_message* omsg = arr[i];
899 osrf_message* success = NULL;
900 osrf_message** result = NULL;
903 //char* newxml = osrf_message_to_xml(omsg);
904 //debug_handler( "Received potential app request from client:\n%s\n", newxml );
907 if(omsg->m_type == CONNECT) {
909 success = osrf_message_init(
910 STATUS, omsg->thread_trace, omsg->protocol );
912 osrf_message_set_status_info(
913 success, "oilsConnectStatus", "Connection Successful", OSRF_STATUS_OK );
915 } else if( omsg->m_type == REQUEST ) {
917 result = router_registrar_process_app_request( router, omsg, &num_responses );
919 } else if(omsg->m_type == DISCONNECT) {
924 success = osrf_message_init(
925 STATUS, omsg->thread_trace, omsg->protocol );
926 osrf_message_set_status_info(
927 success, "oilsMethodException", "Method Not Found", OSRF_STATUS_NOTFOUND );
931 /* now send our new message back */
934 //char* xml = osrf_message_to_xml(success);
935 char* xml = osrf_message_serialize(success);
936 debug_handler( "Sending XML to client app request:\n%s\n", xml );
937 transport_message* return_m = message_init(
938 xml, "", msg->thread, msg->sender, "" );
941 client_send_message(router->jabber->t_client, return_m);
944 osrf_message_free(success);
948 for(i=0; i!= num_responses; i++){
949 //char* xml = osrf_message_to_xml(result[i]);
950 char* xml = osrf_message_serialize(result[i]);
951 debug_handler( "Sending XML to client app request:\n%s\n", xml );
952 transport_message* return_m = message_init(
953 xml, "", msg->thread, msg->sender, "" );
956 client_send_message(router->jabber->t_client, return_m);
959 osrf_message_free(result[i]);
962 osrf_message* complete = osrf_message_init(
963 STATUS, result[i-1]->thread_trace, result[i-1]->protocol );
964 osrf_message_set_status_info( complete,
965 "oilsConnectStatus", "Request Complete", OSRF_STATUS_COMPLETE );
966 //char* complete_xml = osrf_message_to_xml(complete);
967 char* complete_xml = osrf_message_serialize(complete);
968 transport_message* complete_m = message_init(
969 complete_xml, "", msg->thread, msg->sender, "" );
970 client_send_message(router->jabber->t_client, complete_m);
972 osrf_message_free(complete);
986 osrf_message** router_registrar_process_app_request(
987 transport_router_registrar* router, osrf_message* omsg, int* num_responses ) {
990 if( omsg->method_name == NULL )
993 osrf_message** result_array = NULL;
996 debug_handler( "Received method from client: %s", omsg->method_name );
998 if(!strcmp(omsg->method_name,"opensrf.router.info.class.list")) {
1000 object* result_content = json_parse_string("[]");
1002 debug_handler("Processing opensrf.router.info.class.list request");
1004 server_class_node* cur_class = router->server_class_list;
1005 while( cur_class != NULL ) {
1007 debug_handler("Adding %s to request list", cur_class->server_class);
1009 result_content->push(result_content, new_object(cur_class->server_class));
1010 cur_class = cur_class->next;
1012 result_array = safe_malloc(sizeof(osrf_message*));
1015 result_array[0] = osrf_message_init(
1016 RESULT, omsg->thread_trace, omsg->protocol );
1018 osrf_message_set_result_content( result_array[0], object_to_json(result_content));
1019 free_object(result_content);
1022 } else if(!strcmp(omsg->method_name,"opensrf.router.info.stats")) {
1024 /* we have a server_class array which holds an array of node_objects.
1025 each node_object contains an array of stats
1028 debug_handler("Processing opensrf.router.info.stats request");
1030 object* result_content = json_parse_string("{}");
1032 server_class_node* cur_class = router->server_class_list;
1034 while( cur_class != NULL ) {
1036 server_node* start_node = cur_class->current_server_node;
1037 server_node* cur_node = start_node;
1038 if( cur_node == NULL ) continue;
1040 object* server_object = json_parse_string("{}");
1044 object* node_stats_array = json_parse_string("[]");
1046 object* json_reg_time = json_parse_string("{}");
1048 object_add_key( json_reg_time, "reg_time",
1049 new_int_object((int) cur_node->reg_time));
1051 object_push( node_stats_array, json_reg_time );
1053 object* json_upd_time = json_parse_string("{}");
1056 object_add_key( json_upd_time, "upd_time",
1057 new_int_object((int)cur_node->upd_time));
1061 object_push( node_stats_array, json_upd_time );
1065 object* json_la_time = json_parse_string("{}");
1069 object_add_key( json_la_time, "la_time",
1070 new_int_object((int)cur_node->la_time));
1073 object_push( node_stats_array, json_la_time );
1075 object* json_serve_count = json_parse_string("{}");
1078 object_add_key( json_serve_count, "serve_count",
1079 new_int_object((int)cur_node->serve_count));
1082 object_push( node_stats_array, json_serve_count );
1085 object_add_key( server_object, cur_node->remote_id, node_stats_array );
1087 cur_node = cur_node->next;
1089 } while( cur_node != start_node );
1091 object_add_key( result_content, cur_class->server_class, server_object );
1093 cur_class = cur_class->next;
1098 result_array = safe_malloc(sizeof(osrf_message*));
1101 result_array[0] = osrf_message_init(
1102 RESULT, omsg->thread_trace, omsg->protocol );
1104 osrf_message_set_result_content(result_array[0], object_to_json(result_content));
1106 free_object(result_content);
1109 } else if(!strcmp(omsg->method_name,"opensrf.system.method.all")) {
1111 object* content = json_parse_string("{}");
1112 object_add_key(content, "api_level", new_object("1"));
1113 object_add_key(content, "api_name", new_object("opensrf.router.info.class.list"));
1114 object_add_key(content, "server_class", new_object("router"));
1115 object_add_key(content, "stream", new_object("0"));
1117 object* content2 = json_parse_string("{}");
1118 object_add_key(content2, "api_level", new_object("1"));
1119 object_add_key(content2, "api_name", new_object("opensrf.router.info.stats"));
1120 object_add_key(content2, "server_class", new_object("router"));
1121 object_add_key(content2, "stream", new_object("0"));
1123 object* content3 = json_parse_string("{}");
1124 object_add_key(content3, "api_level", new_object("1"));
1125 object_add_key(content3, "api_name", new_object("opensrf.system.method.all"));
1126 object_add_key(content3, "server_class", new_object("router"));
1127 object_add_key(content3, "stream", new_object("1"));
1129 result_array = safe_malloc(3*sizeof(osrf_message*));
1132 result_array[0] = osrf_message_init(
1133 RESULT, omsg->thread_trace, omsg->protocol );
1135 osrf_message_set_result_content( result_array[0], object_to_json(content));
1136 free_object(content);
1138 result_array[1] = osrf_message_init(
1139 RESULT, omsg->thread_trace, omsg->protocol );
1140 osrf_message_set_result_content( result_array[1], object_to_json(content2) );
1141 free_object(content2);
1143 result_array[2] = osrf_message_init(
1144 RESULT, omsg->thread_trace, omsg->protocol );
1145 osrf_message_set_result_content( result_array[1], object_to_json(content3) );
1146 free_object(content3);
1152 if( result_array == NULL || result_array[0] == NULL )
1155 return result_array;
1161 int router_registrar_free( transport_router_registrar* router_registrar ) {
1162 if( router_registrar == NULL ) return 0;
1163 jabber_connect_free( router_registrar->jabber );
1165 /* free the server_class list XXX */
1166 while( router_registrar->server_class_list != NULL ) {
1167 remove_server_class(router_registrar, router_registrar->server_class_list);
1168 debug_handler( "Removed server classes in registrar free");
1171 //transport_router_registrar* router = router_registrar;
1177 if( router->trusted_servers[i] == NULL &&
1178 router->trusted_clients[i] == NULL )
1181 if(router->trusted_servers[i] != NULL)
1182 free(router->trusted_servers[i]);
1183 if(router->trusted_clients[i] != NULL)
1184 free(router->trusted_clients[i]);
1189 free( router_registrar );
1194 int server_class_node_free( server_class_node* node ) {
1195 if( node == NULL ) { return 0; }
1196 if( node->server_class != NULL )
1197 free( node->server_class );
1199 jabber_connect_free( node->jabber );
1201 /* just in case, free the list */
1202 while( node->current_server_node != NULL ) {
1203 unregister_server_node( node, node->current_server_node->remote_id );
1209 int server_node_free( server_node* node ) {
1210 if( node == NULL ) { return 0; }
1211 message_free( node->last_sent );
1212 free( node->remote_id );
1217 int jabber_connect_free( jabber_connect* jabber ) {
1218 if( jabber == NULL ) { return 0; }
1219 client_free( jabber->t_client );
1220 free( jabber->unixpath );
1221 free( jabber->username );
1222 free( jabber->password );
1223 free( jabber->resource );
1224 free( jabber->server );