|
|
@@ -12,11 +12,430 @@
|
|
|
#include "cm_sys_stat.h"
|
|
|
|
|
|
#include "cmsys/Glob.hxx"
|
|
|
+#include <map>
|
|
|
#include <ostream>
|
|
|
#include <set>
|
|
|
#include <string.h>
|
|
|
#include <utility>
|
|
|
|
|
|
+namespace {
|
|
|
+
|
|
|
+class DebGenerator
|
|
|
+{
|
|
|
+public:
|
|
|
+ DebGenerator(cmCPackLog* logger, std::string const& outputName,
|
|
|
+ std::string const& workDir, std::string const& topLevelDir,
|
|
|
+ std::string const& temporaryDir,
|
|
|
+ const char* debianCompressionType,
|
|
|
+ const char* debianArchiveType,
|
|
|
+ std::map<std::string, std::string> const& controlValues,
|
|
|
+ bool genShLibs, std::string const& shLibsFilename,
|
|
|
+ bool genPostInst, std::string const& postInst, bool genPostRm,
|
|
|
+ std::string const& postRm, const char* controlExtra,
|
|
|
+ bool permissionStrctPolicy,
|
|
|
+ std::vector<std::string> const& packageFiles);
|
|
|
+
|
|
|
+ bool generate() const;
|
|
|
+
|
|
|
+private:
|
|
|
+ void generateDebianBinaryFile() const;
|
|
|
+ void generateControlFile() const;
|
|
|
+ bool generateDataTar() const;
|
|
|
+ std::string generateMD5File() const;
|
|
|
+ bool generateControlTar(std::string const& md5Filename) const;
|
|
|
+ bool generateDeb() const;
|
|
|
+
|
|
|
+ cmCPackLog* Logger;
|
|
|
+ const std::string OutputName;
|
|
|
+ const std::string WorkDir;
|
|
|
+ std::string CompressionSuffix;
|
|
|
+ const std::string TopLevelDir;
|
|
|
+ const std::string TemporaryDir;
|
|
|
+ const char* DebianArchiveType;
|
|
|
+ const std::map<std::string, std::string> ControlValues;
|
|
|
+ const bool GenShLibs;
|
|
|
+ const std::string ShLibsFilename;
|
|
|
+ const bool GenPostInst;
|
|
|
+ const std::string PostInst;
|
|
|
+ const bool GenPostRm;
|
|
|
+ const std::string PostRm;
|
|
|
+ const char* ControlExtra;
|
|
|
+ const bool PermissionStrictPolicy;
|
|
|
+ const std::vector<std::string> PackageFiles;
|
|
|
+ cmArchiveWrite::Compress TarCompressionType;
|
|
|
+};
|
|
|
+
|
|
|
+DebGenerator::DebGenerator(
|
|
|
+ cmCPackLog* logger, std::string const& outputName,
|
|
|
+ std::string const& workDir, std::string const& topLevelDir,
|
|
|
+ std::string const& temporaryDir, const char* debianCompressionType,
|
|
|
+ const char* debianArchiveType,
|
|
|
+ std::map<std::string, std::string> const& controlValues, bool genShLibs,
|
|
|
+ std::string const& shLibsFilename, bool genPostInst,
|
|
|
+ std::string const& postInst, bool genPostRm, std::string const& postRm,
|
|
|
+ const char* controlExtra, bool permissionStrictPolicy,
|
|
|
+ std::vector<std::string> const& packageFiles)
|
|
|
+ : Logger(logger)
|
|
|
+ , OutputName(outputName)
|
|
|
+ , WorkDir(workDir)
|
|
|
+ , TopLevelDir(topLevelDir)
|
|
|
+ , TemporaryDir(temporaryDir)
|
|
|
+ , DebianArchiveType(debianArchiveType ? debianArchiveType : "paxr")
|
|
|
+ , ControlValues(controlValues)
|
|
|
+ , GenShLibs(genShLibs)
|
|
|
+ , ShLibsFilename(shLibsFilename)
|
|
|
+ , GenPostInst(genPostInst)
|
|
|
+ , PostInst(postInst)
|
|
|
+ , GenPostRm(genPostRm)
|
|
|
+ , PostRm(postRm)
|
|
|
+ , ControlExtra(controlExtra)
|
|
|
+ , PermissionStrictPolicy(permissionStrictPolicy)
|
|
|
+ , PackageFiles(packageFiles)
|
|
|
+{
|
|
|
+ if (!debianCompressionType) {
|
|
|
+ debianCompressionType = "gzip";
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!strcmp(debianCompressionType, "lzma")) {
|
|
|
+ CompressionSuffix = ".lzma";
|
|
|
+ TarCompressionType = cmArchiveWrite::CompressLZMA;
|
|
|
+ } else if (!strcmp(debianCompressionType, "xz")) {
|
|
|
+ CompressionSuffix = ".xz";
|
|
|
+ TarCompressionType = cmArchiveWrite::CompressXZ;
|
|
|
+ } else if (!strcmp(debianCompressionType, "bzip2")) {
|
|
|
+ CompressionSuffix = ".bz2";
|
|
|
+ TarCompressionType = cmArchiveWrite::CompressBZip2;
|
|
|
+ } else if (!strcmp(debianCompressionType, "gzip")) {
|
|
|
+ CompressionSuffix = ".gz";
|
|
|
+ TarCompressionType = cmArchiveWrite::CompressGZip;
|
|
|
+ } else if (!strcmp(debianCompressionType, "none")) {
|
|
|
+ CompressionSuffix.clear();
|
|
|
+ TarCompressionType = cmArchiveWrite::CompressNone;
|
|
|
+ } else {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error unrecognized compression type: "
|
|
|
+ << debianCompressionType << std::endl);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool DebGenerator::generate() const
|
|
|
+{
|
|
|
+ generateDebianBinaryFile();
|
|
|
+ generateControlFile();
|
|
|
+ if (!generateDataTar()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ std::string md5Filename = generateMD5File();
|
|
|
+ if (!generateControlTar(md5Filename)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return generateDeb();
|
|
|
+}
|
|
|
+
|
|
|
+void DebGenerator::generateDebianBinaryFile() const
|
|
|
+{
|
|
|
+ // debian-binary file
|
|
|
+ const std::string dbfilename = WorkDir + "/debian-binary";
|
|
|
+ cmGeneratedFileStream out(dbfilename);
|
|
|
+ out << "2.0";
|
|
|
+ out << std::endl; // required for valid debian package
|
|
|
+}
|
|
|
+
|
|
|
+void DebGenerator::generateControlFile() const
|
|
|
+{
|
|
|
+ std::string ctlfilename = WorkDir + "/control";
|
|
|
+
|
|
|
+ cmGeneratedFileStream out(ctlfilename);
|
|
|
+ for (auto const& kv : ControlValues) {
|
|
|
+ out << kv.first << ": " << kv.second << "\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ unsigned long totalSize = 0;
|
|
|
+ {
|
|
|
+ std::string dirName = TemporaryDir;
|
|
|
+ dirName += '/';
|
|
|
+ for (std::string const& file : PackageFiles) {
|
|
|
+ totalSize += cmSystemTools::FileLength(file);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ out << "Installed-Size: " << (totalSize + 1023) / 1024 << "\n";
|
|
|
+ out << std::endl;
|
|
|
+}
|
|
|
+
|
|
|
+bool DebGenerator::generateDataTar() const
|
|
|
+{
|
|
|
+ std::string filename_data_tar = WorkDir + "/data.tar" + CompressionSuffix;
|
|
|
+ cmGeneratedFileStream fileStream_data_tar;
|
|
|
+ fileStream_data_tar.Open(filename_data_tar, false, true);
|
|
|
+ if (!fileStream_data_tar) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error opening the file \""
|
|
|
+ << filename_data_tar << "\" for writing" << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ cmArchiveWrite data_tar(fileStream_data_tar, TarCompressionType,
|
|
|
+ DebianArchiveType);
|
|
|
+
|
|
|
+ // uid/gid should be the one of the root user, and this root user has
|
|
|
+ // always uid/gid equal to 0.
|
|
|
+ data_tar.SetUIDAndGID(0u, 0u);
|
|
|
+ data_tar.SetUNAMEAndGNAME("root", "root");
|
|
|
+
|
|
|
+ // now add all directories which have to be compressed
|
|
|
+ // collect all top level install dirs for that
|
|
|
+ // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would
|
|
|
+ // give /usr and /opt
|
|
|
+ size_t topLevelLength = WorkDir.length();
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
+ "WDIR: \"" << WorkDir << "\", length = " << topLevelLength
|
|
|
+ << std::endl);
|
|
|
+ std::set<std::string> orderedFiles;
|
|
|
+
|
|
|
+ // we have to reconstruct the parent folders as well
|
|
|
+
|
|
|
+ for (std::string currentPath : PackageFiles) {
|
|
|
+ while (currentPath != WorkDir) {
|
|
|
+ // the last one IS WorkDir, but we do not want this one:
|
|
|
+ // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
|
|
|
+ // should not add XXX/application
|
|
|
+ orderedFiles.insert(currentPath);
|
|
|
+ currentPath = cmSystemTools::CollapseCombinedPath(currentPath, "..");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for (std::string const& file : orderedFiles) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
+ "FILEIT: \"" << file << "\"" << std::endl);
|
|
|
+ std::string::size_type slashPos = file.find('/', topLevelLength + 1);
|
|
|
+ std::string relativeDir =
|
|
|
+ file.substr(topLevelLength, slashPos - topLevelLength);
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
+ "RELATIVEDIR: \"" << relativeDir << "\"" << std::endl);
|
|
|
+
|
|
|
+#ifdef WIN32
|
|
|
+ std::string mode_t_adt_filename = file + ":cmake_mode_t";
|
|
|
+ cmsys::ifstream permissionStream(mode_t_adt_filename.c_str());
|
|
|
+
|
|
|
+ mode_t permissions = 0;
|
|
|
+
|
|
|
+ if (permissionStream) {
|
|
|
+ permissionStream >> std::oct >> permissions;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (permissions != 0) {
|
|
|
+ data_tar.SetPermissions(permissions);
|
|
|
+ } else if (cmSystemTools::FileIsDirectory(file)) {
|
|
|
+ data_tar.SetPermissions(0755);
|
|
|
+ } else {
|
|
|
+ data_tar.ClearPermissions();
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ // do not recurse because the loop will do it
|
|
|
+ if (!data_tar.Add(file, topLevelLength, ".", false)) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Problem adding file to tar:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << WorkDir << std::endl
|
|
|
+ << "#file: " << file << std::endl
|
|
|
+ << "#error:" << data_tar.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+std::string DebGenerator::generateMD5File() const
|
|
|
+{
|
|
|
+ std::string md5filename = WorkDir + "/md5sums";
|
|
|
+
|
|
|
+ cmGeneratedFileStream out(md5filename);
|
|
|
+
|
|
|
+ std::string topLevelWithTrailingSlash = TemporaryDir;
|
|
|
+ topLevelWithTrailingSlash += '/';
|
|
|
+ for (std::string const& file : PackageFiles) {
|
|
|
+ // hash only regular files
|
|
|
+ if (cmSystemTools::FileIsDirectory(file) ||
|
|
|
+ cmSystemTools::FileIsSymlink(file)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ std::string output =
|
|
|
+ cmSystemTools::ComputeFileHash(file, cmCryptoHash::AlgoMD5);
|
|
|
+ if (output.empty()) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Problem computing the md5 of " << file << std::endl);
|
|
|
+ }
|
|
|
+
|
|
|
+ output += " " + file + "\n";
|
|
|
+ // debian md5sums entries are like this:
|
|
|
+ // 014f3604694729f3bf19263bac599765 usr/bin/ccmake
|
|
|
+ // thus strip the full path (with the trailing slash)
|
|
|
+ cmSystemTools::ReplaceString(output, topLevelWithTrailingSlash.c_str(),
|
|
|
+ "");
|
|
|
+ out << output;
|
|
|
+ }
|
|
|
+ // each line contains a eol.
|
|
|
+ // Do not end the md5sum file with yet another (invalid)
|
|
|
+ return md5filename;
|
|
|
+}
|
|
|
+
|
|
|
+bool DebGenerator::generateControlTar(std::string const& md5Filename) const
|
|
|
+{
|
|
|
+ std::string filename_control_tar = WorkDir + "/control.tar.gz";
|
|
|
+
|
|
|
+ cmGeneratedFileStream fileStream_control_tar;
|
|
|
+ fileStream_control_tar.Open(filename_control_tar, false, true);
|
|
|
+ if (!fileStream_control_tar) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error opening the file \""
|
|
|
+ << filename_control_tar << "\" for writing" << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ cmArchiveWrite control_tar(fileStream_control_tar,
|
|
|
+ cmArchiveWrite::CompressGZip, DebianArchiveType);
|
|
|
+
|
|
|
+ // sets permissions and uid/gid for the files
|
|
|
+ control_tar.SetUIDAndGID(0u, 0u);
|
|
|
+ control_tar.SetUNAMEAndGNAME("root", "root");
|
|
|
+
|
|
|
+ /* permissions are set according to
|
|
|
+ https://www.debian.org/doc/debian-policy/ch-files.html#s-permissions-owners
|
|
|
+ and
|
|
|
+ https://lintian.debian.org/tags/control-file-has-bad-permissions.html
|
|
|
+ */
|
|
|
+ const mode_t permission644 = 0644;
|
|
|
+ const mode_t permissionExecute = 0111;
|
|
|
+ const mode_t permission755 = permission644 | permissionExecute;
|
|
|
+
|
|
|
+ // for md5sum and control (that we have generated here), we use 644
|
|
|
+ // (RW-R--R--)
|
|
|
+ // so that deb lintian doesn't warn about it
|
|
|
+ control_tar.SetPermissions(permission644);
|
|
|
+
|
|
|
+ // adds control and md5sums
|
|
|
+ if (!control_tar.Add(md5Filename, WorkDir.length(), ".") ||
|
|
|
+ !control_tar.Add(WorkDir + "/control", WorkDir.length(), ".")) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error adding file to tar:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << WorkDir << std::endl
|
|
|
+ << "#file: \"control\" or \"md5sums\"" << std::endl
|
|
|
+ << "#error:" << control_tar.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // adds generated shlibs file
|
|
|
+ if (GenShLibs) {
|
|
|
+ if (!control_tar.Add(ShLibsFilename, WorkDir.length(), ".")) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error adding file to tar:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << WorkDir << std::endl
|
|
|
+ << "#file: \"shlibs\"" << std::endl
|
|
|
+ << "#error:" << control_tar.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // adds LDCONFIG related files
|
|
|
+ if (GenPostInst) {
|
|
|
+ control_tar.SetPermissions(permission755);
|
|
|
+ if (!control_tar.Add(PostInst, WorkDir.length(), ".")) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error adding file to tar:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << WorkDir << std::endl
|
|
|
+ << "#file: \"postinst\"" << std::endl
|
|
|
+ << "#error:" << control_tar.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ control_tar.SetPermissions(permission644);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (GenPostRm) {
|
|
|
+ control_tar.SetPermissions(permission755);
|
|
|
+ if (!control_tar.Add(PostRm, WorkDir.length(), ".")) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error adding file to tar:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << WorkDir << std::endl
|
|
|
+ << "#file: \"postinst\"" << std::endl
|
|
|
+ << "#error:" << control_tar.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ control_tar.SetPermissions(permission644);
|
|
|
+ }
|
|
|
+
|
|
|
+ // for the other files, we use
|
|
|
+ // -either the original permission on the files
|
|
|
+ // -either a permission strictly defined by the Debian policies
|
|
|
+ if (ControlExtra) {
|
|
|
+ // permissions are now controlled by the original file permissions
|
|
|
+
|
|
|
+ static const char* strictFiles[] = { "config", "postinst", "postrm",
|
|
|
+ "preinst", "prerm" };
|
|
|
+ std::set<std::string> setStrictFiles(
|
|
|
+ strictFiles, strictFiles + sizeof(strictFiles) / sizeof(strictFiles[0]));
|
|
|
+
|
|
|
+ // default
|
|
|
+ control_tar.ClearPermissions();
|
|
|
+
|
|
|
+ std::vector<std::string> controlExtraList;
|
|
|
+ cmSystemTools::ExpandListArgument(ControlExtra, controlExtraList);
|
|
|
+ for (std::string const& i : controlExtraList) {
|
|
|
+ std::string filenamename = cmsys::SystemTools::GetFilenameName(i);
|
|
|
+ std::string localcopy = WorkDir + "/" + filenamename;
|
|
|
+
|
|
|
+ if (PermissionStrictPolicy) {
|
|
|
+ control_tar.SetPermissions(
|
|
|
+ setStrictFiles.count(filenamename) ? permission755 : permission644);
|
|
|
+ }
|
|
|
+
|
|
|
+ // if we can copy the file, it means it does exist, let's add it:
|
|
|
+ if (cmsys::SystemTools::CopyFileIfDifferent(i, localcopy)) {
|
|
|
+ control_tar.Add(localcopy, WorkDir.length(), ".");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+bool DebGenerator::generateDeb() const
|
|
|
+{
|
|
|
+ // ar -r your-package-name.deb debian-binary control.tar.* data.tar.*
|
|
|
+ // A debian package .deb is simply an 'ar' archive. The only subtle
|
|
|
+ // difference is that debian uses the BSD ar style archive whereas most
|
|
|
+ // Linux distro have a GNU ar.
|
|
|
+ // See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=161593 for more info
|
|
|
+ std::string const outputPath = TopLevelDir + "/" + OutputName;
|
|
|
+ std::string const tlDir = WorkDir + "/";
|
|
|
+ cmGeneratedFileStream debStream;
|
|
|
+ debStream.Open(outputPath, false, true);
|
|
|
+ cmArchiveWrite deb(debStream, cmArchiveWrite::CompressNone, "arbsd");
|
|
|
+
|
|
|
+ // uid/gid should be the one of the root user, and this root user has
|
|
|
+ // always uid/gid equal to 0.
|
|
|
+ deb.SetUIDAndGID(0u, 0u);
|
|
|
+ deb.SetUNAMEAndGNAME("root", "root");
|
|
|
+
|
|
|
+ if (!deb.Add(tlDir + "debian-binary", tlDir.length()) ||
|
|
|
+ !deb.Add(tlDir + "control.tar.gz", tlDir.length()) ||
|
|
|
+ !deb.Add(tlDir + "data.tar" + CompressionSuffix, tlDir.length())) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Error creating debian package:"
|
|
|
+ << std::endl
|
|
|
+ << "#top level directory: " << TopLevelDir << std::endl
|
|
|
+ << "#file: " << OutputName << std::endl
|
|
|
+ << "#error:" << deb.GetError() << std::endl);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+} // end anonymous namespace
|
|
|
+
|
|
|
cmCPackDebGenerator::cmCPackDebGenerator()
|
|
|
{
|
|
|
}
|
|
|
@@ -68,18 +487,20 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
|
|
|
return retval;
|
|
|
}
|
|
|
|
|
|
- cmsys::Glob gl;
|
|
|
- std::string findExpr(this->GetOption("GEN_WDIR"));
|
|
|
- findExpr += "/*";
|
|
|
- gl.RecurseOn();
|
|
|
- gl.SetRecurseListDirs(true);
|
|
|
- if (!gl.FindFiles(findExpr)) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Cannot find any files in the installed directory"
|
|
|
- << std::endl);
|
|
|
- return 0;
|
|
|
+ { // Isolate globbing of binaries vs. dbgsyms
|
|
|
+ cmsys::Glob gl;
|
|
|
+ std::string findExpr(this->GetOption("GEN_WDIR"));
|
|
|
+ findExpr += "/*";
|
|
|
+ gl.RecurseOn();
|
|
|
+ gl.SetRecurseListDirs(true);
|
|
|
+ if (!gl.FindFiles(findExpr)) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Cannot find any files in the installed directory"
|
|
|
+ << std::endl);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ packageFiles = gl.GetFiles();
|
|
|
}
|
|
|
- packageFiles = gl.GetFiles();
|
|
|
|
|
|
int res = createDeb();
|
|
|
if (res != 1) {
|
|
|
@@ -90,6 +511,32 @@ int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
|
|
|
packageFileName += "/";
|
|
|
packageFileName += this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
|
|
|
packageFileNames.push_back(std::move(packageFileName));
|
|
|
+
|
|
|
+ if (this->IsOn("GEN_CPACK_DEBIAN_DEBUGINFO_PACKAGE")) {
|
|
|
+ cmsys::Glob gl;
|
|
|
+ std::string findExpr(this->GetOption("GEN_DBGSYMDIR"));
|
|
|
+ findExpr += "/*";
|
|
|
+ gl.RecurseOn();
|
|
|
+ gl.SetRecurseListDirs(true);
|
|
|
+ if (!gl.FindFiles(findExpr)) {
|
|
|
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
+ "Cannot find any files in the installed directory"
|
|
|
+ << std::endl);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ packageFiles = gl.GetFiles();
|
|
|
+
|
|
|
+ res = createDbgsymDDeb();
|
|
|
+ if (res != 1) {
|
|
|
+ retval = 0;
|
|
|
+ }
|
|
|
+ // add the generated package to package file names list
|
|
|
+ packageFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
|
|
+ packageFileName += "/";
|
|
|
+ packageFileName += this->GetOption("GEN_CPACK_DBGSYM_OUTPUT_FILE_NAME");
|
|
|
+ packageFileNames.push_back(std::move(packageFileName));
|
|
|
+ }
|
|
|
+
|
|
|
return retval;
|
|
|
}
|
|
|
|
|
|
@@ -234,112 +681,81 @@ int cmCPackDebGenerator::PackageFiles()
|
|
|
|
|
|
int cmCPackDebGenerator::createDeb()
|
|
|
{
|
|
|
- // debian-binary file
|
|
|
- const std::string strGenWDIR(this->GetOption("GEN_WDIR"));
|
|
|
- const std::string dbfilename = strGenWDIR + "/debian-binary";
|
|
|
- { // the scope is needed for cmGeneratedFileStream
|
|
|
- cmGeneratedFileStream out(dbfilename);
|
|
|
- out << "2.0";
|
|
|
- out << std::endl; // required for valid debian package
|
|
|
- }
|
|
|
-
|
|
|
- // control file
|
|
|
- std::string ctlfilename = strGenWDIR + "/control";
|
|
|
+ std::map<std::string, std::string> controlValues;
|
|
|
|
|
|
// debian policy enforce lower case for package name
|
|
|
- // mandatory entries:
|
|
|
- std::string debian_pkg_name = cmsys::SystemTools::LowerCase(
|
|
|
+ controlValues["Package"] = cmsys::SystemTools::LowerCase(
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME"));
|
|
|
- const char* debian_pkg_version =
|
|
|
+ controlValues["Version"] =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
|
|
|
- const char* debian_pkg_section =
|
|
|
+ controlValues["Section"] =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SECTION");
|
|
|
- const char* debian_pkg_priority =
|
|
|
+ controlValues["Priority"] =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PRIORITY");
|
|
|
- const char* debian_pkg_arch =
|
|
|
+ controlValues["Architecture"] =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
|
|
|
- const char* maintainer =
|
|
|
+ controlValues["Maintainer"] =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
|
|
|
- const char* desc = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
|
|
|
+ controlValues["Description"] =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
|
|
|
|
|
|
- // optional entries
|
|
|
+ const char* debian_pkg_source =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
|
|
|
+ if (debian_pkg_source && *debian_pkg_source) {
|
|
|
+ controlValues["Source"] = debian_pkg_source;
|
|
|
+ }
|
|
|
const char* debian_pkg_dep =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DEPENDS");
|
|
|
+ if (debian_pkg_dep && *debian_pkg_dep) {
|
|
|
+ controlValues["Depends"] = debian_pkg_dep;
|
|
|
+ }
|
|
|
const char* debian_pkg_rec =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_RECOMMENDS");
|
|
|
+ if (debian_pkg_rec && *debian_pkg_rec) {
|
|
|
+ controlValues["Recommends"] = debian_pkg_rec;
|
|
|
+ }
|
|
|
const char* debian_pkg_sug =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SUGGESTS");
|
|
|
+ if (debian_pkg_sug && *debian_pkg_sug) {
|
|
|
+ controlValues["Suggests"] = debian_pkg_sug;
|
|
|
+ }
|
|
|
const char* debian_pkg_url =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_HOMEPAGE");
|
|
|
+ if (debian_pkg_url && *debian_pkg_url) {
|
|
|
+ controlValues["Homepage"] = debian_pkg_url;
|
|
|
+ }
|
|
|
const char* debian_pkg_predep =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PREDEPENDS");
|
|
|
+ if (debian_pkg_predep && *debian_pkg_predep) {
|
|
|
+ controlValues["Pre-Depends"] = debian_pkg_predep;
|
|
|
+ }
|
|
|
const char* debian_pkg_enhances =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ENHANCES");
|
|
|
+ if (debian_pkg_enhances && *debian_pkg_enhances) {
|
|
|
+ controlValues["Enhances"] = debian_pkg_enhances;
|
|
|
+ }
|
|
|
const char* debian_pkg_breaks =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_BREAKS");
|
|
|
+ if (debian_pkg_breaks && *debian_pkg_breaks) {
|
|
|
+ controlValues["Breaks"] = debian_pkg_breaks;
|
|
|
+ }
|
|
|
const char* debian_pkg_conflicts =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONFLICTS");
|
|
|
+ if (debian_pkg_conflicts && *debian_pkg_conflicts) {
|
|
|
+ controlValues["Conflicts"] = debian_pkg_conflicts;
|
|
|
+ }
|
|
|
const char* debian_pkg_provides =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PROVIDES");
|
|
|
+ if (debian_pkg_provides && *debian_pkg_provides) {
|
|
|
+ controlValues["Provides"] = debian_pkg_provides;
|
|
|
+ }
|
|
|
const char* debian_pkg_replaces =
|
|
|
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_REPLACES");
|
|
|
- const char* debian_pkg_source =
|
|
|
- this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
|
|
|
-
|
|
|
- { // the scope is needed for cmGeneratedFileStream
|
|
|
- cmGeneratedFileStream out(ctlfilename);
|
|
|
- out << "Package: " << debian_pkg_name << "\n";
|
|
|
- out << "Version: " << debian_pkg_version << "\n";
|
|
|
- out << "Section: " << debian_pkg_section << "\n";
|
|
|
- out << "Priority: " << debian_pkg_priority << "\n";
|
|
|
- out << "Architecture: " << debian_pkg_arch << "\n";
|
|
|
- if (debian_pkg_source && *debian_pkg_source) {
|
|
|
- out << "Source: " << debian_pkg_source << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_dep && *debian_pkg_dep) {
|
|
|
- out << "Depends: " << debian_pkg_dep << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_rec && *debian_pkg_rec) {
|
|
|
- out << "Recommends: " << debian_pkg_rec << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_sug && *debian_pkg_sug) {
|
|
|
- out << "Suggests: " << debian_pkg_sug << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_url && *debian_pkg_url) {
|
|
|
- out << "Homepage: " << debian_pkg_url << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_predep && *debian_pkg_predep) {
|
|
|
- out << "Pre-Depends: " << debian_pkg_predep << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_enhances && *debian_pkg_enhances) {
|
|
|
- out << "Enhances: " << debian_pkg_enhances << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_breaks && *debian_pkg_breaks) {
|
|
|
- out << "Breaks: " << debian_pkg_breaks << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_conflicts && *debian_pkg_conflicts) {
|
|
|
- out << "Conflicts: " << debian_pkg_conflicts << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_provides && *debian_pkg_provides) {
|
|
|
- out << "Provides: " << debian_pkg_provides << "\n";
|
|
|
- }
|
|
|
- if (debian_pkg_replaces && *debian_pkg_replaces) {
|
|
|
- out << "Replaces: " << debian_pkg_replaces << "\n";
|
|
|
- }
|
|
|
- unsigned long totalSize = 0;
|
|
|
- {
|
|
|
- std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
|
|
|
- dirName += '/';
|
|
|
- for (std::string const& file : packageFiles) {
|
|
|
- totalSize += cmSystemTools::FileLength(file);
|
|
|
- }
|
|
|
- }
|
|
|
- out << "Installed-Size: " << (totalSize + 1023) / 1024 << "\n";
|
|
|
- out << "Maintainer: " << maintainer << "\n";
|
|
|
- out << "Description: " << desc << "\n";
|
|
|
- out << std::endl;
|
|
|
+ if (debian_pkg_replaces && *debian_pkg_replaces) {
|
|
|
+ controlValues["Replaces"] = debian_pkg_replaces;
|
|
|
}
|
|
|
|
|
|
+ const std::string strGenWDIR(this->GetOption("GEN_WDIR"));
|
|
|
const std::string shlibsfilename = strGenWDIR + "/shlibs";
|
|
|
|
|
|
const char* debian_pkg_shlibs =
|
|
|
@@ -371,314 +787,74 @@ int cmCPackDebGenerator::createDeb()
|
|
|
"fi\n";
|
|
|
}
|
|
|
|
|
|
- cmArchiveWrite::Compress tar_compression_type = cmArchiveWrite::CompressGZip;
|
|
|
- const char* debian_compression_type =
|
|
|
- this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE");
|
|
|
- if (!debian_compression_type) {
|
|
|
- debian_compression_type = "gzip";
|
|
|
- }
|
|
|
-
|
|
|
- std::string compression_suffix;
|
|
|
- if (!strcmp(debian_compression_type, "lzma")) {
|
|
|
- compression_suffix = ".lzma";
|
|
|
- tar_compression_type = cmArchiveWrite::CompressLZMA;
|
|
|
- } else if (!strcmp(debian_compression_type, "xz")) {
|
|
|
- compression_suffix = ".xz";
|
|
|
- tar_compression_type = cmArchiveWrite::CompressXZ;
|
|
|
- } else if (!strcmp(debian_compression_type, "bzip2")) {
|
|
|
- compression_suffix = ".bz2";
|
|
|
- tar_compression_type = cmArchiveWrite::CompressBZip2;
|
|
|
- } else if (!strcmp(debian_compression_type, "gzip")) {
|
|
|
- compression_suffix = ".gz";
|
|
|
- tar_compression_type = cmArchiveWrite::CompressGZip;
|
|
|
- } else if (!strcmp(debian_compression_type, "none")) {
|
|
|
- compression_suffix.clear();
|
|
|
- tar_compression_type = cmArchiveWrite::CompressNone;
|
|
|
- } else {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error unrecognized compression type: "
|
|
|
- << debian_compression_type << std::endl);
|
|
|
- }
|
|
|
-
|
|
|
- const char* debian_archive_type =
|
|
|
- this->GetOption("GEN_CPACK_DEBIAN_ARCHIVE_TYPE");
|
|
|
- if (!debian_archive_type) {
|
|
|
- debian_archive_type = "paxr";
|
|
|
+ DebGenerator gen(
|
|
|
+ Logger, this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME"), strGenWDIR,
|
|
|
+ this->GetOption("CPACK_TOPLEVEL_DIRECTORY"),
|
|
|
+ this->GetOption("CPACK_TEMPORARY_DIRECTORY"),
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE"),
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_ARCHIVE_TYPE"), controlValues, gen_shibs,
|
|
|
+ shlibsfilename, this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST"), postinst,
|
|
|
+ this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"), postrm,
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA"),
|
|
|
+ this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION"),
|
|
|
+ packageFiles);
|
|
|
+
|
|
|
+ if (!gen.generate()) {
|
|
|
+ return 0;
|
|
|
}
|
|
|
+ return 1;
|
|
|
+}
|
|
|
|
|
|
- std::string filename_data_tar =
|
|
|
- strGenWDIR + "/data.tar" + compression_suffix;
|
|
|
-
|
|
|
- // atomic file generation for data.tar
|
|
|
- {
|
|
|
- cmGeneratedFileStream fileStream_data_tar;
|
|
|
- fileStream_data_tar.Open(filename_data_tar, false, true);
|
|
|
- if (!fileStream_data_tar) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error opening the file \""
|
|
|
- << filename_data_tar << "\" for writing" << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- cmArchiveWrite data_tar(fileStream_data_tar, tar_compression_type,
|
|
|
- debian_archive_type);
|
|
|
-
|
|
|
- // uid/gid should be the one of the root user, and this root user has
|
|
|
- // always uid/gid equal to 0.
|
|
|
- data_tar.SetUIDAndGID(0u, 0u);
|
|
|
- data_tar.SetUNAMEAndGNAME("root", "root");
|
|
|
-
|
|
|
- // now add all directories which have to be compressed
|
|
|
- // collect all top level install dirs for that
|
|
|
- // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would
|
|
|
- // give /usr and /opt
|
|
|
- size_t topLevelLength = strGenWDIR.length();
|
|
|
- cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
- "WDIR: \"" << strGenWDIR << "\", length = " << topLevelLength
|
|
|
- << std::endl);
|
|
|
- std::set<std::string> orderedFiles;
|
|
|
-
|
|
|
- // we have to reconstruct the parent folders as well
|
|
|
-
|
|
|
- for (std::string currentPath : packageFiles) {
|
|
|
- while (currentPath != strGenWDIR) {
|
|
|
- // the last one IS strGenWDIR, but we do not want this one:
|
|
|
- // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
|
|
|
- // should not add XXX/application
|
|
|
- orderedFiles.insert(currentPath);
|
|
|
- currentPath = cmSystemTools::CollapseCombinedPath(currentPath, "..");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for (std::string const& file : orderedFiles) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
- "FILEIT: \"" << file << "\"" << std::endl);
|
|
|
- std::string::size_type slashPos = file.find('/', topLevelLength + 1);
|
|
|
- std::string relativeDir =
|
|
|
- file.substr(topLevelLength, slashPos - topLevelLength);
|
|
|
- cmCPackLogger(cmCPackLog::LOG_DEBUG,
|
|
|
- "RELATIVEDIR: \"" << relativeDir << "\"" << std::endl);
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
- std::string mode_t_adt_filename = file + ":cmake_mode_t";
|
|
|
- cmsys::ifstream permissionStream(mode_t_adt_filename.c_str());
|
|
|
-
|
|
|
- mode_t permissions = 0;
|
|
|
-
|
|
|
- if (permissionStream) {
|
|
|
- permissionStream >> std::oct >> permissions;
|
|
|
- }
|
|
|
-
|
|
|
- if (permissions != 0) {
|
|
|
- data_tar.SetPermissions(permissions);
|
|
|
- } else if (cmSystemTools::FileIsDirectory(file)) {
|
|
|
- data_tar.SetPermissions(0755);
|
|
|
- } else {
|
|
|
- data_tar.ClearPermissions();
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- // do not recurse because the loop will do it
|
|
|
- if (!data_tar.Add(file, topLevelLength, ".", false)) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Problem adding file to tar:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << strGenWDIR << std::endl
|
|
|
- << "#file: " << file << std::endl
|
|
|
- << "#error:" << data_tar.GetError() << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- } // scope for file generation
|
|
|
+int cmCPackDebGenerator::createDbgsymDDeb()
|
|
|
+{
|
|
|
+ // Packages containing debug symbols follow the same structure as .debs
|
|
|
+ // but have different metadata and content.
|
|
|
|
|
|
- std::string md5filename = strGenWDIR + "/md5sums";
|
|
|
- {
|
|
|
- // the scope is needed for cmGeneratedFileStream
|
|
|
- cmGeneratedFileStream out(md5filename);
|
|
|
-
|
|
|
- std::string topLevelWithTrailingSlash =
|
|
|
- this->GetOption("CPACK_TEMPORARY_DIRECTORY");
|
|
|
- topLevelWithTrailingSlash += '/';
|
|
|
- for (std::string const& file : packageFiles) {
|
|
|
- // hash only regular files
|
|
|
- if (cmSystemTools::FileIsDirectory(file) ||
|
|
|
- cmSystemTools::FileIsSymlink(file)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
+ std::map<std::string, std::string> controlValues;
|
|
|
+ // debian policy enforce lower case for package name
|
|
|
+ std::string packageNameLower = cmsys::SystemTools::LowerCase(
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME"));
|
|
|
+ const char* debian_pkg_version =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
|
|
|
|
|
|
- std::string output =
|
|
|
- cmSystemTools::ComputeFileHash(file, cmCryptoHash::AlgoMD5);
|
|
|
- if (output.empty()) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Problem computing the md5 of " << file << std::endl);
|
|
|
- }
|
|
|
+ controlValues["Package"] = packageNameLower + "-dbgsym";
|
|
|
+ controlValues["Package-Type"] = "ddeb";
|
|
|
+ controlValues["Version"] = debian_pkg_version;
|
|
|
+ controlValues["Auto-Built-Package"] = "debug-symbols";
|
|
|
+ controlValues["Depends"] = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME") +
|
|
|
+ std::string(" (= ") + debian_pkg_version + ")";
|
|
|
+ controlValues["Section"] = "debug";
|
|
|
+ controlValues["Priority"] = "optional";
|
|
|
+ controlValues["Architecture"] =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
|
|
|
+ controlValues["Maintainer"] =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
|
|
|
+ controlValues["Description"] =
|
|
|
+ std::string("debug symbols for ") + packageNameLower;
|
|
|
|
|
|
- output += " " + file + "\n";
|
|
|
- // debian md5sums entries are like this:
|
|
|
- // 014f3604694729f3bf19263bac599765 usr/bin/ccmake
|
|
|
- // thus strip the full path (with the trailing slash)
|
|
|
- cmSystemTools::ReplaceString(output, topLevelWithTrailingSlash.c_str(),
|
|
|
- "");
|
|
|
- out << output;
|
|
|
- }
|
|
|
- // each line contains a eol.
|
|
|
- // Do not end the md5sum file with yet another (invalid)
|
|
|
+ const char* debian_pkg_source =
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
|
|
|
+ if (debian_pkg_source && *debian_pkg_source) {
|
|
|
+ controlValues["Source"] = debian_pkg_source;
|
|
|
}
|
|
|
-
|
|
|
- std::string filename_control_tar = strGenWDIR + "/control.tar.gz";
|
|
|
- // atomic file generation for control.tar
|
|
|
- {
|
|
|
- cmGeneratedFileStream fileStream_control_tar;
|
|
|
- fileStream_control_tar.Open(filename_control_tar, false, true);
|
|
|
- if (!fileStream_control_tar) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error opening the file \"" << filename_control_tar
|
|
|
- << "\" for writing"
|
|
|
- << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- cmArchiveWrite control_tar(fileStream_control_tar,
|
|
|
- cmArchiveWrite::CompressGZip,
|
|
|
- debian_archive_type);
|
|
|
-
|
|
|
- // sets permissions and uid/gid for the files
|
|
|
- control_tar.SetUIDAndGID(0u, 0u);
|
|
|
- control_tar.SetUNAMEAndGNAME("root", "root");
|
|
|
-
|
|
|
- /* permissions are set according to
|
|
|
- https://www.debian.org/doc/debian-policy/ch-files.html#s-permissions-owners
|
|
|
- and
|
|
|
- https://lintian.debian.org/tags/control-file-has-bad-permissions.html
|
|
|
- */
|
|
|
- const mode_t permission644 = 0644;
|
|
|
- const mode_t permissionExecute = 0111;
|
|
|
- const mode_t permission755 = permission644 | permissionExecute;
|
|
|
-
|
|
|
- // for md5sum and control (that we have generated here), we use 644
|
|
|
- // (RW-R--R--)
|
|
|
- // so that deb lintian doesn't warn about it
|
|
|
- control_tar.SetPermissions(permission644);
|
|
|
-
|
|
|
- // adds control and md5sums
|
|
|
- if (!control_tar.Add(md5filename, strGenWDIR.length(), ".") ||
|
|
|
- !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), ".")) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error adding file to tar:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << strGenWDIR << std::endl
|
|
|
- << "#file: \"control\" or \"md5sums\"" << std::endl
|
|
|
- << "#error:" << control_tar.GetError() << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- // adds generated shlibs file
|
|
|
- if (gen_shibs) {
|
|
|
- if (!control_tar.Add(shlibsfilename, strGenWDIR.length(), ".")) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error adding file to tar:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << strGenWDIR << std::endl
|
|
|
- << "#file: \"shlibs\"" << std::endl
|
|
|
- << "#error:" << control_tar.GetError() << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // adds LDCONFIG related files
|
|
|
- if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
|
|
|
- control_tar.SetPermissions(permission755);
|
|
|
- if (!control_tar.Add(postinst, strGenWDIR.length(), ".")) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error adding file to tar:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << strGenWDIR << std::endl
|
|
|
- << "#file: \"postinst\"" << std::endl
|
|
|
- << "#error:" << control_tar.GetError() << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- control_tar.SetPermissions(permission644);
|
|
|
- }
|
|
|
-
|
|
|
- if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
|
|
|
- control_tar.SetPermissions(permission755);
|
|
|
- if (!control_tar.Add(postrm, strGenWDIR.length(), ".")) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error adding file to tar:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << strGenWDIR << std::endl
|
|
|
- << "#file: \"postinst\"" << std::endl
|
|
|
- << "#error:" << control_tar.GetError() << std::endl);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- control_tar.SetPermissions(permission644);
|
|
|
- }
|
|
|
-
|
|
|
- // for the other files, we use
|
|
|
- // -either the original permission on the files
|
|
|
- // -either a permission strictly defined by the Debian policies
|
|
|
- const char* controlExtra =
|
|
|
- this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA");
|
|
|
- if (controlExtra) {
|
|
|
- // permissions are now controlled by the original file permissions
|
|
|
-
|
|
|
- const bool permissionStrictPolicy =
|
|
|
- this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION");
|
|
|
-
|
|
|
- static const char* strictFiles[] = { "config", "postinst", "postrm",
|
|
|
- "preinst", "prerm" };
|
|
|
- std::set<std::string> setStrictFiles(
|
|
|
- strictFiles,
|
|
|
- strictFiles + sizeof(strictFiles) / sizeof(strictFiles[0]));
|
|
|
-
|
|
|
- // default
|
|
|
- control_tar.ClearPermissions();
|
|
|
-
|
|
|
- std::vector<std::string> controlExtraList;
|
|
|
- cmSystemTools::ExpandListArgument(controlExtra, controlExtraList);
|
|
|
- for (std::string const& i : controlExtraList) {
|
|
|
- std::string filenamename = cmsys::SystemTools::GetFilenameName(i);
|
|
|
- std::string localcopy = strGenWDIR + "/" + filenamename;
|
|
|
-
|
|
|
- if (permissionStrictPolicy) {
|
|
|
- control_tar.SetPermissions(setStrictFiles.count(filenamename)
|
|
|
- ? permission755
|
|
|
- : permission644);
|
|
|
- }
|
|
|
-
|
|
|
- // if we can copy the file, it means it does exist, let's add it:
|
|
|
- if (cmsys::SystemTools::CopyFileIfDifferent(i, localcopy)) {
|
|
|
- control_tar.Add(localcopy, strGenWDIR.length(), ".");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
+ const char* debian_build_ids = this->GetOption("GEN_BUILD_IDS");
|
|
|
+ if (debian_build_ids && *debian_build_ids) {
|
|
|
+ controlValues["Build-Ids"] = debian_build_ids;
|
|
|
}
|
|
|
|
|
|
- // ar -r your-package-name.deb debian-binary control.tar.* data.tar.*
|
|
|
- // A debian package .deb is simply an 'ar' archive. The only subtle
|
|
|
- // difference is that debian uses the BSD ar style archive whereas most
|
|
|
- // Linux distro have a GNU ar.
|
|
|
- // See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=161593 for more info
|
|
|
- std::string const outputDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
|
|
- std::string const outputName = this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
|
|
|
- std::string const outputPath = outputDir + "/" + outputName;
|
|
|
- std::string const tlDir = strGenWDIR + "/";
|
|
|
- cmGeneratedFileStream debStream;
|
|
|
- debStream.Open(outputPath, false, true);
|
|
|
- cmArchiveWrite deb(debStream, cmArchiveWrite::CompressNone, "arbsd");
|
|
|
+ DebGenerator gen(
|
|
|
+ Logger, this->GetOption("GEN_CPACK_DBGSYM_OUTPUT_FILE_NAME"),
|
|
|
+ this->GetOption("GEN_DBGSYMDIR"),
|
|
|
|
|
|
- // uid/gid should be the one of the root user, and this root user has
|
|
|
- // always uid/gid equal to 0.
|
|
|
- deb.SetUIDAndGID(0u, 0u);
|
|
|
- deb.SetUNAMEAndGNAME("root", "root");
|
|
|
+ this->GetOption("CPACK_TOPLEVEL_DIRECTORY"),
|
|
|
+ this->GetOption("CPACK_TEMPORARY_DIRECTORY"),
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE"),
|
|
|
+ this->GetOption("GEN_CPACK_DEBIAN_ARCHIVE_TYPE"), controlValues, false, "",
|
|
|
+ false, "", false, "", nullptr,
|
|
|
+ this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION"),
|
|
|
+ packageFiles);
|
|
|
|
|
|
- if (!deb.Add(tlDir + "debian-binary", tlDir.length()) ||
|
|
|
- !deb.Add(tlDir + "control.tar.gz", tlDir.length()) ||
|
|
|
- !deb.Add(tlDir + "data.tar" + compression_suffix, tlDir.length())) {
|
|
|
- cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
|
- "Error creating debian package:"
|
|
|
- << std::endl
|
|
|
- << "#top level directory: " << outputDir << std::endl
|
|
|
- << "#file: " << outputName << std::endl
|
|
|
- << "#error:" << deb.GetError() << std::endl);
|
|
|
+ if (!gen.generate()) {
|
|
|
return 0;
|
|
|
}
|
|
|
return 1;
|
Andrew Fuller