vos/corelibs/vos/typingtweaks/localsite.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, 2002 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 <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

#include <algorithm>
#include <typeinfo>


#ifdef USE_STRSTREAM
#include <strstream>
#else
#include <sstream>
#endif

#include "vos.hh"

/** @file
    Implements LocalSite.
 */

multimap<string, metaobject_extender_t> LocalSite::localObjectExtensionTable;

LocalSite::LocalSite()
    : VobjectImplementation("", 0, true), LocalVobject("", 0, 0),
      LocalMetaObject("", 0, 0), MetaObject(0), selectwait(new struct timeval()),
      callbacklock(false), notifyflushlock(false)
{
    setGreeted(true);
}

LocalSite::~LocalSite()
{
}

void LocalSite::scheduleMessageBlock(MessageBlock* mb, MessageContext* mc, Site* ss,
                                     double plustime, const char* extradependency)
{
    if(mb->getName() != "" && mc == 0) {
        ss->addMessageBlock(mb);
    } else {
        if(mb->numMessages() > 1 && !mc) {
            /* note: So as to prevent outgoing message traps from
               persisting for the entire session defaultContext is NOT
               a parent context.  It is used only for the special
               cases of "to", "from" and "method".
            */
            mc = new MessageContext(); // released: after the for loop
            try {
                mc->setParameter("to", ss->defaultContext.getParameter("to"));
                mc->setParameter("from", ss->defaultContext.getParameter("from"));
                mc->setParameter("method", ss->defaultContext.getParameter("method"));
            } catch(MessageContext::NoSuchParameterError x) {
                LOG("localsite", 3, "scheduleMessageBlock error " << x.what());
            }
        }
        else if(mc) mc->acquire(); // released: after the for loop
        for(int j=0; j < mb->numMessages(); j++) {
            vRef<Message> m = mb->getMessage(j);

            if(m->getType() == "default") {
                if(mc) {
                    if(m->hasMethod()) mc->setParameter("method", m->getMethod());
                    if(m->hasTo()) mc->setParameter("to", m->getTo());
                    if(m->hasFrom()) mc->setParameter("from", m->getFrom());
                } else {
                    if(m->hasMethod()) ss->defaultContext.setParameter("method", m->getMethod());
                    if(m->hasTo()) ss->defaultContext.setParameter("to", m->getTo());
                    if(m->hasFrom()) ss->defaultContext.setParameter("from", m->getFrom());
                }
            } else if(m->getType() == "include") {
                try {
                    vRef<MessageBlock> mb = ss->getMessageBlock(m->getMethod());
                    vRef<MessageContext> newmc = new MessageContext();
                    newmc->setParentContext(mc);
                    try {
                        if(m->hasTo()) newmc->setParameter("to", m->getTo());
                        else newmc->setParameter("to", ss->defaultContext.getParameter("to"));

                        if(m->hasFrom()) newmc->setParameter("from", m->getFrom());
                        else newmc->setParameter("from", ss->defaultContext.getParameter("from"));

                        if(m->hasMethod()) newmc->setParameter("method", m->getMethod());
                        else newmc->setParameter("method", ss->defaultContext.getParameter("method"));
                    } catch(MessageContext::NoSuchParameterError x) {
                        LOG("localsite", 3, "scheduleMessageBlock Error " << x.what());
                    }
                    for(int i = 0; i < m->getNumFields(); i++) {
                        const Message::Field& f = m->getField(i);
                        newmc->setParameter(f.key, f.source);
                    }
                    string extradep = m->getDependency();
                    mc->doSubstitution(extradep);
                    scheduleMessageBlock(&mb, &newmc, ss, plustime + m->getTime(), extradep.c_str());
                } catch(NoSuchMessageBlockError) { }
            } else {
                vRef<Message> mcopy = (mb->getName() == "" && mc==0) ? (m->acquire(), &m) : (new Message(*m));
                if(mcopy != m && mcopy->getCount() != 1) LOG("refcount", 5, "count on new (copied) message is "
                                                             << mcopy->getCount());
                if(extradependency) {
                    if(mcopy->getDependency() == "") mcopy->setDependency(extradependency);
                    else {
                        string s = mcopy->getDependency();
                        s += ",";
                        s += extradependency;
                        mcopy->setDependency(s);
                    }
                }
                mcopy->setSourceSite(ss);
                mcopy->setMessageContext(mc);
                if(mcopy->getDependency() != "") {
                    ss->trapOutgoingReply(&mcopy);
                }
                if(mc) {
                    try {
                        if(! mcopy->hasMethod()) mcopy->setMethod(mc->getParameter("method"));
                        if(! mcopy->hasTo()) mcopy->setTo(mc->getParameter("to"));
                        if(! mcopy->hasFrom()) mcopy->setFrom(mc->getParameter("from"));
                    } catch(MessageContext::NoSuchParameterError x) {
                        LOG("localsite", 3, "scheduleMessageBlock error " << x.what());
                    }
                } else {
                    try {
                        if(! mcopy->hasMethod()) mcopy->setMethod(ss->defaultContext.getParameter("method"));
                        if(! mcopy->hasTo()) mcopy->setTo(ss->defaultContext.getParameter("to"));
                        if(! mcopy->hasFrom()) mcopy->setFrom(ss->defaultContext.getParameter("from"));
                    } catch(MessageContext::NoSuchParameterError x) {
                        LOG("localsite", 3, "scheduleMessageBlock error " << x.what());
                    }
                }

                double now = getTimer();

//    LOG("localsite", 3, "entered scheduleMessageBlock " << tv.tv_sec << "." << tv.tv_usec);

                LOG("localsite", 4, "scheduling incoming message " << mcopy->incoming_debug);
                mcopy->acquire(); // released by: runSchedule()
                siteMessageQueue[now + plustime + mcopy->getTime()].push_back(&mcopy);
            }
        }
        if(mc) mc->release(); // acquired by: new MessageContext() or mc->acquire() before the for loop
    }
}

void LocalSite::addCallback(callback_t callback, void* userdata, double timeout, bool repeat)
{
    double now = getTimer();

    for(map<double, Callback>::iterator i = callbacks.begin(); i != callbacks.end(); ) {
        if((*i).second.callback == callback) {
            (*i).second.userdata = userdata;
            (*i).second.timeout = timeout;
            (*i).second.repeat = repeat;
            return;
        } else i++;
    }

    if(! callbacklock) {
        callbacks[now + timeout].callback = callback;
        callbacks[now + timeout].userdata = userdata;
        callbacks[now + timeout].timeout = timeout;
        callbacks[now + timeout].repeat = repeat;
    } else {
        pair<double, Callback> p;
        p.first = now + timeout;
        p.second.callback = callback;
        p.second.userdata = userdata;
        p.second.timeout = timeout;
        p.second.repeat = repeat;
        callbackaddqueue.push(p);
    }
}

void LocalSite::removeCallback(callback_t callback)
{
    if(! callbacklock) {
        for(map<double, Callback>::iterator i = callbacks.begin(); i != callbacks.end(); ) {
            if((*i).second.callback == callback) {
                map<double, Callback>::iterator tmp = i;
                i++;
                callbacks.erase(tmp);
            } else i++;
        }
    } else {
        callbackremovequeue.push(callback);
    }
}


void LocalSite::doCallbacks()
{
    if(! callbacklock) { // callback could call runSchedule()
        callbacklock = true;

        double now = getTimer();

        LOG("localsite", 4, "Running callbacks (" << callbacks.size() << ")");

        for(map<double, Callback>::iterator i = callbacks.begin(); i != callbacks.end(); ) {
            if((*i).first <= now) {
                try {
                    (*i).second.callback((*i).second.userdata);
                } catch(exception e) {
                    LOG("localsite", 1, "Callback emitted exception: " << e.what());
                } catch(...) {
                    LOG("localsite", 1, "Callback emitted unknown exception!");
                }

                if((*i).second.repeat) {
                    pair<double, Callback> p;
                    p.first = now + (*i).second.timeout;
                    p.second = (*i).second;
                    callbackaddqueue.push(p);
                    LOG("localsite", 5, "resetting callback to trigger in " << (*i).second.timeout << " seconds");
                }

                map<double, Callback>::iterator tmp = i;
                i++;
                callbacks.erase(tmp);
            } else break;
        }

        callbacklock = false;

        while(! callbackaddqueue.empty())
        {
            callbacks[callbackaddqueue.front().first] = callbackaddqueue.front().second;
            callbackaddqueue.pop();
        }

        while(! callbackremovequeue.empty())
        {
            removeCallback(callbackremovequeue.front());
        }

        LOG("localsite", 4, "Done with callbacks");
    }
}

void LocalSite::runSchedule()
{
    double now = getTimer();

    LOG("localsite", 5, "Running schedule");

    deque<Message*> prioritizedQueue;
    bool inc_i;
    for(map<double, list<Message*> >::iterator i = siteMessageQueue.begin(); i != siteMessageQueue.end(); inc_i ? i++ : 0) {
        inc_i = true;
        if((*i).first <= now) {
            bool inc_q;
            for(list<Message*>::iterator q = (*i).second.begin(); q != (*i).second.end(); inc_q ? q++ : 0) {
                inc_q = true;
                MessageContext* mc = (*q)->getMessageContext(); // released by: mc->release() below
                bool depsatisfied=true;
                string dep = (*q)->getDependency();
                if((*q)->getDependency() != "" && mc) {
                    unsigned int i=0;
                    unsigned int n=0;
                    while(i < dep.size()) {
                        while(i < dep.size() && dep[i] != ',') i++;
                        LOG("localsite", 5, "--- 0 depsatisfied " << depsatisfied << " ---");
                        LOG("localsite", 5, "dep.substr: " << dep.substr(n, i-n));
                        depsatisfied &= mc->replyRecordContains(dep.substr(n, i-n));
                        LOG("localsite", 5, "1 depsatisfied " << depsatisfied);
                        n=++i;
                    }
                }
                LOG("localsite", 5, "2 depsatisfied " << depsatisfied);
                bool removeQ = false;
                if(depsatisfied) {
                    map<string, RemoteSite*>::iterator r;
                    vRef<Site> s = (*q)->getSourceSite();
                    if(&s && (s->getGreeted() || ((*q)->getMethod() == "core:hello" && (*q)->getType() == "message")))
                    {
                        URL to((*q)->getTo());
                        if(! pendingValidationHosts.count(to.getHostAndPort())) {
                            r = prioritized.find((*q)->getNonce());
                            if(r != prioritized.end() && (*r).second == &s) prioritizedQueue.push_back(*q);
                            else msgsReady.push_back(*q);

                            LOG("localsite", 4, "adding msg " << (*q)->incoming_debug << " to schedule with time");
                            //fprintf(stderr, "%16.16f\n", (*i).first);
                        }

                        removeQ = true;

                    } else {
                        LOG("localsite", 4, "can't deliver mesage " << (*q)->getMethod() << " until source site greets us");
                        if(!s->isConnected() && !s->getGreeted()) removeQ = true;
                    }
                } else {
                    vRef<Site> s = (*q)->getSourceSite();
                    if(! s->isConnected()) removeQ = true;
                }
                if(removeQ) {
                    list<Message*>::iterator old = q;
                    q++;
                    inc_q = false;
                    (*i).second.erase(old);
                    if(q == (*i).second.end()) {
                        if(mc) mc->release(); // acquired by: getMessageContext() above
                        break;
                    }
                }
                if(mc) mc->release(); // acquired by: getMessageContext() above
            }
            if((*i).second.size() == 0) {
                map<double, list<Message*> >::iterator old = i;
                i++;
                inc_i = false;
                siteMessageQueue.erase(old);
                if(i == siteMessageQueue.end()) break;
            }
        } else break;
    }

    LOG("localsite", 4, "Done building schedule (" << msgsReady.size() << ", " << prioritizedQueue.size() << ")");

    if(msgsReady.empty() && prioritizedQueue.empty()) {
        LOG("localsite", 5, "Done running schedule");

        flushNotifications();
        doCallbacks();

        return;
    }

    /*
    while(! prioritizedQueue.empty()) {
        vRef<Message> m = prioritizedQueue.front();
        prioritizedQueue.pop_front();
        vRef<Site> s = m->getSourceSite();
        if(&s) LOG("refcount", 5, "scheduleMessageBlock refcount on sourcesite is " << s->getCount());
        try {
            sendMessage(&m);
        } catch(runtime_error e) {
            LOG("localsite", 2, "sendMessage emitted exception: " << e.what());
        } catch(...) {
            LOG("localsite", 2, "sendMessage emitted unknown exception");
        }
        if(!s->isConnected() && !checkScheduleHoldsSite(&s)) {
            Site::removeSite(*s);
        }
    }
    */

    while(! msgsReady.empty()) {
        vRef<Message> m = msgsReady.front();
        msgsReady.pop_front();
        vRef<Site> s = m->getSourceSite();
        if(&s) LOG("refcount", 5, "scheduleMessageBlock refcount on sourcesite is " << s->getCount());
        LOG("msgrefcount", 5, "about to send message number " << m->refcount_debug << " with count " << m->getCount());

        for(int i = 0; i < messagefilters.size(); i++) {
            if(! messagefilters[i]->checkMessage(&m)) {
                LOG("localsite", 4, "Dropping filtered message: " << m->getLoggableString());
                return;
            }
        }

        try {
            sendMessage(&m);
        } catch(runtime_error e) {
            LOG("localsite", 2, "sendMessage emitted exception: " << e.what());
        } catch(...) {
            LOG("localsite", 2, "sendMessage emitted unknown exception");
        }

        if(!s->isConnected() && !checkScheduleHoldsSite(&s)) {
            Site::removeSite(*s);
        }
    }

    runSchedule();
}

void LocalSite::removeRemotePeer(RemoteSite* rs)
{
    if(iteratorsUsingPeerSites == 0) {
        map<RemoteSite*, SiteTableEntry*>::iterator i = peerSites.find(rs);
        if(i != peerSites.end()) {
            LOG("refcount", 5, "localsite: removing remote peer, count is " << (*i).first->getCount());
            (*i).first->release(); // acquired by: doSitePeering()
            if((*i).second->partialMessage)
                (*i).second->partialMessage->release(); // acquired by: flushIncomingBuffers()
            delete (*i).second;
            peerSites.erase(i);
        }
    } else {
        boost::mutex::scoped_lock lock(peerSitesBuffer_mutex);
        peerSitesBuffer_remove.push_back(rs);
    }
}

bool LocalSite::checkScheduleHoldsSite(Site* site)
{
    for(map<double, list<Message*> >::iterator i = siteMessageQueue.begin();
        i != siteMessageQueue.end(); i++)
    {
        for(list<Message*>::iterator n = (*i).second.begin();
            n != (*i).second.end(); n++)
        {
            bool ret = false;
            pREF(Site*, s, (*n)->getSourceSite(),
                 if(s == site) ret = true;
                 );
            if(ret) return true;
        }
    }
    return false;
}

void LocalSite::sendMessage(MessageBlock* mb)
{
    Site::sendMessage(mb);
    LocalVobject::sendMessage(mb);
}

void LocalSite::verifyCheckIDPair(RemoteSocketSite* rss, const string& spoofID)
{
    vRef<Message> nm = new Message();
    nm->setType("message");
    nm->setTo(rss->getURL().getString());
    nm->setMethod("core:anti-spoof-check");
    nm->generateNonce();
    nm->insertField(-1, "peek", spoofID);
    rss->sendMessage(&nm);
}

void LocalSite::sendMessage(Message* m)
{
    /*static int nextexpected = 1;
    if(m->incoming_debug != nextexpected) {
        LOG("localsite", 1, "Inconsistant incoming!  Expected " << nextexpected << " but got " << m->incoming_debug);
        nextexpected = m->incoming_debug + 1;
        } else nextexpected++;*/

    vRef<Site> sourcesite = m->getSourceSite();
    LOG("LocalSite::sendMessage", 3, "Incoming message: " << m->getMethod() << " (to site " << getURL().getString()
        << "  from " << (sourcesite==0 ? "NULL" : sourcesite->getURL().getString()) << ")");
    LOG("LocalSite::sendMessage", 4, "<<<(incoming)<<< sending to " << getURL().getString() << " [" << m->refcount_debug
        << "/" << m->incoming_debug << "/" << m->getCount() << "]\n" << m->getLoggableString());

    Site::sendMessage(m);

    if(m->getType() == "message") {
        if(m->getMethod() == "core:hello") {
            vRef<RemoteSocketSite> st = dynamic_cast<RemoteSocketSite*>(m->getSourceSite());
            LOG("refcount", 5, "localsite sendMessage: got handshake, refcount on site is " << st->getCount());
            string checkid;
            bool foundFavorite = false;
            bool shouldGreet = true;
            for(int i=0; i < m->getNumFields(); i++) {
                const Message::Field& a=m->getField(i);
                if(a.key == "antispoof") {
                    checkid = a.value;
                    setAntiSpoofIDMapping(checkid, st->getAntiSpoofID());
                }
                if(a.key == "alias" && !hasHostAlias(a.value) && !st->checkFlag("spoof-test")) {
                    LOG("localsite", 3, "Validating alias " << a.value);
                    bool checkit = false;
                    if(! getAllSites().count(a.value)) checkit = true;
                    else {
                        vRef<RemoteSocketSite> existingsite = meta_cast<RemoteSocketSite&>(findSite(a.value));
                        if(!(*st == *existingsite)) {
                            if(! existingsite->isConnected()) {
                                removeSite(*existingsite);
                                checkit = true;
                            }
                            LOG("localsite", 2, "We have a multiconnection.  Verifying...");
                            LOG("localsite", 2, "May need to bind site " << st->getURL().getString()
                                << " to site " << a.value);
                            // do something?
                        }
                    }
                    if(checkit) {
                        bool isok = false;
                        if(checkid != "") {
                            string host;
                            int port;
                            unsigned int i;
                            for(i = 0; i < a.value.size() && a.value[i] != ':'; i++);
                            host = a.value.substr(0, i);
                            if(i < a.value.size()) port = atoi(a.value.substr(i+1).c_str());
                            else port = VOS_DEFAULT_PORT;
                            try {
                                vRef<RemoteSocketSite> rss = AsyncConnect::connect(host, port, this, true);

                                rss->removeHostAlias(a.value);
                                st->addHostAlias(a.value);

                                // the AntiSpoofID is the nonce *we* sent with core:hello
                                verifyCheckIDPair(&rss, st->getAntiSpoofID());
                                st->suppressOutgoing(true);

                                rss->acquire(); // released by: handler for anti-spoof-reply
                                st->acquire(); // released by:  handler for anti-spoof-reply
                                pendingValidations[&rss].realsite = st;
                                pendingValidations[&rss].checkid = checkid;
                                pendingValidations[&rss].hostalias = a.value;
                                pendingValidations[&rss].favored = ! foundFavorite;
                                pendingValidationHosts.insert(a.value);
                                foundFavorite = true;
                                shouldGreet = false;
                            } catch(RemoteSite::SiteConnectionError) {
                                LOG("localsite", 1, "Tried to verify '" << a.value << "' but could not connect.");
                                vRef<Message> err = new Message();
                                err->setType("message");
                                err->setMethod("core:error");
                                err->insertField(-1, "error", "Could not verify your hostname '"
                                                 + a.value + "'");
                                st->sendMessage(&err);
                            }
                        }
                    } else {
                        if(st->getURL().getHostAndPort() != a.value) {
                            LOG("localsite", 1, "Attempted spoof! '" << st->getURL().getString() << "' claimed to be '"
                                << a.value << "' but failed verification!");
                        }
                    }
                }
            }
            st->setGreeted(shouldGreet);
            LOG("refcount", 5, "localsite sendMessage: done with hello, refcount on site is " << st->getCount());
        } else if(m->getMethod() == "core:anti-spoof-check") {
            try {
                vRef<RemoteSite> st = dynamic_cast<RemoteSite*>(m->getSourceSite());
                const Message::Field& f = m->getField("peek");
                string spid = getAntiSpoofIDMapping(f.value);
                if(spid == "") {
                    st->acquire(); // released by: doSitePeering
                    needSpoofIDreply.push_back(pair<string, RemoteSite*>(f.value, &st));
                } else {
                    vRef<Message> reply = new Message();
                    initReply(this, &reply, m, "core:anti-spoof-reply");
                    reply->setFrom("");
                    reply->setType("message");
                    reply->insertField(-1, "poke", spid);
                    st->sendMessage(&reply);
                }
            } catch(...) { }
        } else if(m->getMethod() == "core:anti-spoof-reply") {
            vRef<RemoteSocketSite> rss = dynamic_cast<RemoteSocketSite*>(m->getSourceSite());
            if(pendingValidations.count(&rss)) {
                string hostalias = pendingValidations[&rss].hostalias;
                vRef<RemoteSocketSite> st = pendingValidations[&rss].realsite;

                bool isok=false;
                try {
                    if(m->getField("poke").value == pendingValidations[&rss].checkid) isok = true;
                } catch(Message::NoSuchFieldError) {
                }

                rss->handleDisconnection();
                if(isok) {
                    LOG("localsite", 3, "Adding verified host alias " << hostalias
                        << " to " << st->getURL().getString());
                    pendingValidationHosts.erase(hostalias);
                    if(pendingValidations[&rss].favored) {
                        URL u = st->getURL();
                        u.setHostAndPort(hostalias);
                        st->setURL(u);
                        LOG("localsite", 3, "New preferred alias: " << st->getURL().getString());
                    }
                    st->setGreeted(true);
                    st->enableOutgoing(true, st->getURL().getHostAndPort());
                } else {
                    LOG("localsite", 1, "Attempted spoof?  Was given " << hostalias
                        << " by " << st->getURL().getString() << " but could not verify");
                    vRef<Message> err = new Message();
                    err->setType("message");
                    err->setMethod("core:error");
                    err->insertField(-1, "error", "Could not verify your hostname '" + hostalias
                                     + "' (I'm not going to talk to you. Sorry).");
                    st->sendMessage(&err);
                    st->removeHostAlias(hostalias);
                }
                pendingValidations.erase(&rss);
                rss->release(); // acquired by: handler for core:hello
            }
            return; // no reason to process this message any more
        } else if(m->getMethod() == "core:error") {
            try {
                LOG("localsite", 1, "Got error: " << m->getField("error").value);
            } catch(Message::NoSuchFieldError) { }
        } else if(m->getMethod() == "core:create-object") {
            vRef<Message> reply = new Message();
            initReply(this, &reply, m, "core:set-child-update");
            string newobjname;
            deque<string> newobjtypes;
            try {
                for(int i=0; i < m->getNumFields(); i++) {
                    const Message::Field& f = m->getField(i);
                    if(f.key == "type") {
                        newobjtypes.push_back(f.value);
                    } else if(f.key == "name") {
                        newobjname = f.value;
                    }
                }
            } catch(Message::NoSuchFieldError) { }
            SiteAccessControl* sac;
            vRef<Site> ss = m->getSourceSite();
            if((sac = dynamic_cast<SiteAccessControl*>(getAccessControl()))
               && sac->checkCreateVobjectPermission(*ss, *this, newobjname, newobjtypes)) {
                vRef<LocalMetaObject> newobj =
                    meta_cast<LocalMetaObject*>(createMetaObject(newobjname.c_str(), (char*)0));

                for(deque<string>::iterator i = newobjtypes.begin();
                    i != newobjtypes.end(); i++)
                {
                    if(getAccessControl()->checkAddTypePermission(*ss, *i))
                        newobj->addType(*i, &ss);
                }
                vRef<ParentChildRelation> pcr = newobj->findParent(*this);
                char n[16];
                snprintf(n, sizeof(n), "%i", pcr->position);
                reply->insertField(-1, "pos", n);
                reply->insertField(-1, "name", pcr->contextual_name);
                reply->insertField(-1, "path", newobj->getURL().getString());
                const TypeSet& ts = newobj->getTypes();
                if(ts.size() > 0) {
                    for(TypeSet::const_iterator ti = ts.begin(); ti != ts.end(); ti++) {
                        reply->insertField(-1, "type", *ti);
                    }
                } else reply->insertField(-1, "type", "");
                try {
                    ss->sendMessage(&reply);
                } catch(...) { }

                LOG("refcounted", 5, "Done creating meta object, count (after release) is " << (newobj->getCount()-1));
            } else {
                if(!sac) LOG("accesscontrol", 2, "Warning!  " << getURL().getString()
                             << " has no access control policy!  Failing by default.");
                reply->insertField(-1, "error", "Permission denied");
            }
        }
    }

    if(&sourcesite && sourcesite->checkFlag("spoof-test")) return;

    try {
        URL to(m->getTo());
        URL from(m->getFrom());

        if(! getAllSites().count(to.getHostAndPort())) {
            LOG("localsite", 3, "dropping message with unknown to field " << to.getString());
            return;
        }

        map<string, Site*>::const_iterator sti = getAllSites().find(from.getHostAndPort());
        vRef<Site> fromsite;
        if(sti != getAllSites().end()) {
            fromsite = (*sti).second;
            fromsite->acquire();
        }
        if(! &fromsite) {
            LOG("localsite", 3, "dropping message with unknown from field " << from.getString());
            return;
        }

        LOG("refcount", 5, "localsite sendMessage: fromsite refcount is " << fromsite->getCount());
        vRef<Site> st = m->getSourceSite();
        if(! &st) {
            LOG("localsite", 3, "dropping message with no sourcesite!");
            return;
        }

        if(&fromsite != &st && st->isRemote()) {
            if(!st->checkFlag("spoof-test") && m->getMethod() != "core:type-add-update") {
                LOG("sendMessage", 2, "Note: site in from field \"" << fromsite->getURL().getString()
                    << "\" and actual source site \"" << st->getURL().getString()
                    << "\" are not the same object");
                LOG("sendMessage", 3, "error happened on message " << m->getLoggableString());
            }
            return;
        }
        if(peerSites.count(dynamic_cast<RemoteSite*>(&fromsite))) {
            if(peerSites[dynamic_cast<RemoteSite*>(&fromsite)]->localPeerName == "") {
                peerSites[dynamic_cast<RemoteSite*>(&fromsite)]->localPeerName = to.getHostAndPort();
            }
            if(peerSites[dynamic_cast<RemoteSite*>(&fromsite)]->localPeerName == to.getHostAndPort()) {
                to.setHostAndPort(getURL().getHostAndPort());
                m->setTo(to.getString());
            }
        }
        vRef<Vobject> vob = Vobject::findObjectFromRoot(m->getTo());
        if(!(dynamic_cast<LocalSite*>(&vob) == this)) {
            try {
                vob->sendMessage(m);
            } catch(runtime_error e) {
                LOG("localsite", 2, "sendMessage emitted exception: " << e.what());
                return;
            } catch(...) {
                LOG("localsite", 2, "sendMessage emitted unknown exception");
                return;
            }
        }
    } catch(NoSuchSiteError) {
        LOG("localsite", 3, "No such site on to (\"" << m->getTo() << "\") or from (\"" << m->getFrom() << "\")  "
            << m->getLoggableString());
        return;
    } catch(NoSuchObjectError) {
        LOG("localsite", 3, "No such to (\"" << m->getTo() << "\") or from (\"" << m->getFrom() << "\") object");
        return;
    } catch(URL::BadURLError) {
        LOG("localsite", 3, "Bad to (\"" << m->getTo() << "\") or from (\"" << m->getFrom() << "\") field");
        return;
    }

    if(m->getType() == "update") {
        try {
            vRef<Vobject> target = Vobject::findObjectFromRoot(m->getFrom());
            LOG("refcount", 5, "about to deliver to update Message, count on msg is " << m->getCount());
            target->sendUpdateMessage(m);
            LOG("refcount", 5, "did deliver to updateMessage, count on msg is " << m->getCount());
        } catch(NoSuchObjectError) {
            return;
        } catch(runtime_error e) {
            LOG("localsite", 2, "sendMessage emitted exception: " << e.what());
            return;
        } catch(...) {
            LOG("localsite", 2, "sendMessage emitted unknown exception");
            return;
        }
    }

    LocalMetaObject::sendMessage(m);

    LOG("localsite", 4, "did deliver to sendMessage, count on msg is " << m->getCount());
}

void LocalSite::setURL(const URL& u)
{
    url = u;
}

void LocalSite::setTimeoutOnSelect(double sec)
{
    delete selectwait;
    if(sec < 0) selectwait = 0;
    else {
        selectwait = new struct timeval();
        selectwait->tv_sec = (long)floor(sec);
        selectwait->tv_usec = (long)((sec - floor(sec))*1000000.0);
    }
}

double LocalSite::getTimeoutOnSelect()
{
    if(selectwait) return (((double)selectwait->tv_sec) + (((double)selectwait->tv_usec) / 1000000.0));
    else return -1;
}

void LocalSite::addPrioritizedNonce(const string& nonce, RemoteSite* source)
{
    source->acquire(); // released by: removePrioritizedNonce()
    LOG("refcount", 5, "addPrioritizedNonce for " << nonce << " acquired " << source->getURL().getString()
        << " count is now " << source->getCount());
    prioritized[nonce] = source;
}

void LocalSite::removePrioritizedNonce(const string& nonce, RemoteSite* source)
{
    map<string, RemoteSite*>::iterator i = prioritized.find(nonce);
    if(i != prioritized.end() && (*i).second == source) {
        prioritized.erase(i);
        LOG("refcount", 5, "removePrioritizedNonce released " << source->getURL().getString()
            << " count is now " << (source->getCount()-1));
        source->release(); // acquired by: addPrioritizedNonce()
    }
}


void LocalSite::extendMetaObject(LocalMetaObject* root, const char* t) {
    if(localObjectExtensionTable.count(t) == 0) {
        root->addType(t);
    } else {
        pair<MI, MI> range = localObjectExtensionTable.equal_range(t); // get iterator range of types matching t
        for(MI it = range.first; it != range.second; it++) {
            MetaObject* newext = (*it).second(root, t);
            root->addType(newext->getType()); // add all the metaobjects for type t
        }
    }
}


MetaObject* LocalSite::createMetaObject(const char* desiredName, VobjectAccessControl* ac, const deque<string>& typelist)
{
    string name = uniqueName(desiredName);
    if(!ac) ac = getAccessControl();
    LocalMetaObject* root = new LocalMetaObject(name, this, ac);
    LocalVobject::insertChild(-1, root->getName(), root);
    for(deque<string>::const_iterator i = typelist.begin(); i != typelist.end() ; i++) {
        extendMetaObject(root, (*i).c_str());
    }
    return root;
}

MetaObject* LocalSite::createMetaObject(const char* name, const deque<string>& typelist) {
    return createMetaObject(name, 0, typelist);
}

MetaObject* LocalSite::createMetaObject(const char* desiredName, VobjectAccessControl* ac, const char* firstType, ...)
{
    string name = uniqueName(desiredName);
    if(!ac)
        ac = getAccessControl();
    LocalMetaObject* root = new LocalMetaObject(name, this, ac);
    LocalVobject::insertChild(-1, root->getName(), root);
    if(!firstType)
        return root;
    extendMetaObject(root, firstType);
    va_list ap;
    va_start(ap, firstType);
    for(;;) {
        char* p=va_arg(ap, char*);
        if(p == 0) break;
        extendMetaObject(root, p);
    }
    va_end(ap);
    return root;
}


MetaObject* LocalSite::createMetaObject(const char* desiredName, const char* first, ...)
{
    string name = uniqueName(desiredName);
    LocalMetaObject* root = new LocalMetaObject(name, this, getAccessControl());
    LocalVobject::insertChild(-1, root->getName(), root);
    if(!first)
        return root;
    extendMetaObject(root, first);
    va_list ap;
    va_start(ap, first);
    for(;;) {
        char* t = va_arg(ap, char*);
        if(t == 0)
            break;
        extendMetaObject(root, t);
    }
    va_end(ap);
    return root;
}


void LocalSite::addLocalObjectExtension(const char* type, metaobject_extender_t newmethod)
{
    localObjectExtensionTable.insert(multimap<string, metaobject_extender_t>::value_type(string(type), newmethod));
}

bool LocalSite::hasLocalObjectExtension(const char* type)
{
    return (localObjectExtensionTable.count(type) > 0);
}

void LocalSite::removeLocalObjectExtension(const char* type, metaobject_extender_t oldmethod)
{
    pair<MI, MI> g = localObjectExtensionTable.equal_range(type);
    for(MI it = g.first; it != g.second; it++) {
        if((*it).second == oldmethod) {
            localObjectExtensionTable.erase(it);
            break;
        }
    }
}

void LocalSite::printExtensionTable(ostream& stream) {
    for(MI i = localObjectExtensionTable.begin(); i != localObjectExtensionTable.end(); i++) {
        stream << i->first << endl;
    }
}

void LocalSite::addNotification(NotifyEvent* ev)
{
    notifyEvents.push(ev);
}

void LocalSite::lockNotificationFlush()
{
    notifyflushlock = true;
}

void LocalSite::unlockNotificationFlush()
{
    notifyflushlock = false;
    flushNotifications();
}

void LocalSite::flushNotifications()
{
    if(! notifyflushlock) {
        LOG("localsite", 5, "Flushing notifications (queue size is " << notifyEvents.size() << ")");
        while(! notifyEvents.empty()) {
            NotifyEvent* n = notifyEvents.front();
            notifyEvents.pop();
            try {
                n->notify();
            } catch(runtime_error x) {
                LOG("localsite", 0, "call to notify emitted exception: " << x.what());
            } catch(...) { }
            delete n;
        }
        LOG("localsite", 5, "Done flushing notifications");
    }
}


void LocalSite::insertChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    throw AccessControlError("Impossible to do insertChild on a site, try createObject");
}

void LocalSite::setChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    throw AccessControlError("Impossible to do setChild on a site, try createObject");
}

void LocalSite::removeChild(int position)
    throw (AccessControlError, RemoteError)
{
    throw AccessControlError("Impossible to do removeChild on a site, try excise");
}

void LocalSite::takeOverMessages(Site* was, Site* now)
{
    for(map<double, list<Message*> >::iterator i = siteMessageQueue.begin();
        i != siteMessageQueue.end();
        i++)
    {
        for(list<Message*>::iterator n = (*i).second.begin();
            n != (*i).second.end();
            n++)
        {
            vRef<Site> s = (*n)->getSourceSite();
            if(&s == was) (*n)->setSourceSite(now);
        }
    }
}

// There is a tiny, tiny chance that somehow the main thread
// shrink the child list right in the middle of this loop,
// which would cause the iterator to run off the end.
// This seems like a fairly infrequent race condition,
// and one which is incredibly difficult to fix
// due to the fact that it would require locking
// the child list (which is used everywhere).
// Of course, this loop should only ever run once anyway...
void LocalSite::setPrimaryHostname(string s)
{
    if(s != url.getHost()) {
        url.setHost(s);
        addHostAlias(url.getHostAndPort());
        for(unsigned int i = 0; i < children.size(); i++) {
            if(LocalVobject* v = dynamic_cast<LocalVobject*>(children[i]->child)) {
                URL u = v->getURL();
                u.setHost(s);
                v->setURL(u);
            }
        }
    }
}

---