vos/metaobjects/property/localproperty.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 <stdio.h>
#include <iostream>
#include <fstream>

#include <vos/corelibs/vos/vos.hh>
#include "property.hh"
#include <typechain/typechain.hh>

#include <assert.h>

/* LocalProperty */

LocalProperty::LocalProperty(MetaObject* superobject)
    : MetaObject(superobject), Property(superobject)
{
    addMessageHandler<LocalProperty>("property:get-length", this, &LocalProperty::getLengthHandler);
    addMessageHandler<LocalProperty>("property:read", this, &LocalProperty::readHandler);
    addMessageHandler<LocalProperty>("property:write", this, &LocalProperty::writeHandler);
    addMessageHandler<LocalProperty>("property:replace", this, &LocalProperty::replaceHandler);
    addMessageHandler<LocalProperty>("property:start-listening", this, &LocalProperty::startListeningHandler);
    addMessageHandler<LocalProperty>("property:stop-listening", this, &LocalProperty::stopListeningHandler);
}

LocalProperty::LocalProperty(MetaObject* superobject, const string& d, const string& dt)
    : MetaObject(superobject), Property(superobject)
{
    raw_data = d;
    raw_datatype = dt;
    raw_length = raw_data.size();

    addMessageHandler<LocalProperty>("property:get-length", this, &LocalProperty::getLengthHandler);
    addMessageHandler<LocalProperty>("property:read", this, &LocalProperty::readHandler);
    addMessageHandler<LocalProperty>("property:write", this, &LocalProperty::writeHandler);
    addMessageHandler<LocalProperty>("property:replace", this, &LocalProperty::replaceHandler);
    addMessageHandler<LocalProperty>("property:start-listening", this, &LocalProperty::startListeningHandler);
    addMessageHandler<LocalProperty>("property:stop-listening", this, &LocalProperty::stopListeningHandler);
}


LocalProperty::~LocalProperty() {
}


void LocalProperty::setSecurityCallback(PropertySecurityInitializer* newcallback)
{
    if(RefCounted* r = dynamic_cast<RefCounted*>(securitycallback)){
        r->release(); // acquired by: this method
    }
    if(RefCounted* r = dynamic_cast<RefCounted*>(newcallback)){
        r->acquire(); // released by: this method
    }
    securitycallback = newcallback;
}



void LocalProperty::write(Vobject& initiator, int start, const string& newdata)
{
    string oldvalue;
    string newvalue;
    Property::read(oldvalue);
    Property::write(start, newdata);
    Property::read(newvalue);

    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyWrite,
                                                  initiator, *this,
                                                  start, newdata.size(),
                                                  newvalue,
                                                  getDataType(),
                                                  oldvalue,
                                                  getDataType(),
                                                  false);
    
    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        (*i).second->notifyPropertyChange(*event);
    }
}

void LocalProperty::write(int start, const string& newdata)
{
    write(*this, start, newdata);
}


void LocalProperty::replace(Vobject& initiator, const string& newdata, 
                            const string& newtype)
{
    string oldvalue;
    string olddatatype;
    Property::read(oldvalue);
    olddatatype = Property::getDataType();

    Property::replace(newdata, newtype);

    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyWrite,
                                                  initiator, *this,
                                                  newdata,
                                                  newtype,
                                                  oldvalue,
                                                  olddatatype,
                                                  false);


    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        (*i).second->notifyPropertyChange(*event);
    }
}


void LocalProperty::replace(const string& newdata, const string& newtype)
{
    replace(*this, newdata, newtype);
}

void LocalProperty::getLengthHandler(Message* m)
{
    vRef<Message> reply = new Message();
    LocalVobject::initReply(this, &reply, m, "property:length-update");

    vRef<Vobject> from = Vobject::findObjectFromRoot(m->getFrom());

    
    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyRead,
                                                  *from, *this,
                                                  read(), 
                                                  getDataType(), 
                                                  true);
    string message;
    if(validatePropertyAccess(*event, message)) {
        char sz[16];
        sprintf(sz, "%i", getRawLength());
        reply->insertField(-1, "len", string(sz));
    } else {
        reply->insertField(-1, "error", message);
    }

    from->sendMessage(&reply);
}

void LocalProperty::readHandler(Message* m)
{
    vRef<Message> reply = new Message();
    vRef<Vobject> from = Vobject::findObjectFromRoot(m->getFrom());

    int off=atoi(m->getField("start").value.c_str());
    int len=atoi(m->getField("length").value.c_str());
    if(off == 0 && len == -1) LocalVobject::initReply(this, &reply, m, "property:replace-update");
    else LocalVobject::initReply(this, &reply, m, "property:update");


    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyRead,
                                                  *from, *this,
                                                  off, len,
                                                  read(), 
                                                  getDataType(),
                                                  true);
    string message;

    if(validatePropertyAccess(*event, message)) {
        string dat;
        readRaw(dat, off, len);
        reply->insertField(-1, "start", m->getField("start").value);
        reply->insertField(-1, "data", dat, true);
                  reply->insertField(-1, "datatype", getRawDataType(), true);
    } else {
        reply->insertField(-1, "error", message);
    }

    from->sendMessage(&reply);
}

void LocalProperty::writeHandler(Message* m)
{
    vRef<Message> reply = new Message();
    LocalVobject::initReply(this, &reply, m, "property:update");
    vRef<Vobject> from = Vobject::findObjectFromRoot(m->getFrom());
    try {
        int off=atoi(m->getField("start").value.c_str());
        string f = m->getField("data").value;

        string precommit;
        readRaw(precommit);
        precommit.replace(off, f.size(), f);

        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyWrite,
            *from, *this,
            off, f.size(),
            precommit, getDataType(),
            read(), getDataType(),
            true);
        string message;
        if(validatePropertyAccess(*event, message)) {
            vRef<Site> site = from->getSite();
            PropertyListenerSiteWrapper plsw(&site);
            PropertyListenerMap::iterator plsit = 
                propertyListeners.find(&plsw);
            PropertyListener* plsw2 = 0;
            if(plsit != propertyListeners.end()) plsw2 = (*plsit).second;
            if(plsw2) propertyListeners.erase(plsw2);
            write(*from, off, f);
            if(plsw2) propertyListeners[plsw2] = plsw2;
            string d;
            readRaw(d, off, f.size());
            reply->insertField(-1, "data", d, true);
        } else {
            reply->insertField(-1, "error", message);
        }
    } catch(Message::NoSuchFieldError) {
        reply->insertField(-1, "error", "no data field");
    }

    from->sendMessage(&reply);
}

void LocalProperty::replaceHandler(Message* m)
{
    vRef<Message> reply = new Message();
    if(m->getNonce() != "") LocalVobject::initReply(this, &reply, m, "property:replace-update");

    vRef<Vobject> from = Vobject::findObjectFromRoot(m->getFrom());
    try {
        string d = m->getField("data").value;
        string t = m->getField("datatype").value;

        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyReplace,
            *from, *this,
            d, t,
            read(), getDataType(),
            true);
        string message;

        if(validatePropertyAccess(*event, message)) {
            vRef<Site> site = from->getSite();
            PropertyListenerSiteWrapper plsw(&site);
            PropertyListenerMap::iterator plsit = 
                propertyListeners.find(&plsw);
            PropertyListener* plsw2 = 0;
            if(plsit != propertyListeners.end()) plsw2 = (*plsit).second;
            if(plsw2) propertyListeners.erase(plsw2);
            replace(*from, d, t);
            if(plsw2) propertyListeners[plsw2] = plsw2;
            string nd;
            readRaw(nd);
            if(m->getNonce() != "") {
                reply->insertField(-1, "data", d, true);
                reply->insertField(-1, "datatype", getRawDataType(), true);
            }
    } else {
            if(m->getNonce() != "") reply->insertField(-1, "error", message);
            LOG("property", 2, "permission denied to " << m->getFrom() << " to write to " << getURL().getString() << " (" << message << ")");
        }
    } catch(Message::NoSuchFieldError) {
        if(m->getNonce() != "") reply->insertField(-1, "error", "no data field");
    }

    if(m->getNonce() != "") from->sendMessage(&reply);
}

void LocalProperty::startListeningHandler(Message* m)
{
    try {
        for(int i = 0; i < m->getNumFields(); i++) {
            if(m->getField(i).key == "listen"
               && m->getField(i).value == "property") {
                vRef<Site> st = m->getSourceSite();

                vRef<PropertyEvent> event = 
                    new PropertyEvent(PropertyEvent::PropertyRead,
                                      *st, *this,
                                      read(), 
                                      getDataType(),
                                      true);
                string message;
                if(validatePropertyAccess(*event, message)) {
                    vRef<Message> reply = new Message();
                    LocalVobject::initReply(this, &reply, m, "property:start-listening-reply");
                    reply->setNonce(m->getNonce() + string("-1"));
                    reply->insertField(-1, "listen", "property");
                    vRef<Vobject> from = findObject(m->getFrom());
                    from->sendMessage(&reply);

                    PropertyListenerSiteWrapper* pl = new PropertyListenerSiteWrapper(&st, m->getNonce());
                    LOG("Property", 5, "allocated plsw at " << pl);

                    addPropertyListener(pl);
                    st->addExciseListener(this);
                } else {
                }
            break;
        }
    }
    } catch(Message::NoSuchFieldError) {
    } catch(NoSuchObjectError) { }
}

void LocalProperty::stopListeningHandler(Message* m)
{
    try {
        if(m->getField("listen").value == "property") {
            PropertyListenerMap::iterator i;
            vRef<Site> st = m->getSourceSite();
            PropertyListenerSiteWrapper plsw(&st);
            i = propertyListeners.find(&plsw);
            if(i != propertyListeners.end()) {
                removePropertyListener((*i).second);
                st->removeExciseListener(this);
                LOG("Property", 4, "aha did a stop-listening here! " << (*i).second);
                delete (*i).second;
            }
        }
    } catch(Message::NoSuchFieldError) { }
}

MetaObject* LocalProperty::new_LocalProperty(MetaObject* superobject, const string& type)
{
    return new LocalProperty(superobject);
}

void LocalProperty::addPropertyListener(PropertyListener* pl, bool refresh)
{
    Property::addPropertyListener(pl, refresh);
    if(refresh) {
        string d;
        read(d);
        vRef<PropertyEvent> event = 
            new PropertyEvent(PropertyEvent::PropertyReplace,
                              *this, *this, d, getDataType(), false);

        pl->notifyPropertyChange(*event);
    }
}

void LocalProperty::initializeSecurity(Vobject& requester)
{
    LOG("LocalProperty", 4, "initializing security on this property with requester "
         << requester.getURL().getString());
    securitycallback->initializePropertyAccessControl(this, requester);
}


void LocalProperty::insertPropertyAccessControl(int pos, PropertyAccessControl* ac)
{
    if(pos < 0) pos += accesscontrols.size() + 1;
    accesscontrols.insert(accesscontrols.begin() + pos, ac);
}

void LocalProperty::insertPropertyAccessControl(int pos, const string& policyname)
{
    if(pos < 0) pos += accesscontrols.size() + 1;

    PropertyAccessControl* ac = PropertyAccessControl::getPolicy(policyname, this);
    if(ac) accesscontrols.insert(accesscontrols.begin() + pos, ac);
}

void LocalProperty::removePropertyAccessControl(int pos)
{
    if(pos < 0) pos += accesscontrols.size() + 1;
    accesscontrols.erase(accesscontrols.begin() + pos);
}

void LocalProperty::removePropertyAccessControl(PropertyAccessControl* ac)
{
    for(unsigned int i = 0; i < accesscontrols.size(); i++) {
        if(accesscontrols[i] == ac) {
            accesscontrols.erase(accesscontrols.begin() + i);
            i--;
        }
    }
}

void LocalProperty::removePropertyAccessControl(const string& policyname)
{
    for(unsigned int i = 0; i < accesscontrols.size(); i++) {
        if(accesscontrols[i]->getPolicyName() == policyname) {
            accesscontrols.erase(accesscontrols.begin() + i);
            i--;
        }
    }
}

const deque<PropertyAccessControl*>& LocalProperty::getPropertyAccessControls()
{
    return accesscontrols;
}

bool LocalProperty::validatePropertyAccess(PropertyEvent& e, string& message)
{
    if(accesscontrols.size() == 0) {
        message = "Error in access policy list.  Permission denied by default.";
        LOG("localproperty", 1, "Access policy list for "
            << e.getProperty()->getURL().getString() << " is empty!");
        return false;
    }

    for(unsigned int i = 0; i < accesscontrols.size(); i++) {
        if(! accesscontrols[i]) {
            message = "Error in access policy list.  Permission denied by default.";
            LOG("localvobject", 1, "Access policy list "
                << e.getProperty()->getURL().getString() << " contains an invalid (null) policy!");
            return false;
        }
        switch(e.getEvent()) {
        case PropertyEvent::PropertyWrite:
        case PropertyEvent::PropertyReplace:
            if(! accesscontrols[i]->checkChangePermission(e, message)) return false;
            break;
        case PropertyEvent::PropertyRead:
            if(! accesscontrols[i]->checkReadPermission(e, message)) return false;
            break;
        default:
            message = "Supplied validateAccess with an unsupported event type!";
            LOG("localvobject", 1, "Supplied validateAccess with an unsupported event type " << e.getEvent());
            return false;
        }
    }
    return true;
}

---