summaryrefslogtreecommitdiffstats
path: root/heimdall-frontend/Source/Packaging.cpp
diff options
context:
space:
mode:
authorBenjamin Dobell <benjamin.dobell@glassechidna.com.au>2011-07-05 18:58:28 +0200
committerBenjamin Dobell <benjamin.dobell@glassechidna.com.au>2011-07-05 18:58:28 +0200
commitb6ffa766b21fe2c985437aa80824a3cd4c384de8 (patch)
treeda9f5c33b33074748bd981175d36d2974ff3fb98 /heimdall-frontend/Source/Packaging.cpp
parentMerge pull request #15 from alanorth/patch-1 (diff)
downloadHeimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar.gz
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar.bz2
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar.lz
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar.xz
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.tar.zst
Heimdall-b6ffa766b21fe2c985437aa80824a3cd4c384de8.zip
Diffstat (limited to 'heimdall-frontend/Source/Packaging.cpp')
-rwxr-xr-xheimdall-frontend/Source/Packaging.cpp345
1 files changed, 345 insertions, 0 deletions
diff --git a/heimdall-frontend/Source/Packaging.cpp b/heimdall-frontend/Source/Packaging.cpp
new file mode 100755
index 0000000..cbd03a4
--- /dev/null
+++ b/heimdall-frontend/Source/Packaging.cpp
@@ -0,0 +1,345 @@
+/* Copyright (c) 2010 Benjamin Dobell, Glass Echidna
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.*/
+
+// C/C++ Standard Library
+#include <stdio.h>
+
+// zlib
+#include "zlib.h"
+
+// Qt
+#include <QDateTime>
+#include <QDir>
+
+// Heimdall Frontend
+#include "Packaging.h"
+
+using namespace HeimdallFrontend;
+
+const char *Packaging::ustarMagic = "ustar";
+
+bool Packaging::ExtractTar(QTemporaryFile& tarFile, PackageData *outputPackageData)
+{
+ TarHeader tarHeader;
+
+ tarFile.reset();
+
+ bool previousEmpty = false;
+
+ while (!tarFile.atEnd())
+ {
+ qint64 dataRead = tarFile.read(tarHeader.buffer, TarHeader::kBlockLength);
+
+ if (dataRead != TarHeader::kBlockLength)
+ return (false);
+
+ bool ustarFormat = strcmp(tarHeader.fields.magic, ustarMagic) == 0;
+ bool empty = true;
+
+ for (int i = 0; i < TarHeader::kBlockLength; i++)
+ {
+ if (tarHeader.buffer[i] != 0)
+ {
+ empty = false;
+ break;
+ }
+ }
+
+ if (empty)
+ {
+ if (previousEmpty)
+ {
+ // Two empty blocks in a row means we've reached the end of the archive.
+ // TODO: Make sure we're at the end of the file.
+ break;
+ }
+ }
+ else
+ {
+ // TODO: Check checksum
+
+ bool parsed = false;
+
+ // The size field is not always null terminated, so we must create a copy and null terminate it for parsing.
+ char fileSizeString[13];
+ memcpy(fileSizeString, tarHeader.fields.size, 12);
+ fileSizeString[12] = '\0';
+
+ qulonglong fileSize = QString(fileSizeString).toULongLong(&parsed, 8);
+
+ if (!parsed)
+ {
+ // TODO: Error message?
+ return (false);
+ }
+
+ if (fileSize > 0 && tarHeader.fields.typeFlag == '0')
+ {
+ // We're working with a file.
+ QString filename = QString::fromUtf8(tarHeader.fields.name);
+
+ // This is slightly pointless as we don't support directories...
+ if (ustarFormat)
+ filename.prepend(tarHeader.fields.prefix);
+
+ QTemporaryFile *outputFile = new QTemporaryFile("XXXXXX-" + filename);
+ outputFile->open();
+
+ outputPackageData->GetFiles().append(outputFile);
+
+ qulonglong dataRemaining = fileSize;
+ char readBuffer[TarHeader::kBlockReadCount * TarHeader::kBlockLength];
+
+ // Copy the file contents from tarFile to outputFile
+ while (dataRemaining > 0)
+ {
+ qint64 fileDataToRead = (dataRemaining < TarHeader::kBlockReadCount * TarHeader::kBlockLength)
+ ? dataRemaining : TarHeader::kBlockReadCount * TarHeader::kBlockLength;
+
+ qint64 dataRead = tarFile.read(readBuffer, fileDataToRead + (TarHeader::kBlockLength - fileDataToRead % TarHeader::kBlockLength) % TarHeader::kBlockLength);
+
+ if (dataRead < fileDataToRead || dataRead % TarHeader::kBlockLength != 0)
+ return (false);
+
+ outputFile->write(readBuffer, fileDataToRead);
+
+ dataRemaining -= fileDataToRead;
+ }
+
+ outputFile->close();
+ }
+ else
+ {
+ // We don't support links/directories.
+ return (false);
+ }
+ }
+
+ previousEmpty = empty;
+ }
+
+ return (true);
+}
+
+bool Packaging::CreateTar(const PackageData& packageData, QTemporaryFile *outputTarFile)
+{
+ const QList<FileInfo>& fileInfos = packageData.GetFirmwareInfo().GetFileInfos();
+
+ if (!outputTarFile->open())
+ {
+ // TODO: "Failed to open \"%s\""
+ return (false);
+ }
+
+ bool failure = false;
+
+ TarHeader tarHeader;
+
+ for (int i = 0; i < fileInfos.length(); i++)
+ {
+ memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+
+ QFile file(fileInfos[i].GetFilename());
+
+ if (!file.open(QFile::ReadOnly))
+ {
+ // TODO: "Failed to open \"%s\""
+ failure = true;
+ break;
+ }
+
+ if (file.size() > TarHeader::kMaxFileSize)
+ {
+ // TODO: "File is too large to packaged"
+ failure = true;
+ break;
+ }
+
+ QFileInfo qtFileInfo(file);
+ strcpy(tarHeader.fields.name, qtFileInfo.fileName().toUtf8().constData());
+
+ unsigned int mode = 0;
+
+ QFile::Permissions permissions = file.permissions();
+
+ // Other
+ if (permissions.testFlag(QFile::ExeOther))
+ mode |= TarHeader::kModeOtherExecute;
+ if (permissions.testFlag(QFile::WriteOther))
+ mode |= TarHeader::kModeOtherWrite;
+ if (permissions.testFlag(QFile::ReadOther))
+ mode |= TarHeader::kModeOtherRead;
+
+ // Group
+ if (permissions.testFlag(QFile::ExeGroup))
+ mode |= TarHeader::kModeGroupExecute;
+ if (permissions.testFlag(QFile::WriteGroup))
+ mode |= TarHeader::kModeGroupWrite;
+ if (permissions.testFlag(QFile::ReadGroup))
+ mode |= TarHeader::kModeGroupRead;
+
+ // Owner
+ if (permissions.testFlag(QFile::ExeOwner))
+ mode |= TarHeader::kModeOwnerExecute;
+ if (permissions.testFlag(QFile::WriteOwner))
+ mode |= TarHeader::kModeOwnerWrite;
+ if (permissions.testFlag(QFile::ReadOwner))
+ mode |= TarHeader::kModeOwnerRead;
+
+ sprintf(tarHeader.fields.mode, "%o", mode);
+
+ sprintf(tarHeader.fields.userId, "%o", qtFileInfo.ownerId());
+ sprintf(tarHeader.fields.groupId, "%o", qtFileInfo.groupId());
+
+ // Note: We don't support base-256 encoding. Support could be added in future.
+ sprintf(tarHeader.fields.size, "%o", file.size());
+
+ sprintf(tarHeader.fields.modifiedTime, "%o", qtFileInfo.lastModified().toMSecsSinceEpoch());
+
+ // Regular File
+ tarHeader.fields.typeFlag = '0';
+
+ // Calculate checksum
+ int checksum = 0;
+
+ for (int i = 0; i < TarHeader::kTarHeaderLength; i++)
+ checksum += tarHeader.buffer[i];
+
+ sprintf(tarHeader.fields.checksum, "%o", checksum);
+
+ // Write the header to the TAR file.
+ outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+ char buffer[TarHeader::kBlockWriteCount * TarHeader::kBlockLength];
+
+ for (qint64 i = 0; i < file.size(); i++)
+ {
+ qint64 dataRead = file.read(buffer, TarHeader::kBlockWriteCount * TarHeader::kBlockLength);
+
+ if (outputTarFile->write(buffer, dataRead) != dataRead)
+ {
+ // TODO: "Failed to write data to the temporary TAR file."
+ failure = true;
+ break;
+ }
+
+ if (dataRead % TarHeader::kBlockLength != 0)
+ {
+ int remainingBlockLength = TarHeader::kBlockLength - dataRead % TarHeader::kBlockLength;
+ memset(buffer, 0, remainingBlockLength);
+
+ if (outputTarFile->write(buffer, remainingBlockLength) != remainingBlockLength)
+ {
+ // TODO: "Failed to write data to the temporary TAR file."
+ failure = true;
+ break;
+ }
+ }
+
+ i += dataRead;
+ }
+
+ if (failure)
+ break;
+ }
+
+ if (failure)
+ {
+ outputTarFile->resize(0);
+ outputTarFile->close();
+ return (false);
+ }
+
+ // Write two empty blocks to signify the end of the archive.
+ memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+ outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+ outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+ outputTarFile->close();
+
+ return (true);
+}
+
+bool Packaging::ExtractPackage(const QString& packagePath, PackageData *outputPackageData)
+{
+ FILE *compressedPackageFile = fopen(packagePath.toStdString().c_str(), "rb");
+ gzFile packageFile = gzdopen(fileno(compressedPackageFile), "rb");
+
+ QTemporaryFile outputTar("XXXXXX.tar");
+
+ if (!outputTar.open())
+ {
+ gzclose(packageFile);
+
+ return (false);
+ }
+
+ char buffer[32768];
+
+ int bytesRead;
+
+ do
+ {
+ bytesRead = gzread(packageFile, buffer, 32768);
+
+ if (bytesRead == -1)
+ {
+ gzclose(packageFile);
+
+ return (false);
+ }
+
+ outputTar.write(buffer, bytesRead);
+ } while (bytesRead > 0);
+
+ gzclose(packageFile); // Closes packageFile and compressedPackageFile
+
+ if (!ExtractTar(outputTar, outputPackageData))
+ return (false);
+
+ // Find and read firmware.xml
+ for (int i = 0; i < outputPackageData->GetFiles().length(); i++)
+ {
+ QTemporaryFile *file = outputPackageData->GetFiles()[i];
+
+ if (file->fileTemplate() == "XXXXXX-firmware.xml")
+ {
+ if (!outputPackageData->ReadFirmwareInfo(file))
+ {
+ outputPackageData->Clear();
+ return (false);
+ }
+
+ return (true);
+ }
+ }
+
+ return (false);
+}
+
+bool Packaging::BuildPackage(const QString& packagePath, const PackageData& packageData)
+{
+ QTemporaryFile temporaryFile("XXXXXX.tar");
+
+ if (!CreateTar(packageData, &temporaryFile))
+ return (false);
+
+ return (true);
+}