vos/corelibs/vos/remotesocketsite.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/

#include "remotesocketsite.hh"
#include "message.hh"
#include "messageblock.hh"
#include "timer.hh"

using namespace VOS;

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>

#include <deque>
#include <string>
#include <map>

/** @file
    Implements RemoteSocketSite.
*/

#ifndef SOL_TCP
#define SOL_TCP 6
#endif

#if !defined(HAVE_SOCKLEN_T) && !defined(__socklen_t_defined)
//#warning socklen_t not defined. Defining it as int.
typedef int socklen_t;
#define __socklen_t_defined 1
#endif

#ifdef SOCKS_SUPPORT
#undef __P
#if defined (__STDC__) || defined (_AIX) \
        || (defined (__mips) && defined (_SYSTYPE_SVR4)) \
        || defined(WIN32) || defined(__cplusplus)
# define __P(protos) protos
#else
# define __P(protos) ()
#endif
extern "C" {
    struct hostent *Rgethostbyname __P((const char *));
    int Rconnect __P((int, const struct sockaddr *, socklen_t));
    ssize_t Rrecv __P((int s, void *msg, size_t len, int flags));
    ssize_t Rsend __P((int s, const void *msg, size_t len, int flags));
}
#endif

#if !defined(HAVE_SOCKLEN_T) && !defined(__socklen_t_defined)
//#warning socklen_t not defined. Defining it as int.
typedef int socklen_t;
#define __socklen_t_defined 1
#endif

void RemoteSocketSite::init(const string& hostname, unsigned short int port) throw (SiteConnectionError)
{
    remoteport=port;

    struct hostent *hp;
    struct sockaddr_in sa;

#ifdef SOCKS_SUPPORT
    if(getenv("VOS_USE_SOCKS")) {
        if((hp=Rgethostbyname(hostname.c_str())) == 0) throw SiteConnectionError("DNS lookup failed");
        usingSOCKS = true;
    } else {
#endif

        int err;
#ifdef HAVE_GETIPNODEBYNAME
        hp = getipnodebyname(hostname.c_str(), AF_INET, 0, &err);
#else
        hp = gethostbyname_locked(hostname.c_str());
    err = h_errno;
#endif
        if(!hp) throw SiteConnectionError("DNS lookup failed");

#ifdef SOCKS_SUPPORT
        usingSOCKS = false;
    }
#endif

    memset(&sa, 0, sizeof(sa));
    sa.sin_port=htons(port);
    sa.sin_family=AF_INET;
    sa.sin_addr=*((struct in_addr *)hp->h_addr);

#ifdef HAVE_GETIPNODEBYNAME
    freehostent(hp);
#else
    freeHostEnt(hp);
#endif

#ifdef SOCKS_SUPPORT
    if(usingSOCKS) {
        if((readingFD = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
           Rconnect(readingFD, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0)
        {
            readingFD = writingFD = -1;
            throw SiteConnectionError(strerror(errno));
        }
    } else {
#endif
        if((readingFD = (int)socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
           connect(readingFD, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0)
        {
            readingFD = writingFD = -1;
            throw SiteConnectionError(strerror(errno));
        }
#ifdef SOCKS_SUPPORT
    }
#endif

    writingFD = readingFD;
    int x = 1;
    setsockopt(writingFD, SOL_TCP, TCP_NODELAY, (char*)&x, sizeof(int));
#ifdef WIN32
    unsigned long one = 1;
    ioctlsocket(writingFD, FIONBIO, &one);
#else
    unsigned int one = fcntl(writingFD, F_GETFL);
    one = one | O_NONBLOCK;
    fcntl(writingFD, F_SETFL, one);
#endif
    allOpenSockets.insert(readingFD); // need to lock this (?)
    char p[256];

    snprintf(p, sizeof(p), "%i", port);
    url.setPort(p);
    url.setHost(hostname);
    name = url.getHostAndPort();

    socklen_t st = sizeof(int);
#ifdef WIN32
    getsockopt(writingFD, SOL_SOCKET, SO_SNDBUF, (char*)&sockSendBufSz, &st);
#else
    getsockopt(writingFD, SOL_SOCKET, SO_SNDBUF, &sockSendBufSz, &st);
#endif
    sockSendBufSz = sockSendBufSz / 2;

    addHostAlias(url.getHostAndPort());
    addSite(this);
}

RemoteSocketSite::RemoteSocketSite(const string& hostname, unsigned short int port) throw (SiteConnectionError)
    : VobjectImplementation(hostname, 0, false), RemoteMetaObject(hostname, 0),
      RemoteVobject(hostname, 0), MetaObject(0), ssl(0),
      partialMessage(new MessageBlock())
{
    try {
        init(hostname, port);
    } catch(SiteConnectionError x) {
        throw;
    }
}

RemoteSocketSite::RemoteSocketSite(const string& hostname) throw (SiteConnectionError)
    : VobjectImplementation(hostname, 0, false), RemoteMetaObject(hostname, 0),
      RemoteVobject(hostname, 0), MetaObject(0), ssl(0),
      partialMessage(new MessageBlock())
{
    try {
        init(hostname, VOS_DEFAULT_PORT);
    } catch(SiteConnectionError x) {
        throw;
    }
}

RemoteSocketSite::RemoteSocketSite(int fd, sockaddr_in* peername)
    : VobjectImplementation("fd", 0, false), RemoteMetaObject("fd", 0), RemoteVobject("fd", 0),
      MetaObject(0), readingFD(fd), writingFD(fd), ssl(0),
      partialMessage(new MessageBlock())
{
    struct hostent* hp=0;
    if(getenv("VOS_DOREVERSELOOKUP")) {
        hp = gethostbyaddr((char*)&(peername->sin_addr.s_addr), 4, AF_INET);
    }
    char p[16];
    remoteport=ntohs(peername->sin_port);
    snprintf(p, sizeof(p), "%i", remoteport);
    if(hp) {
        url.setHost(string(hp->h_name));
    } else {
        char s[32];

        // Convert address from host byte order, then out in nice dotted format.
        // (becuase inet_ntoa() doesn't exist on all platforms)
        long addr = htonl(peername->sin_addr.s_addr);
        snprintf(s, sizeof(s), "%i.%i.%i.%i",
                (int)(addr >> 24) & 0xFF,
                (int)(addr >> 16) & 0xFF,
                (int)(addr >> 8) & 0xFF,
                (int)(addr & 0xFF) ) ;

        url.setHost(s);
    }

    socklen_t st = sizeof(int);
#ifdef WIN32
    getsockopt(writingFD, SOL_SOCKET, SO_SNDBUF, (char*)&sockSendBufSz, &st);
#else
    getsockopt(writingFD, SOL_SOCKET, SO_SNDBUF, &sockSendBufSz, &st);
#endif
    sockSendBufSz = sockSendBufSz / 2;

    url.setPort(p);
    addHostAlias(url.getHostAndPort());
    addSite(this);
}

RemoteSocketSite::~RemoteSocketSite()
{
    LOG("remotesocketsite", 5, "deleting " << getURL().getString());
}

void RemoteSocketSite::handleDisconnection()
{
    LOG("remotesite", 3, "remote site disconnected: " << strerror(errno));
    LOG("refcount", 5, "handleDisconnection: remote site count is " << getCount());

    excise();
}

void RemoteSocketSite::excise()
{
    LOG("remotesite", 4, "closing connection rfd " << readingFD << "  wrf " << writingFD);

    if(readingFD > -1) allOpenSockets.erase(readingFD);
#ifdef HAVE_LIBWS2_32
    if(readingFD > -1) closesocket(readingFD);
    if(writingFD > -1) closesocket(writingFD);
#else
    if(readingFD > -1) close(readingFD);
    if(writingFD > -1) close(writingFD);
#endif
    readingFD = writingFD = -1;

    RemoteSite::excise();
}

void RemoteSocketSite::flushIncomingBuffers()
{
    LOG("remotestreamsite", 5, "check baby, remote stream site " << this);
    if(readingFD < 0) return;
    do {
        /*fd_set fs;
        FD_ZERO(&fs);
        FD_SET(readingFD, &fs);
        struct timeval tv;
        tv.tv_sec = 0;
        tv.tv_usec = 0;
        select(readingFD+1, &fs, 0, 0, &tv);
        if(! FD_ISSET(readingFD, &fs)) break;*/

        char data[16384];

        LOG("remotesocketsite", 5, "about to go into readStream");
        int r=readStream(data, sizeof(data));               
        LOG("remotesocketsite", 4, "read stream got " << r);
        if(r == -1 || r == 0) {
#ifdef WIN32
            int err = WSAGetLastError();
            if(!(err == WSAEWOULDBLOCK || err == WSAEINTR)) handleDisconnection();
#else
            if(!(errno == EWOULDBLOCK || errno == EINTR)) handleDisconnection();
#endif
            return;
        }
        string s((const char*)data, r);
        LOG("remotesocketsite", 5, "received " << s);
        int p=partialMessage->parseUpdate(s);
        LOG("remotesocketsite", 4, "parseUpdate returned " << p);

        vRef<Message> last = partialMessage->lastMessage();
        if(&last) {
            LOG("remotesocketsite", 4, "saw msg with nonce '" << last->getNonce() << "'");
            if(last->getNonce() != "" && waitingFor.count(last->getNonce())) {
                LOG("remotesocketsite", 4, "caching msg with nonce " << last->getNonce());
                waitingFor[last->getNonce()].first = true;
            }
        }
        while(p > 0) {
            static int incoming_count = 1;
            last->incoming_debug = incoming_count++;
            if(last->getNonce() != "" && waitingFor.count(last->getNonce())) {
                last->acquire(); // released by: clearCaughtMessage()
                waitingFor[last->getNonce()].second = &last;
            }
            localpeer->scheduleMessageBlock(partialMessage, 0, this);
            partialMessage->release(); // acquired by: new MessageBlock() above or below
            s.erase(s.begin(), s.begin() + p);
            partialMessage = new MessageBlock(); // released by: completed message (above) or destructor
            if(s.size() > 0) {
                p = partialMessage->parseUpdate(s);
                last = partialMessage->lastMessage();
                if(&last) {
                    LOG("remotestreamsite", 4, "saw msg with nonce '" << last->getNonce() << "'");
                    if(last->getNonce() != "" && waitingFor.count(last->getNonce())) {
                        LOG("remotestreamsite", 4, "caching msg with nonce " << last->getNonce());
                        waitingFor[last->getNonce()].first = true;
                    }
                }
            } else break;
        }
    } while(1);
}

void RemoteSocketSite::flushOutgoingBuffers(const char* newdata, unsigned int newsize)
{
    if(outputBuffer.size() == 0 && newsize == 0) return;

    const char* data;
    unsigned int datasize;
    bool buffered;
    if(outputBuffer.size() == 0) {
        data = newdata;
        datasize = newsize;
        buffered = false;
    } else {
        if(newsize > 0) outputBuffer.append(newdata, newsize);
        data = outputBuffer.c_str();
        datasize = outputBuffer.size();
        buffered = true;
    }

    LocalSocketSite* lss = dynamic_cast<LocalSocketSite*>(localpeer);

    int total = 0;
    do {
        int sendsize = (datasize - total) < sockSendBufSz ? (datasize - total) : sockSendBufSz;
        int ret = writeStream(data + total, sendsize);
        if(ret == -1) {
#ifdef WIN32
            int err = WSAGetLastError();
            if(err == WSAEWOULDBLOCK || err == WSAEINTR) {   
#else
            if(errno == EWOULDBLOCK || errno == EINTR) {
#endif
                if(buffered) outputBuffer.replace(0, total, "");
                else outputBuffer.append(data + total, datasize - total);
                lss->addFDtoSelect(writingFD, LocalSocketSite::SELECTWRITE);
                return;
            } else throw SiteConnectionError("disconnected");
        } else total += ret;
    } while(total < datasize);

    if(buffered) outputBuffer.replace(0, total, "");
    if(outputBuffer.size() == 0) {
        lss->removeFDfromSelect(writingFD, LocalSocketSite::SELECTWRITE);
    }
}

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

int RemoteSocketSite::readStream(char* data, unsigned int datasize)
{
#ifdef SSL_SUPPORT
    if(ssl) {
        int ret = SSL_read(ssl, data, datasize);
        if(ret <= 0) {
            if(ERR_get_error() == SSL_ERROR_WANT_READ) {
                errno = EAGAIN;
            } else {
                LOG("remotestreamsite", 2, "SSL error " << ERR_error_string(ERR_get_error(), 0));
            }
        }
        return ret;
    } else {
#endif
#ifdef SOCKS_SUPPORT
        if(usingSOCKS) {
            return Rrecv(readingFD, data, datasize, MSG_NOSIGNAL);
        } else {
#endif
            return recv(readingFD, data, datasize, MSG_NOSIGNAL);
#ifdef SOCKS_SUPPORT
        }
#endif
#ifdef SSL_SUPPORT
    }
#endif
}

int RemoteSocketSite::writeStream(const char* data, unsigned int datasize)
{
#ifdef SSL_SUPPORT
    if(ssl) {
        int ret = SSL_write(ssl, data, datasize);
        if(ret <= 0) {
            if(ERR_get_error() == SSL_ERROR_WANT_WRITE) {
                errno = EAGAIN;
            } else {
                LOG("remotestreamsite", 2, "SSL error " << ERR_error_string(ERR_get_error(), 0));
            }
        }
        return ret;
    } else {
#endif
#ifdef SOCKS_SUPPORT
        if(usingSOCKS) {
            return Rsend(writingFD, data, datasize, MSG_NOSIGNAL);
        } else {
#endif
            return send(writingFD, data, datasize, MSG_NOSIGNAL);
#ifdef SOCKS_SUPPORT
        }
#endif
#ifdef SSL_SUPPORT
    }
#endif
}

void RemoteSocketSite::secureConnection(const string& protocol)
{
#ifdef SSL_SUPPORT
    if(ssl) throw RemoteError("A secure connection has already been established\n");

    SSL_CTX* ctx = meta_cast<LocalSocketSite*>(localpeer)->getSSLContext(protocol);

    pREF(Message*, m, new Message(),
         rREF(LocalSite&, ls, initFields(this, m, "core:protocol-switch", true), );
         m->insertField(-1, "protocol", protocol);
         sendMessage(m);

         suppressOutgoing(true);
         try {
             pREF(Message*, r, localpeer->waitFor(m->getNonce(), this),
                  if(r->getField("result").value == "ready") {
                      ssl = SSL_new(ctx);
                      if(! ssl) {
                          throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
                      }

                      int ret = SSL_set_wfd(ssl, writingFD);
                      if(ret != 1) {
                          throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
                      }

                      ret = SSL_set_rfd(ssl, readingFD);
                      if(ret != 1) {
                          throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
                      }

                      ret = SSL_connect(ssl);
                      if(ret != 1) {
                          throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
                      }

                      enableOutgoing(true);
                  } else {
                      enableOutgoing(true);
                      throw RemoteError(r->getField("result").value);
                  }
                 );
         } catch(Message::NoSuchFieldError) {
             enableOutgoing(true);
             throw RemoteError("reply did not contain a result field");
         } catch(...) {
             enableOutgoing(true);
             throw;
         }
        );
#else
    throw RemoteError("libvos was not compiled with SSL/TLS support");
#endif
}

void RemoteSocketSite::switchProtocol(SSL_CTX* context)
{
#ifdef SSL_SUPPORT
    ssl = SSL_new(context);
    if(! ssl) {
        throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
    }

    int ret = SSL_set_wfd(ssl, writingFD);
    if(ret != 1) {
        throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
    }

    ret = SSL_set_rfd(ssl, readingFD);
    if(ret != 1) {
        throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
    }

    ret = SSL_accept(ssl);
    if(ret != 1) {
        throw LocalSocketSite::SSLError(ERR_error_string(ERR_get_error(), 0));
    }
#else
    throw RemoteError("libvos was not compiled with SSL/TLS support");
#endif
}

X509* RemoteSocketSite::getCertificate()
{
#ifdef SSL_SUPPORT
    if(ssl) return SSL_get_peer_certificate(ssl);
    else throw RemoteError("No secure session established");
#else
    throw RemoteError("libvos was not compiled with SSL/TLS support");
#endif
}

bool RemoteSocketSite::isConnected()
{
    return (readingFD > -1);
}

bool OutgoingLock::checkMessage(Message* m)
{
    return (m->getMethod() == "core:anti-spoof-check"
             || m->getMethod() == "core:anti-spoof-reply"
             || m->getMethod() == "core:error");
}

bool EnqueueOutgoing::checkMessage(Message* m)
{
    if(m->getMethod() == "core:anti-spoof-check"
        || m->getMethod() == "core:anti-spoof-reply"
        || m->getMethod() == "core:error")
    {
        return true;
    } else {
        m->acquire();
        outgoingQueue.push(pair<Message*, MessageBlock*>(m, 0));
        return false;
    }
}

bool EnqueueOutgoing::checkMessage(MessageBlock* m)
{
    m->acquire();  // released by: enableOutgoing()
    outgoingQueue.push(pair<Message*, MessageBlock*>(0, m));
    return true;
}

bool RewriteTo::checkMessage(Message* m)
{
    URL to(m->getTo());
    to.setHostAndPort(hostandport);
    m->setTo(to.getString());
    return true;
}

void RemoteSocketSite::suppressOutgoing(bool enqueue)
{
    if(enqueue) {
        insertMessageFilter(0, &enqueueOutgoing);
    } else {
        insertMessageFilter(-1, &outgoinglock);
    }
}

void RemoteSocketSite::enableOutgoing(bool sendqueue, const string& rewriteTo)
{
    removeMessageFilter(&outgoinglock);
    removeMessageFilter(&enqueueOutgoing);

    RewriteTo rt(rewriteTo);
    if(rewriteTo != "?") {
        insertMessageFilter(-1, &rt);
    }

    while(!enqueueOutgoing.outgoingQueue.empty()) {
        if(enqueueOutgoing.outgoingQueue.front().first) {
            if(sendqueue) sendMessage(enqueueOutgoing.outgoingQueue.front().first);
            enqueueOutgoing.outgoingQueue.front().first->release();  // acquired by: sendMessage()
        }
        if(enqueueOutgoing.outgoingQueue.front().second) {
            if(sendqueue) sendMessage(enqueueOutgoing.outgoingQueue.front().second);
            enqueueOutgoing.outgoingQueue.front().second->release();  // acquired by: sendMessage()
        }
        enqueueOutgoing.outgoingQueue.pop();
    }

    removeMessageFilter(&rt);
}

void RemoteSocketSite::sendMessage(Message* m)
{
    for(unsigned int i = 0; i < messagefilters.size(); i++) {
        if(! messagefilters[i]->checkMessage(m)) {
            LOG("remotesocketsite", 3, "Not sending filtered message");
            return;
        }
    }

    Site::sendMessage(m);
    LOG("RemoteStreamSite::sendMessage", 4, ">>>(outgoing)>>> sending to " << getURL().getString()
        << " [" << m->refcount_debug
        << "/" << m->getCount() <<  "]\n" << m->getFormattedString().substr(0, 768));
    LOG("refcount", 5, "sendMessage: count on this remotesite is " << getCount());

    if(writingFD > -1) {
        const string& s = m->getFormattedString();
        flushOutgoingBuffers(s.c_str(), (unsigned int)s.size());
    } else throw SiteConnectionError("Tried to send a message to a disconnected site");
}

void RemoteSocketSite::sendMessage(MessageBlock* m)
{
    for(unsigned int i = 0; i < messagefilters.size(); i++) {
        if(! messagefilters[i]->checkMessage(m)) {
            return;
        }
    }

    if(! m->numMessages()) return;

    Site::sendMessage(m);
    LOG("RemoteStreamSite::sendMessage", 4, ">>>(outgoing)>>> sending to " << getURL().getString() << "\n" << m->getString());
    LOG("refcount", 5, "sendMessage: count on this remotesite is " << getCount());

    if(writingFD > -1) {
        const string& s = m->getString();
        flushOutgoingBuffers(s.c_str(), (unsigned int)s.size());
    } else throw SiteConnectionError("Tried to send message to disconnected site");
}

/*
void RemoteSocketSite::takeOver(RemoteSocketSite* rs)
{
    readingFD = rs->readingFD;
    rs->readingFD = rs->writingFD = -1;
    rs->handleDisconnection();
    localpeer->takeOverMessages(rs, this);
}
*/


AsyncConnect::AsyncConnect(bool* isdone, RemoteSocketSite** rs, LocalSite* ls,
                           const string& host, unsigned short int port, bool isspooftest)
    : done(isdone), remotesite(rs), localpeer(ls), remotehost(host), remoteport(port), spooftest(isspooftest)
{
    *done = false;
    *remotesite = 0;
}

RemoteSocketSite* AsyncConnect::connect(const string& h, unsigned short int p, LocalSite* defaultPeer, bool isspooftest)
{
    RemoteSocketSite* rss;
    bool isdone;

    AsyncConnect ac(&isdone, &rss, defaultPeer, h, p, isspooftest);

    boost::thread connectthread(ac);
    double timeout = defaultPeer->getTimeoutOnSelect();

    if(timeout == -1 || timeout > 1) defaultPeer->setTimeoutOnSelect(.2);
    while(!isdone) {
        defaultPeer->flushIncomingBuffers();
    }

    connectthread.join();

    defaultPeer->setTimeoutOnSelect(timeout);

    if(rss == 0) {
        throw RemoteSite::SiteConnectionError(ac.exstring);
    }

    double start = getRealTime();
    while(rss->isConnected() && !rss->getGreeted() && (getRealTime() - start) < VOS_DEFAULT_TIMEOUT) {
        defaultPeer->flushIncomingBuffers();
    }

    if(!rss->isConnected() || !rss->getGreeted()) {
        rss->handleDisconnection();
        rss->release();
        throw RemoteSite::SiteConnectionError("Remote site disconnected or did not greet us");
    }

    return rss;
}

// This runs in a separate thread
void AsyncConnect::operator()()
{
    try {
        LOG("AsyncConnect", 3, "ready to start connecting to " << remotehost << ":" << remoteport);
        *remotesite = new RemoteSocketSite(remotehost, remoteport);

        if(spooftest) (*remotesite)->addFlag("spoof-test");

        if(getenv("VOS_HOSTNAME") == 0) {
            unsigned char ipaddr[4];
            string host = Site::detectHostname((*remotesite)->getReadingFD(), ipaddr);
            LOG("AsyncConnect", 3, "detected IP is "
                << (unsigned int)ipaddr[0] << "." << (unsigned int)ipaddr[1] << "."
                << (unsigned int)ipaddr[2] << "." << (unsigned int)ipaddr[3]);
            URL u(localpeer->getURL());
            u.setHost(host);
            localpeer->addHostAlias(u.getHostAndPort());
            if(!(ipaddr[0] == 10 || ipaddr[0] == 127 || (ipaddr[0] == 192 && ipaddr[1] == 168))) {
                localpeer->setPrimaryHostname(host);
            }
        }
        Site::doSitePeering(localpeer, *remotesite, spooftest, false);
    } catch(runtime_error e) {
        exstring = e.what();
        LOG("remotesocketsite", 2, "Caught exception " << exstring);
    }
    *done = true;
    LOG("AsyncConnect", 3, "done trying to connect to " << remotehost << ":" << remoteport);
}

---