vos/corelibs/vos/message.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 "message.hh"
#include "log.hh"
#include "site.hh"
#include "messagecontext.hh"

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

using namespace VOS;

/** @file
    Implements Message.
 */

int Message::refcount_debug_counter=0;

#ifdef LEAKYSET_DEBUG
set<Message*> Message::leakySet;
#endif

Message::Message() : mtime(0.0), source_site(0), messageContext(0), formattedString(0)
{
    setMappingFunc(xmlFormatting);
    refcount_debug = ++refcount_debug_counter;
    incoming_debug = 0;
    LOG("message", 5, "created message " << refcount_debug);
#ifdef LEAKYSET_DEBUG
    leakySet.insert(this);
#endif
}

Message::Message(Message& m) : type(m.type), to(m.to),
    from(m.from), method(m.method), nonce(m.nonce), mtime(m.mtime),
    dependsOn(m.dependsOn), source_site(m.source_site),
    messageContext(m.messageContext), formattedString(m.formattedString),
    fields(m.fields), parse_extra(m.parse_extra), parse_buffer(m.parse_buffer),
    format_func(m.format_func), parse_func(m.parse_func)
{
    refcount_debug = ++refcount_debug_counter;
    LOG("message", 5, "created message " << refcount_debug);
#ifdef LEAKYSET_DEBUG
    leakySet.insert(this);
#endif
}


Message::~Message()
{
    if(formattedString) delete formattedString;
    LOG("refcount", 5, "message: deleting message [" << refcount_debug << "]");
    if(source_site) {
        LOG("refcount", 5, "about to release source site, count is " << source_site->getCount());
        source_site->release(); // acquired by: setSourceSite
    }
    if(messageContext) messageContext->release(); // acquired by: setMessageContext()
#ifdef LEAKYSET_DEBUG
    leakySet.erase(this);
#endif
}

#ifdef LEAKYSET_DEBUG
void Message::printLeakySet()
{
    LOG("leakyset", 5, "size of set is " << leakySet.size());
    for(set<Message*>::iterator i = leakySet.begin(); i != leakySet.end(); i++) {
        pREF(Site*, s, (*i)->getSourceSite(),
             if(s) {
                 LOG("leakyset", 5, "Source site is " << s->getURL().getString()
                     << " leaky msg is " << (*i)->getFormattedString());
             } else {
                 LOG("leakyset", 5, "No source site,  leaky msg is " << (*i)->getFormattedString());
             }
        );
    }
}
#endif

#define RESET_FMTSTR { \
    if(formattedString) { \
        delete formattedString; \
        formattedString=0; \
    } \
}


void Message::setTo(const string& s) { to=s; RESET_FMTSTR; }
void Message::setType(const string& s) { type=s; RESET_FMTSTR; }
void Message::setFrom(const string& s) { from=s; RESET_FMTSTR; }
void Message::setMethod(const string& s) { method=s; RESET_FMTSTR; }
void Message::setNonce(const string& s) { nonce=s; RESET_FMTSTR; }
void Message::setTime(double t) { mtime = t; RESET_FMTSTR; }
void Message::setSourceSite(Site* s) {
    if(source_site) source_site->release(); // acquired by: setSourceSite
    if(s) s->acquire(); // released by: Message destructor or setSourceSite
    source_site=s;
}
void Message::setMessageContext(MessageContext* mb) {
    if(messageContext) messageContext->release(); // acquired by: this method (below)
    if(mb) mb->acquire(); // released by: Message destructor or setMessageContext()
    messageContext=mb;
}
void Message::setDependency(const string& nonce) {
    dependsOn = nonce;
    RESET_FMTSTR;
}

bool Message::hasTo() const
{
    return (to != "");
}

bool Message::hasFrom() const
{
    return (from != "");
}

bool Message::hasMethod() const
{
    return (method != "");
}

bool Message::hasNonce() const
{
    return (nonce != "");
}

bool Message::hasDependency() const
{
    return (dependsOn != "");
}

string Message::getTo() const {
    string s = to;
    if(messageContext) messageContext->doSubstitution(s);
    return s;
}
string Message::getFrom() const {
    string s = from;
    if(messageContext) messageContext->doSubstitution(s);
    return s;
}
string Message::getMethod() const {
    string s = method;
    if(messageContext) messageContext->doSubstitution(s);
    return s;
}
const string& Message::getType() const { return type; }
string Message::getNonce() const {
    string s = nonce;
    if(messageContext) messageContext->doSubstitution(s);
    return s;
}
double Message::getTime() const { return mtime; }
Site* Message::getSourceSite() {
    if(source_site) {
        source_site->acquire(); // released by: the caller of this method
        return source_site;
    } else return 0;
}
MessageContext* Message::getMessageContext()
{
    if(messageContext) {
        messageContext->acquire(); // released by: the caller of this method
        return messageContext;
    } else return 0;
}
string Message::getDependency() {
    string s = dependsOn;
    if(messageContext) messageContext->doSubstitution(s);
    return s;
}
int Message::getNumFields() const { return (int)fields.size(); }

void Message::generateNonce()
{
    char nonce[16];
    snprintf(nonce, sizeof(nonce), "%i", (int)rand());
    setNonce(string(nonce));
}

const Message::Field& Message::getField(const string& key) throw (NoSuchFieldError)
{
    for(deque<Field>::iterator i = fields.begin(); i != fields.end(); i++) {
        if((*i).key == key) {
            (*i).value = (*i).source;
            if(messageContext && !(*i).quoted) messageContext->doSubstitution((*i).value);
            return (*i);
        }
    }
    throw NoSuchFieldError(string("No such field tag ") + key);
}

const Message::Field& Message::getField(int n) throw (NoSuchFieldError)
{
    if(n < 0) n = (int)fields.size() + n + 1;
    if(n >= (int)fields.size()) throw NoSuchFieldError("Field index out of range");
    Field& f = fields[n];
    f.value = f.source;
    if(messageContext && !f.quoted) messageContext->doSubstitution(f.value);
    return f;
}

void Message::insertField(int n, const string& key, const string& val, bool quoted)
{

    if(n < 0) n = (int)fields.size() + n + 1;
    Field f;
    f.key = key;
    f.source = val;
    f.quoted = quoted;
    if(!quoted) {
        // check for overrides (can't possible transmit unquoted string with there characters)
        for(unsigned int i = 0; i < val.length(); i++) {
            if(val[i] == '<' || val[i] == '>' || val[i] == '\0') {
                f.quoted = true;
                break;
            }
        }
    }
    fields.insert(fields.begin()+n, f);
    RESET_FMTSTR;
}

void Message::insertField(int n, const string& key, int val)
{

    if(n < 0) n = (int)fields.size() + n + 1;
    Field f;
    f.key = key;
    char s[32];
    snprintf(s, sizeof(s), "%i", val);
    f.source = s;
    f.quoted = false;

    fields.insert(fields.begin()+n, f);
    RESET_FMTSTR;
}

void Message::insertField(int n, const string& key, double val)
{

    if(n < 0) n = (int)fields.size() + n + 1;
    Field f;
    f.key = key;
    char s[32];
    snprintf(s, sizeof(s), "%f", val);
    f.source = s;
    f.quoted = false;
    fields.insert(fields.begin()+n, f);
    RESET_FMTSTR;
}

void Message::removeField(int n)
{
    if(n < 0) n = (int)fields.size() + n;
    fields.erase(fields.begin()+n);
    RESET_FMTSTR;
}

void Message::removeField(const string& key)
{
    for(unsigned int i=0; i < fields.size(); i++) {
        if(fields[i].key==key) {
            fields.erase(fields.begin()+i);
            break;
        }
    }
    RESET_FMTSTR;
}


void Message::setMappingFunc(string* (*func)(const string& type,
                                             const string& to,
                                             const string& from,
                                             const string& method,
                                             const string& nonce,
                                             const string& dependsOn,
                                             double mtime,
                                             const deque<Message::Field>& fields,
                                             bool withLength))
{
    format_func=func;
    RESET_FMTSTR;
}

const string& Message::getFormattedString(bool withLength)
{
    if(formattedString != 0) return *formattedString;
    else return *(formattedString = format_func(type, to, from, method, nonce, dependsOn, mtime, fields, withLength));
}

string Message::getLoggableString()
{
    string s;
    string n;

    s += "<" + type + " ";
    n = to;
    if(messageContext) messageContext->doSubstitution(n);
    s += "to=\"" + n + "\"";

    n = from;
    if(messageContext) messageContext->doSubstitution(n);
    s += "\n  from=\"" + n + "\"";

    n = method;
    if(messageContext) messageContext->doSubstitution(n);
    s += "\n  method=\"" + n + "\"";

    n = nonce;
    if(messageContext) messageContext->doSubstitution(n);
    if(n != "") s += "\n  nonce=\"" + n + "\"";

    n = dependsOn;
    if(messageContext) messageContext->doSubstitution(n);
    if(n != "") s += "\n  depends=\"" + n + "\"";

    if(mtime != 0.0) {
        char timing[16];
        snprintf(timing, sizeof(timing), "%6.6f", mtime);
        s += "\n  time=\"";
        s += timing;
        s += "\"";
    }

    if(fields.size() == 0) {
        s += " />";
    } else {
        s += ">";
        deque<Message::Field>::iterator f=fields.begin();

        while(f != fields.end()) {
            if((*f).source == "") {
                s += "<" + (*f).key + " />\n    ";
            } else {
                (*f).value = (*f).source;
                if(messageContext && !(*f).quoted) messageContext->doSubstitution((*f).value);
                s += "\n    <" + (*f).key + ">" + (*f).value + "</" + (*f).key + ">";
            }
            f++;
        }
        s += "\n</" + type + ">";
    }

    return s;
}

/*
int Message::parseUpdate(const string& data)
{
    int oldsize=parse_buffer.size();
    parse_buffer.append(data);

    int ret=parse_func(*this, parse_extra, parse_buffer);
    if(ret > 0) {
        parse_buffer.erase(parse_buffer.begin(), parse_buffer.end());
        if(formattedString != 0) {
            delete formattedString;
            formattedString=0;
        }
        return (ret - oldsize);
    } else {
        fields.resize(0);
        return 0;
    }
}
*/

/* these are functions for the parsing/formatting */

string* VOS::xmlFormatting(const string& type,
                           const string& to,
                           const string& from,
                           const string& method,
                           const string& nonce,
                           const string& dependsOn,
                           double mtime,
                           const deque<Message::Field>& fields,
                           bool withLength)
{
    string* s=new string();

    *s += "<" + type + " ";
    if(withLength) *s += "length=\"\"\n";
    if(to != "") *s += "to=\"" + to + "\"\n";
    if(from != "") *s += "from=\"" + from + "\"\n";
    if(method != "") *s += "method=\"" + method + "\"";
    if(nonce != "") *s += "\nnonce=\"" + nonce + "\"";
    if(dependsOn != "") *s += "\ndepends=\"" + dependsOn + "\"";
    if(mtime != 0.0) {
        char timing[16];
        snprintf(timing, sizeof(timing), "%6.6f", mtime);
        *s += "\ntime=\"";
        *s += timing;
        *s += "\"";
    }

    if(fields.size() == 0) {
        *s += " />";
    } else {
        *s += ">\n";
        deque<Message::Field>::const_iterator f=fields.begin();

        while(f != fields.end()) {
            if((*f).source == "") {
                *s += "<" + (*f).key + " />\n";
            } else {
                if((*f).quoted) {
                    *s += "<" + (*f).key + " ";
                    *s += "length=\"";
                    char n[16];
                    snprintf(n, sizeof(n), "%i", (*f).source.length());
                    *s += n;
                    *s += "\">" + (*f).source + "</" + (*f).key + ">\n";
                } else {
                    *s += "<" + (*f).key + ">" + (*f).source + "</" + (*f).key + ">\n";
                }
            }
            f++;
        }
        *s += "</" + type + ">";
    }

    if(withLength) {
        unsigned int size = (unsigned int)s->size();
        char len[16];
        int width=snprintf(len, sizeof(len), "%i", size);
        size += (unsigned int)strlen(len);
        if(width < snprintf(len, sizeof(len), "%i", size)) snprintf(len, sizeof(len), "%i", size+1);
        // '< length="' is 10 characters
        s->insert(10+type.size(), len);
        LOG("message", 5, "generated message exactly " << (unsigned int)s->size() << " bytes long");
    }

    return s;
}

---