Skip to Navigation

User login

Username: *

Password: *

• Request new password

• jigdo
• Development
• Debian jigdo mini-HOWTO

Home › jigdo › Development › jigdo API

jigdo API

Last update by Admin on 2010-05-23

• Namespaces
• Class hierarchy
• Class list
• File list
• Namespace Members
• Class Members
• File Members

util/gunzip.hh

Go to the documentation of this file.

/* $Id: gunzip.hh,v 1.4 2003/06/24 13:55:07 richard Exp $ -*- C++ -*-
  __   _
  |_) /|  Copyright (C) 2003  |  richard@
  | \/¯|  Richard Atterer     |  atterer.net
  ¯ '` ¯
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License, version 2. See
  the file COPYING for details.

*/
#ifndef GUNZIP_HH
#define GUNZIP_HH

#include <config.h>

#include <string>
#include <zlib.h>

#include <debug.hh>

#ifdef TRANSPARENT
#  undef TRANSPARENT
#endif
#ifdef ERROR
#  undef ERROR
#endif
//______________________________________________________________________

class Gunzip {
public:
  //________________________________________

  class IO {
  public:

    virtual ~IO() { }

    virtual void gunzip_deleted() = 0;

    virtual void gunzip_data(Gunzip* self, byte* decompressed,
                             unsigned size) = 0;

    virtual void gunzip_needOut(Gunzip* self) = 0;

    //virtual void gunzip_succeeded() = 0;

    virtual void gunzip_failed(string* message) = 0;
  };
  //________________________________________

  class IOPtr { // cf. job.hh
  public:
    IOPtr(IO* io) : ptr(io) { }
    ~IOPtr() { ptr->gunzip_deleted(); }

    IO& operator*()  const throw() { return *ptr; }
    IO* operator->() const throw() { return ptr; }
    operator bool()  const throw() { return ptr != 0; }
    IO* get()        const throw() { return ptr; }
    void set(IO* io) {
      if (ptr == io) return;
      if (ptr != 0) ptr->gunzip_deleted();
      ptr = io;
    }
  private:
    IO* ptr;
  };
  IOPtr io;
  //________________________________________

  Gunzip(IO* ioPtr);

  virtual ~Gunzip();

  void inject(const byte* compressed, unsigned size);

  inline byte* nextOut() const;

  inline unsigned availOut() const;

  inline void setOut(byte* newNextOut, unsigned newAvailOut);

private:
  // Pass zlib error to IO object
  void error(const char* msg);
  // Ensure that at least one output byte is writable in z.next_out/avail_out
  inline void needOutByte();
  // Advance z.next_in/z.avail_in by one byte & return it
  inline byte nextInByte();
  // Output a single byte. Calls needOutByte() and io->data(this,...,1)
  inline void outputByte(byte b);

  /* zlib doesn't support in-memory decompression of .gz files, only of zlib
     streams, so we need to extract the zlib stream from the .gz file. Keep
     track of our progress in a state var. */
  enum {
    INIT0, // Guessing whether or not .gz format: First two bytes \x1f \x8b
    INIT1,
    HEADER_CM, // .gz header: compression method byte
    HEADER_FLG, // .gz header: flag byte
    HEADER_FEXTRA0, // .gz header: optional extra fields
    HEADER_FEXTRA1,
    HEADER_FNAME, // .gz header: Original file name
    HEADER_FCOMMENT, // .gz header: Comment field
    ZLIB, // Found zlib stream, pass to zlib
    TRAILER_CRC0, // Checksum of uncompressed data, after zlib data
    TRAILER_CRC1,
    TRAILER_CRC2,
    TRAILER_CRC3,
    TRANSPARENT, // Final state: Not .gz format, pass to IO unmodified
    ERROR // Final state: zlib error or error in .gz header
  };
  int state;
  byte headerFlags;
  z_stream z;
  unsigned skip; // Nr of bytes to ignore in input stream
  unsigned data; // to accumulate parameters from the stream
  uLong crc; // CRC32 checksum of uncompressed data
};
//______________________________________________________________________

byte* Gunzip::nextOut() const {
  return z.next_out;
}

unsigned Gunzip::availOut() const {
  return z.avail_out;
}

void Gunzip::setOut(byte* newNextOut, unsigned newAvailOut) {
  z.next_out = newNextOut;
  z.avail_out = newAvailOut;
}

void Gunzip::needOutByte() {
  if (availOut() == 0) {
    io->gunzip_needOut(this);
    Paranoid(availOut() > 0);
  }
}

void Gunzip::outputByte(byte b) {
  needOutByte();
  *z.next_out = b;
  --z.avail_out;
  ++z.next_out;
  io->gunzip_data(this, z.next_out - 1, 1);
}

byte Gunzip::nextInByte() {
  byte result = *z.next_in;
  ++z.next_in;
  --z.avail_in;
  return result;
}

#endif

---

• Photography
• Software
• jigdo
• Research
• About

© Copyright 2014 Richard Atterer

 Top of page  •  Home  •  Sitemap  •  Contact  •  About