zip.cc

Go to the documentation of this file.

#include <stdlib.h>
#include <assert.h>
#include <algorithm>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include "boost/iostreams/slice.hpp"
#include "boost/iostreams/copy.hpp"
#include "boost/iostreams/filter/zlib.hpp"
#include "boost/iostreams/filtering_stream.hpp"


namespace io = boost::iostreams;

using namespace std;

namespace {
  template <typename T> T get(istream& is);
  template <typename I, typename J> I _get(istream& is) {
       I x( get<J>(is) );
       x |= I( get<J>(is) )<<(8*sizeof(J)); 
       return x;
  }
  template <> uint8_t get<uint8_t>(istream& is) {
      uint8_t x;
      is.read((char*)&x,sizeof(uint8_t));
      // TODO: if not OK, throw exception...
      return x;
  }
  template <> uint16_t get<uint16_t>(istream& is) { return _get<uint16_t, uint8_t>(is); }
  template <> uint32_t get<uint32_t>(istream& is) { return _get<uint32_t,uint16_t>(is); }
  template <> uint64_t get<uint64_t>(istream& is) { return _get<uint64_t,uint32_t>(is); }
}

struct ZipInfo {
        uint16_t compress;
        uint16_t time;
        uint16_t date;
        uint32_t crc;
        uint32_t data_size;
        uint32_t file_size;
        uint32_t file_offset;
        string name;
};

class ZipFile  {
public:
  ZipFile(const string& name) 
    : m_name( name )
    , m_file( name.c_str(), ios::in | ios::binary )
  {
      index();
  } 

  bool dump(const std::string& fname, ostream& os) {
        map<string,ZipInfo>::const_iterator i = m_index.find(fname);
        if ( i == m_index.end() ) return false;
        cout << " found " << fname  <<endl;
        cout << " compress = " << i->second.compress << endl;
        cout << " crc = " << i->second.crc << endl;
        cout << " data_size = " << i->second.data_size << endl;
        cout << " file_size = " << i->second.file_size << endl;
        cout << " file_offset = " << i->second.file_offset << endl;

        m_file.seekg( i->second.file_offset,ios::beg);
        uint32_t magic = get<uint32_t>(m_file);
        if (magic!=0x04034B50) {
                cout << "bad magic " << hex << magic << endl;
                return false;
        }
        m_file.seekg(22,ios::cur);
        uint16_t fnamsize = get<uint16_t>(m_file) ;
        cout << " got fnamsize " << fnamsize << endl;
        uint16_t extrasize= get<uint16_t>(m_file); // fname len + extra len
        cout << " got extrasize " << extrasize << endl;
        m_file.seekg( 0, ios::beg );
        uint32_t offset = i->second.file_offset+30+fnamsize+extrasize; 
        if (i->second.compress == 0 ) {
            cout << "creating slice at " << offset << " + " << i->second.data_size << endl;
            io::copy( io::slice( m_file,offset,i->second.data_size), os );
            return true;
        } else if (i->second.compress == 8) {
            io::zlib_params params; params.noheader = true;
            io::filtering_istream in;
            in.push(io::zlib_decompressor(params));
            cout << "creating slice at " << offset << " + " << i->second.data_size << endl;
            in.push(io::slice(m_file,       offset,i->second.data_size));
            io::copy(in,os);

            /*
            std::stringstream data;
            io::copy( io::slice( m_file,i->second.file_offset+30+fnamsize+extrasize,i->second.data_size), data );
            data << 'Z' ; // data <<'\0';
            io::filtering_istream in;
            in.push(io::gzip_decompressor());
            in.push(data);
            io::copy( in, os ) ;
            */
            return true;
        }
        return false;
  }

private:

  long getlong(const unsigned char* buf) { 
      long l = (long)buf[0];
      l |= (long)buf[1] << 8;
      l |= (long)buf[2] << 16;
      l |= (long)buf[3] << 24;
      return l;
  }

  void index() {
      m_file.seekg(0,ios::end);
      m_file.seekg(-22,ios::end);
      std::ios::streamoff header_position = m_file.tellg();
      char endof_central_dir[22];
      m_file.read( endof_central_dir,sizeof(endof_central_dir));
      if (getlong((unsigned char *)endof_central_dir) != 0x06054B50) {
          cout <<"wrong magic: " << hex << getlong((unsigned char *)endof_central_dir)<<endl;
      }
      uint32_t header_size   = getlong((unsigned char *)endof_central_dir + 12);
      uint32_t header_offset = getlong((unsigned char *)endof_central_dir + 16);
      uint32_t arc_offset = header_position - header_offset - header_size;
      header_offset += arc_offset;

    /* Start of Central Directory */
    for (;;) {
        ZipInfo info;
        m_file.seekg( header_offset, std::ios::beg);
        uint32_t magic = get<uint32_t>(m_file);
        if (magic != 0x02014B50) break;     /* Bad: Central Dir File Header */
        m_file.seekg( header_offset + 10, std::ios::beg);
        info.compress  = get<uint16_t>(m_file);
        info.time      = get<uint16_t>(m_file);
        info.date      = get<uint16_t>(m_file);
        info.crc       = get<uint32_t>(m_file);
        info.data_size = get<uint32_t>(m_file);
        info.file_size = get<uint32_t>(m_file);
        uint16_t name_size = get<uint16_t>(m_file);
        header_size = 46 + name_size + get<uint16_t>(m_file) + get<uint16_t>(m_file);
        m_file.seekg( header_offset + 42, std::ios::beg);
        info.file_offset = get<uint32_t>(m_file) + arc_offset;
        std::stringstream fname;
        io::copy(io::slice(m_file,0,name_size),fname );
        info.name = fname.str();
        header_offset += header_size;
        m_index[ info.name ] = info;
    }
    cout << "got " << m_index.size() << "entries " << endl;
  }

  string  m_name; 
  mutable fstream m_file;
  map<string,ZipInfo> m_index;
};

int main(int argc, char **argv)
{
    if (argc<2) { 
            cerr << "Must give at least filename" << endl; 
            ::exit(1);
    }
    ZipFile file(argv[1]);
    int i = 1;
    while (++i<argc) {
        cout << "================== " << argv[i] << "==================" << endl;
        if (! file.dump( string(argv[i]), cout ) ) {
            cout << " NOT FOUND! " << endl;
        }
   }
}