308 lines
8.4 KiB
PHP
308 lines
8.4 KiB
PHP
<?php
|
|
|
|
namespace ownCloud\TarStreamer;
|
|
|
|
class TarStreamer {
|
|
|
|
const REGTYPE = 0;
|
|
const DIRTYPE = 5;
|
|
const XHDTYPE = 'x';
|
|
|
|
/**
|
|
* Process in 1 MB chunks
|
|
*/
|
|
protected $blockSize = 1048576;
|
|
protected $outStream;
|
|
protected $needHeaders = false;
|
|
|
|
/**
|
|
* Create a new TarStreamer object.
|
|
*
|
|
* @param array $options
|
|
*/
|
|
public function __construct($options = []){
|
|
if (isset($options['outstream'])){
|
|
$this->outStream = $options['outstream'];
|
|
} else {
|
|
$this->outStream = fopen('php://output', 'w');
|
|
// turn off output buffering
|
|
while (ob_get_level() > 0){
|
|
ob_end_flush();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send appropriate http headers before streaming the tar file and disable output buffering.
|
|
* This method, if used, has to be called before adding anything to the tar file.
|
|
*
|
|
* @param string $archiveName Filename of archive to be created (optional, default 'archive.tar')
|
|
* @param string $contentType Content mime type to be set (optional, default 'application/x-tar')
|
|
* @throws \Exception
|
|
*/
|
|
public function sendHeaders($archiveName = 'archive.tar', $contentType = 'application/x-tar'){
|
|
$encodedArchiveName = rawurlencode($archiveName);
|
|
if (headers_sent($headerFile, $headerLine)){
|
|
throw new \Exception("Unable to send file $encodedArchiveName. HTML Headers have already been sent from $headerFile in line $headerLine");
|
|
}
|
|
$buffer = ob_get_contents();
|
|
if (!empty($buffer)){
|
|
throw new \Exception("Unable to send file $encodedArchiveName. Output buffer already contains text (typically warnings or errors).");
|
|
}
|
|
|
|
$headers = [
|
|
'Pragma' => 'public',
|
|
'Last-Modified' => gmdate('D, d M Y H:i:s T'),
|
|
'Expires' => '0',
|
|
'Accept-Ranges' => 'bytes',
|
|
'Connection' => 'Keep-Alive',
|
|
'Content-Type' => $contentType,
|
|
'Cache-Control' => 'public, must-revalidate',
|
|
'Content-Transfer-Encoding' => 'binary',
|
|
];
|
|
|
|
// Use UTF-8 filenames when not using Internet Explorer
|
|
if(strpos($_SERVER['HTTP_USER_AGENT'], 'MSIE') > 0) {
|
|
header('Content-Disposition: attachment; filename="' . rawurlencode($archiveName) . '"');
|
|
} else {
|
|
header('Content-Disposition: attachment; filename*=UTF-8\'\'' . rawurlencode($archiveName)
|
|
. '; filename="' . rawurlencode($archiveName) . '"');
|
|
}
|
|
|
|
foreach ($headers as $key => $value){
|
|
header("$key: $value");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a file to the archive at the specified location and file name.
|
|
*
|
|
* @param resource $stream Stream to read data from
|
|
* @param string $filePath Filepath and name to be used in the archive.
|
|
* @param int $size
|
|
* @param array $options Optional, additional options
|
|
* Valid options are:
|
|
* * int timestamp: timestamp for the file (default: current time)
|
|
* @return bool $success
|
|
*/
|
|
public function addFileFromStream($stream, $filePath, $size, $options = []){
|
|
if (!is_resource($stream) || get_resource_type($stream) != 'stream'){
|
|
return false;
|
|
}
|
|
|
|
$this->initFileStreamTransfer($filePath, self::REGTYPE, $size, $options);
|
|
|
|
// send file blocks
|
|
while ($data = fread($stream, $this->blockSize)){
|
|
// send data
|
|
$this->streamFilePart($data);
|
|
}
|
|
|
|
// complete the file stream
|
|
$this->completeFileStream($size);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Explicitly adds a directory to the tar (necessary for empty directories)
|
|
*
|
|
* @param string $name Name (path) of the directory
|
|
* @param array $opt Additional options to set
|
|
* Valid options are:
|
|
* * int timestamp: timestamp for the file (default: current time)
|
|
* @return void
|
|
*/
|
|
public function addEmptyDir($name, $opt = []){
|
|
$opt['type'] = self::DIRTYPE;
|
|
|
|
// send header
|
|
$this->initFileStreamTransfer($name, self::DIRTYPE, 0, $opt);
|
|
|
|
// complete the file stream
|
|
$this->completeFileStream(0);
|
|
}
|
|
|
|
/**
|
|
* Close the archive.
|
|
* A closed archive can no longer have new files added to it. After
|
|
* closing, the file is completely written to the output stream.
|
|
* @return bool $success */
|
|
public function finalize(){
|
|
// tar requires the end of the file have two 512 byte null blocks
|
|
$this->send(pack('a1024', ''));
|
|
|
|
// flush the data to the output
|
|
fflush($this->outStream);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Initialize a file stream
|
|
*
|
|
* @param string $name file path or just name
|
|
* @param int $type type of the item
|
|
* @param int $size size in bytes of the file
|
|
* @param array $opt array (optional)
|
|
* Valid options are:
|
|
* * int timestamp: timestamp for the file (default: current time)
|
|
*/
|
|
protected function initFileStreamTransfer($name, $type, $size, $opt = []){
|
|
$dirName = (dirname($name) == '.') ? '' : dirname($name);
|
|
$fileName = ($type == self::DIRTYPE) ? basename($name) . '/' : basename($name);
|
|
|
|
|
|
// handle long file names via PAX
|
|
if (strlen($fileName) > 99 || strlen($dirName) > 154){
|
|
$pax = $this->paxGenerate([ 'path' => $dirName . '/' . $fileName]);
|
|
$paxSize = strlen($pax);
|
|
|
|
$this->initFileStreamTransfer('', self::XHDTYPE, $paxSize);
|
|
|
|
$this->streamFilePart($pax);
|
|
$this->completeFileStream($paxSize);
|
|
}
|
|
|
|
// process optional arguments
|
|
$time = isset($opt['timestamp']) ? $opt['timestamp'] : time();
|
|
|
|
// build data descriptor
|
|
$fields = [
|
|
['a100', substr($fileName, 0, 100)],
|
|
['a8', str_pad('777', 7, '0', STR_PAD_LEFT)],
|
|
['a8', decoct(str_pad('0', 7, '0', STR_PAD_LEFT))],
|
|
['a8', decoct(str_pad('0', 7, '0', STR_PAD_LEFT))],
|
|
['a12', str_pad(decoct($size), 11, '0', STR_PAD_LEFT)],
|
|
['a12', str_pad(decoct($time), 11, '0', STR_PAD_LEFT)],
|
|
['a8', ''],
|
|
['a1', $type],
|
|
['a100', ''],
|
|
['a6', 'ustar'],
|
|
['a2', '00'],
|
|
['a32', ''],
|
|
['a32', ''],
|
|
['a8', ''],
|
|
['a8', ''],
|
|
['a155', substr($dirName, 0, 155)],
|
|
['a12', ''],
|
|
];
|
|
|
|
// pack fields and calculate "total" length
|
|
$header = $this->packFields($fields);
|
|
|
|
// Compute header checksum
|
|
$checksum = str_pad(decoct($this->computeUnsignedChecksum($header)), 6, "0", STR_PAD_LEFT);
|
|
for ($i = 0; $i < 6; $i++){
|
|
$header[(148 + $i)] = substr($checksum, $i, 1);
|
|
}
|
|
$header[154] = chr(0);
|
|
$header[155] = chr(32);
|
|
|
|
// print header
|
|
$this->send($header);
|
|
}
|
|
|
|
/**
|
|
* Stream the next part of the current file stream.
|
|
*
|
|
* @param string $data raw data to send
|
|
*/
|
|
protected function streamFilePart($data){
|
|
// send data
|
|
$this->send($data);
|
|
|
|
// flush the data to the output
|
|
fflush($this->outStream);
|
|
}
|
|
|
|
/**
|
|
* Complete the current file stream
|
|
* @param $size
|
|
*/
|
|
protected function completeFileStream($size){
|
|
// ensure we pad the last block so that it is 512 bytes
|
|
if (($mod = ($size % 512)) > 0){
|
|
$this->send(pack('a' . (512 - $mod), ''));
|
|
}
|
|
|
|
// flush the data to the output
|
|
fflush($this->outStream);
|
|
}
|
|
|
|
/**
|
|
* Send string, sending HTTP headers if necessary.
|
|
*
|
|
* @param string $data data to send
|
|
*/
|
|
protected function send($data){
|
|
if ($this->needHeaders){
|
|
$this->sendHeaders();
|
|
}
|
|
$this->needHeaders = false;
|
|
|
|
fwrite($this->outStream, $data);
|
|
}
|
|
|
|
/**
|
|
* Create a format string and argument list for pack(), then call pack() and return the result.
|
|
*
|
|
* @param array $fields key being the format string and value being the data to pack
|
|
* @return string binary packed data returned from pack()
|
|
*/
|
|
protected function packFields($fields){
|
|
list ($fmt, $args) = ['', []];
|
|
|
|
// populate format string and argument list
|
|
foreach ($fields as $field){
|
|
$fmt .= $field[0];
|
|
$args[] = $field[1];
|
|
}
|
|
|
|
// prepend format string to argument list
|
|
array_unshift($args, $fmt);
|
|
|
|
// build output string from header and compressed data
|
|
return call_user_func_array('pack', $args);
|
|
}
|
|
|
|
/**
|
|
* Generate unsigned checksum of header
|
|
*
|
|
* @param string $header
|
|
* @return string unsigned checksum
|
|
*/
|
|
protected function computeUnsignedChecksum($header){
|
|
$unsignedChecksum = 0;
|
|
for ($i = 0; $i < 512; $i++){
|
|
$unsignedChecksum += ord($header[$i]);
|
|
}
|
|
for ($i = 0; $i < 8; $i++){
|
|
$unsignedChecksum -= ord($header[148 + $i]);
|
|
}
|
|
$unsignedChecksum += ord(" ") * 8;
|
|
|
|
return $unsignedChecksum;
|
|
}
|
|
|
|
/**
|
|
* Generate a PAX string
|
|
*
|
|
* @param array $fields key value mapping
|
|
* @return string PAX formated string
|
|
* @link http://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5&manpath=FreeBSD+8-current tar / PAX spec
|
|
*/
|
|
protected function paxGenerate($fields){
|
|
$lines = '';
|
|
foreach ($fields as $name => $value){
|
|
// build the line and the size
|
|
$line = ' ' . $name . '=' . $value . "\n";
|
|
$size = strlen(strlen($line)) + strlen($line);
|
|
|
|
// add the line
|
|
$lines .= $size . $line;
|
|
}
|
|
|
|
return $lines;
|
|
}
|
|
}
|