vos/corelibs/typechain/handlers/type_z.cc

Go to the documentation of this file.

/* $Id: type_z.cc,v 1.4 2003/07/25 06:13:39 tetron Exp $ */

/*
    Copyright (C) 2003 Reed Hedges <reed@zerohour.net>

    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 <sys/types.h>
#include <sys/uio.h>
#include <string>
#include <fstream>
#include <iostream>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <zlib.h>

#include "type_z.hh"

static const int GZREAD_BUFSIZE = 2048;
static const int GZWRITE_BUFSIZE = 2048;

/* Called when loaded as shared library */

extern "C" void plugin_init(void *param) {
    void (*registerHandler)(TypeHandler* handler) = (void (*)(TypeHandler*))param;
    registerHandler(new TypeDeflate());
    registerHandler(new TypeGZip());
}



/* Constructors */

TypeDeflate::TypeDeflate() : TypeHandler("deflate", "deflated") {

}

TypeGZip::TypeGZip() : TypeHandler("gzip", "gz") {

}

/*  Decode */

void TypeDeflate::decode(string& data, TypeParams& params)
{
    fprintf(stderr, "Deflate: starting...\n");
    string dl = params["datalen"];
    cerr << "there are " << params.size() << " parameters.\n";
    for(map<string,string>::const_iterator i = params.begin(); i != params.end(); i++) {
        cerr << " params[" << i->first << "] = " << i->second << endl;
    }
    cerr << "datalen is: " << params["datalen"] << endl;
    if(dl == "")
        throw TypeChain::DecodeError("no \"datalen\" parameter!", "deflate");
    unsigned long destlen = atoi(dl.c_str());
    char dest[destlen];
    int r = uncompress((Bytef*)dest, &destlen, (Bytef*)data.c_str(), data.length());
                // does data.c_str() need to be massaged?
    if(r != Z_OK || r < 0) {
        string error;
        switch(r) {
            case Z_MEM_ERROR: error = "zlib couldn't allocate memory"; break;
            case Z_BUF_ERROR: error = "zlib: buffer too small"; break;
            case Z_DATA_ERROR: error = "zlib: bad data"; break;
            default: error = "unknown error";
        }
        throw TypeChain::DecodeError(error, "deflate");
    }
    fprintf(stderr, "Deflate: done.\n");
    data = dest; // Will this copy dest, or do we need to strdup?
}



void TypeGZip::decode(string& data, TypeParams& params) {
    int r;
    char buf[GZREAD_BUFSIZE];
//    printf("type_z(gzip): data is %ld bytes long.\n", data.length());
    int p[2];
    r = pipe(p);
    if(r < 0) {
        throw TypeChain::DecodeError("error creating pipe", "gzip");
        exit(r);
    }
    int readMe = p[0];
    int writeMe = p[1];
    r = write(writeMe, data.c_str(), data.length());
    close(writeMe);
    gzFile z = gzdopen(readMe, "rb");
    if(z == NULL)
        throw TypeChain::DecodeError("error: zlib couldn't open the pipe", "gzip");
    data = "";
    while((r = gzread(z, buf, GZREAD_BUFSIZE))) {
        data.append(buf, r);
    }
    if(r < 0)  {
        gzclose(z);
        throw TypeChain::DecodeError("error reading gz data", "gzip");
    }
    gzclose(z);
}




void TypeDeflate::encode(string& data, TypeParams& params)
{
    // TODO: get compression level out of params and call compress2.

    // This buffer will hold the result. From the zlib manual:
    //   "...must be at least 0.1% larger than sourceLen plus 12 bytes."
    unsigned long destlen = data.length() + (int)ceil(data.length() * 0.01) + 12;
    char dest[destlen];

    fprintf(stderr, "Deflate: encoding...\n");
    int r = compress((Bytef*)dest, &destlen, (Bytef*)data.c_str(), data.length());
    if(r != Z_OK || r < 0) {
        string error;
        switch(r) {
            case Z_MEM_ERROR: error = "zlib couldn't allocate memory"; break;
            case Z_BUF_ERROR: error = "zlib: buffer too small"; break;
            case Z_DATA_ERROR: error = "zlib: bad data"; break;
            default: error = "unknown error";
        }
        throw TypeChain::DecodeError(error, "deflate");
    }
    fprintf(stderr, "Deflate: done compressing.\n");
    params["datalen"] = data.length();
    data = dest;    // Will dest be copied, or do I need to use strdup?
}


void TypeGZip::encode(string& data, TypeParams& params)
{
    // TODO: get compression level and other options out of params.
    fprintf(stderr, "Gzip: encoding...\n");
    int r;
    char buf[GZWRITE_BUFSIZE];
    int p[2];
    r = pipe(p);
    if(r < 0) {
        throw TypeChain::EncodeError("error creating pipe", "gzip");
    }
    int readMe = p[0];
    int writeMe = p[1];
    gzFile z = gzdopen(writeMe, "wb");
    if(z == NULL)
        throw TypeChain::EncodeError("error: zlib couldn't open the pipe", "gzip");
    gzwrite(z, (char*)data.c_str(), data.length());
    gzclose(z);
    close(writeMe);
    data = "";
    while((r = read(readMe, buf, GZWRITE_BUFSIZE))) {
        data.append(buf, r);
    }
    if(r < 0) {
        close(readMe);
        throw TypeChain::EncodeError("error reading gz data", "gzip");
    }

    close(readMe);

/*
    int s = 0;
    int e = GZREAD_BUFSIZE;
    while(1) {
        fprintf("writing chunk from %d to %d to gzip...\n", s, e);
        r = gzwrite(z, data.substr(s, e), s - e);
        if(r <= 0)
            break;
        s = e;
        e += r;
    }
    gzclose(z);
*/
}

---