vos/metaobjects/misc/cod.cc

Go to the documentation of this file.

/*
    Copyright (C) 2003 Peter Amstutz <tetron@interreality.org>

    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

*/

#include <stdarg.h>

#include <vos/metaobjects/misc/cod.hh>
#include <vos/metaobjects/property/property.hh>

#ifdef WIN32
#define ZLIB_DLL
#endif

#include <zlib.h>

COD::COD(iostream& io, LocalSite& l)
    : f(&io), ls(l), offset(0), buffersize(0), buffer(0)
{
    ls.acquire(); // released by: destructor
}

COD::COD(LocalSite& l)
    : f(0), ls(l), offset(0), buffersize(0), buffer(0)
{
    ls.acquire(); // released by: destructor
}


COD::~COD()
{
    ls.release(); // acquired by: constructor
    if(buffer) free(buffer);

    clear();
}

void COD::setStream(iostream& io)
{
    f = &io;
}

void COD::clear()
{
    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        if(vobjectorder[i]) {
            if(vobjectorder[i]->vobject) vobjectorder[i]->vobject->release(); // acquired by: addVobject
            if(vobjectorder[i]->mb) vobjectorder[i]->mb->release(); // acquired by: addVobject
            delete vobjectorder[i];
        }
    }
    vobjectorder.resize(0);
    vobjectTable.clear();
}

int COD::addVobject(Vobject* v, bool portable, bool saveChildren)
{
    v->acquire(); // released by: removeVobject() or destructor
    Entry* e = new Entry;
    e->vobject = v;
    e->mb = new MessageBlock();
    e->vobject->saveState(*e->mb, e->types, portable);
    e->savechildren = saveChildren;

    vobjectTable[v->getName()] = e;
    vobjectorder.push_back(e);
    e->pos = vobjectorder.size() - 1;
    return e->pos;
}

int COD::addVobject(Vobject* v, const set<string>& types, MessageBlock* mb, bool saveChildren)
{
    v->acquire(); // released by: removeVobject() or destructor
    Entry* e = new Entry;
    e->vobject = v;
    mb->acquire(); // released by: removeVobject() or destructor
    e->mb = mb;
    e->types = types;
    e->savechildren = saveChildren;

    vobjectTable[v->getName()] = e;
    vobjectorder.push_back(e);
    e->pos = vobjectorder.size() - 1;
    return e->pos;
}

int COD::addVobject(Vobject* v, const deque<string>& types, MessageBlock* mb, bool saveChildren)
{
    v->acquire(); // released by: removeVobject() or destructor
    Entry* e = new Entry;
    e->vobject = v;
    mb->acquire(); // released by: removeVobject() or destructor
    e->mb = mb;
    e->savechildren = saveChildren;

    for(unsigned int i = 0; i < types.size(); i++) {
        e->types.insert(types[i]);
    }

    vobjectTable[v->getName()] = e;
    vobjectorder.push_back(e);
    e->pos = vobjectorder.size() - 1;
    return e->pos;
}


int COD::numVobjects()
{
    return vobjectorder.size();
}

COD::Entry* COD::getVobject(const string& name)
{
    map<string, Entry*>::iterator i = vobjectTable.find(name);
    if(i != vobjectTable.end()) return (*i).second;
    else return 0;
}

COD::Entry* COD::getVobject(int pos)
{
    if(pos < 0) pos += vobjectorder.size() + 1;
    if(pos >= vobjectorder.size()) return 0;
    else return vobjectorder[pos];
}

void COD::removeVobject(const string& name)
{
    map<string, Entry*>::iterator i = vobjectTable.find(name);
    if(i == vobjectTable.end()) return;
    Entry* e = (*i).second;
    vobjectTable.erase(i);
    vobjectorder.erase(vobjectorder.begin() + e->pos);

    e->vobject->release();
    e->mb->release();

    delete e;
}

void COD::removeVobject(int pos)
{
    if(pos < 0) pos += vobjectorder.size() + 1;
    if(pos >= vobjectorder.size()) return;

    Entry* e = vobjectorder[pos];

    vobjectorder.erase(vobjectorder.begin() + pos);
    vobjectTable.erase(e->vobject->getName());

    e->vobject->release();
    e->mb->release();

    delete e;
}


int COD::writeObjectDesc(Entry* e, bool doWrite)
{
    unsigned char buffer[65361];
    int numbytes = 0;
    int nb;

    vRef<Vobject::ParentChildRelation> pcr = ls.findChild(e->vobject->getName());

    nb = pack(buffer, sizeof(buffer), "Sls",
              e->vobject->getName().c_str(), e->vobject->getName().size(),
              pcr->position,
              e->types.size());
    if(doWrite) write(buffer, nb);
    numbytes += nb;

    for(Vobject::TypeSet::const_iterator i = e->types.begin(); i != e->types.end(); i++)
    {
        nb = pack(buffer, sizeof(buffer), "S", (*i).c_str(), (*i).size());
        if(doWrite) write(buffer, nb);
        numbytes += nb;
    }

    nb = pack(buffer, sizeof(buffer), "s", e->mb->numMessages());
    if(doWrite) write(buffer, nb);
    numbytes += nb;

    for(int i = 0; i < e->mb->numMessages(); i++) {
        vRef<Message> m = e->mb->getMessage(i);
        nb = pack(buffer, sizeof(buffer), "Ss", m->getMethod().c_str(),
                  m->getMethod().size(), m->getNumFields());
        if(doWrite) write(buffer, nb);
        numbytes += nb;

        for(int n = 0; n < m->getNumFields(); n++) {
            const Message::Field& fl = m->getField(n);
            nb = pack(buffer, sizeof(buffer), "Sl", fl.key.c_str(), fl.key.size(), fl.value.size());
            if(doWrite) write(buffer, nb);
            numbytes += nb;

            nb = fl.value.size();
            if(doWrite) write(fl.value.c_str(), nb);
            numbytes += nb;
        }
    }

    return numbytes;
}

int COD::writeObjectChildren(Vobject* child, bool doWrite)
{
    unsigned char buffer[65361];
    int numbytes = 0;
    int nb;

    const Vobject::ChildList& cl2 = child->getChildren();
    nb = pack(buffer, sizeof(buffer), "Sl", child->getName().c_str(),
              child->getName().size(), cl2.size());
    if(doWrite) write(buffer, nb);
    numbytes += nb;
    for(unsigned int n = 0; n < cl2.size(); n++) {
        Vobject::ParentChildRelation* pcr2 = cl2[n];
        nb = pack(buffer, sizeof(buffer), "S",
                  pcr2->contextual_name.c_str(),
                  pcr2->contextual_name.size());
        if(doWrite) write(buffer, nb);
        numbytes += nb;
        if(pcr2 && pcr2->child) {
            if(pcr2->child->isLocal() && vobjectTable.count(pcr2->child->getName())) {
                nb = pack(buffer, sizeof(buffer), "S",
                          pcr2->child->getName().c_str(),
                          pcr2->child->getName().size());
                if(doWrite) write(buffer, nb);
                numbytes += nb;
            } else {
                nb = pack(buffer, sizeof(buffer), "S",
                          pcr2->child->getURL().getString().c_str(),
                          pcr2->child->getURL().getString().size());
                if(doWrite) write(buffer, nb);
                numbytes += nb;
            }
        } else {
            nb = pack(buffer, sizeof(buffer), "Ss", 0);
            if(doWrite) write(buffer, nb);
            numbytes += nb;
        }
    }
    return numbytes;
}

string COD::readStr()
{
    static int r=0;
    r++;
    unsigned char buffer[66461];
    unsigned short int sz;
    read(buffer, 2);
    unpack(buffer, sizeof(buffer), "s", &sz);

    read(buffer, sz);
    return string((char*)buffer, (unsigned int)sz);
}

unsigned short int COD::readShort()
{
    unsigned char buffer[2];
    read(buffer, 2);
    unsigned short int nt;
    unpack(buffer, sizeof(buffer), "s", &nt);
    return nt;
}

unsigned long COD::readLong()
{
    unsigned char buffer[4];
    read(buffer, 4);
    unsigned long nt;
    unpack(buffer, sizeof(buffer), "l", &nt);
    return nt;
}

void COD::readObjectDesc(string& name, long& pos, deque<string>& types, MessageBlock& mb)
{
    LOG("COD", 4, "about to read name");
    name = readStr();

    LOG("COD", 4, "read name " << name);

    pos = readLong();

    LOG("COD", 4, "read pos " << pos);

    short int nt = readShort();
    for(int n = 0; n < nt; n++) {
        string type = readStr();
        types.push_back(type);
    }

    unsigned short int nm = readShort();
    for(int n = 0; n < nm; n++) {
        string method = readStr();

        vRef<Message> msg = new Message();
        msg->setMethod(method);

        unsigned short int nf = readShort();
        for(int m = 0; m < nf; m++) {
            string key = readStr();
            unsigned long vlen = readLong();
            char* b2 = (char*)malloc(vlen+1);
            read(b2, vlen);
            string data(b2, vlen);
            msg->insertField(-1, key, data, true);
            free(b2);
        }

        mb.insertMessage(-1, &msg);
    }
}

void COD::readObjectChildren(string& parent, deque<PCR>& children)
{
    parent = readStr();
    unsigned long ch = readLong();
    for(unsigned int n = 0; n < ch; n++) {
        PCR p;
        p.context = readStr();
        p.child = readStr();
        children.push_back(p);
    }
}

int COD::computeSize()
{
    int numbytes = 14;

    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        numbytes += writeObjectDesc(vobjectorder[i], false);
    }

    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        if(vobjectorder[i]->vobject->getChildren().size() > 0 && vobjectorder[i]->savechildren) {
            numbytes += writeObjectChildren(vobjectorder[i]->vobject, false);
        }
    }

    return numbytes;
}

void COD::writeCOD(bool gzip)
{
    if(f) {
        unsigned int size;
        writeCOD(&buffer, &size, gzip);
        f->write((char*)buffer, size);
    }
}

void COD::write(const unsigned char* data, unsigned int size)
{
    memcpy(buffer + offset, data, size);
    offset += size;
}

void COD::write(const char* data, unsigned int size)
{
    memcpy(buffer + offset, data, size);
    offset += size;
}

void COD::read(unsigned char* data, unsigned int size)
{
    if(f) {
        f->read((char*)data, size);
        if(f->eof()) throw eof();
    } else {
        if(offset + size > buffersize) throw eof();
        memcpy(data, buffer + offset, size);
        offset += size;
    }
}

void COD::read(char* data, unsigned int size)
{
    if(f) {
        f->read(data, size);
        if(f->eof()) throw eof();
    } else {
        if(offset + size > buffersize) throw eof();
        memcpy(data, buffer + offset,  size);
        offset += size;
    }
}

void COD::writeCOD(unsigned char** data, unsigned int* size, bool gzip)
{
    if(buffer) free(buffer);
    *size = buffersize = computeSize() + 1;
    *data = buffer = (unsigned char*)malloc(buffersize + 1);
    offset = 0;

    write("VOS", 4); // writing a \x0 deliberately
    char version[2] = {1, 0}; // major, minor
    write(version, 2);

    unsigned char buf[16];
    write(buf, pack(buf, sizeof(buf), "l", vobjectorder.size()));

    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        writeObjectDesc(vobjectorder[i]);
    }

    unsigned long objsWithChildren = 0;
    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        if(vobjectorder[i]->vobject->getChildren().size() > 0 && vobjectorder[i]->savechildren) {
            objsWithChildren++;
        }
    }

    write(buf, pack(buf, sizeof(buf), "l", objsWithChildren));

    for(unsigned int i = 0; i < vobjectorder.size(); i++) {
        if(vobjectorder[i]->vobject->getChildren().size() > 0 && vobjectorder[i]->savechildren) {
            writeObjectChildren(vobjectorder[i]->vobject);
        }
    }

    *size = offset;

    if(gzip) {
        gzipCompress((unsigned char**)data, size, (const unsigned char*)buffer, offset);
    }
}

void COD::readCOD(unsigned char* readfrom, unsigned int size)
{
    buffer = readfrom;
    buffersize = size;
    offset = 0;
    readCOD();
    buffer = 0;
    buffersize = 0;
}

bool COD::checkCOD()
{
    unsigned char buf[66461];

    read(buf, 4);
    if(!(buf[0] == 'V'
         && buf[1] == 'O'
         && buf[2] == 'S'
         && buf[3] == 0))
    {
        if(buf[0] == 31 && buf[1] == 139) {
            if(f) {
                string comp;
                comp.append((const char*)buf, 4);
                while(! f->eof()) {
                    f->read((char*)buf, sizeof(buf));
                    comp.append((const char*)buf, f->gcount());
                }
                gzipUncompress((unsigned char**)&buffer, &buffersize, (unsigned char*)comp.c_str(), (unsigned int)comp.size());
            } else {
                unsigned char* uncompressedbuffer;
                unsigned int uncompressedsize;
                gzipUncompress((unsigned char**)&uncompressedbuffer, &uncompressedsize, buffer, buffersize);
                buffer = uncompressedbuffer;
                buffersize = uncompressedsize;
            }
            iostream* oldf = f;
            f = 0;
            readCOD(buffer, buffersize);
            f = oldf;
            free(buffer);
            return false;
        } else {
            LOG("COD", 1, "This does not appear to be a COD file\n");
            return false;
        }
    }
    return true;
}

void COD::readCOD()
{
    if(! checkCOD()) return;

    char version[2] = {0, 0}; // major, minor
    read(version, 2);

    //LOG("COD", 3, "File format version << " (int)version[0] << "." << (int)version[1]);

    long numobjs = readLong();

    map<string, string> fileToActual;

    for(int i = 0; i < numobjs; i++) {
        deque<string> types;
        string name;
        vRef<MessageBlock> mb = new MessageBlock();

        long pos;
        readObjectDesc(name, pos, types, *mb);

        vRef<MetaObject> newvob = ls.createMetaObject(name.c_str(), types);
        fileToActual[name] = newvob->getName();

        addVobject(&newvob, types, &mb, true);

        /* XXX TEMPORARY HACK */
        if(LocalProperty* lp = MetaObject::meta_cast<LocalProperty*>(&newvob)) {
            lp->initializeSecurity(ls);
        }

        for(int n = 0; n < mb->numMessages(); n++) {
            vRef<Message> msg = mb->getMessage(n);
            msg->setType("message");
            msg->setTo(newvob->getURL().getString());
            msg->setFrom(ls.getURL().getString());
            newvob->sendMessage(&msg);
        }
    }

    numobjs = readLong();

    for(int i = 0; i < numobjs; i++) {
        string parent;
        deque<PCR> children;

        readObjectChildren(parent, children);
        parent = fileToActual[parent];

        Entry* e = vobjectTable[parent];
        if(! e) throw eof();
        e->savechildren = true;

        LOG("COD", 4, "Looking for " << parent);
        vRef<Vobject::ParentChildRelation> pcr = ls.findChild(parent);
        LOG("COD", 4, "found it");
        for(unsigned int n = 0; n < children.size(); n++) {
            string cl = fileToActual[children[n].child];
            LOG("COD", 4, "Looking for " << cl << " (was " << children[n].child << ")");
            vRef<Vobject::ParentChildRelation> pcr2 = ls.findChild(cl);
            LOG("COD", 4, "found it");
            pcr->child->insertChild(-1, children[n].context, pcr2->child);
        }
    }
}


LocalSite& COD::getLocalSite()
{
    ls.acquire();
    return ls;
}

RemoteCOD::RemoteCOD(LocalSite& l, RemoteSite& r)
    : COD(l), rs(r)
{
    rs.acquire(); // released by: destructor
}

RemoteCOD::RemoteCOD(iostream& io, LocalSite& l, RemoteSite& r)
    : COD(io, l), rs(r)
{
    rs.acquire(); // released by: destructor
}

RemoteCOD::~RemoteCOD()
{
    rs.release(); // acquired by: constructor
}

void RemoteCOD::readCOD()
{
    LOG("COD", 4, "Starting COD read");

    if(! checkCOD()) return;

    char version[2] = {0, 0}; // major, minor
    read(version, 2);

    LOG("COD", 3, "File format version " << (int)version[0] << "." << (int)version[1]);

    long numobjs = readLong();

    LOG("COD", 4, "expecting " << numobjs << " objects");

    double start, end, tot;
    start = getRealTime();
    for(int i = 0; i < numobjs; i++) {
        double start2, end2, tot2;
        start2 = getRealTime();

        deque<string> types;
        string name;
        vRef<MessageBlock> mb = new MessageBlock();

        long pos;
        readObjectDesc(name, pos, types, *mb);

        LOG("COD", 4, "read child " << name);

        vRef<Message> msg = new Message();
        msg->setType("update");
        msg->setMethod("core:set-child-update");
        msg->setFrom(rs.getURL().getString());
        msg->setSourceSite(&rs);
        msg->insertField(-1, "pos", (int)pos);
        msg->insertField(-1, "name", name);
        string path(rs.getURL().getString());
        path += "/";
        path += name;
        msg->insertField(-1, "path", path);
        if(types.size()) {
            for(unsigned int n = 0; n < types.size(); n++) {
                msg->insertField(-1, "type", types[n]);
            }
        } else msg->insertField(-1, "type", "");
        rs.sendUpdateMessage(&msg);
        vRef<Vobject::ParentChildRelation> newvob = rs.findChild(name);

        addVobject(newvob->child, types, &mb, false);

        for(int n = 0; n < mb->numMessages(); n++) {
            msg = mb->getMessage(n);
            msg->setType("update");
            msg->setFrom(path);
            msg->setSourceSite(&rs);
            LOG("COD", 4, "update to " << newvob->child->getURL().getString() << " is "
                << msg->getFormattedString());
            newvob->child->sendUpdateMessage(&msg);
        }
        
        end2 = getRealTime();
        tot2 = end2 - start2;
    }
    end = getRealTime();
    tot = end - start;

    LOG("COD", 4, "starting children read");

    numobjs = readLong();

    start = getRealTime();
    for(int i = 0; i < numobjs; i++) {
        string parent;
        deque<PCR> children;

        readObjectChildren(parent, children);

        vRef<Vobject::ParentChildRelation> newobj = rs.findChild(parent);
        vRef<Message> msg = new Message();
        msg->setType("update");
        msg->setMethod("core:set-child-update");
        msg->setFrom(rs.getURL().getString());
        msg->setSourceSite(&rs);
        for(unsigned int n = 0; n < children.size(); n++) {
            msg->insertField(-1, "pos", (int)n);
            msg->insertField(-1, "name", children[n].context);
            if(children[n].child.substr(0, 6) == "vop://") msg->insertField(-1, "path", children[n].child);
            else msg->insertField(-1, "path", rs.getURL().getString() + string("/") + children[n].child);
        }
        newobj->child->sendUpdateMessage(&msg);
    }
    end = getRealTime();
    tot = end - start;
}

RemoteSite& RemoteCOD::getRemoteSite()
{
    rs.acquire();
    return rs;
}

int COD::pack(uint8_t *buf, int maxsize, char *fmt, ...)
{
    va_list args;
    char* p;
    uint8_t* bp;
    uint8_t* st;
    uint16_t s, len;
    uint32_t l, i;

    bp=buf;
    va_start(args, fmt);
    for(p=fmt; *p; p++)
    {
        switch(*p)
        {
        case 'c':
            if((bp - buf + 1) > maxsize) return -1;
            ///*bp++ = (ub*bp++ = (uint8_t)va_arg(args, uint8_t); XXX gcc 2.96 complained about using uint8_t in va_arg
            *bp++ = (uint8_t)va_arg(args, int);
            break;
        case 's':
            //s = (uint16_t)va_arg(args, uint16_t); XXX gcc 2.96 complained about using uint8_t in va_arg
            if((bp - buf + 4) > maxsize) return -1;
            s = (uint16_t)va_arg(args, int);
            *bp++ = s >> 8;
            *bp++ = s;
            break;
        case 'l':
            if((bp - buf + 4) > maxsize) return -1;
            l = (uint32_t)va_arg(args, uint32_t);
            *bp++ = l >> 24;
            *bp++ = l >> 16;
            *bp++ = l >> 8;
            *bp++ = l;
            break;
        case 'S':
            st = va_arg(args, uint8_t*);
            len = va_arg(args, int);
            if((bp - buf + 2 + len) > maxsize) return -1;
            *bp++ = len >> 8;
            *bp++ = len;
            for(i = 0; i < len; i++)
                *bp++ = *st++;
            break;
        case 'f':
        {
            if((bp - buf + 4) > maxsize) return -1;
            float f = (float)va_arg(args, double);
            uint32_t zz = *((uint32_t*)&f);
            *bp++ = zz >> 24;
            *bp++ = zz >> 16;
            *bp++ = zz >> 8;
            *bp++ = zz;
            break;
        }
        default:
            va_end(args);
            return -1;
        }
    }
    va_end(args);
    return (bp - buf);
}

int COD::unpack(const uint8_t *buf, int maxsize, char *fmt, ...)
{
    va_list args;
    char* p;
    const uint8_t* bp;
    uint8_t* pc;
    uint16_t* ps;
    uint32_t* pl;
    uint8_t** st;
    int len, i;

    bp=buf;
    va_start(args, fmt);
    for(p=fmt; *p; p++)
    {
        switch(*p)
        {
        case 'c':
            if(bp - buf + 1 > maxsize) return -1;
            pc = va_arg(args, uint8_t*);
            *pc = *bp++;
            break;
        case 's':
            if(bp - buf + 2 > maxsize) return -1;
            ps = va_arg(args, uint16_t*);
            *ps = *bp++ << 8;
            *ps |= *bp++;
            break;
        case 'l':
            if(bp - buf + 4 > maxsize) return -1;
            pl = va_arg(args, uint32_t*);
            *pl = *bp++ << 24;
            *pl |= *bp++ << 16;
            *pl |= *bp++ << 8;
            *pl |= *bp++;
            break;
        case 'S':
            st = va_arg(args, uint8_t**);
            pl = va_arg(args, uint32_t*);
            if(bp - buf + 2 > maxsize) return -1;
            len = *bp++ << 8;
            len |= *bp++;
            if(bp - buf + len > maxsize) return -1;
            *pl = len;
            *st = (uint8_t*)malloc(len+1);
            for(i = 0; i < len; i++)
                (*st)[i] = *bp++;
            (*st)[i] = 0;
            break;
        case 'f':
        {
            if(bp - buf + 4 > maxsize) return -1;
            float* f = va_arg(args, float*);
            uint32_t l = *bp++ << 24;
            l |= *bp++ << 16;
            l |= *bp++ << 8;
            l |= *bp++;
            *f = *((float*)&l);
            break;
        }
        default:
            va_end(args);
            return -1;
        }
    }
    va_end(args);
    return bp - buf;
}

void COD::gzipCompress(unsigned char** dest, unsigned int* destlen, const unsigned char* source, unsigned int srclen)
{
    *destlen = srclen + (srclen/1000) + 13 + 18;
    *dest = (unsigned char*)malloc(*destlen);

    int t = time(0);

    // note: the gzip file format is little-endian, so we can't use
    // pack() and unpack() because they encode everything big-endian!

    (*dest)[0] = 31; // magic number
    (*dest)[1] = 139;  // magic number
    (*dest)[2] = 8;  // using the standard deflate method
    (*dest)[3] = 0;  // no other headers
    (*dest)[4] = t & 0xFF;  // timestamp
    (*dest)[5] = (t >> 8) & 0xFF;
    (*dest)[6] = (t >> 16) & 0xFF;
    (*dest)[7] = (t >> 24) & 0xFF;
    (*dest)[8] = 0; // some other flags
    (*dest)[9] = 255; // unknown operating system

    z_stream st;
    st.next_in = (Bytef*)source;  /* next input byte */
    st.avail_in = srclen;  /* number of bytes available at next_in */
    st.total_in = 0;  /* total nb of input bytes read so far */

    st.next_out = (Bytef*)(*dest + 10); /* next output byte should be put there */
    st.avail_out = *destlen; /* remaining free space at next_out */
    st.total_out = 0; /* total nb of bytes output so far */

    st.zalloc = 0;  /* used to allocate the internal state */
    st.zfree = 0;   /* used to free the internal state */

    deflateInit2(&st, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
    if(deflate(&st, Z_FINISH) != Z_STREAM_END) {
        throw eof();
    }
    deflateEnd(&st);
    *destlen = st.total_out;

    int crc = crc32(0, (const Bytef*)source, srclen);
    (*dest)[10 + *destlen + 0] = crc & 0xFF;
    (*dest)[10 + *destlen + 1] = (crc >> 8) & 0xFF;
    (*dest)[10 + *destlen + 2] = (crc >> 16) & 0xFF;
    (*dest)[10 + *destlen + 3] = (crc >> 24) & 0xFF;
    (*dest)[10 + *destlen + 4] = srclen & 0xFF;
    (*dest)[10 + *destlen + 5] = (srclen >> 8) & 0xFF;
    (*dest)[10 + *destlen + 6] = (srclen >> 16) & 0xFF;
    (*dest)[10 + *destlen + 7] = (srclen >> 24) & 0xFF;

    *destlen += 18;
}

void COD::gzipUncompress(unsigned char** dest, unsigned int* destlen, const unsigned char* source, unsigned int srclen)
{
    unsigned int len = 0;
    unsigned int crc = 0;

    len = source[srclen-4]
        | (source[srclen-3] << 8)
        | (source[srclen-2] << 16)
        | (source[srclen-1] << 24);

    crc = source[srclen-8]
        | (source[srclen-7] << 8)
        | (source[srclen-6] << 16)
        | (source[srclen-5] << 24);

    *destlen = len;
    *dest = (unsigned char*)malloc(*destlen);

    // note: the gzip file format is little-endian, so we can't use
    // pack() and unpack() because they encode everything big-endian!

    if(source[0] != 31 || source[1] != 139 || source[2] != 8) throw eof();

    int offset = 10;

#define FTEXT       0x01
#define FHCRC       0x02
#define FEXTRA      0x04
#define FNAME       0x08
#define FCOMMENT    0x10
#define FRESERVED   (0x20 | 0x40 | 0x80)

    if(source[3] & FRESERVED) throw eof();

    if(source[3] & FEXTRA) {
        int skip = 0;
        skip = source[offset] | (source[offset+1] << 8);
        offset += 2 + skip;
    }

    if(source[3] & FNAME) {
        while(source[offset]) offset++;
        offset++;
    }

    if(source[3] & FCOMMENT) {
        while(source[offset]) offset++;
        offset++;
    }

    if(source[3] & FHCRC) {
        offset += 2;
    }

    z_stream st;
    st.next_in = (Bytef*)source + offset;  /* next input byte */
    st.avail_in = srclen;  /* number of bytes available at next_in */
    st.total_in = 0;  /* total nb of input bytes read so far */

    st.next_out = (Bytef*)(*dest); /* next output byte should be put there */
    st.avail_out = *destlen; /* remaining free space at next_out */
    st.total_out = 0; /* total nb of bytes output so far */

    st.zalloc = 0;  /* used to allocate the internal state */
    st.zfree = 0;   /* used to free the internal state */

    inflateInit2(&st, -MAX_WBITS);
    if(inflate(&st, Z_FINISH) != Z_STREAM_END) {
        throw eof();
    }
    inflateEnd(&st);
    *destlen = st.total_out;

    if(crc32(0, (const Bytef*)*dest, *destlen) != crc) {
        free(*dest);
        throw eof();
    }
}

---