CMake/Source/CPack/cmCPackTGZGenerator.cxx

291 lines
8.0 KiB
C++
Raw Normal View History

2006-01-02 07:21:05 +03:00
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
2006-03-10 21:06:26 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
2006-01-02 07:21:05 +03:00
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "cmCPackTGZGenerator.h"
#include "cmake.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmSystemTools.h"
#include "cmMakefile.h"
#include "cmGeneratedFileStream.h"
2006-01-03 00:14:21 +03:00
#include "cmCPackLog.h"
2006-01-02 07:21:05 +03:00
#include <cmsys/SystemTools.hxx>
#include <cm_zlib.h>
2006-01-02 15:53:05 +03:00
#include <libtar/libtar.h>
#include <memory> // auto_ptr
#include <fcntl.h>
#include <errno.h>
2006-01-02 07:21:05 +03:00
2006-01-02 18:37:00 +03:00
//----------------------------------------------------------------------
class cmCPackTGZGeneratorForward
{
public:
static int GenerateHeader(cmCPackTGZGenerator* gg, std::ostream* os)
{
return gg->GenerateHeader(os);
}
};
2006-01-02 15:53:05 +03:00
//----------------------------------------------------------------------
cmCPackTGZGenerator::cmCPackTGZGenerator()
2006-01-02 07:21:05 +03:00
{
this->Compress = true;
2006-01-02 07:21:05 +03:00
}
2006-01-02 15:53:05 +03:00
//----------------------------------------------------------------------
cmCPackTGZGenerator::~cmCPackTGZGenerator()
2006-01-02 07:21:05 +03:00
{
}
static const size_t cmCPackTGZ_Data_BlockSize = 16384;
2006-01-02 07:21:05 +03:00
//----------------------------------------------------------------------
class cmCPackTGZ_Data
{
public:
cmCPackTGZ_Data(cmCPackTGZGenerator* gen, bool compress) :
OutputStream(0), Generator(gen),
CompressionLevel(Z_DEFAULT_COMPRESSION),
Compress(compress) {}
2006-01-02 07:21:05 +03:00
std::ostream* OutputStream;
cmCPackTGZGenerator* Generator;
2006-03-10 21:06:26 +03:00
char CompressedBuffer[cmCPackTGZ_Data_BlockSize];
int CompressionLevel;
z_stream ZLibStream;
uLong CRC;
bool Compress;
2006-01-02 07:21:05 +03:00
};
2006-01-03 00:14:21 +03:00
//----------------------------------------------------------------------
2006-01-02 18:37:00 +03:00
extern "C" {
int cmCPackTGZ_Data_Open(void *client_data, const char* name, int oflags,
mode_t mode);
2006-01-02 18:37:00 +03:00
ssize_t cmCPackTGZ_Data_Write(void *client_data, void *buff, size_t n);
int cmCPackTGZ_Data_Close(void *client_data);
}
2006-01-02 07:21:05 +03:00
//----------------------------------------------------------------------
int cmCPackTGZ_Data_Open(void *client_data, const char* pathname,
int, mode_t)
2006-01-02 07:21:05 +03:00
{
cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
if ( mydata->Compress )
{
mydata->ZLibStream.zalloc = Z_NULL;
mydata->ZLibStream.zfree = Z_NULL;
mydata->ZLibStream.opaque = Z_NULL;
int strategy = Z_DEFAULT_STRATEGY;
if ( deflateInit2(&mydata->ZLibStream, mydata->CompressionLevel,
Z_DEFLATED, -MAX_WBITS, 8, strategy) != Z_OK )
{
return -1;
}
}
2006-01-12 03:12:21 +03:00
cmGeneratedFileStream* gf = new cmGeneratedFileStream;
// Open binary
gf->Open(pathname, false, true);
2006-01-02 15:53:05 +03:00
mydata->OutputStream = gf;
if ( !*mydata->OutputStream )
2006-01-02 07:21:05 +03:00
{
2006-01-02 15:53:05 +03:00
return -1;
2006-01-02 07:21:05 +03:00
}
2006-03-10 21:06:26 +03:00
2006-01-03 00:14:21 +03:00
if ( !cmCPackTGZGeneratorForward::GenerateHeader(mydata->Generator,gf))
2006-01-02 07:21:05 +03:00
{
2006-01-02 15:53:05 +03:00
return -1;
2006-01-02 07:21:05 +03:00
}
if ( mydata->Compress )
{
mydata->CRC = crc32(0L, Z_NULL, 0);
}
2006-01-02 15:53:05 +03:00
return 0;
2006-01-02 07:21:05 +03:00
}
//----------------------------------------------------------------------
2006-01-02 18:37:00 +03:00
ssize_t cmCPackTGZ_Data_Write(void *client_data, void *buff, size_t n)
2006-01-02 07:21:05 +03:00
{
cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
if ( mydata->Compress )
{
mydata->ZLibStream.avail_in = n;
mydata->ZLibStream.next_in = reinterpret_cast<Bytef*>(buff);
do {
mydata->ZLibStream.avail_out = cmCPackTGZ_Data_BlockSize;
mydata->ZLibStream.next_out
= reinterpret_cast<Bytef*>(mydata->CompressedBuffer);
// no bad return value
int ret = deflate(&mydata->ZLibStream, (n?Z_NO_FLUSH:Z_FINISH));
if(ret == Z_STREAM_ERROR)
{
return 0;
}
size_t compressedSize
= cmCPackTGZ_Data_BlockSize - mydata->ZLibStream.avail_out;
mydata->OutputStream->write(
reinterpret_cast<const char*>(mydata->CompressedBuffer),
compressedSize);
} while ( mydata->ZLibStream.avail_out == 0 );
if ( !*mydata->OutputStream )
2006-01-05 00:24:24 +03:00
{
return 0;
}
if ( n )
{
mydata->CRC = crc32(mydata->CRC, reinterpret_cast<Bytef *>(buff), n);
}
2006-01-02 07:21:05 +03:00
}
else
{
2006-05-03 02:47:49 +04:00
mydata->OutputStream->write(reinterpret_cast<char*>(buff), n);
}
2006-01-02 07:21:05 +03:00
return n;
}
//----------------------------------------------------------------------
2006-01-02 18:37:00 +03:00
int cmCPackTGZ_Data_Close(void *client_data)
2006-01-02 07:21:05 +03:00
{
cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
if ( mydata->Compress )
{
cmCPackTGZ_Data_Write(client_data, 0, 0);
char buffer[8];
int n;
uLong x = mydata->CRC;
for (n = 0; n < 4; n++) {
buffer[n] = (int)(x & 0xff);
x >>= 8;
}
x = mydata->ZLibStream.total_in;
for (n = 0; n < 4; n++) {
buffer[n+4] = (int)(x & 0xff);
x >>= 8;
}
mydata->OutputStream->write(buffer, 8);
(void)deflateEnd(&mydata->ZLibStream);
}
2006-01-02 07:21:05 +03:00
delete mydata->OutputStream;
2006-01-02 15:53:05 +03:00
mydata->OutputStream = 0;
2006-01-02 07:21:05 +03:00
return (0);
}
//----------------------------------------------------------------------
int cmCPackTGZGenerator::InitializeInternal()
{
this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
return this->Superclass::InitializeInternal();
}
2006-01-02 07:21:05 +03:00
//----------------------------------------------------------------------
int cmCPackTGZGenerator::CompressFiles(const char* outFileName,
const char* toplevel, const std::vector<std::string>& files)
2006-01-02 07:21:05 +03:00
{
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
<< (toplevel ? toplevel : "(NULL)") << std::endl);
cmCPackTGZ_Data mydata(this, this->Compress);
2006-01-02 15:53:05 +03:00
TAR *t;
char buf[TAR_MAXPATHLEN];
char pathname[TAR_MAXPATHLEN];
tartype_t gztype = {
2006-01-02 18:37:00 +03:00
(openfunc_t)cmCPackTGZ_Data_Open,
(closefunc_t)cmCPackTGZ_Data_Close,
2006-01-02 15:53:05 +03:00
(readfunc_t)0,
2006-01-02 18:37:00 +03:00
(writefunc_t)cmCPackTGZ_Data_Write,
2006-01-02 15:53:05 +03:00
&mydata
};
// Ok, this libtar is not const safe. for now use auto_ptr hack
char* realName = new char[ strlen(outFileName) + 1 ];
std::auto_ptr<char> realNamePtr(realName);
strcpy(realName, outFileName);
int flags = O_WRONLY | O_CREAT;
if (tar_open(&t, realName,
&gztype,
flags, 0644,
2006-03-10 21:06:26 +03:00
(this->GeneratorVerbose?TAR_VERBOSE:0)
2006-01-02 15:53:05 +03:00
| 0) == -1)
{
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem with tar_open(): "
<< strerror(errno) << std::endl);
2006-01-02 15:53:05 +03:00
return 0;
}
2006-01-02 07:21:05 +03:00
std::vector<std::string>::const_iterator fileIt;
for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
{
std::string rp = cmSystemTools::RelativePath(toplevel, fileIt->c_str());
2006-01-02 15:53:05 +03:00
strncpy(pathname, fileIt->c_str(), sizeof(pathname));
pathname[sizeof(pathname)-1] = 0;
strncpy(buf, rp.c_str(), sizeof(buf));
2006-01-02 15:53:05 +03:00
buf[sizeof(buf)-1] = 0;
if (tar_append_tree(t, pathname, buf) != 0)
2006-01-02 07:21:05 +03:00
{
2006-01-03 00:14:21 +03:00
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Problem with tar_append_tree(\"" << buf << "\", \""
<< pathname << "\"): "
2006-01-03 00:14:21 +03:00
<< strerror(errno) << std::endl);
2006-01-02 15:53:05 +03:00
tar_close(t);
return 0;
2006-01-02 07:21:05 +03:00
}
}
2006-01-02 15:53:05 +03:00
if (tar_append_eof(t) != 0)
{
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem with tar_append_eof(): "
<< strerror(errno) << std::endl);
2006-01-02 15:53:05 +03:00
tar_close(t);
return 0;
2006-01-02 07:21:05 +03:00
}
2006-01-02 15:53:05 +03:00
if (tar_close(t) != 0)
{
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem with tar_close(): "
<< strerror(errno) << std::endl);
2006-01-02 15:53:05 +03:00
return 0;
2006-01-02 07:21:05 +03:00
}
2006-01-02 15:53:05 +03:00
return 1;
2006-01-02 07:21:05 +03:00
}
2006-01-02 18:37:00 +03:00
//----------------------------------------------------------------------
int cmCPackTGZGenerator::GenerateHeader(std::ostream* os)
{
if ( this->Compress )
{
const int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
char header[11];
sprintf(header, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/,
3 /* zlib os code for UNIX, not really used anyway */);
os->write(header, 10);
}
2006-01-02 18:37:00 +03:00
return 1;
}