zipEntry.js

'use strict';

var Utils = require("./util"),
  Headers = require("./headers"),
  Constants = Utils.Constants,
  Methods = require("./methods");

module.exports = function (/*Buffer*/input) {

  var _entryHeader = new Headers.EntryHeader(),
    _entryName = new Buffer(0),
    _comment = new Buffer(0),
    _isDirectory = false,
    uncompressedData = null,
    _extra = new Buffer(0);

  function getCompressedDataFromZip() {
    if (!input || !Buffer.isBuffer(input)) {
      return new Buffer(0);
    }
    _entryHeader.loadDataHeaderFromBinary(input);
    return input.slice(_entryHeader.realDataOffset, _entryHeader.realDataOffset + _entryHeader.compressedSize)
  }

  function crc32OK(data) {
    // if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written
    if (_entryHeader.flags & 0x8 != 0x8) {
      if (Utils.crc32(data) != _entryHeader.crc) {
        return false;
      }
    } else {
      // @TODO: load and check data descriptor header
      // The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure
      // (optionally preceded by a 4-byte signature) immediately after the compressed data:
    }
    return true;
  }

  function decompress(/*Boolean*/async, /*Function*/callback, /*String*/pass) {
    if(typeof callback === 'undefined' && typeof async === 'string') {
      pass=async;
      async=void 0;
    }
    if (_isDirectory) {
      if (async && callback) {
        callback(new Buffer(0), Utils.Errors.DIRECTORY_CONTENT_ERROR); //si added error.
      }
      return new Buffer(0);
    }

    var compressedData = getCompressedDataFromZip();

    if (compressedData.length == 0) {
      if (async && callback) callback(compressedData, Utils.Errors.NO_DATA);//si added error.
      return compressedData;
    }

    var data = new Buffer(_entryHeader.size);
    data.fill(0);

    switch (_entryHeader.method) {
      case Utils.Constants.STORED:
        compressedData.copy(data);
        if (!crc32OK(data)) {
          if (async && callback) callback(data, Utils.Errors.BAD_CRC);//si added error
          return Utils.Errors.BAD_CRC;
        } else {//si added otherwise did not seem to return data.
          if (async && callback) callback(data);
          return data;
        }
        break;
      case Utils.Constants.DEFLATED:
        var inflater = new Methods.Inflater(compressedData);
        if (!async) {
          inflater.inflate(data);
          if (!crc32OK(data)) {
            console.warn(Utils.Errors.BAD_CRC + " " + _entryName.toString())
          }
          return data;
        } else {
          inflater.inflateAsync(function(result) {
            result.copy(data, 0);
            if (!crc32OK(data)) {
              if (callback) callback(data, Utils.Errors.BAD_CRC); //si added error
            } else { //si added otherwise did not seem to return data.
              if (callback) callback(data);
            }
          })
        }
        break;
      default:
        if (async && callback) callback(new Buffer(0), Utils.Errors.UNKNOWN_METHOD);
        return Utils.Errors.UNKNOWN_METHOD;
    }
  }

  function compress(/*Boolean*/async, /*Function*/callback) {
    if ((!uncompressedData || !uncompressedData.length) && Buffer.isBuffer(input)) {
      // no data set or the data wasn't changed to require recompression
      if (async && callback) callback(getCompressedDataFromZip());
      return getCompressedDataFromZip();
    }

    if (uncompressedData.length && !_isDirectory) {
      var compressedData;
      // Local file header
      switch (_entryHeader.method) {
        case Utils.Constants.STORED:
          _entryHeader.compressedSize = _entryHeader.size;

          compressedData = new Buffer(uncompressedData.length);
          uncompressedData.copy(compressedData);

          if (async && callback) callback(compressedData);
          return compressedData;

          break;
        default:
        case Utils.Constants.DEFLATED:

          var deflater = new Methods.Deflater(uncompressedData);
          if (!async) {
            var deflated = deflater.deflate();
            _entryHeader.compressedSize = deflated.length;
            return deflated;
          } else {
            deflater.deflateAsync(function(data) {
              compressedData = new Buffer(data.length);
              _entryHeader.compressedSize = data.length;
              data.copy(compressedData);
              callback && callback(compressedData);
            })
          }
          deflater = null;
          break;
      }
    } else {
      if (async && callback) {
        callback(new Buffer(0));
      } else {
        return new Buffer(0);
      }
    }
  }

  function readUInt64LE(buffer, offset) {
    return (buffer.readUInt32LE(offset + 4) << 4) + buffer.readUInt32LE(offset);
  }

  function parseExtra(data) {
    var offset = 0;
    var signature, size, part;
    while(offset<data.length) {
      signature = data.readUInt16LE(offset);
      offset += 2;
      size = data.readUInt16LE(offset);
      offset += 2;
      part = data.slice(offset, offset+size);
      offset += size;
      if(Constants.ID_ZIP64 === signature) {
        parseZip64ExtendedInformation(part);
      }
    }
  }

  //Override header field values with values from the ZIP64 extra field
  function parseZip64ExtendedInformation(data) {
    var size, compressedSize, offset, diskNumStart;

    if(data.length >= Constants.EF_ZIP64_SCOMP) {
      size = readUInt64LE(data, Constants.EF_ZIP64_SUNCOMP);
      if(_entryHeader.size === Constants.EF_ZIP64_OR_32) {
        _entryHeader.size = size;
      }
    }
    if(data.length >= Constants.EF_ZIP64_RHO) {
      compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP);
      if(_entryHeader.compressedSize === Constants.EF_ZIP64_OR_32) {
        _entryHeader.compressedSize = compressedSize;
      }
    }
    if(data.length >= Constants.EF_ZIP64_DSN) {
      offset = readUInt64LE(data, Constants.EF_ZIP64_RHO);
      if(_entryHeader.offset === Constants.EF_ZIP64_OR_32) {
        _entryHeader.offset = offset;
      }
    }
    if(data.length >= Constants.EF_ZIP64_DSN+4) {
      diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN);
      if(_entryHeader.diskNumStart === Constants.EF_ZIP64_OR_16) {
        _entryHeader.diskNumStart = diskNumStart;
      }
    }
  }


  return {
    get entryName () { return _entryName.toString(); },
    get rawEntryName() { return _entryName; },
    set entryName (val) {
      _entryName = Utils.toBuffer(val);
      var lastChar = _entryName[_entryName.length - 1];
      _isDirectory = (lastChar == 47) || (lastChar == 92);
      _entryHeader.fileNameLength = _entryName.length;
    },

    get extra () { return _extra; },
    set extra (val) {
      _extra = val;
      _entryHeader.extraLength = val.length;
      parseExtra(val);
    },

    get comment () { return _comment.toString(); },
    set comment (val) {
      _comment = Utils.toBuffer(val);
      _entryHeader.commentLength = _comment.length;
    },

    get name () { var n = _entryName.toString(); return _isDirectory ? n.substr(n.length - 1).split("/").pop() : n.split("/").pop(); },
    get isDirectory () { return _isDirectory },

    getCompressedData : function() {
      return compress(false, null)
    },

    getCompressedDataAsync : function(/*Function*/callback) {
      compress(true, callback)
    },

    setData : function(value) {
      uncompressedData = Utils.toBuffer(value);
      if (!_isDirectory && uncompressedData.length) {
        _entryHeader.size = uncompressedData.length;
        _entryHeader.method = Utils.Constants.DEFLATED;
        _entryHeader.crc = Utils.crc32(value);
      } else { // folders and blank files should be stored
        _entryHeader.method = Utils.Constants.STORED;
      }
    },

    getData : function(pass) {
      return decompress(false, null, pass);
    },

    getDataAsync : function(/*Function*/callback, pass) {
      decompress(true, callback, pass)
    },

    set attr(attr) { _entryHeader.attr = attr; },
    get attr() { return _entryHeader.attr; },

    set header(/*Buffer*/data) {
      _entryHeader.loadFromBinary(data);
    },

    get header() {
      return _entryHeader;
    },

    packHeader : function() {
      var header = _entryHeader.entryHeaderToBinary();
      // add
      _entryName.copy(header, Utils.Constants.CENHDR);
      if (_entryHeader.extraLength) {
        _extra.copy(header, Utils.Constants.CENHDR + _entryName.length)
      }
      if (_entryHeader.commentLength) {
        _comment.copy(header, Utils.Constants.CENHDR + _entryName.length + _entryHeader.extraLength, _comment.length);
      }
      return header;
    },

    toString : function() {
      return '{\n' +
        '\t"entryName" : "' + _entryName.toString() + "\",\n" +
        '\t"name" : "' + _entryName.toString().split("/").pop() + "\",\n" +
        '\t"comment" : "' + _comment.toString() + "\",\n" +
        '\t"isDirectory" : ' + _isDirectory + ",\n" +
        '\t"header" : ' + _entryHeader.toString().replace(/\t/mg, "\t\t") + ",\n" +
        '\t"compressedData" : <' + (input && input.length  + " bytes buffer" || "null") + ">\n" +
        '\t"data" : <' + (uncompressedData && uncompressedData.length  + " bytes buffer" || "null") + ">\n" +
        '}';
    }
  }
};