Patch from Scott McKellar:
[OpenSRF.git] / src / jserver / osrf_chat.c
index 0a2a7c2..f09d636 100644 (file)
@@ -16,12 +16,17 @@ GNU General Public License for more details.
 #include "osrf_chat.h"
 #include <string.h>
 #include <stdio.h>
+#include <time.h>
 
-int __osrfChatXMLErrorOcurred = 0;
-int __osrfChatClientSentDisconnect = 0;
+static int osrfChatXMLErrorOcurred = 0;
+
+/* This is used by code in osrfChatPushData, but that code is
+   currently commented out.  Uncomment the next line if needed. */
+//static int osrfChatClientSentDisconnect = 0;
 
 /* shorter version of strcmp */
 static int eq(const char* a, const char* b) { return (a && b && !strcmp(a,b)); }
+//#define eq(a,b) ((a && b && !strcmp(a,b)) ? 1 : 0)
 
 /* gnarly debug function */
 static void chatdbg( osrfChatServer* server ) {
@@ -66,7 +71,7 @@ static void chatdbg( osrfChatServer* server ) {
                        node->to, node->resource, node->username, node->domain, node->authkey, node->type );
        }
 
-       debug_handler("DEBUG:\n%s", buf->buf );
+       osrfLogDebug( OSRF_LOG_MARK, "DEBUG:\n%s", buf->buf );
        buffer_free(buf);
        osrfListIteratorFree(itr);
 }
@@ -76,27 +81,29 @@ osrfChatServer* osrfNewChatServer( char* domain, char* secret, int s2sport ) {
 
        osrfChatServer* server = safe_malloc(sizeof(osrfChatServer));
 
-       server->nodeHash = osrfNewHash();
-       server->nodeList = osrfNewList();
+       server->nodeHash        = osrfNewHash();
+       server->nodeList        = osrfNewList();
        server->deadNodes = osrfNewList();
        server->nodeList->freeItem = &osrfChatNodeFree;
-       server->domain = strdup(domain);
-       server->s2sport = s2sport;
+       server->domain          = strdup(domain);
+       server->secret      = strdup(secret);
+       server->s2sport = s2sport;
+       server->port        = 0;
 
+       // Build socket manager
        server->mgr = safe_malloc(sizeof(socket_manager));
        server->mgr->data_received = &osrfChatHandleData;
+       server->mgr->socket = NULL;
        server->mgr->blob = server;
        server->mgr->on_socket_closed = &osrfChatSocketClosed;
 
-       if(secret) server->secret = strdup(secret);
        return server;
 }
 
 void osrfChatCleanupClients( osrfChatServer* server ) {
-       if(server) {
-               osrfListFree(server->deadNodes);
-               server->deadNodes = osrfNewList();
-       }
+       if(!server) return;
+       osrfListFree(server->deadNodes);
+       server->deadNodes = osrfNewList();
 }
 
 
@@ -104,7 +111,11 @@ void osrfChatCleanupClients( osrfChatServer* server ) {
 osrfChatNode* osrfNewChatNode( int sockid, char* domain ) {
        if(sockid < 1 || !domain) return NULL;
        osrfChatNode* node      = safe_malloc(sizeof(osrfChatNode));
+       node->sockid            = 0;
+       node->remote            = NULL;
        node->state                             = OSRF_CHAT_STATE_NONE;
+       node->xmlstate          = 0;
+       node->inparse           = 0;
        node->msgs                              = NULL; /* only s2s nodes cache messages */
        node->parserCtx         = xmlCreatePushParserCtxt(osrfChatSaxHandler, node, "", 0, NULL);
        node->msgDoc                    = xmlNewDoc(BAD_CAST "1.0");
@@ -115,6 +126,7 @@ osrfChatNode* osrfNewChatNode( int sockid, char* domain ) {
        node->resource                  = NULL;
        node->to                                        = NULL;
        node->type = 0;
+       node->parent            = NULL;
        return node;
 }
 
@@ -181,7 +193,7 @@ int osrfChatServerWait( osrfChatServer* server ) {
        if(!server) return -1;
        while(1) {
                if(socket_wait_all(server->mgr, -1) < 0)
-                       warning_handler( "jserver_wait(): socket_wait_all() returned error");
+                       osrfLogWarning( OSRF_LOG_MARK,  "jserver_wait(): socket_wait_all() returned error");
        }
        return -1;
 }
@@ -191,8 +203,12 @@ void osrfChatServerFree(osrfChatServer* server ) {
        if(!server) return;
        osrfHashFree(server->nodeHash);
        osrfListFree(server->nodeList);
-       free(server->mgr);
+       osrfListFree(server->deadNodes);
+       socket_manager_free(server->mgr);
+       free(server->domain);
        free(server->secret);
+
+       free(server);
 }
 
 
@@ -205,14 +221,19 @@ void osrfChatHandleData( void* cs,
 
        osrfChatNode* node = osrfListGetIndex( server->nodeList, sockid );
 
+       if(node)
+               osrfLogDebug( OSRF_LOG_MARK, "Found node for sockid %d with state %d", sockid, node->state);
+
        if(!node) {
-               debug_handler("Adding new connection for sockid %d", sockid );
+               osrfLogDebug( OSRF_LOG_MARK, "Adding new connection for sockid %d", sockid );
                node = osrfChatAddNode( server, sockid );
        }
 
        if(node) {
                if( (osrfChatPushData( server, node, data ) == -1) ) {
-                       warning_handler("Node at socket %d received bad XML, disconnecting...", sockid );
+                       osrfLogError( OSRF_LOG_MARK, 
+                                       "Node at socket %d with remote address %s and destination %s, "
+                                       "received bad XML [%s], disconnecting...", sockid, node->remote, node->to, data );
                        osrfChatSendRaw(  node, OSRF_CHAT_PARSE_ERROR );
                        osrfChatRemoveNode( server, node );
                }
@@ -248,12 +269,10 @@ void osrfChatRemoveNode( osrfChatServer* server, osrfChatNode* node ) {
 
 int osrfChatSendRaw( osrfChatNode* node, char* msgXML ) {
        if(!(node && msgXML)) return -1;
-       return socket_send( node->sockid, msgXML );
+       /* wait at most 3 second for this client to take our data */
+       return socket_send_timeout( node->sockid, msgXML, 3000000 ); 
 }
 
-
-
-
 void osrfChatNodeFinish( osrfChatServer* server, osrfChatNode* node ) {
        if(!(server && node)) return;
        osrfChatSendRaw( node, "</stream:stream>");
@@ -266,22 +285,41 @@ int osrfChatSend( osrfChatServer* cs, osrfChatNode* node, char* toAddr, char* fr
 
        int l = strlen(toAddr);
        char dombuf[l];
-       bzero(dombuf, l);
+       memset(dombuf, 0, sizeof(dombuf));
        jid_get_domain( toAddr, dombuf, l );    
 
        if( eq( dombuf, cs->domain ) ) { /* this is to a user we host */
 
-               info_handler("Sending message on local connection\nfrom: %s\nto: %s", fromAddr, toAddr );
+               osrfLogInfo( OSRF_LOG_MARK, "Sending message on local connection\nfrom: %s\nto: %s", fromAddr, toAddr );
                osrfChatNode* tonode = osrfHashGet(cs->nodeHash, toAddr);
                if(tonode) {
-                       osrfChatSendRaw( tonode, msgXML );
+
+                       /* if we can't send to the recipient (recipient is gone or too busy, 
+                        * we drop the recipient and inform the sender that the recipient
+                        * is no more */
+                       if( osrfChatSendRaw( tonode, msgXML ) < 0 ) {
+
+                               osrfChatRemoveNode( cs, tonode );
+                               char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
+
+                               osrfLogError( OSRF_LOG_MARK, "Node failed to function. "
+                                               "Responding to caller with error: %s", toAddr);
+
+
+                               if( osrfChatSendRaw( node, xml ) < 0 ) {
+                                       osrfLogError(OSRF_LOG_MARK, "Sending node is now gone..removing");
+                                       osrfChatRemoveNode( cs, node );
+                               }
+                               free(xml);
+                       }
 
                } else {
 
                        /* send an error message saying we don't have this connection */
-                       warning_handler("We have no connection for %s", toAddr);
+                       osrfLogInfo( OSRF_LOG_MARK, "We have no connection for %s", toAddr);
                        char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
-                       osrfChatSendRaw( node, xml );
+                       if( osrfChatSendRaw( node, xml ) < 0 ) 
+                               osrfChatRemoveNode( cs, node );
                        free(xml);
                }
 
@@ -290,18 +328,26 @@ int osrfChatSend( osrfChatServer* cs, osrfChatNode* node, char* toAddr, char* fr
                osrfChatNode* tonode = osrfHashGet(cs->nodeHash, dombuf);
                if(tonode) {
                        if( tonode->state == OSRF_CHAT_STATE_CONNECTED ) {
-                               debug_handler("Routing message to server %s", dombuf);
-                               osrfChatSendRaw( tonode, msgXML );
+                               osrfLogDebug( OSRF_LOG_MARK, "Routing message to server %s", dombuf);
+
+                               if( osrfChatSendRaw( tonode, msgXML ) < 0 ) {
+                                       osrfLogError( OSRF_LOG_MARK, "Node failed to function: %s", toAddr);
+                                       char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
+                                       if( osrfChatSendRaw( node, xml ) < 0 ) 
+                                               osrfChatRemoveNode( cs, node );
+                                       free(xml);
+                                       osrfChatRemoveNode( cs, tonode );
+                               }
 
                        } else {
-                               info_handler("Received s2s message and we're still trying to connect...caching");
+                               osrfLogInfo( OSRF_LOG_MARK, "Received s2s message and we're still trying to connect...caching");
                                osrfListPush( tonode->msgs, strdup(msgXML) );
                        }
 
                } else {
 
                        if( osrfChatInitS2S( cs, dombuf, toAddr, msgXML ) != 0 ) {
-                               warning_handler("We are unable to connect to remote server %s for recipient %s", dombuf, toAddr);
+                               osrfLogWarning( OSRF_LOG_MARK, "We are unable to connect to remote server %s for recipient %s", dombuf, toAddr);
                                char* xml = va_list_to_string( OSRF_CHAT_NO_RECIPIENT, toAddr, fromAddr );
                                osrfChatSendRaw( node, xml );
                                free(xml);
@@ -319,7 +365,7 @@ void osrfChatCacheS2SMessage( char* toAddr, char* msgXML, osrfChatNode* snode )
        osrfChatS2SMessage* msg = safe_malloc(sizeof(osrfChatS2SMessage));
        msg->toAddr = strdup(toAddr);
        msg->msgXML = strdup(msgXML);
-       info_handler("Pushing client message onto s2s queue waiting for connect... ");
+       osrfLogInfo( OSRF_LOG_MARK, "Pushing client message onto s2s queue waiting for connect... ");
        osrfListPush( snode->msgs, msgXML );
 }
 */
@@ -328,14 +374,15 @@ void osrfChatCacheS2SMessage( char* toAddr, char* msgXML, osrfChatNode* snode )
 int osrfChatInitS2S( osrfChatServer* cs, char* remote, char* toAddr, char* msgXML ) {
        if(!(cs && remote && toAddr && msgXML)) return -1;
 
-       info_handler("Initing server2server connection to domain %s", remote );
+       osrfLogInfo( OSRF_LOG_MARK, "Initing server2server connection to domain %s", remote );
        osrfChatNode* snode = osrfNewChatS2SNode( cs->domain, remote );
        snode->parent = cs;
 
        /* try to connect to the remote site */
        snode->sockid = socket_open_tcp_client(cs->mgr, cs->s2sport, remote);
        if(snode->sockid < 1) {
-               warning_handler("Unable to connect to remote server at %s", remote );
+               osrfLogWarning( OSRF_LOG_MARK, "Unable to connect to remote server at %s", remote );
+               osrfChatNodeFree( snode );
                return -1;
        }
 
@@ -348,7 +395,7 @@ int osrfChatInitS2S( osrfChatServer* cs, char* remote, char* toAddr, char* msgXM
        /* send the initial s2s request */
        osrfChatSendRaw( snode, OSRF_CHAT_S2S_INIT );
 
-       debug_handler("Added new s2s node...");
+       osrfLogDebug( OSRF_LOG_MARK, "Added new s2s node...");
        chatdbg(cs);
 
        return 0;
@@ -362,21 +409,22 @@ int osrfChatPushData( osrfChatServer* server, osrfChatNode* node, char* data ) {
 
        chatdbg(server);
 
-       debug_handler("pushing data into xml parser for node %d:\n%s", node->sockid, data);
+       osrfLogDebug( OSRF_LOG_MARK, "pushing data into xml parser for node %d with state %d:\n%s", 
+                                                node->sockid, node->state, data);
        node->inparse = 1;
        xmlParseChunk(node->parserCtx, data, strlen(data), 0);
        node->inparse = 0;
 
-       if(__osrfChatXMLErrorOcurred) {
-               __osrfChatXMLErrorOcurred = 0;
+       if(osrfChatXMLErrorOcurred) {
+               osrfChatXMLErrorOcurred = 0;
                return -1;
        }
 
        /* we can't do cleanup of the XML handlers while in the middle of a 
                data push, so set flags in the data push and doe the cleanup here */
        /*
-       if(__osrfChatClientSentDisconnect) {
-               __osrfChatClientSentDisconnect  = 0;
+       if(osrfChatClientSentDisconnect) {
+               osrfChatClientSentDisconnect  = 0;
                osrfChatNodeFinish( server, node );
        }
        */
@@ -386,7 +434,7 @@ int osrfChatPushData( osrfChatServer* server, osrfChatNode* node, char* data ) {
 
 
 void osrfChatStartStream( void* blob ) {
-       debug_handler("Starting new client stream...");
+       osrfLogDebug( OSRF_LOG_MARK, "Starting new client stream...");
 }
 
 
@@ -397,12 +445,14 @@ void osrfChatStartElement( void* blob, const xmlChar *name, const xmlChar **atts
        int status = -1;
        char* nm = (char*) name;
 
-       debug_handler("Starting element %s with namespace %s", nm, xmlSaxAttr(atts, "xmlns") );
+       osrfLogDebug( OSRF_LOG_MARK, "Starting element %s with namespace %s and node state %d", 
+                                                nm, xmlSaxAttr(atts, "xmlns"), node->state );
 
        switch( node->state ) {
 
                case OSRF_CHAT_STATE_NONE:
                        status = osrfChatHandleNewConnection( node, nm, atts );
+                       osrfLogDebug( OSRF_LOG_MARK, "After NewConnection we have state %d", node->state);
                        break;
 
                case OSRF_CHAT_STATE_CONNECTING:
@@ -420,7 +470,10 @@ void osrfChatStartElement( void* blob, const xmlChar *name, const xmlChar **atts
                case OSRF_CHAT_STATE_S2S_RESPONSE: /* server waiting for client response to challenge */
                        if(eq(nm, "db:result")) {
                                char* remote = xmlSaxAttr(atts, "from");
-                               if(remote) node->remote = strdup(remote); /* copy off the client's id */
+                               if(remote) {
+                                       if( node->remote) free( node->remote );
+                                       node->remote = strdup(remote); /* copy off the client's id */
+                               }
                                status = 0;
                                node->xmlstate |= OSRF_CHAT_STATE_INS2SRESULT;
                        } else status = -1; 
@@ -451,7 +504,7 @@ void osrfChatStartElement( void* blob, const xmlChar *name, const xmlChar **atts
                osrfChatParseError( node, "We don't know how to handle the XML data received" );
 }
 
-#define CHAT_CHECK_VARS(x,y,z) if(!(x && y)) return -1; if(z) debug_handler(z);
+#define CHAT_CHECK_VARS(x,y,z) if(!(x && y)) return -1; if(z) osrfLogDebug( OSRF_LOG_MARK, z);
 
 
 
@@ -479,7 +532,7 @@ int osrfChatHandleS2SConnected( osrfChatNode* node, const char* name, const xmlC
                                char* from = (char*) xmlGetProp(xmlDocGetRootElement(doc), BAD_CAST "from");
                                char* to = (char*) xmlGetProp(xmlDocGetRootElement(doc), BAD_CAST "to");
                                osrfChatSend( node->parent, node, to, from, xml );
-                               debug_handler("Sending cached message from %s to %s", from, to);
+                               osrfLogDebug( OSRF_LOG_MARK, "Sending cached message from %s to %s", from, to);
                                xmlFree(to); xmlFree(from);
                                xmlFreeDoc(doc);
                        }
@@ -492,7 +545,7 @@ int osrfChatHandleS2SConnected( osrfChatNode* node, const char* name, const xmlC
        }
 
        if(status == 0) {
-               info_handler("Successfully made S2S connection to %s", node->remote );
+               osrfLogInfo( OSRF_LOG_MARK, "Successfully made S2S connection to %s", node->remote );
                node->state = OSRF_CHAT_STATE_CONNECTED;
                node->xmlstate = 0;
        }
@@ -507,6 +560,7 @@ int osrfChatHandleNewConnection( osrfChatNode* node, const char* name, const xml
 
        if(!eq(name, "stream:stream")) return -1;
 
+       if( node->authkey ) free( node->authkey );
        node->authkey = osrfChatMkAuthKey();
        char* ns = xmlSaxAttr(atts, "xmlns");
        if(!ns) return -1;
@@ -517,14 +571,18 @@ int osrfChatHandleNewConnection( osrfChatNode* node, const char* name, const xml
                if(!domain) return -1; 
        
                if(!eq(domain, node->domain)) {
-                       warning_handler("Client attempting to connect to invalid domain");
+                       osrfLogWarning( OSRF_LOG_MARK, 
+                               "Client attempting to connect to invalid domain %s. Our domain is %s", domain, node->domain);
                        return -1;
                }
        
                char* buf = va_list_to_string( OSRF_CHAT_START_STREAM, domain, node->authkey );
                node->state = OSRF_CHAT_STATE_CONNECTING;
+
+               osrfLogDebug( OSRF_LOG_MARK, "Server node %d setting state to OSRF_CHAT_STATE_CONNECTING[%d]",
+                                                        node->sockid, node->state );
        
-               debug_handler("Server responding to connect message with\n%s\n", buf );
+               osrfLogDebug( OSRF_LOG_MARK, "Server responding to connect message with\n%s\n", buf );
                osrfChatSendRaw( node, buf );
                free(buf);
                return 0;
@@ -532,7 +590,7 @@ int osrfChatHandleNewConnection( osrfChatNode* node, const char* name, const xml
 
        /* server to server init */
        if(eq(ns, "jabber:server")) { /* client connection */
-               info_handler("We received a new server 2 server connection, generating auth key...");
+               osrfLogInfo( OSRF_LOG_MARK, "We received a new server 2 server connection, generating auth key...");
                char* xml = va_list_to_string( OSRF_CHAT_S2S_CHALLENGE, node->authkey );
                osrfChatSendRaw( node, xml );
                free(xml);
@@ -547,15 +605,17 @@ int osrfChatHandleNewConnection( osrfChatNode* node, const char* name, const xml
 
 
 char* osrfChatMkAuthKey() {
+       char hostname[HOST_NAME_MAX + 1] = "";
+       gethostname(hostname, sizeof(hostname) );
+       hostname[HOST_NAME_MAX] = '\0';
        char keybuf[112];
-       bzero(keybuf, 112);
-       snprintf(keybuf, 111, "%d%d%s", (int) time(NULL), getpid(), getenv("HOSTNAME"));
+       snprintf(keybuf, sizeof(keybuf), "%d%ld%s", (int) time(NULL), (long) getpid(), hostname);
        return strdup(shahash(keybuf));
 }
 
 int osrfChatHandleConnecting( osrfChatNode* node, const char* name, const xmlChar** atts ) {
        CHAT_CHECK_VARS(node, name, "osrfChatHandleConnecting()");
-       debug_handler("Handling connect node %s", name );
+       osrfLogDebug( OSRF_LOG_MARK, "Handling connect node %s", name );
 
        if(eq(name, "iq")) node->xmlstate |= OSRF_CHAT_STATE_INIQ;
        else if(eq(name,"username")) node->xmlstate |= OSRF_CHAT_STATE_INUSERNAME;
@@ -569,7 +629,7 @@ int osrfChatHandleConnected( osrfChatNode* node, const char* name, const xmlChar
        if(eq(name,"message")) {
 
                /* drop the old message and start with a new one */
-               xmlNodePtr root = xmlNewNode(NULL, name);
+               xmlNodePtr root = xmlNewNode(NULL, BAD_CAST name);
                xmlAddAttrs(root, atts);
                xmlNodePtr oldRoot = xmlDocSetRootElement(node->msgDoc, root);
                free(node->to);
@@ -584,7 +644,7 @@ int osrfChatHandleConnected( osrfChatNode* node, const char* name, const xmlChar
        } else {
 
                /* all non "message" nodes are simply added to the message */
-               xmlNodePtr nodep = xmlNewNode(NULL, name);
+               xmlNodePtr nodep = xmlNewNode(NULL, BAD_CAST name);
                xmlAddAttrs(nodep, atts);
                xmlAddChild(xmlDocGetRootElement(node->msgDoc), nodep);
        }
@@ -595,12 +655,12 @@ int osrfChatHandleConnected( osrfChatNode* node, const char* name, const xmlChar
 /* takes s2s secret, hashdomain, and the s2s auth token */
 static char* osrfChatGenerateS2SKey( char* secret, char* hashdomain, char* authtoken ) {
        if(!(secret && hashdomain && authtoken)) return NULL;
-       info_handler("Generating s2s key with auth token: %s", authtoken );
+       osrfLogInfo( OSRF_LOG_MARK, "Generating s2s key with auth token: %s", authtoken );
        char* a = shahash(secret);
-       debug_handler("S2S secret hash: %s", a);
+       osrfLogDebug( OSRF_LOG_MARK, "S2S secret hash: %s", a);
        char* b = va_list_to_string("%s%s", a, hashdomain);
        char* c = shahash(b);
-       debug_handler("S2S intermediate hash: %s", c);
+       osrfLogDebug( OSRF_LOG_MARK, "S2S intermediate hash: %s", c);
        char* d = va_list_to_string("%s%s", c, authtoken);
        char* e = strdup(shahash(d));
        free(b); free(d); 
@@ -617,7 +677,7 @@ int osrfChatHandleS2SChallenge( osrfChatNode* node, const char* name, const xmlC
                        /* we use our domain in the s2s challenge hash */
                        char* d = osrfChatGenerateS2SKey(node->parent->secret, node->domain, id );
                        char* e = va_list_to_string(OSRF_CHAT_S2S_RESPONSE, node->remote, node->domain, d );
-                       info_handler("Answering s2s challenge with key:  %s", e );
+                       osrfLogInfo( OSRF_LOG_MARK, "Answering s2s challenge with key:  %s", e );
                        osrfChatSendRaw( node, e );
                        free(d); free(e);
                        node->state = OSRF_CHAT_STATE_S2S_VERIFY;
@@ -663,7 +723,7 @@ void osrfChatEndElement( void* blob, const xmlChar* name ) {
                        char* string = xmlDocToString(node->msgDoc, 0 );
 
                        char* from = (char*) xmlGetProp(msg, BAD_CAST "from");
-                       debug_handler( "Routing message to %s\n%s\n", node->to, from, string );
+                       osrfLogDebug( OSRF_LOG_MARK,  "Routing message to %s\n%s\n", node->to, from, string );
                        osrfChatSend( node->parent, node, node->to, from, string ); 
                        xmlFree(from);
                        free(string);
@@ -675,13 +735,18 @@ void osrfChatEndElement( void* blob, const xmlChar* name ) {
 
                        if(eq(nm, "iq")) {
                                node->xmlstate &= ~OSRF_CHAT_STATE_INIQ;
+                               if( node->remote ) free( node->remote );
                                node->remote = va_list_to_string( 
                                                "%s@%s/%s", node->username, node->domain, node->resource );
 
-                               info_handler("%s successfully logged in", node->remote );
+                               osrfLogInfo( OSRF_LOG_MARK, "%s successfully logged in", node->remote );
 
-                               debug_handler("Setting remote address to %s", node->remote );
+                               osrfLogDebug( OSRF_LOG_MARK, "Setting remote address to %s", node->remote );
                                osrfChatSendRaw( node, OSRF_CHAT_LOGIN_OK );
+                               if(osrfHashGet( node->parent->nodeHash, node->remote ) ) {
+                                       osrfLogWarning( OSRF_LOG_MARK, "New node replaces existing node for remote id %s", node->remote);
+                                       osrfHashRemove(node->parent->nodeHash, node->remote);
+                               }
                                osrfHashSet( node->parent->nodeHash, node, node->remote );
                                node->state = OSRF_CHAT_STATE_CONNECTED;
                        }
@@ -695,7 +760,7 @@ void osrfChatHandleCharacter( void* blob, const xmlChar *ch, int len) {
        osrfChatNode* node = (osrfChatNode*) blob;
 
        /*
-       debug_handler("Char Handler: state %d, xmlstate %d, chardata %s", 
+       osrfLogDebug( OSRF_LOG_MARK, "Char Handler: state %d, xmlstate %d, chardata %s", 
                        node->state, node->xmlstate, (char*) ch );
                        */
 
@@ -729,9 +794,9 @@ void osrfChatHandleCharacter( void* blob, const xmlChar *ch, int len) {
                        (node->xmlstate & OSRF_CHAT_STATE_INS2SRESULT) ) {
 
                char* key = strndup((char*) ch, len);
-               debug_handler("Got s2s key from %s : %s", node->remote, key );
+               osrfLogDebug( OSRF_LOG_MARK, "Got s2s key from %s : %s", node->remote, key );
                char* e = osrfChatGenerateS2SKey(node->parent->secret, node->remote, node->authkey );
-               info_handler("\nReceived s2s key from server: %s\nKey should be: %s", key, e );
+               osrfLogInfo( OSRF_LOG_MARK, "\nReceived s2s key from server: %s\nKey should be: %s", key, e );
 
                if(eq(key, e)) {
                        char* msg = va_list_to_string(OSRF_CHAT_S2S_VERIFY_REQUEST,  
@@ -742,18 +807,20 @@ void osrfChatHandleCharacter( void* blob, const xmlChar *ch, int len) {
                        node->xmlstate = 0;
 
                } else {
-                       warning_handler("Server2Server keys do not match!");
+                       osrfLogWarning( OSRF_LOG_MARK, "Server2Server keys do not match!");
                }
 
+               free( e );
+               free( key );
+
                /* do the hash dance again */
        }
-
 }
 
 
 void osrfChatParseError( void* blob, const char* msg, ... ) {
 
-       __osrfChatXMLErrorOcurred = 1;
+       osrfChatXMLErrorOcurred = 1;
 }