bool ZipArchive::copyFileToNewZip(CentralDir *cdir, Stream *newZipStream)
{
// [tom, 1/24/2007] Using the stored compressor allows us to copy the raw
// data regardless of compression method without having to re-compress it.
Compressor *comp = Compressor::findCompressor(Stored);
if(comp == NULL)
return false;
if(! mStream->setPosition(cdir->mLocalHeadOffset))
return false;
// Copy file header
// FIXME [tom, 1/24/2007] This will currently not copy the extra fields
FileHeader fh;
if(! fh.read(mStream))
return false;
cdir->mLocalHeadOffset = newZipStream->getPosition();
if(! fh.write(newZipStream))
return false;
// Copy file data
Stream *readS = comp->createReadStream(cdir, mStream);
if(readS == NULL)
return false;
bool ret = newZipStream->copyFrom(readS);
// [tom, 1/24/2007] closeFile() just frees the relevant filters and
// thus it is safe to call from here.
closeFile(readS);
return ret;
}
int main(int argc, char** argv)
{
if (argc != 2)
die_printf("Usage: %s <sio-file>\n", argv[0]);
try
{
// Load a CODA stream
FileInputStream input(argv[1]);
// Create a reader
FileReader r(&input);
FileHeader* header = r.readHeader();
// Now let's spit out header info
std::cout << ". nl: " << header->getNumLines() << std::endl;
std::cout << ". ne: " << header->getNumElements() << std::endl;
std::cout << ". et: " << header->getElementTypeAsString() << std::endl;
std::cout << ". es: " << header->getElementSize() << std::endl;
printUserData(header);
}
catch (Exception& e)
{
std::cout << "Caught exception: " << e.getMessage() << std::endl;
std::cout << "Trace:" << std::endl << e.getTrace() << std::endl;
}
}
// 文件加密函数
// 这个函数有点长，但是基本上都是检错的代码。逻辑还是很清晰的。
errno_t EasyEncrypt(const string& inFilename, const string& outFilename, const string& key)
{
LOGPOS();
FileReader fileReader;
FilePath inFilePath(inFilename);
if (fileReader.Open(inFilePath.value()) != CPT_OK) {
LOGW("Open file %s failed!", inFilePath.value().c_str());
return CPT_ERROR;
}
Encrypt encrypt;
if (encrypt.SetReader(dynamic_cast<Reader*>(&fileReader)) != CPT_OK) {
LOGW("Encrypt Set Reader failed");
return CPT_ERROR;
}
FileHeader *fileHeader = encrypt.GenrHeader();
if (fileHeader == NULL) {
LOGW("Generate file header failed!");
return CPT_ERROR;
}
fileHeader->SetFormat(inFilePath.Extension());
if (encrypt.EncryptHeader(key.c_str(), key.length()) != CPT_OK) {
LOGW("Encrypt file header failed");
return CPT_ERROR;
}
FileWriter writer;
if (writer.Open(outFilename) != CPT_OK) {
LOGW("Create file %s failed!", outFilename.c_str());
return CPT_ERROR;
}
if (encrypt.SetWriter(dynamic_cast<Writer*>(&writer)) != CPT_OK) {
LOGW("encrypt set writer failed!");
return CPT_ERROR;
}
if (encrypt.WriteHeader() != CPT_OK) {
LOGW("Encrypt write header failed!");
return CPT_ERROR;
}
int err = encrypt.PreEncrypt();
ASSERT(err == CPT_OK);
if (encrypt.DoEncrypt(key.c_str(), key.length()) != CPT_OK) {
LOGW("Encrypt encrypt failed!");
return CPT_ERROR;
}
err = encrypt.PostEncrypt();
ASSERT(err == CPT_OK);
return CPT_OK;
}
/*
* Update the file with new FileHeader information
*/
bool FileHeaderUpdater::Update(std::ofstream& os, FileHeader& updateHdr, FileHeader& currentHdr)
{
// There is nothing at this time to update in the FileHeader
// Move on to the GenericDataHeader
GenericDataHeaderUpdater genUpdater;
return genUpdater.Update(os, *updateHdr.GetGenericDataHdr(), *currentHdr.GetGenericDataHdr());
}
void GenericFileWriterTest::testCreation()
{
FileHeader* fHdr = new FileHeader();
fHdr->SetFilename("generic_file_writer");
GenericFileWriter w(fHdr);
CPPUNIT_ASSERT(1);
delete fHdr;
}
void TestFileGenerator::WriteOutGenericDATDataFileNoGrid()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L"First Data Cube");
// Fill the DataSetHeader
DataSetHeader dph;
dph.SetName(L"acquired data");
ParameterNameValueType nvt;
nvt.SetName(L"Scanner");
nvt.SetValueText(L"M10");
dph.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dph.AddNameValParam(nvt);
dph.AddColumn(UShortColumn(L"Pixel"));
int32_t rows = 100;
dph.SetRowCnt(rows);
dch.AddDataSetHdr(dph);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_dat");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
dpwBegin->WriteHeader();
// Write out the data
for( int32_t i=0; i < rows; ++i )
{
u_int16_t value = (u_int16_t)(i*10+i);
dpwBegin->Write(value);
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
void FileHeaderWriter::WriteGenericDataHdr(std::ofstream &os, FileHeader &g)
{
GenericDataHeaderWriter writer;
// Check if a file ID has been assign, if not assign one.
if (g.GetGenericDataHdr()->GetFileId().length() == 0)
g.GetGenericDataHdr()->SetFileId(AffymetrixGuid::GenerateNewGuid());
writer.Write(os, *(g.GetGenericDataHdr()));
}
errno_t EasyDecrypt(const string& filename, const string& key, string *outFilename)
{
LOGPOS();
FilePath inFilePath(filename);
FileReader reader;
if (reader.Open(inFilePath.value()) != CPT_OK) {
LOGW("Open file %s failed!", inFilePath.value().c_str());
return CPT_ERROR;
}
Decrypt decrypt;
if (decrypt.SetReader(&reader) != CPT_OK) {
LOGW("Decrypt set reader failed!");
return CPT_ERROR;
}
if (decrypt.LoadHeader() != CPT_OK) {
LOGW("Decrypt load header failed!");
return CPT_ERROR;
}
FileHeader *fileHeader = decrypt.DecryptHeader(key.c_str(), key.length());
if (fileHeader == NULL) {
LOGW("LoadHeader error");
return CPT_ERROR;
}
FilePath outFilePath = inFilePath.ReplaceExtension(fileHeader->GetFormat());
*outFilename = outFilePath.value();
FileWriter writer;
if (writer.Open(outFilePath.value()) != CPT_OK) {
LOGW("Create file %s failed!", outFilePath.value().c_str());
return CPT_ERROR;
}
if (decrypt.SetWriter(dynamic_cast<Writer*>(&writer)) != CPT_OK) {
LOGW("Decrypt set writer failed!");
return CPT_ERROR;
}
int err = decrypt.PreDecrypt();
ASSERT(err == CPT_OK);
if (decrypt.DoDecrypt(key.c_str(), key.length())) {
LOGW("Decrypt decrypt file failed!");
return CPT_ERROR;
}
err = decrypt.PostDecrypt();
ASSERT(err == CPT_OK);
return CPT_OK;
}
SerialNum
IndexReadUtilities::readSerialNum(const vespalib::string &dir)
{
const vespalib::string fileName = IndexDiskLayout::getSerialNumFileName(dir);
Fast_BufferedFile file;
file.ReadOpen(fileName.c_str());
FileHeader fileHeader;
fileHeader.readFile(file);
if (fileHeader.hasTag(IndexDiskLayout::SerialNumTag)) {
return fileHeader.getTag(IndexDiskLayout::SerialNumTag).asInteger();
}
return 0;
}
void CDFDataTest::FileHeaderTest()
{
// Put something into the header.
data->SetArrayCols(45);
// Get the header.
FileHeader* fh = data->GetFileHeader();
CPPUNIT_ASSERT(fh);
// Try to read the thing from the header.
ParameterNameValueType pvt;
CPPUNIT_ASSERT(fh->GetGenericDataHdr()->FindNameValParam(CDF_COLS_PARAM, pvt));
CPPUNIT_ASSERT(pvt.GetValueUInt32() == 45);
}
void CDFFileReaderTest::ReadSmallCDFFileBasicTest()
{
CDFData data;
CDFFileReader reader;
CPPUNIT_ASSERT_NO_THROW(reader.SetFilename(SMALL_CDF_FILE));
CPPUNIT_ASSERT_NO_THROW(reader.Read(data));
CPPUNIT_ASSERT(data.GetFilename() == SMALL_CDF_FILE);
FileHeader* fh = data.GetFileHeader();
u_int32_t pos = fh->GetFirstDataGroupFilePos();
CPPUNIT_ASSERT(pos == 0x1BD);
CPPUNIT_ASSERT(data.GetProbeSetCnt() == 10);
CPPUNIT_ASSERT(data.GetArrayRows() == 10*2);
CPPUNIT_ASSERT(data.GetArrayCols() == 11);
}
/*
* Reads all the DataGroupHeaders in a file and all information for each DataSetHeader in every DataGroup.
*/
void DataGroupHeaderReader::ReadAll(std::ifstream& fileStream, FileHeader& fh, u_int32_t dataGroupCnt)
{
// Get the first data group offset
u_int32_t nextDataGroupFilePos = fh.GetFirstDataGroupFilePos();
for (u_int32_t i = 0; i < dataGroupCnt; ++i)
{
// Read the DataGroupHeader
DataGroupHeader dch;
// Move to the indicated position in the file
fileStream.seekg(nextDataGroupFilePos, std::ios_base::beg);
nextDataGroupFilePos = Read(fileStream, dch);
fh.AddDataGroupHdr(dch);
}
}
void CPHDWriter::writeMetadata(size_t vmbSize,
size_t cphdSize)
{
const std::string xmlMetadata(CPHDXMLControl().toXMLString(mMetadata));
FileHeader header;
header.set(xmlMetadata.size(), vmbSize, cphdSize);
mFile.write(header.toString().c_str(), header.size());
mFile.write("\f\n", 2);
mFile.write(xmlMetadata.c_str(), xmlMetadata.size());
mFile.write("\f\n", 2);
// Pad bytes
char zero = 0;
for (sys::Off_T ii = 0; ii < header.getPadBytes(); ++ii)
{
mFile.write(&zero, 1);
}
}
Stream *ZipArchive::openFileForRead(const CentralDir *fileCD)
{
if(mMode != Read && mMode != ReadWrite)
return NULL;
if((fileCD->mInternalFlags & (CDFileDeleted | CDFileOpen)) != 0)
return NULL;
Stream *stream = mStream;
if(fileCD->mInternalFlags & CDFileDirty)
{
// File is dirty, we need to read from the temporary file
for(S32 i = 0;i < mTempFiles.size();++i)
{
if(mTempFiles[i]->getCentralDir() == fileCD)
{
// Found the temporary file
if(! mTempFiles[i]->rewind())
{
if(isVerbose())
Con::errorf("ZipArchive::openFile - %s: %s is dirty, but could not rewind temporary file?", mFilename ? mFilename : "<no filename>", fileCD->mFilename.c_str());
return NULL;
}
stream = mTempFiles[i];
break;
}
}
if(stream == mStream)
{
if(isVerbose())
Con::errorf("ZipArchive::openFile - %s: %s is dirty, but no temporary file found?", mFilename ? mFilename : "<no filename>", fileCD->mFilename.c_str());
return NULL;
}
}
else
{
// Read from the zip file directly
if(! mStream->setPosition(fileCD->mLocalHeadOffset))
{
if(isVerbose())
Con::errorf("ZipArchive::openFile - %s: Could not locate local header for file %s", mFilename ? mFilename : "<no filename>", fileCD->mFilename.c_str());
return NULL;
}
FileHeader fh;
if(! fh.read(mStream))
{
if(isVerbose())
Con::errorf("ZipArchive::openFile - %s: Could not read local header for file %s", mFilename ? mFilename : "<no filename>", fileCD->mFilename.c_str());
return NULL;
}
}
Stream *attachTo = stream;
U16 compMethod = fileCD->mCompressMethod;
if(fileCD->mFlags & Encrypted)
{
if(fileCD->mCompressMethod == AESEncrypted)
{
// [tom, 1/19/2007] Whilst AES support does exist, I'm not including it in TGB
// to avoid having to deal with crypto export legal issues.
Con::errorf("ZipArchive::openFile - %s: File %s is AES encrypted, but AES is not supported in this version.", mFilename ? mFilename : "<no filename>", fileCD->mFilename.c_str());
}
else
{
ZipCryptRStream *cryptStream = new ZipCryptRStream;
cryptStream->setPassword(DEFAULT_ZIP_PASSWORD);
cryptStream->setFileEndPos(stream->getPosition() + fileCD->mCompressedSize);
if(! cryptStream->attachStream(stream))
{
delete cryptStream;
return NULL;
}
attachTo = cryptStream;
}
}
Compressor *comp = Compressor::findCompressor(compMethod);
if(comp == NULL)
{
if(isVerbose())
Con::errorf("ZipArchive::openFile - %s: Unsupported compression method (%d) for file %s", mFilename ? mFilename : "<no filename>", fileCD->mCompressMethod, fileCD->mFilename.c_str());
return NULL;
}
return comp->createReadStream(fileCD, attachTo);
}
void TestFileGenerator::WriteOutGenericDATDataFileWithGrid()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L""); // unnamed DataGroup
// Fill the pixel intensity DataSetHeader
DataSetHeader dphPixel;
dphPixel.SetName(L"acquired data");
ParameterNameValueType nvt;
nvt.SetName(L"Scanner");
nvt.SetValueText(L"M10");
dphPixel.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dphPixel.AddNameValParam(nvt);
dphPixel.AddColumn(UShortColumn(L"Pixel"));
int32_t rows = 1000;
dphPixel.SetRowCnt(rows);
dch.AddDataSetHdr(dphPixel);
// Fill the grid DataSetHeader
DataSetHeader dphGrid;
dphGrid.SetName(L"grid position");
nvt.SetName(L"GhostGrids");
nvt.SetValueText(L"True");
dphGrid.AddNameValParam(nvt);
nvt.SetName(L"Pixel Size");
nvt.SetValueFloat(0.051f);
dphGrid.AddNameValParam(nvt);
dphGrid.AddColumn(FloatColumn(L"Upper left x"));
dphGrid.AddColumn(FloatColumn(L"Upper left y"));
dphGrid.AddColumn(FloatColumn(L"Upper right x"));
dphGrid.AddColumn(FloatColumn(L"Upper right y"));
dphGrid.AddColumn(FloatColumn(L"Lower right x"));
dphGrid.AddColumn(FloatColumn(L"Lower right y"));
dphGrid.AddColumn(FloatColumn(L"Lower left x"));
dphGrid.AddColumn(FloatColumn(L"Lower left y"));
int32_t grids = 5; // first is the global grid with 4 subgrids
dphGrid.SetRowCnt(grids);
dch.AddDataSetHdr(dphGrid);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_dat_with_grid");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
// Write out the pixel DataSet
dpwBegin->WriteHeader();
for( int32_t i=0; i < rows; ++i )
{
u_int16_t value = (u_int16_t)(i*10+i);
dpwBegin->Write(value);
}
dpwBegin->UpdateNextDataSetOffset();
++dpwBegin;
// Write out the grid DataSet
dpwBegin->WriteHeader();
for( int32_t i=0; i < grids; ++i )
{
for (int32_t corner = 0; corner < 4; ++corner)
{
float value = (float)(i*100 + corner);
dpwBegin->Write(value);
dpwBegin->Write(value);
}
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
void TestFileGenerator::WriteOutGenericDataFileWithAllColumnTypes()
{
GenericDataHeader gdh;
AddStandardGenericDataHeader(gdh);
// Fill the DataGroupHeader
DataGroupHeader dch;
dch.SetName(L"default"); // default DataGroup
// Fill the all types DataSetHeader
DataSetHeader dphAT;
dphAT.SetName(L"all types");
ParameterNameValueType nvt;
nvt.SetName(L"How many types");
nvt.SetValueText(L"All types");
dphAT.AddNameValParam(nvt);
nvt.SetName(L"Powered by");
nvt.SetValueText(L"Affymetrix");
dphAT.AddNameValParam(nvt);
dphAT.AddColumn(ByteColumn(L"Byte type"));
dphAT.AddColumn(UByteColumn(L"UByte type"));
dphAT.AddColumn(ASCIIColumn(L"ASCII type", 10));
dphAT.AddColumn(ShortColumn(L"Short type"));
dphAT.AddColumn(UShortColumn(L"UShort type"));
dphAT.AddColumn(IntColumn(L"Int type"));
dphAT.AddColumn(UIntColumn(L"UInt type"));
dphAT.AddColumn(UnicodeColumn(L"Unicode type", 15));
dphAT.AddColumn(FloatColumn(L"Float type"));
int32_t rows = 2;
dphAT.SetRowCnt(rows);
dch.AddDataSetHdr(dphAT);
// Set the FileHeader
FileHeader fh;
fh.SetFilename("test.file.data_all_column_types");
fh.SetGenericDataHdr(gdh);
fh.AddDataGroupHdr(dch);
// Create the generic file writer
GenericFileWriter gfWriter(&fh);
gfWriter.WriteHeader();
DataGroupWriterIt dcwBegin, dcwEnd;
gfWriter.GetDataGroupWriters(dcwBegin, dcwEnd);
DataGroupWriter d = *dcwBegin;
dcwBegin->WriteHeader();
DataSetWriterIt dpwBegin, dpwEnd;
dcwBegin->GetDataSetWriters(dpwBegin, dpwEnd);
// Write out the all types DataSet
dpwBegin->WriteHeader();
for( int32_t row = 0; row < rows; ++row )
{
char str[10];
wchar_t wstr[15];
int8_t b = 1+10*row;
u_int8_t ub = 2+10*row;
sprintf(str, "%d", 3+10*row);
int16_t s = 4+10*row;
u_int16_t us = 5+10*row;
int32_t i = 6+10*row;
u_int32_t ui = 7+10*row;
FormatString1(wstr, 15, L"%d", 8+10*row);
float f = 9+10*row;
dpwBegin->Write(b); // btye
dpwBegin->Write(ub); // unsigned byte
dpwBegin->Write(str, 10); // ACSII string
dpwBegin->Write(s); // short
dpwBegin->Write(us); // unsigned short
dpwBegin->Write(i); // int
dpwBegin->Write(ui); // unsigned int
dpwBegin->Write(wstr, 15); // Unicode string
dpwBegin->Write(f); // float
}
dpwBegin->UpdateNextDataSetOffset();
dcwBegin->Close();
}
void FileHeaderWriter::WriteDataGroupCnt(std::ofstream &os, FileHeader &g)
{
FileOutput::WriteInt32(os, g.GetDataGroupCnt());
}
void FileHeaderWriter::WriteVersion(std::ofstream &os, FileHeader &g)
{
FileOutput::WriteInt8(os, g.GetVersion());
}
void FileHeaderWriter::WriteMagicNumber(std::ofstream &os, FileHeader &g)
{
FileOutput::WriteInt8(os, g.GetMagicNumber());
}
void navigate(const char* path, std::list<FileHeader*>& fileHeaders) throw (FileException)
{
INFO("Navigating a zip file in the path: %s", path);
int signature;
const char* zipExtension = ".zip";
if (!path)
{
WARN("%s", "The path is NULL.");
throw NullPathException(INVALID_PARAMETERS);
}
if (!exist(path))
{
WARN("%s", "The path doesn't exist.")
throw FileNotFoundExpcetion(path, FILE_NOT_FOUND);
}
FILE* file = fopen(path, "rb");
fread(&signature, sizeof (int), 1, file);
if (strlen(path) < 4 || strcmp(path + (strlen(path) - 4), zipExtension) != 0 ||
signature != FILE_HEADER_SIGNATURE)
{
fclose(file);
WARN("%s", "The path isn't for a zip file.")
throw NotZipFileException(path, INVALID_ZIP_FILE);
}
while (feof(file) == 0)
{
if (signature == FILE_HEADER_SIGNATURE)
{
FileHeader* fh = new FileHeader();
fread(&fh->versionToExtract, sizeof (short), 1, file);
fread(&fh->flag, sizeof (short), 1, file);
fread(&fh->compressionMethod, sizeof (short), 1, file);
fread(&fh->lastModificationTime, sizeof (short), 1, file);
fread(&fh->lastModificationDate, sizeof (short), 1, file);
fread(&fh->crc, sizeof (int), 1, file);
fread(&fh->compressedSize, sizeof (int), 1, file);
fread(&fh->uncompressedSize, sizeof (int), 1, file);
fread(&fh->fileNameLength, sizeof (short), 1, file);
fread(&fh->extraFieldLength, sizeof (short), 1, file);
char* fileName = (char*) calloc(fh->fileNameLength + 1, sizeof (char));
fileName[fh->fileNameLength] = '\0';
fread(fileName, sizeof (char), fh->fileNameLength, file);
fh->fileName = fileName;
free(fileName);
char* extraField = (char*) malloc(fh->extraFieldLength);
fread(extraField, sizeof (char), fh->extraFieldLength, file);
fh->setExtraField(extraField, fh->extraFieldLength);
free(extraField);
char* data = (char*) malloc(fh->compressedSize);
fread(data, sizeof (char), fh->compressedSize, file);
fh->setData(data, fh->compressedSize);
free(data);
fileHeaders.push_back(fh);
}
fread(&signature, sizeof (int), 1, file);
}
fclose(file);
}
