From 3ab7b68b5c3969cea64ff4da396a710774ae0ecf Mon Sep 17 00:00:00 2001 From: scottmk Date: Sat, 31 Oct 2009 16:28:38 +0000 Subject: [PATCH 1/1] Tinkering with white space and comments. No substantive changes. M src/router/osrf_router.c git-svn-id: svn://svn.open-ils.org/OpenSRF/trunk@1834 9efc2488-bf62-4759-914b-345cdb29e865 --- src/router/osrf_router.c | 365 +++++++++++++++++++++++---------------- 1 file changed, 216 insertions(+), 149 deletions(-) diff --git a/src/router/osrf_router.c b/src/router/osrf_router.c index 4a888d9..87b4709 100644 --- a/src/router/osrf_router.c +++ b/src/router/osrf_router.c @@ -1,18 +1,33 @@ #include "osrf_router.h" -/* a class maintains a set of server nodes */ +/** + @file osrf_router.c + @brief Implementation of osrfRouter. +*/ + +/** + @brief Maintains a set of server nodes belonging to the same class. +*/ struct _osrfRouterClassStruct { - osrfRouter* router; /* our router handle */ - osrfHashIterator* itr; + osrfRouter* router; /**< The osrfRouter that owns this osrfRouterClass */ + osrfHashIterator* itr; /**< Iterator for set of osrfRouterNodes. */ + /** + @brief Hash store of server nodes. + + The key of each entry is a node name, and the associated data is an osrfRouterNode. + We install a callback for freeing the entries. + */ osrfHash* nodes; transport_client* connection; }; typedef struct _osrfRouterClassStruct osrfRouterClass; -/* represents a link to a single server's inbound connection */ +/** + @brief Represents a link to a single server's inbound connection. +*/ struct _osrfRouterNodeStruct { - char* remoteId; /* send message to me via this login */ - int count; /* how many message have been sent to this node */ + char* remoteId; /**< Send message to me via this login. */ + int count; /**< How many message have been sent to this node. */ transport_message* lastMessage; }; typedef struct _osrfRouterNodeStruct osrfRouterNode; @@ -41,7 +56,7 @@ static int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg, osrfMessage* omsg ); static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* msg, osrfMessage* omsg ); -static int osrfRouterHandleAppResponse( osrfRouter* router, +static int osrfRouterHandleAppResponse( osrfRouter* router, transport_message* msg, osrfMessage* omsg, const jsonObject* response ); static int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* msg, osrfMessage* omsg ); @@ -57,43 +72,66 @@ static int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* #define ROUTER_REQUEST_STATS_CLASS "opensrf.router.info.stats.class" #define ROUTER_REQUEST_STATS_CLASS_SUMMARY "opensrf.router.info.stats.class.summary" -osrfRouter* osrfNewRouter( - const char* domain, const char* name, +/** + @brief Allocate and initialize a new osrfRouter. + @param domain Domain name of Jabber server + @param name Router's username for the Jabber logon. + @param resource Router's resource name for the Jabber logon. + @param password Router's password for the Jabber logon. + @param port Jabber's port number. + @param trustedClients The array of client domains that we allow to send requests through us. + @param trustedServers The array of server domains that we allow to register, etc. with us. + @return Pointer to the newly allocated osrfRouter. + + Don't connect to Jabber yet. We'll do that later, upon a call to osrfRouterConnect(). + + The calling code is responsible for freeing the osrfRouter by calling osrfRouterFree(). +*/ +osrfRouter* osrfNewRouter( + const char* domain, const char* name, const char* resource, const char* password, int port, osrfStringArray* trustedClients, osrfStringArray* trustedServers ) { - if(!( domain && name && resource && password && port && trustedClients && trustedServers )) return NULL; + if(!( domain && name && resource && password && port && trustedClients && trustedServers )) + return NULL; - osrfRouter* router = safe_malloc(sizeof(osrfRouter)); - router->domain = strdup(domain); - router->name = strdup(name); - router->password = strdup(password); - router->resource = strdup(resource); - router->port = port; + osrfRouter* router = safe_malloc(sizeof(osrfRouter)); + router->domain = strdup(domain); + router->name = strdup(name); + router->password = strdup(password); + router->resource = strdup(resource); + router->port = port; router->trustedClients = trustedClients; router->trustedServers = trustedServers; - - router->classes = osrfNewHash(); + + router->classes = osrfNewHash(); osrfHashSetCallback(router->classes, &osrfRouterClassFree); + // Prepare to connect to Jabber, as a non-component, over TCP (not UNIX domain). router->connection = client_init( domain, port, NULL, 0 ); return router; } +/** + @brief Connect to Jabber. + @param router Pointer to the osrfRouter to connect to Jabber + @return 0 if successful, or -1 on error. + Allow up to 10 seconds for the logon to succeed. + We connect over TCP (not over a UNIX domain), as a non-component. +*/ int osrfRouterConnect( osrfRouter* router ) { if(!router) return -1; - int ret = client_connect( router->connection, router->name, + int ret = client_connect( router->connection, router->name, router->password, router->resource, 10, AUTH_DIGEST ); if( ret == 0 ) return -1; return 0; } - void osrfRouterRun( osrfRouter* router ) { if(!(router && router->classes)) return; @@ -150,20 +188,19 @@ void osrfRouterRun( osrfRouter* router ) { /** - Utility method for handling incoming requests to the router - and making sure the sender is allowed. - */ + @brief Handle incoming requests to the router and make sure the sender is allowed. + @param router Pointer to the osrfRouter. +*/ static void osrfRouterHandleIncoming( osrfRouter* router ) { if(!router) return; transport_message* msg = NULL; - //if( (msg = client_recv( router->connection, 0 )) ) { - while( (msg = client_recv( router->connection, 0 )) ) { + while( (msg = client_recv( router->connection, 0 )) ) { if( msg->sender ) { - osrfLogDebug(OSRF_LOG_MARK, + osrfLogDebug(OSRF_LOG_MARK, "osrfRouterHandleIncoming(): investigating message from %s", msg->sender); /* if the sender is not a trusted server, drop the message */ @@ -172,10 +209,11 @@ static void osrfRouterHandleIncoming( osrfRouter* router ) { memset(domain, 0, sizeof(domain)); jid_get_domain( msg->sender, domain, len - 1 ); - if(osrfStringArrayContains( router->trustedServers, domain)) + if(osrfStringArrayContains( router->trustedServers, domain)) osrfRouterHandleMessage( router, msg ); - else - osrfLogWarning( OSRF_LOG_MARK, "Received message from un-trusted server domain %s", msg->sender); + else + osrfLogWarning( OSRF_LOG_MARK, + "Received message from un-trusted server domain %s", msg->sender); } message_free(msg); @@ -183,9 +221,13 @@ static void osrfRouterHandleIncoming( osrfRouter* router ) { } /** - Utility method for handling incoming requests to a router class, - makes sure sender is a trusted client - */ + @brief Handle incoming requests to a router class. + @param router Pointer to the osrfRouter. + @param classname Class name. + @param class Pointer to an osrfRouterClass. + + Make sure sender is a trusted client. +*/ static int osrfRouterClassHandleIncoming( osrfRouter* router, const char* classname, osrfRouterClass* class ) { if(!(router && class)) return -1; @@ -195,11 +237,11 @@ static int osrfRouterClassHandleIncoming( osrfRouter* router, const char* classn while( (msg = client_recv( class->connection, 0 )) ) { - osrfLogSetXid(msg->osrf_xid); + osrfLogSetXid(msg->osrf_xid); if( msg->sender ) { - osrfLogDebug(OSRF_LOG_MARK, + osrfLogDebug(OSRF_LOG_MARK, "osrfRouterClassHandleIncoming(): investigating message from %s", msg->sender); /* if the client is not from a trusted domain, drop the message */ @@ -214,7 +256,8 @@ static int osrfRouterClassHandleIncoming( osrfRouter* router, const char* classn if( msg->is_error ) { /* handle bounced message */ - if( !(bouncedMessage = osrfRouterClassHandleBounce( router, classname, class, msg )) ) + if( !(bouncedMessage = osrfRouterClassHandleBounce( router, classname, + class, msg )) ) return -1; /* we have no one to send the requested message to */ message_free( msg ); @@ -223,29 +266,30 @@ static int osrfRouterClassHandleIncoming( osrfRouter* router, const char* classn osrfRouterClassHandleMessage( router, class, msg ); } else { - osrfLogWarning( OSRF_LOG_MARK, "Received client message from untrusted client domain %s", domain ); + osrfLogWarning( OSRF_LOG_MARK, + "Received client message from untrusted client domain %s", domain ); } } - osrfLogClearXid(); + osrfLogClearXid(); message_free( msg ); } return 0; } - - - /** - Handles top level router messages - @return 0 on success - */ + @brief Handle a top level router message. + @param router Pointer to the osrfRouter. + @param msg Pointer to the transport_message to be handled. + @return 0 on success. +*/ static int osrfRouterHandleMessage( osrfRouter* router, transport_message* msg ) { if(!(router && msg)) return -1; - if( !msg->router_command || !strcmp(msg->router_command,"")) - return osrfRouterHandleAppRequest( router, msg ); /* assume it's an app session level request */ + if( !msg->router_command || !strcmp(msg->router_command,"")) + /* assume it's an app session level request */ + return osrfRouterHandleAppRequest( router, msg ); if(!msg->router_class) return -1; @@ -257,14 +301,14 @@ static int osrfRouterHandleMessage( osrfRouter* router, transport_message* msg ) if(!class) class = osrfRouterAddClass( router, msg->router_class ); - if(class) { + if(class) { if( osrfRouterClassFindNode( class, msg->sender ) ) return 0; - else + else osrfRouterClassAddNode( class, msg->sender ); - } + } } else if( !strcmp( msg->router_command, ROUTER_UNREGISTER ) ) { @@ -280,11 +324,12 @@ static int osrfRouterHandleMessage( osrfRouter* router, transport_message* msg ) /** - Allocates and adds a new router class handler to the router's list of handlers. - Also connects the class handler to the network at @domain/ - @param router The current router instance - @param classname The name of the class this node handles. - @return 0 on success, -1 on connection error. + @brief Adds a new router class handler to the router's list of handlers. + @param router The current router instance. + @param classname The name of the class this node handles. + @return 0 on success, -1 on connection error. + + Also connects the class handler to the network at "routername@domain/classname". */ static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* classname ) { if(!(router && router->classes && classname)) return NULL; @@ -293,7 +338,7 @@ static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* clas class->nodes = osrfNewHash(); class->itr = osrfNewHashIterator(class->nodes); osrfHashSetCallback(class->nodes, &osrfRouterNodeFree); - class->router = router; + class->router = router; class->connection = client_init( router->domain, router->port, NULL, 0 ); @@ -307,18 +352,18 @@ static osrfRouterClass* osrfRouterAddClass( osrfRouter* router, const char* clas osrfRouterClassFree( (char *) classname, class ); return NULL; } - + osrfHashSet( router->classes, class, classname ); return class; } /** - Adds a new server node to the given class. - @param rclass The Router class to add the node to - @param remoteId The remote login of this node - @return 0 on success, -1 on generic error - */ + @brief Add a new server node to the given class. + @param rclass The Router class to add the node to. + @param remoteId The remote login of this node. + @return 0 on success, -1 on generic error. +*/ static int osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId ) { if(!(rclass && rclass->nodes && remoteId)) return -1; @@ -333,15 +378,15 @@ static int osrfRouterClassAddNode( osrfRouterClass* rclass, const char* remoteId return 0; } -/* copy off the lastMessage, remove the offending node, send error if it's tht last node +/* copy off the lastMessage, remove the offending node, send error if it's tht last node ? return NULL if it's the last node ? - */ +*/ /* handles case where router node is not longer reachable. copies over the data from the last sent message and returns a newly crafted suitable for treating as a newly inconing message. Removes the dead node and If there are no more nodes to send the new message to, returns NULL. - */ +*/ static transport_message* osrfRouterClassHandleBounce( osrfRouter* router, const char* classname, osrfRouterClass* rclass, transport_message* msg ) { @@ -354,22 +399,24 @@ static transport_message* osrfRouterClassHandleBounce( osrfRouter* router, if( node && osrfHashGetCount(rclass->nodes) == 1 ) { /* the last node is dead */ if( node->lastMessage ) { - osrfLogWarning( OSRF_LOG_MARK, "We lost the last node in the class, responding with error and removing..."); - - transport_message* error = message_init( - node->lastMessage->body, node->lastMessage->subject, - node->lastMessage->thread, node->lastMessage->router_from, node->lastMessage->recipient ); - message_set_osrf_xid(error, node->lastMessage->osrf_xid); + osrfLogWarning( OSRF_LOG_MARK, + "We lost the last node in the class, responding with error and removing..."); + + transport_message* error = message_init( + node->lastMessage->body, node->lastMessage->subject, + node->lastMessage->thread, node->lastMessage->router_from, + node->lastMessage->recipient ); + message_set_osrf_xid(error, node->lastMessage->osrf_xid); set_msg_error( error, "cancel", 501 ); - + /* send the error message back to the original sender */ client_send_message( rclass->connection, error ); message_free( error ); } - + return NULL; - - } else { + + } else { if( node ) { if( node->lastMessage ) { @@ -377,7 +424,7 @@ static transport_message* osrfRouterClassHandleBounce( osrfRouter* router, lastSent = message_init( node->lastMessage->body, node->lastMessage->subject, node->lastMessage->thread, "", node->lastMessage->router_from ); message_set_router_info( lastSent, node->lastMessage->router_from, NULL, NULL, NULL, 0 ); - message_set_osrf_xid( lastSent, node->lastMessage->osrf_xid ); + message_set_osrf_xid( lastSent, node->lastMessage->osrf_xid ); } } else { @@ -392,15 +439,15 @@ static transport_message* osrfRouterClassHandleBounce( osrfRouter* router, } -/** - Handles class level requests - If we get a regular message, we send it to the next node in the list of nodes - if we get an error, it's a bounce back from a previous attempt. We take the - body and thread from the last sent on the node that had the bounced message - and propogate them on to the new message being sent - @return 0 on success - */ -static int osrfRouterClassHandleMessage( +/* + Handles class level requests + If we get a regular message, we send it to the next node in the list of nodes + if we get an error, it's a bounce back from a previous attempt. We take the + body and thread from the last sent on the node that had the bounced message + and propogate them on to the new message being sent + @return 0 on success +*/ +static int osrfRouterClassHandleMessage( osrfRouter* router, osrfRouterClass* rclass, transport_message* msg ) { if(!(router && rclass && msg)) return -1; @@ -414,35 +461,41 @@ static int osrfRouterClassHandleMessage( if(node) { - transport_message* new_msg= message_init( msg->body, + transport_message* new_msg= message_init( msg->body, msg->subject, msg->thread, node->remoteId, msg->sender ); message_set_router_info( new_msg, msg->sender, NULL, NULL, NULL, 0 ); - message_set_osrf_xid( new_msg, msg->osrf_xid ); + message_set_osrf_xid( new_msg, msg->osrf_xid ); - osrfLogInfo( OSRF_LOG_MARK, "Routing message:\nfrom: [%s]\nto: [%s]", + osrfLogInfo( OSRF_LOG_MARK, "Routing message:\nfrom: [%s]\nto: [%s]", new_msg->router_from, new_msg->recipient ); message_free( node->lastMessage ); node->lastMessage = new_msg; - if ( client_send_message( rclass->connection, new_msg ) == 0 ) + if ( client_send_message( rclass->connection, new_msg ) == 0 ) node->count++; else { message_prepare_xml(new_msg); - osrfLogWarning( OSRF_LOG_MARK, "Error sending message from %s to %s\n%s", + osrfLogWarning( OSRF_LOG_MARK, "Error sending message from %s to %s\n%s", new_msg->sender, new_msg->recipient, new_msg->msg_xml ); } - } + } return 0; } /** - Removes a given class from the router, freeing as it goes - */ + @brief Remove a given class from the router, freeing as it goes + @param router Pointer to the osrfRouter. + @param classname The name of the class to be removed. + @return 0 if successful, or -1 upon error. + + The only error conditions are when one of the parameters is NULL, or when the + class name is an empty string. +*/ static int osrfRouterRemoveClass( osrfRouter* router, const char* classname ) { if(!(router && router->classes && classname)) return -1; osrfLogInfo( OSRF_LOG_MARK, "Removing router class %s", classname ); @@ -451,14 +504,14 @@ static int osrfRouterRemoveClass( osrfRouter* router, const char* classname ) { } -/** - Removes the given node from the class. Also, if this is that last node in the set, - removes the class from the router - @return 0 on successful removal with no class removal - @return 1 on successful remove with class removal - @return -1 error on removal - */ -static int osrfRouterClassRemoveNode( +/* + Removes the given node from the class. Also, if this is that last node in the set, + removes the class from the router + @return 0 on successful removal with no class removal + @return 1 on successful remove with class removal + @return -1 error on removal +*/ +static int osrfRouterClassRemoveNode( osrfRouter* router, const char* classname, const char* remoteId ) { if(!(router && router->classes && classname && remoteId)) return 0; @@ -483,32 +536,37 @@ static int osrfRouterClassRemoveNode( /** - Frees a router class object - Takes a void* since it is freed by the hash code - */ + @brief Free a router class object. + @param classname Class name. + @param c Pointer to the osrfRouterClass, cast to a void pointer. + + This function is designated to the osrfHash as a callback. +*/ static void osrfRouterClassFree( char* classname, void* c ) { if(!(classname && c)) return; osrfRouterClass* rclass = (osrfRouterClass*) c; - client_disconnect( rclass->connection ); - client_free( rclass->connection ); + client_disconnect( rclass->connection ); + client_free( rclass->connection ); osrfHashIteratorReset( rclass->itr ); osrfRouterNode* node; - while( (node = osrfHashIteratorNext(rclass->itr)) ) + while( (node = osrfHashIteratorNext(rclass->itr)) ) osrfRouterClassRemoveNode( rclass->router, classname, node->remoteId ); - osrfHashIteratorFree(rclass->itr); - osrfHashFree(rclass->nodes); + osrfHashIteratorFree(rclass->itr); + osrfHashFree(rclass->nodes); free(rclass); } - /** - Frees a router node object - Takes a void* since it is freed by the list code - */ + @brief Free an osrfRouterNode. + @param remoteId Name of router (not used). + @param n Pointer to the osrfRouterNode to be freed, cast to a void pointer. + + This is a callback installed in an osrfHash (the nodes member of an osrfRouterClass). +*/ static void osrfRouterNodeFree( char* remoteId, void* n ) { if(!n) return; osrfRouterNode* node = (osrfRouterNode*) n; @@ -522,7 +580,7 @@ void osrfRouterFree( osrfRouter* router ) { if(!router) return; osrfHashFree(router->classes); - free(router->domain); + free(router->domain); free(router->name); free(router->resource); free(router->password); @@ -536,18 +594,18 @@ void osrfRouterFree( osrfRouter* router ) { -/** - Finds the class associated with the given class name in the list of classes - */ +/* + Finds the class associated with the given class name in the list of classes +*/ static osrfRouterClass* osrfRouterFindClass( osrfRouter* router, const char* classname ) { if(!( router && router->classes && classname )) return NULL; return (osrfRouterClass*) osrfHashGet( router->classes, classname ); } -/** - Finds the router node within this class with the given remote id - */ +/* + Finds the router node within this class with the given remote id +*/ static osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass, const char* remoteId ) { if(!(rclass && remoteId)) return NULL; @@ -555,12 +613,21 @@ static osrfRouterNode* osrfRouterClassFindNode( osrfRouterClass* rclass, } +/* + Clears and populates the provided fd_set* with file descriptors + from the router's top level connection as well as each of the + router class connections + @return The largest file descriptor found in the filling process +*/ /** - Clears and populates the provided fd_set* with file descriptors - from the router's top level connection as well as each of the - router class connections - @return The largest file descriptor found in the filling process - */ + @brief Fill an fd_set with all the sockets owned by the osrfRouter. + @param router Pointer to the osrfRouter whose sockets are to be used. + @param set Pointer to the fd_set that is to be filled. + @return The largest file descriptor loaded into the fd_set; or -1 upon error. + + There's one socket for the osrfRouter as a whole, and one for each osrfRouterClass + that belongs to it. We load them all. +*/ static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set ) { if(!(router && router->classes && set)) return -1; @@ -578,13 +645,14 @@ static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set ) { if( classname && (class = osrfRouterFindClass( router, classname )) ) { sockid = class->ROUTER_SOCKFD; - + if( osrfUtilsCheckFileDescriptor( sockid ) ) { - osrfLogWarning(OSRF_LOG_MARK, - "Removing router class '%s' because of a bad top-level file descriptor [%d]", classname, sockid); + osrfLogWarning(OSRF_LOG_MARK, + "Removing router class '%s' because of a bad top-level file descriptor [%d]", + classname, sockid ); osrfRouterRemoveClass( router, classname ); - + } else { if( sockid > maxfd ) maxfd = sockid; FD_SET(sockid, set); @@ -596,10 +664,10 @@ static int _osrfRouterFillFDSet( osrfRouter* router, fd_set* set ) { return maxfd; } -/** - handles messages that don't have a 'router_command' set. They are assumed to - be app request messages - */ +/* + handles messages that don't have a 'router_command' set. They are assumed to + be app request messages +*/ static int osrfRouterHandleAppRequest( osrfRouter* router, transport_message* msg ) { int T = 32; @@ -641,12 +709,12 @@ static int osrfRouterRespondConnect( osrfRouter* router, transport_message* msg, osrfLogDebug( OSRF_LOG_MARK, "router received a CONNECT message from %s", msg->sender ); - osrf_message_set_status_info( + osrf_message_set_status_info( success, "osrfConnectStatus", "Connection Successful", OSRF_STATUS_OK ); - char* data = osrf_message_serialize(success); + char* data = osrf_message_serialize(success); - transport_message* return_m = message_init( + transport_message* return_m = message_init( data, "", msg->thread, msg->sender, "" ); client_send_message(router->connection, return_m); @@ -718,7 +786,8 @@ static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* m osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes); while( (node = osrfHashIteratorNext(node_itr)) ) { - jsonObjectSetKey( jresponse, node->remoteId, jsonNewNumberObject( (double) node->count ) ); + jsonObjectSetKey( jresponse, node->remoteId, + jsonNewNumberObject( (double) node->count ) ); } osrfHashIteratorFree(node_itr); @@ -736,7 +805,8 @@ static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* m osrfHashIterator* node_itr = osrfNewHashIterator(class->nodes); while( (node = osrfHashIteratorNext(node_itr)) ) { - jsonObjectSetKey( class_res, node->remoteId, jsonNewNumberObject( (double) node->count ) ); + jsonObjectSetKey( class_res, node->remoteId, + jsonNewNumberObject( (double) node->count ) ); } osrfHashIteratorFree(node_itr); @@ -776,19 +846,18 @@ static int osrfRouterProcessAppRequest( osrfRouter* router, transport_message* m osrfRouterHandleAppResponse( router, msg, omsg, jresponse ); - jsonObjectFree(jresponse); + jsonObjectFree(jresponse); return 0; } - -static int osrfRouterHandleMethodNFound( +static int osrfRouterHandleMethodNFound( osrfRouter* router, transport_message* msg, osrfMessage* omsg ) { osrfMessage* err = osrf_message_init( STATUS, omsg->thread_trace, 1); - osrf_message_set_status_info( err, + osrf_message_set_status_info( err, "osrfMethodException", "Router method not found", OSRF_STATUS_NOTFOUND ); char* data = osrf_message_serialize(err); @@ -805,36 +874,35 @@ static int osrfRouterHandleMethodNFound( } - -static int osrfRouterHandleAppResponse( osrfRouter* router, +static int osrfRouterHandleAppResponse( osrfRouter* router, transport_message* msg, osrfMessage* omsg, const jsonObject* response ) { if( response ) { /* send the response message */ osrfMessage* oresponse = osrf_message_init( RESULT, omsg->thread_trace, omsg->protocol ); - + char* json = jsonObjectToJSON(response); osrf_message_set_result_content( oresponse, json); - + char* data = osrf_message_serialize(oresponse); osrfLogDebug( OSRF_LOG_MARK, "Responding to client app request with data: \n%s\n", data ); transport_message* tresponse = message_init( data, "", msg->thread, msg->sender, msg->recipient ); - + client_send_message(router->connection, tresponse ); - osrfMessageFree(oresponse); + osrfMessageFree(oresponse); message_free(tresponse); free(json); free(data); } - /* now send the 'request complete' message */ osrfMessage* status = osrf_message_init( STATUS, omsg->thread_trace, 1); - osrf_message_set_status_info( status, "osrfConnectStatus", "Request Complete", OSRF_STATUS_COMPLETE ); + osrf_message_set_status_info( status, "osrfConnectStatus", "Request Complete", + OSRF_STATUS_COMPLETE ); char* statusdata = osrf_message_serialize(status); @@ -842,7 +910,6 @@ static int osrfRouterHandleAppResponse( osrfRouter* router, statusdata, "", msg->thread, msg->sender, msg->recipient ); client_send_message(router->connection, sresponse ); - free(statusdata); osrfMessageFree(status); message_free(sresponse); -- 2.43.2