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 osrfConfig* cfg = osrfConfigInit( argv[1], "router" );
28 osrfConfigSetDefaultConfig(cfg);
30 init_proc_title( argc, argv );
31 set_proc_title( "OpenSRF Router" );
33 /* load the config options */
34 char* server = osrfConfigGetValue(NULL, "/transport/server");
35 char* port = osrfConfigGetValue(NULL, "/transport/port");
36 char* unixpath = osrfConfigGetValue(NULL, "/transport/unixpath");
37 char* username = osrfConfigGetValue(NULL, "/transport/username");
38 char* password = osrfConfigGetValue(NULL, "/transport/password");
39 router_resource = osrfConfigGetValue(NULL, "/transport/resource");
40 char* con_timeout = osrfConfigGetValue(NULL, "/transport/connect_timeout" );
41 char* max_retries = osrfConfigGetValue(NULL, "/transport/max_reconnect_attempts" );
42 char* component = osrfConfigGetValue(NULL, "/component" );
44 fprintf(stderr, "Router connecting with uname %s, server %s, port %s, unixpath %s",
45 username, server, port, unixpath );
47 /* set up the logger */
48 char* level = osrfConfigGetValue(NULL, "/loglevel");
49 char* log_file = osrfConfigGetValue(NULL, "/logfile");
51 int llevel = atoi(level);
52 fprintf(stderr, "Level %d; file %s\n", llevel, log_file );
54 if(!log_init( llevel, log_file ))
55 fprintf(stderr, "Unable to init logging, going to stderr...\n" );
61 fprintf(stderr, "Router connecting as \nserver: %s \nport: %s \nunixpath: %s\nuser:%s \nresource:%s\n",
62 server, port, unixpath, username, router_resource );
65 if(port) iport = atoi( port );
67 int con_itimeout = atoi( con_timeout );
68 int max_retries_ = atoi(max_retries);
71 icomponent = atoi(component);
73 /* build the router_registrar */
74 transport_router_registrar* router_registrar =
75 router_registrar_init( server, iport, unixpath, username, password, router_resource, 0, con_itimeout, icomponent );
77 routt = router_registrar;
89 signal(SIGHUP,sig_hup_handler);
90 signal(SIGINT,sig_hup_handler);
91 signal(SIGTERM,sig_hup_handler);
95 /* wait for incoming... */
96 while( ++counter <= max_retries_ ) {
98 /* connect to jabber */
99 if( router_registrar_connect( router_registrar ) ) {
100 info_handler( "Connected..." );
101 fprintf(stderr, "- Connected -\n");
103 listen_loop( router_registrar );
105 fatal_handler( "Could not connect to Jabber Server" );
107 /* this should never happen */
108 warning_handler( "Jabber server probably went away, attempting reconnect" );
114 router_registrar_free( router_registrar );
119 transport_router_registrar* router_registrar_init( char* server,
120 int port, char* unixpath, char* username, char* password,
121 char* resource, int client_timeout, int con_timeout, int component ) {
123 if( server == NULL ) { return NULL; }
125 /* allocate a new router_registrar object */
126 size_t size = sizeof( transport_router_registrar );
127 transport_router_registrar* router_registrar = (transport_router_registrar*) safe_malloc( size );
129 router_registrar->client_timeout = client_timeout;
130 router_registrar->jabber = jabber_connect_init( server, port, unixpath, username, password, resource, con_timeout, component );
131 _build_trusted_sites( router_registrar );
133 return router_registrar;
136 void _build_trusted_sites( transport_router_registrar* router ) {
138 router->trusted_servers = osrfNewStringArray(4);
139 router->trusted_clients = osrfNewStringArray(4);
140 osrfConfigGetValueList(NULL, router->trusted_servers, "/trusted_domains/server" );
141 osrfConfigGetValueList(NULL, router->trusted_clients, "/trusted_domains/client" );
143 if(router->trusted_servers->size < 1 ||
144 router->trusted_clients->size < 1 )
145 fatal_handler( "You must specify at least one trusted server and client in the config file");
149 jabber_connect* jabber_connect_init(
150 char* server, int port, char* unixpath, char* username,
151 char* password, char* resource, int connect_timeout, int component ) {
153 size_t len = sizeof(jabber_connect);
154 jabber_connect* jabber = (jabber_connect*) safe_malloc( len );
157 jabber->connect_timeout = connect_timeout;
158 jabber->unixpath = strdup(unixpath);
160 jabber->server = strdup(server);
161 jabber->username = strdup(username);
162 jabber->password = strdup(password);
163 jabber->resource = strdup(resource);
165 if( jabber->server == NULL || jabber->username == NULL ||
166 jabber->password == NULL || jabber->resource == NULL ) {
167 fatal_handler( "jabber_init(): Out of Memory" );
171 /* build the transport client */
172 jabber->t_client = client_init( jabber->server, jabber->port, unixpath, component );
177 /* connect the router_registrar to jabber */
178 int router_registrar_connect( transport_router_registrar* router ) {
179 return j_connect( router->jabber );
182 /* connect a jabber_connect object jabber */
183 int j_connect( jabber_connect* jabber ) {
184 if( jabber == NULL ) { return 0; }
185 return client_connect( jabber->t_client,
186 jabber->username, jabber->password, jabber->resource,
187 jabber->connect_timeout, AUTH_DIGEST );
190 int fill_fd_set( transport_router_registrar* router, fd_set* set ) {
195 int router_fd = router->jabber->t_client->session->sock_id;
197 FD_SET( router_fd, set );
199 server_class_node* cur_node = router->server_class_list;
200 while( cur_node != NULL ) {
201 int cur_class_fd = cur_node->jabber->t_client->session->sock_id;
202 if( cur_class_fd > max_fd )
203 max_fd = cur_class_fd;
204 FD_SET( cur_class_fd, set );
205 cur_node = cur_node->next;
213 void listen_loop( transport_router_registrar* router ) {
219 int router_fd = router->jabber->t_client->session->sock_id;
220 transport_message* cur_msg;
225 int max_fd = fill_fd_set( router, &listen_set );
228 fatal_handler( "fill_fd_set return bogus max_fd: %d", max_fd );
231 info_handler( "Router going into select() wait..." );
233 if( (select_ret=select(max_fd+ 1, &listen_set, NULL, NULL, NULL)) < 0 ) {
235 warning_handler( "Select returned error %d", select_ret );
236 warning_handler( "Select Error %d on fd %d", errno );
237 perror( "Select Error" );
238 warning_handler( "Errors: EBADF %d, EINTR %d, EINVAL %d, ENOMEM %d",
239 EBADF, EINTR, EINVAL, ENOMEM );
244 info_handler( "Select returned %d", select_ret );
246 if( FD_ISSET( router_fd, &listen_set ) ) {
247 cur_msg = client_recv( router->jabber->t_client, 1 );
249 /* We only process a message if we have some trusted servers and the current
250 message came from one of those servers */
253 if( router->trusted_servers->size > 0 ) {
258 if( cur_msg->sender ) {
260 int len = strlen(cur_msg->sender) + 1; /* there's no way it could be that big, but... */
261 char server_buf[len];
262 memset(server_buf,0,len);
263 jid_get_domain( cur_msg->sender, server_buf );
264 info_handler("Received top level message from %s", server_buf );
267 char* domain = osrfStringArrayGetString(router->trusted_servers, i);
269 if(!strcmp(domain, server_buf)) {
279 router_registrar_handle_msg( router, cur_msg );
281 warning_handler( "Received top level message from unpriveleged sender %s", cur_msg->sender );
284 message_free( cur_msg );
287 if( ++num_handled == select_ret )
291 /* cycle through the children and find any whose fd's are ready for reading */
292 server_class_node* cur_node = router->server_class_list;
293 while( cur_node != NULL ) {
294 debug_handler( "Checking File Descriptor" );
295 int cur_fd = cur_node->jabber->t_client->session->sock_id;
297 debug_handler("Router checking file descriptor %d", cur_fd);
299 if( FD_ISSET(cur_fd, &listen_set) ) {
301 FD_CLR(cur_fd,&listen_set);
303 debug_handler("Router has data on file descriptor %d", cur_fd);
304 cur_msg = client_recv( cur_node->jabber->t_client, 1 );
308 info_handler( "%s received from %s", cur_node->server_class, cur_msg->sender );
309 int handle_ret = server_class_handle_msg( router, cur_node, cur_msg );
311 if( handle_ret == -1 ) {
312 warning_handler( "server_class_handle_msg() returned -1" );
313 cur_node = router->server_class_list; /*start over*/
316 } else if( handle_ret == 0 ) {
317 /* delete and continue */
318 warning_handler( "server_class_handle_msg() returned 0" );
319 remove_server_class( router, cur_node );
320 debug_handler( "Removed Server Class" );
321 cur_node = router->server_class_list; /*start over*/
325 info_handler( "%s handled message successfully", cur_node->server_class );
326 /* dont free message here */
327 if( num_handled == select_ret )
333 if( num_handled == select_ret )
336 cur_node = cur_node->next;
338 } /* cycling through the server_class list */
340 } /* no select errors */
345 /* determine where to route top level messages */
346 int router_registrar_handle_msg( transport_router_registrar* router_registrar, transport_message* msg ) {
348 info_handler( "Received class: %s : command %s ", msg->router_class, msg->router_command );
350 if( router_registrar == NULL || msg == NULL ) { return 0; }
352 if( msg->router_command == NULL || !strcmp(msg->router_command,"") ) {
353 return router_registrar_handle_app_request( router_registrar, msg );
356 // user issued a ruoter query
357 /* a query command has router_command="query" and the actual query type
358 is the content of the message */
359 if( !strcmp(msg->router_command,"query")) {
360 info_handler( "Router received query command" );
362 // user issues a servers query
363 if( !strcmp(msg->body, "servers")) {
365 info_handler( "Router received servers query command" );
366 router_return_server_info( router_registrar, msg );
372 info_handler("Looking for server_class_node %s...",msg->router_class);
373 server_class_node* active_class_node = find_server_class( router_registrar, msg->router_class );
375 if( active_class_node == NULL ) {
376 info_handler("Could not find server_class_node %s, creating one.",msg->router_class);
378 /* there is no server_class for msg->router_class so we build it here */
379 if( strcmp( msg->router_command, "register") == 0 ) {
381 info_handler("Adding server_class_node for %s",msg->router_class);
383 init_server_class( router_registrar, msg->sender, msg->router_class );
385 if( active_class_node == NULL ) {
386 fatal_handler( "router_listen(): active_class_node == NULL for %s", msg->sender );
390 if (router_registrar->server_class_list != NULL) {
391 active_class_node->next = router_registrar->server_class_list;
392 router_registrar->server_class_list->prev = active_class_node;
394 router_registrar->server_class_list = active_class_node;
396 //spawn_server_class( (void*) active_class_node );
399 warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
400 msg->router_command, msg->router_class );
403 } else if( strcmp( msg->router_command, "register") == 0 ) {
404 /* there is a server_class for msg->router_class so we
405 need to either add a new server_node or update the existing one */
408 server_node* s_node = find_server_node( active_class_node, msg->sender );
410 if( s_node != NULL ) {
411 s_node->available = 1;
412 s_node->upd_time = time(NULL);
413 info_handler( "Found matching registered server: %s. Updating.",
416 s_node = init_server_node( msg->sender );
418 info_handler( "Adding server_node for: %s.", s_node->remote_id );
420 if (s_node == NULL ) {
421 warning_handler( " Could not create new xerver_node for %s.",
426 s_node->next = active_class_node->current_server_node->next;
427 s_node->prev = active_class_node->current_server_node;
429 active_class_node->current_server_node->next->prev = s_node;
430 active_class_node->current_server_node->next = s_node;
434 } else if( strcmp( msg->router_command, "unregister") == 0 ) {
436 if( ! unregister_server_node( active_class_node, msg->sender ) ) {
437 remove_server_class( router_registrar, active_class_node );
438 debug_handler( "Removed server class after final unregister");
442 warning_handler( "router_register_handler_msg(): Bad Command [%s] for class [%s]",
443 msg->router_command, msg->router_class );
450 /* removes a server class node from the top level router_registrar */
451 int unregister_server_node( server_class_node* active_class_node, char* remote_id ) {
453 server_node* d_node = find_server_node( active_class_node, remote_id );
455 if ( d_node != NULL ) {
457 info_handler( "Removing server_node for: %s.", d_node->remote_id );
459 if ( d_node->next == NULL ) {
460 warning_handler( "NEXT is NULL in ring [%s] -- "
461 "THIS SHOULD NEVER HAPPEN",
466 if ( d_node->prev == NULL ) {
467 warning_handler( "PREV is NULL in a ring [%s] -- "
468 "THIS SHOULD NEVER HAPPEN",
473 if ( d_node->next == d_node && d_node->prev == d_node) {
474 info_handler( "Last node, setting ring to NULL: %s.",
477 active_class_node->current_server_node = NULL;
479 server_node_free( d_node );
483 info_handler( "Nodes remain, splicing: %s, %s",
484 d_node->prev->remote_id,
485 d_node->next->remote_id);
487 info_handler( "d_node => %x, next => %x, prev => %x",
488 d_node, d_node->next, d_node->prev );
491 d_node->prev->next = d_node->next;
492 d_node->next->prev = d_node->prev;
494 info_handler( "prev => %x, prev->next => %x, prev->prev => %x",
495 d_node->prev, d_node->prev->next, d_node->prev->prev );
497 info_handler( "next => %x, next->next => %x, next->prev => %x",
498 d_node->next, d_node->next->next, d_node->next->prev );
500 if (active_class_node->current_server_node == d_node)
501 active_class_node->current_server_node = d_node->next;
504 server_node_free( d_node );
511 server_node * find_server_node ( server_class_node * class, const char * remote_id ) {
513 if ( class == NULL ) {
514 warning_handler(" find_server_node(): bad arg!");
518 server_node * start_node = class->current_server_node;
519 server_node * node = class->current_server_node;
525 if ( strcmp(node->remote_id, remote_id) == 0 )
530 } while ( node != start_node );
535 /* if we return -1, then we just deleted the server_class you were looking for
536 if we return 0, then some other error has occured
537 we return 1 otherwise */
538 int remove_server_class( transport_router_registrar* router, server_class_node* class ) {
542 transport_message * msg = NULL;
543 while ( (msg = client_recv(class->jabber->t_client, 0)) != NULL ) {
544 debug_handler( "Looping on messages to dead class" );
545 if( server_class_handle_msg(router, class, msg) < 0 ) {
546 debug_handler( "This class was freed by a recursive call, exiting 'remove_server_class'");
547 //message_free(msg); - this will be freed by server_class_handle_msg
548 debug_handler( "Message Freed");
555 free( class->server_class );
556 class->server_class = NULL;
558 find_server_class( router, router_resource ); /* find deletes for us */
559 debug_handler( "Successfuly called 'find_server_class' on class to delete" );
561 if( router->server_class_list == NULL )
566 server_class_node * find_server_class ( transport_router_registrar * router, const char * class_id ) {
568 if ( router == NULL ) {
569 warning_handler(" find_server_class(): bad arg!");
573 info_handler( "Finding server class for %s", class_id );
574 server_class_node * class = router->server_class_list;
575 server_class_node * dead_class = NULL;
577 while ( class != NULL ) {
579 if ( class->server_class == NULL ) {
580 info_handler( "Found an empty server class" );
582 if ( class->prev != NULL ) {
583 class->prev->next = class->next;
584 if( class->next != NULL ) {
585 class->next->prev = class->prev;
589 info_handler( "Empty class is the first on the list" );
590 if( class->next != NULL )
591 router->server_class_list = class->next;
593 else { /* we're the last class node in the class node list */
594 info_handler( "Empty class is the last on the list" );
595 server_class_node_free( router->server_class_list );
596 router->server_class_list = NULL;
605 info_handler( "Tossing our dead class" );
606 server_class_node_free( dead_class );
612 if ( strcmp(class->server_class, class_id) == 0 )
614 info_handler( "%s != %s", class->server_class, class_id );
619 debug_handler( "Returning NULL from find_server_class()" );
623 /* builds a new server class and connects to the jabber server with the new resource */
624 server_class_node* init_server_class(
625 transport_router_registrar* router, char* remote_id, char* server_class ) {
627 size_t len = sizeof( server_class_node );
628 server_class_node* node = (server_class_node*) safe_malloc( len );
630 node->jabber = jabber_connect_init( router->jabber->server,
631 router->jabber->port, router->jabber->unixpath, router->jabber->username,
632 router->jabber->password, server_class, router->jabber->connect_timeout, router->component );
636 node->server_class = strdup( server_class );
637 if( server_class == NULL ) {
638 fatal_handler( "imit_server_class(): out of memory for %s", server_class );
642 info_handler( "Received class to init_server_class: %s", server_class );
643 node->current_server_node = init_server_node( remote_id );
644 if( node->current_server_node == NULL ) {
645 fatal_handler( "init_server_class(): NULL server_node for %s", remote_id );
650 if( ! j_connect( node->jabber ) ) {
651 fatal_handler( "Unable to init server class %s", node->server_class );
655 info_handler( "Jabber address in init for %s : address %x : username %s : resource %s",
656 node->server_class, node->jabber->t_client->session->sock_id,
657 node->jabber->username, node->jabber->resource );
663 /* builds a new server_node to be added to the ring of server_nodes */
664 server_node* init_server_node( char* remote_id ) {
666 info_handler( "Initing server node for %s", remote_id );
667 server_node* current_server_node;
668 size_t size = sizeof( server_node);
669 current_server_node = (server_node*) safe_malloc( size );
671 current_server_node->remote_id = strdup(remote_id);
672 if( current_server_node->remote_id == NULL ) {
673 fatal_handler("init_server_class(): Out of Memory for %s", remote_id );
677 current_server_node->reg_time = time(NULL);
678 current_server_node->available = 1;
679 current_server_node->next = current_server_node;
680 current_server_node->prev = current_server_node;
683 return current_server_node;
687 int server_class_handle_msg( transport_router_registrar* router,
688 server_class_node* s_node, transport_message* msg ) {
690 if( s_node->current_server_node == NULL ) {
691 /* return error to client ??!*/
692 /* WE have no one to send the message to */
693 warning_handler( "We no longer have any servers for %s : "
694 "no one to send the message to. Sending error message to %s", s_node->server_class, msg->sender );
695 free( msg->recipient );
697 char* rec = strdup( msg->sender );
699 fatal_handler( "class msg_handler: out of memory");
703 info_handler( "Building error message to return for %s", s_node->server_class);
704 msg->recipient = rec;
705 set_msg_error(msg, "cancel", 501);
707 client_send_message( s_node->jabber->t_client, msg );
710 remove_server_class( router, s_node );
711 debug_handler( "Successfully removed server class" );
716 info_handler( "[%s] Received \nfrom: %s \nto: %s",
717 s_node->server_class, msg->sender, msg->recipient );
719 if( msg->is_error ) {
720 warning_handler( "We've received an error message type: %s : code: %d",
721 msg->error_type, msg->error_code );
723 if( strcmp( msg->error_type, "cancel" ) == 0 ) {
724 warning_handler( "Looks like we've lost a server!" );
725 server_node* dead_node = find_server_node( s_node, msg->sender );
727 if( dead_node != NULL ) {
728 //message_free( msg );
729 transport_message* tmp = dead_node->last_sent;
731 /* copy over last sent, it will be freed in the unregister function */
732 transport_message* tmp2 = message_init( tmp->body, tmp->subject, tmp->thread,
733 tmp->recipient, tmp->sender );
735 message_set_router_info( tmp2, tmp->router_from,
736 tmp->router_to, tmp->router_class, tmp->router_command, tmp->broadcast );
738 if( ! unregister_server_node( s_node, dead_node->remote_id ) ) {
739 /* WE have no one to send the message to */
740 warning_handler( "We no longer have any servers for %s : "
741 "no one to send the message to.", s_node->server_class );
742 free( msg->recipient );
744 char* rec = strdup( msg->router_from );
746 fatal_handler( "class msg_handler: out of memory");
750 info_handler( "Building error message to return for %s", s_node->server_class);
751 msg->recipient = rec;
752 client_send_message( s_node->jabber->t_client, msg );
753 message_free( tmp2 );
765 server_node* c_node = s_node->current_server_node->next;
767 /* not implemented yet */
768 while( ! c_node->available ) {
769 if( c_node == s_node->current_server_node ) {
770 warning_handler("No server_node's are available for %s", s_node->server_class );
771 /* XXX send error message to client */
774 c_node = c_node->next;
776 s_node->current_server_node = c_node;
778 transport_message * new_msg =
779 message_init( msg->body, msg->subject, msg->thread,
780 s_node->current_server_node->remote_id, msg->sender );
782 message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 );
784 info_handler( "[%s] Routing message from [%s]\nto [%s]", s_node->server_class, msg->sender, new_msg->recipient );
785 //info_handler( "New Message Details: sender:%s recipient: %s \nbody: %s",
786 // new_msg->sender, new_msg->recipient, new_msg->body );
788 message_free( s_node->current_server_node->last_sent );
789 s_node->current_server_node->last_sent = msg;
791 if ( new_msg != NULL && client_send_message( s_node->jabber->t_client, new_msg ) ) {
792 s_node->current_server_node->serve_count++;
793 s_node->current_server_node->la_time = time(NULL);
794 message_free( new_msg ); // XXX
797 message_free( new_msg ); // XXX
803 int router_return_server_info(
804 transport_router_registrar* router, transport_message* msg ) {
806 server_class_node* cur_class = router->server_class_list;
807 growing_buffer* buffer = buffer_init(1024);
809 while( cur_class != NULL ) {
811 server_node* start_node = cur_class->current_server_node;
812 server_node* cur_node = start_node;
813 if( cur_node == NULL ) continue;
819 sprintf( tbuf, "%d", (int)cur_node->reg_time );
820 buffer_add( buffer, tbuf );
821 buffer_add( buffer, " | ");
824 sprintf( tbuf, "%d", (int)cur_node->upd_time );
825 buffer_add( buffer, tbuf );
826 buffer_add( buffer, " | ");
829 sprintf( tbuf, "%d", (int)cur_node->la_time );
830 buffer_add( buffer, tbuf );
831 buffer_add( buffer, " | ");
836 sprintf(sbuf,"%d",cur_node->serve_count);
838 buffer_add( buffer, "#" );
839 buffer_add( buffer, sbuf );
840 buffer_add( buffer, " | ");
842 buffer_add( buffer, cur_class->server_class );
843 buffer_add( buffer, " | ");
845 buffer_add( buffer, cur_node->remote_id );
847 buffer_add( buffer, "\n" );
848 cur_node = cur_node->next;
850 } while( cur_node != start_node );
852 cur_class = cur_class->next;
856 info_handler( "Router returning servers query command: %s", buffer->buf );
858 transport_message* new_msg;
860 if( buffer->buf == NULL || strlen(buffer->buf) == 0 )
861 new_msg = message_init( "0", NULL, NULL, msg->sender, NULL );
863 new_msg = message_init( buffer->buf, NULL, NULL, msg->sender, NULL );
865 client_send_message( router->jabber->t_client, new_msg );
866 message_free( new_msg );
872 int router_registrar_handle_app_request(
873 transport_router_registrar* router, transport_message* msg ) {
875 osrf_message* arr[ROUTER_MAX_MSGS_PER_PACKET];
876 memset(arr, 0, ROUTER_MAX_MSGS_PER_PACKET );
877 //int num_msgs = osrf_message_from_xml( msg->body, arr );
878 int num_msgs = osrf_message_deserialize( msg->body, arr, ROUTER_MAX_MSGS_PER_PACKET );
881 for( i = 0; i != num_msgs; i++ ) {
883 osrf_message* omsg = arr[i];
884 osrf_message* success = NULL;
885 osrf_message** result = NULL;
888 //char* newxml = osrf_message_to_xml(omsg);
889 //debug_handler( "Received potential app request from client:\n%s\n", newxml );
892 if(omsg->m_type == CONNECT) {
894 success = osrf_message_init(
895 STATUS, omsg->thread_trace, omsg->protocol );
897 osrf_message_set_status_info(
898 success, "osrfConnectStatus", "Connection Successful", OSRF_STATUS_OK );
900 } else if( omsg->m_type == REQUEST ) {
902 result = router_registrar_process_app_request( router, omsg, &num_responses );
904 } else if(omsg->m_type == DISCONNECT) {
909 success = osrf_message_init(
910 STATUS, omsg->thread_trace, omsg->protocol );
911 osrf_message_set_status_info(
912 success, "osrfMethodException", "Method Not Found", OSRF_STATUS_NOTFOUND );
916 /* now send our new message back */
919 char* xml = osrf_message_serialize(success);
920 debug_handler( "Sending XML to client app request:\n%s\n", xml );
921 transport_message* return_m = message_init(
922 xml, "", msg->thread, msg->sender, "" );
925 client_send_message(router->jabber->t_client, return_m);
928 osrf_message_free(success);
932 for(i=0; i!= num_responses; i++){
933 char* xml = osrf_message_serialize(result[i]);
934 debug_handler( "Sending XML to client app request:\n%s\n", xml );
935 transport_message* return_m = message_init(
936 xml, "", msg->thread, msg->sender, "" );
939 client_send_message(router->jabber->t_client, return_m);
942 osrf_message_free(result[i]);
945 osrf_message* complete = osrf_message_init(
946 STATUS, result[i-1]->thread_trace, result[i-1]->protocol );
947 osrf_message_set_status_info( complete,
948 "osrfConnectStatus", "Request Complete", OSRF_STATUS_COMPLETE );
949 char* complete_xml = osrf_message_serialize(complete);
950 transport_message* complete_m = message_init(
951 complete_xml, "", msg->thread, msg->sender, "" );
952 client_send_message(router->jabber->t_client, complete_m);
954 osrf_message_free(complete);
968 osrf_message** router_registrar_process_app_request(
969 transport_router_registrar* router, osrf_message* omsg, int* num_responses ) {
972 if( omsg->method_name == NULL )
975 osrf_message** result_array = NULL;
978 debug_handler( "Received method from client: %s", omsg->method_name );
980 if(!strcmp(omsg->method_name,"opensrf.router.info.class.list")) {
982 jsonObject* result_content = jsonParseString("[]");
984 debug_handler("Processing opensrf.router.info.class.list request");
986 server_class_node* cur_class = router->server_class_list;
987 while( cur_class != NULL ) {
989 debug_handler("Adding %s to request list", cur_class->server_class);
991 jsonObjectPush(result_content, jsonNewObject(cur_class->server_class));
992 cur_class = cur_class->next;
994 result_array = safe_malloc(sizeof(osrf_message*));
997 result_array[0] = osrf_message_init(
998 RESULT, omsg->thread_trace, omsg->protocol );
1000 osrf_message_set_result_content( result_array[0], jsonObjectToJSON(result_content));
1001 jsonObjectFree(result_content);
1004 } else if(!strcmp(omsg->method_name,"opensrf.router.info.stats")) {
1006 /* we have a server_class array which holds an array of node_objects.
1007 each node_object contains an array of stats
1010 debug_handler("Processing opensrf.router.info.stats request");
1012 jsonObject* result_content = jsonParseString("{}");
1014 server_class_node* cur_class = router->server_class_list;
1016 while( cur_class != NULL ) {
1018 server_node* start_node = cur_class->current_server_node;
1019 server_node* cur_node = start_node;
1020 if( cur_node == NULL ) continue;
1022 jsonObject* server_object = jsonParseString("{}");
1026 jsonObject* node_stats_array = jsonParseString("[]");
1028 jsonObject* json_reg_time = jsonParseString("{}");
1030 jsonObjectSetKey( json_reg_time, "reg_time",
1031 jsonNewNumberObject((double) cur_node->reg_time));
1033 jsonObjectPush( node_stats_array, json_reg_time );
1035 jsonObject* json_upd_time = jsonParseString("{}");
1038 jsonObjectSetKey( json_upd_time, "upd_time",
1039 jsonNewNumberObject((int)cur_node->upd_time));
1043 jsonObjectPush( node_stats_array, json_upd_time );
1047 jsonObject* json_la_time = jsonParseString("{}");
1051 jsonObjectSetKey( json_la_time, "la_time",
1052 jsonNewNumberObject((int)cur_node->la_time));
1055 jsonObjectPush( node_stats_array, json_la_time );
1057 jsonObject* json_serve_count = jsonParseString("{}");
1060 jsonObjectSetKey( json_serve_count, "serve_count",
1061 jsonNewNumberObject((int)cur_node->serve_count));
1064 jsonObjectPush( node_stats_array, json_serve_count );
1067 jsonObjectSetKey( server_object, cur_node->remote_id, node_stats_array );
1069 cur_node = cur_node->next;
1071 } while( cur_node != start_node );
1073 jsonObjectSetKey( result_content, cur_class->server_class, server_object );
1075 cur_class = cur_class->next;
1080 result_array = safe_malloc(sizeof(osrf_message*));
1083 result_array[0] = osrf_message_init(
1084 RESULT, omsg->thread_trace, omsg->protocol );
1086 osrf_message_set_result_content(result_array[0], jsonObjectToJSON(result_content));
1088 jsonObjectFree(result_content);
1091 } else if(!strcmp(omsg->method_name,"opensrf.system.method.all")) {
1093 jsonObject* content = jsonParseString("{}");
1094 jsonObjectSetKey(content, "api_level", jsonNewObject("1"));
1095 jsonObjectSetKey(content, "api_name", jsonNewObject("opensrf.router.info.class.list"));
1096 jsonObjectSetKey(content, "server_class", jsonNewObject("router"));
1097 jsonObjectSetKey(content, "stream", jsonNewObject("0"));
1099 jsonObject* content2 = jsonParseString("{}");
1100 jsonObjectSetKey(content2, "api_level", jsonNewObject("1"));
1101 jsonObjectSetKey(content2, "api_name", jsonNewObject("opensrf.router.info.stats"));
1102 jsonObjectSetKey(content2, "server_class", jsonNewObject("router"));
1103 jsonObjectSetKey(content2, "stream", jsonNewObject("0"));
1105 jsonObject* content3 = jsonParseString("{}");
1106 jsonObjectSetKey(content3, "api_level", jsonNewObject("1"));
1107 jsonObjectSetKey(content3, "api_name", jsonNewObject("opensrf.system.method.all"));
1108 jsonObjectSetKey(content3, "server_class", jsonNewObject("router"));
1109 jsonObjectSetKey(content3, "stream", jsonNewObject("1"));
1111 result_array = safe_malloc(3*sizeof(osrf_message*));
1114 result_array[0] = osrf_message_init(
1115 RESULT, omsg->thread_trace, omsg->protocol );
1117 osrf_message_set_result_content( result_array[0], jsonObjectToJSON(content));
1118 jsonObjectFree(content);
1120 result_array[1] = osrf_message_init(
1121 RESULT, omsg->thread_trace, omsg->protocol );
1122 osrf_message_set_result_content( result_array[1], jsonObjectToJSON(content2) );
1123 jsonObjectFree(content2);
1125 result_array[2] = osrf_message_init(
1126 RESULT, omsg->thread_trace, omsg->protocol );
1127 osrf_message_set_result_content( result_array[1], jsonObjectToJSON(content3) );
1128 jsonObjectFree(content3);
1134 if( result_array == NULL || result_array[0] == NULL )
1137 return result_array;
1143 int router_registrar_free( transport_router_registrar* router_registrar ) {
1144 if( router_registrar == NULL ) return 0;
1145 jabber_connect_free( router_registrar->jabber );
1147 /* free the server_class list XXX */
1148 while( router_registrar->server_class_list != NULL ) {
1149 remove_server_class(router_registrar, router_registrar->server_class_list);
1150 debug_handler( "Removed server classes in registrar free");
1153 osrfStringArrayFree(router_registrar->trusted_servers);
1154 osrfStringArrayFree(router_registrar->trusted_clients);
1156 free( router_registrar );
1161 int server_class_node_free( server_class_node* node ) {
1162 if( node == NULL ) { return 0; }
1163 if( node->server_class != NULL )
1164 free( node->server_class );
1166 jabber_connect_free( node->jabber );
1168 /* just in case, free the list */
1169 while( node->current_server_node != NULL ) {
1170 unregister_server_node( node, node->current_server_node->remote_id );
1176 int server_node_free( server_node* node ) {
1177 if( node == NULL ) { return 0; }
1178 message_free( node->last_sent );
1179 free( node->remote_id );
1184 int jabber_connect_free( jabber_connect* jabber ) {
1185 if( jabber == NULL ) { return 0; }
1186 client_free( jabber->t_client );
1187 free( jabber->unixpath );
1188 free( jabber->username );
1189 free( jabber->password );
1190 free( jabber->resource );
1191 free( jabber->server );