XtrMetadata.h

Go to the documentation of this file.

/*
* Copyright (c) 2005,2006,2007 The Regents of the University of California.
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright
*       notice, this list of conditions and the following disclaimer in the
*       documentation and/or other materials provided with the distribution.
*     * Neither the name of the University of California, nor the
*       names of its contributors may be used to endorse or promote products
*       derived from this software without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY OF CALIFORNIA ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#include <cstdlib>
#include <cassert>
#include <cstring>

#include "XtrConstants.h"
#include "XtrOption.h"

#ifndef _XTR_METADATA_H
#define _XTR_METADATA_H

namespace xtr {
/*********************************************************/

template <size_t max_len> class Id
{
public:
    Id() : length(0) {}; 
    Id(size_t _length);
    Id(const u_int8_t* from, size_t len); 
    virtual ~Id() {};

    bool isLengthValid() const {return isValidLength(length);};
    size_t getLength() const {return length;};
    const u_int8_t* getBytes() const {return id;};
    u_int8_t& operator[](size_t i) {assert(i < length); return id[i];}; 
    virtual bool isEqual(const Id< max_len>& other) const;

    void setLength(size_t _length) {assert(_length <= max_len); length = _length;};
    xtr_result setBytes(const u_int8_t* from, size_t len);

    xtr_result pack(u_int8_t *dest, size_t *size) const;

    char* toString(char *dest, size_t size) const;
    virtual bool isValidLength(size_t len) const {return (len <= max_len);};
protected:
    size_t length;
    u_int8_t id[max_len];
};


template <size_t max_len>
Id< max_len >::Id(size_t _length) 
    : length(0) 
{
    //assert(_length <= max_len); 
    memset(id, 0, sizeof(id));
    if (isValidLength(_length)) {
        length = _length; 
    }
}

template <size_t max_len>
Id< max_len >::Id(const u_int8_t* from, size_t len)
    : length(0)
{
    assert(from);
    //assert(len <= max_len);
    if (isValidLength(len)) {
        length = len;
        memset(id, 0, sizeof(id));
        memcpy(id, from, len);
    }
};

template <size_t max_len>
xtr_result Id<max_len>::setBytes(const u_int8_t* from, size_t len) {
    assert(from);
    assert(len <= max_len);
    if (isValidLength(len)) {   
        length = len;
        memcpy(id, from, len);
        return XTR_SUCCESS;
    } else
        return XTR_FAIL;
}

template <size_t max_len>
xtr_result Id <max_len>::pack(u_int8_t *dest, size_t *size) const
{
    assert(dest);
    assert(size);
    if (*size < length) {
        *size = 0;
        return XTR_FAIL;
    }
    memcpy(dest, id, length);
    *size = length;
    return XTR_SUCCESS;
}
 
template <size_t max_len>
bool Id< max_len >::isEqual(const Id< max_len>& other) const
{
    unsigned int i;
    bool equal = 1;
    if (length != other.length)
        equal =  0;
    for (i = 0; i < length && equal; i++) {
       equal &= (id[i] == other.id[i]); 
    }
    return equal;
}

void xtr_btoh(u_int8_t b, char*p);

template <size_t max_len>
char* Id< max_len >::toString(char *dest, size_t size) const
{
    char* p = dest;
    size_t k = 0;

    if (!dest)
        return dest;
    *dest = 0;
    if (length == 0)
        return dest;
    if (size < length*2 + 1)
        return dest;

    while ( k < length ) {
    xtr_btoh(id[k++], p);
        p += 2;
    }
    *p = 0;
    return dest;
}

class OpId : public Id<XTR_MAX_OP_ID_LEN>
{
public:
    OpId(size_t len = 4);
    
    OpId(const u_int8_t* from, size_t len);

    bool isValidLength(size_t len) const {
        return (len == 4 || len == 8);
    };
};


class TaskId : public Id<XTR_MAX_TASK_ID_LEN>
{
public:
    TaskId(size_t len = 4);
    TaskId(const u_int8_t* from, size_t len);
    
    bool isValid() const;

    bool isValidLength(size_t len) const {
        return (len == 4 || len == 8 || len == 12 || len == 20);
    }
};


/*********************************************************/

class Options {
public:
    Options() : reserved_count(0), count(0), length(0), opts(0){};
    Options(const u_int8_t *from, u_int8_t len);

    Options(const Options&);

    ~Options();
    Options& operator=(const Options& other);

    size_t getCount() const {return count;};
    size_t getLength() const {return length;};
    
    bool isEqual(const Options& other) const;

    xtr_result reserve(u_int8_t n);
    void clear();

    Option& operator[](size_t i) const {assert(i < count); return *opts[i];};

    xtr_result addOption(const Option& option);

    xtr_result removeOptionAt(u_int8_t i);

    xtr_result pack(u_int8_t *dest, size_t *size) const;

private:
    u_int8_t reserved_count;
    u_int8_t count;
    u_int8_t length;
    Option **opts;
};


class Metadata 
{
public:
    Metadata(size_t tlen=4, size_t olen=4) : version(XTR_CURRENT_VERSION), 
                             taskId(tlen), opId(olen) , options()
        {initRandom();};

    Metadata(const TaskId &id, size_t opIdLen=4) : version(XTR_CURRENT_VERSION),
                                                taskId(), opId() , options()
        {initRandom(); setTaskId(id); setRandomOpId(opIdLen);};

    Metadata(const TaskId &id, const OpId &opId)
        :  version(XTR_CURRENT_VERSION), taskId(), opId(), options() 
        {initRandom(); setTaskId(id); setOpId(opId); };


    static Metadata createFromString(const char* s, size_t len)
    { 
        return Metadata(CREATE_FROM_STRING, s, len);
    }

    static Metadata createFromBytes(const u_int8_t* b, size_t len)
    { 
        return Metadata(CREATE_FROM_BYTES, b, len);
    }

    static Metadata createRandom(size_t taskIdLen = 4, size_t opIdLen = 4) 
    {
        return Metadata(CREATE_RANDOM, taskIdLen, opIdLen);
    }   

    static size_t sizeInArray(const u_int8_t *to, size_t len); 


    void clear();
    
    bool isValid() const {return taskId.isValid();};

    bool isEqual(const Metadata& other) const;

    const TaskId& getTaskId() const {return taskId;};
     
    const OpId& getOpId() const {return opId;};
    Options& getOptions() {return options;};

    xtr_result setTaskId(const TaskId &id);

    xtr_result setRandomTaskId(size_t len = 4);

    xtr_result setOpId(const OpId &id);


    xtr_result setRandomOpId(size_t opIdLen = 4);

    xtr_result addOption(const Option& opt) {return options.addOption(opt);};

    /* Setting of some important options. These are shortcuts to actually
     * creating and adding the options, but come in handy. */

    /* ChainId:*/
    u_int16_t getChainId() const;

    xtr_result setChainId(u_int16_t id);

    xtr_result newChainId();

    /* Severity Option Convenience Functions */

    u_int8_t getSeverityThreshold() const;

    xtr_result setSeverityThreshold(u_int8_t s);

    xtr_result unsetSeverityThreshold();

    /* Serialization related functions */
    size_t sizeAsBytes() const;

    xtr_result pack(u_int8_t *to, size_t *len) const;

    size_t sizeAsString() const {return sizeAsBytes() * 2;};
    char* toString(char* to, size_t len) const;

private:
    typedef enum {
        CREATE_RANDOM,
        CREATE_FROM_BYTES,
        CREATE_FROM_STRING,
    } create_t;

    /* Used by named constructor createRandom */
    Metadata (create_t t, size_t taskIdLen = 4, size_t opIdLen = 4);
    Metadata (create_t t, const void *from, size_t len);

    u_int8_t version;
    TaskId taskId;
    OpId opId;
    Options options;

    static void initRandom();

};
}; //namespace Xtr

#endif // _XTR_METADATA_H