untar.js

(function () {
	"use strict";

	var Stream = require('stream').Stream,
    path = require('path'),
    utils = require('./utils'),
		headerFormat = require('./header').structure,
		buffer,
		totalRead = 0,
		recordSize = 512,
		fileStream,
		leftToRead;

	function filterDecoder(input) {
		var filter = [];
		if (!input) {
			return [0, 7];
		}

		if (typeof input === 'string') {
			input = [].push(input);
		}

		if (!(input instanceof Array)) {
			console.error('Invalid fileType. Only Arrays or strings are accepted');
			return;
		}

		input.forEach(function (i) {
			utils.fileTypeToIndex(i, function(err, index) {
        if (err) {
          console.error(err + " Ignoring input:" + i);
        } else {
          filter.push(index);
        }
      });
		});

		return filter;
	}

	function readInt(value) {
		return parseInt(value.replace(/^0*/, ''), 8) || 0;
	}

	function readString(buf) {
		var i, length;
		for (i = 0, length = buf.length; i < buf.length; i += 1) {
			if (buf[i] === 0) {
				return buf.toString('utf8', 0, i);
			}
		}
	}

	function doHeader(buf, cb) {
		var data = {}, offset = 0, checksum = 0;

		function updateChecksum(value) {
			var i, length;

			for (i = 0, length = value.length; i < length; i += 1) {
				checksum += value.charCodeAt(i);
			}
		}

		headerFormat.some(function (field) {
			var tBuf = buf.slice(offset, offset + field.length),
				tString = tBuf.toString();

			offset += field.length;

			if (field.field === 'magic' && !/ustar/.test(tString)) {
				// end the loop if not using the extended header
				return true;
			} else if (field.field === 'chksum') {
				updateChecksum('        ');
			} else {
				updateChecksum(tString);
			}

			if (field.type === 'string') {
				data[field.field] = readString(tBuf);
			} else if (field.type === 'number') {
				data[field.field] = readInt(tString);
			}
		});

		if (typeof cb === 'function') {
			if (checksum !== data.chksum) {
				return cb.call(this, 'Checksum not equal', checksum, data.chksum);
			}
			cb.call(this, null, data, recordSize);
		}
	}

	/*
	 * Extract data from an input.
	 * 
	 * @param opts- object of options
	 * @param cb- callback for each file
	 */
	function Untar(opts, cb) {
		if (typeof opts === 'function') {
			cb = opts;
			opts = {};
		}

		// I should probably actually add some options...
		opts = opts || {};

		this.fileTypes = filterDecoder(opts.filter);

		this.cb = cb;
	}

	Untar.prototype = Object.create(Stream.prototype, {
		constructor: {
			value: Untar
		}
	});

	Untar.prototype.end = function (data, encoding) {
		if (data) {
			this.write(data, encoding);
		}

    var oldLength = 0;
    while (buffer && buffer.length != oldLength) {
      oldLength = buffer.length;
      this.write();
    }

    if (buffer || leftToRead > 0) {
      this.cb('unexpected end of archive, archive is corrupt');
      return;
    }

    this.emit('end');
	};

	Untar.prototype.write = function write(data, encoding) {
		var buf, tBuf, bytesBuffer;

		// get a Buffer object
		if (typeof data === 'string') {
			buf = new Buffer(data, encoding);
		} else if (typeof data === 'array') {
			buf = new Buffer(data);
		} else {
			buf = data;
		}

		if (!buf) {
			tBuf = buffer;
		} else if (buffer) {
			// create new buffer with old and new data
			tBuf = new Buffer(buffer.length + buf.length);
			buffer.copy(tBuf);
			buf.copy(tBuf, buffer.length);
		} else {
			tBuf = buf;
		}

		// clear old buffer
		buffer = undefined;

		// nothing to do, just give up ='(
		if (!tBuf || tBuf.length === 0) {
			return;
		}

		// stream the file
		if (fileStream) {
			if (tBuf.length >= leftToRead) {
				fileStream.emit('data', tBuf.slice(0, leftToRead));
				fileStream.emit('end');
				fileStream = undefined;

				buffer = tBuf.slice(leftToRead);
				totalRead += leftToRead;
				leftToRead = 0;
				return;
			}

			fileStream.emit('data', tBuf);
			leftToRead -= tBuf.length;
			totalRead += tBuf.length;
			return;
		}

		// no file to read, so let's try reading a header

		// if we're not an even multiple, account for trailing nulls
		if (totalRead % recordSize) {
			bytesBuffer = recordSize - (totalRead % recordSize);

			// if we don't have enough bytes to account for the nulls
			if (tBuf.length < bytesBuffer) {
				totalRead += tBuf.length;
				return;
			}

			// throw away trailing nulls
			tBuf = tBuf.slice(bytesBuffer);
			totalRead += bytesBuffer;
		}

		// if we don't have enough for a full header, wait 'til we do...
		if (tBuf.length < recordSize) {
			buffer = tBuf;
			return;
		}

		doHeader.call(this, tBuf, function (err, data, rOffset) {
			if (err) {
				if (rOffset === 0) {
					return;
				}
				return this.cb(err);
			}

			// update total; rOffset should always be 512
			totalRead += rOffset;
			buffer = tBuf.slice(rOffset);

			fileStream = new Stream();

			if (this.fileTypes.indexOf(data.typeflag) >= 0) {
				// we'll let the user know if they want this type of file
        if (data.prefix) {
          data.name = path.join(data.prefix, data.name);
        }
        data.typeflag = utils.getFileType(data.typeflag);
        this.cb(err, data, fileStream);
			}

			if (buffer.length >= data.size) {
        if (data.size > 0) {
          fileStream.emit('data', buffer.slice(0, data.size));
          totalRead += data.size;
          buffer = buffer.slice(data.size);
        }
				fileStream.emit('end');

				fileStream = undefined;

				// recurse, we still have data
				return write.call(this);
			}

			leftToRead = data.size - buffer.length;
      if (buffer.length > 0) {
        fileStream.emit('data', buffer);
        totalRead += buffer.length;
      }

			buffer = undefined;
		});
	};

	Untar.prototype.writable = true;

	module.exports = Untar;
}());