ExecGPGV: Fork in all cases

[apt.git] / apt-pkg / contrib / gpgv.cc

diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc
index 5921d7c67cd5f4929b96b988d1db456e00017d09..4247a1562073e983901cb997ba28d641810b3c51 100644 (file)
--- a/apt-pkg/contrib/gpgv.cc
+++ b/apt-pkg/contrib/gpgv.cc
@@ -2,83 +2,83 @@
 // Include Files                                                       /*{{{*/
 #include<config.h>
 
 // Include Files                                                       /*{{{*/
 #include<config.h>
 

+#include<apt-pkg/configuration.h>
+#include<apt-pkg/error.h>
+#include<apt-pkg/strutl.h>
+#include<apt-pkg/fileutl.h>
+#include<apt-pkg/gpgv.h>
+

 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <fcntl.h>

-#include <sys/stat.h>
-#include <sys/types.h>

 #include <sys/wait.h>
 #include <sys/wait.h>

+#include <unistd.h>
+#include <stddef.h>

 
 

-#include<apt-pkg/configuration.h>
-#include<apt-pkg/error.h>
-#include<apt-pkg/strutl.h>
-#include<apt-pkg/fileutl.h>
-#include<apt-pkg/gpgv.h>
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/

-char * GenerateTemporaryFileTemplate(const char *basename)             /*{{{*/
+static char * GenerateTemporaryFileTemplate(const char *basename)      /*{{{*/

 {
 {

-   const char *tmpdir = getenv("TMPDIR");
-#ifdef P_tmpdir
-   if (!tmpdir)
-      tmpdir = P_tmpdir;
-#endif
-   if (!tmpdir)
-      tmpdir = "/tmp";
-

    std::string out;
    std::string out;

-   strprintf(out,  "%s/%s.XXXXXX", tmpdir, basename);
+   std::string tmpdir = GetTempDir();
+   strprintf(out,  "%s/%s.XXXXXX", tmpdir.c_str(), basename);

    return strdup(out.c_str());
 }
                                                                        /*}}}*/
 // ExecGPGV - returns the command needed for verify                    /*{{{*/
 // ---------------------------------------------------------------------
    return strdup(out.c_str());
 }
                                                                        /*}}}*/
 // ExecGPGV - returns the command needed for verify                    /*{{{*/
 // ---------------------------------------------------------------------

-/* Generating the commandline for calling gpgv is somehow complicated as
+/* Generating the commandline for calling gpg is somehow complicated as

    we need to add multiple keyrings and user supplied options.
    we need to add multiple keyrings and user supplied options.

-   Also, as gpgv has no options to enforce a certain reduced style of
+   Also, as gpg has no options to enforce a certain reduced style of

    clear-signed files (=the complete content of the file is signed and
    the content isn't encoded) we do a divide and conquer approach here
    clear-signed files (=the complete content of the file is signed and
    the content isn't encoded) we do a divide and conquer approach here

+   and split up the clear-signed file in message and signature for gpg.
+   And as a cherry on the cake, we use our apt-key wrapper to do part
+   of the lifting in regards to merging keyrings. Fun for the whole family.

 */
 void ExecGPGV(std::string const &File, std::string const &FileGPG,
 */
 void ExecGPGV(std::string const &File, std::string const &FileGPG,

-             int const &statusfd, int fd[2])
+             int const &statusfd, int fd[2], std::string const &key)

 {
    #define EINTERNAL 111
 {
    #define EINTERNAL 111

-   std::string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv");
-   // FIXME: remove support for deprecated APT::GPGV setting
-   std::string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted"));
-   std::string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts");
+   std::string const aptkey = _config->Find("Dir::Bin::apt-key", "/usr/bin/apt-key");

 
    bool const Debug = _config->FindB("Debug::Acquire::gpgv", false);
 
    bool const Debug = _config->FindB("Debug::Acquire::gpgv", false);

+   struct exiter {
+      std::vector<const char *> files;
+      void operator ()(int code) APT_NORETURN {
+        std::for_each(files.begin(), files.end(), unlink);
+        exit(code);
+      }
+   } local_exit;

 
 

-   if (Debug == true)
-   {
-      std::clog << "gpgv path: " << gpgvpath << std::endl;
-      std::clog << "Keyring file: " << trustedFile << std::endl;
-      std::clog << "Keyring path: " << trustedPath << std::endl;
-   }
-
-   std::vector<std::string> keyrings;
-   if (DirectoryExists(trustedPath))
-     keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true);
-   if (RealFileExists(trustedFile) == true)
-     keyrings.push_back(trustedFile);

 
    std::vector<const char *> Args;
 
    std::vector<const char *> Args;

-   Args.reserve(30);
+   Args.reserve(10);

 
 

-   if (keyrings.empty() == true)
+   Args.push_back(aptkey.c_str());
+   Args.push_back("--quiet");
+   Args.push_back("--readonly");
+   if (key.empty() == false)

    {
    {

-      // TRANSLATOR: %s is the trusted keyring parts directory
-      ioprintf(std::cerr, _("No keyring installed in %s."),
-           _config->FindDir("Dir::Etc::TrustedParts").c_str());
-      exit(EINTERNAL);
+      if (key[0] == '/')
+      {
+        Args.push_back("--keyring");
+        Args.push_back(key.c_str());
+      }
+      else
+      {
+        Args.push_back("--keyid");
+        Args.push_back(key.c_str());
+      }

    }
    }

-
-   Args.push_back(gpgvpath.c_str());
-   Args.push_back("--ignore-time-conflict");
+   Args.push_back("verify");

 
    char statusfdstr[10];
    if (statusfd != -1)
 
    char statusfdstr[10];
    if (statusfd != -1)


@@ -88,13 +88,6 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       Args.push_back(statusfdstr);
    }
 
       Args.push_back(statusfdstr);
    }
 

-   for (std::vector<std::string>::const_iterator K = keyrings.begin();
-       K != keyrings.end(); ++K)
-   {
-      Args.push_back("--keyring");
-      Args.push_back(K->c_str());
-   }
-

    Configuration::Item const *Opts;
    Opts = _config->Tree("Acquire::gpgv::Options");
    if (Opts != 0)
    Configuration::Item const *Opts;
    Opts = _config->Tree("Acquire::gpgv::Options");
    if (Opts != 0)


@@ -108,14 +101,12 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       }
    }
 
       }
    }
 

-   int sigFd = -1;
-   int dataFd = -1;
+   enum  { DETACHED, CLEARSIGNED } releaseSignature = (FileGPG != File) ? DETACHED : CLEARSIGNED;

    std::vector<std::string> dataHeader;
    char * sig = NULL;
    char * data = NULL;
 
    std::vector<std::string> dataHeader;
    char * sig = NULL;
    char * data = NULL;
 

-   // file with detached signature
-   if (FileGPG != File)
+   if (releaseSignature == DETACHED)

    {
       Args.push_back(FileGPG.c_str());
       Args.push_back(File.c_str());
    {
       Args.push_back(FileGPG.c_str());
       Args.push_back(File.c_str());


@@ -125,28 +116,34 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       sig = GenerateTemporaryFileTemplate("apt.sig");
       data = GenerateTemporaryFileTemplate("apt.data");
       if (sig == NULL || data == NULL)
       sig = GenerateTemporaryFileTemplate("apt.sig");
       data = GenerateTemporaryFileTemplate("apt.data");
       if (sig == NULL || data == NULL)

+      {
+        ioprintf(std::cerr, "Couldn't create tempfile names for splitting up %s", File.c_str());
+        local_exit(EINTERNAL);
+      }
+
+      int const sigFd = mkstemp(sig);
+      int const dataFd = mkstemp(data);
+      if (dataFd != -1)
+        local_exit.files.push_back(data);
+      if (sigFd != -1)
+        local_exit.files.push_back(sig);
+      if (sigFd == -1 || dataFd == -1)

       {
         ioprintf(std::cerr, "Couldn't create tempfiles for splitting up %s", File.c_str());
       {
         ioprintf(std::cerr, "Couldn't create tempfiles for splitting up %s", File.c_str());

-        exit(EINTERNAL);
+        local_exit(EINTERNAL);

       }
 
       }
 

-      sigFd = mkstemp(sig);
-      dataFd = mkstemp(data);
-      int const duppedSigFd = dup(sigFd);
-      int const duppedDataFd = dup(dataFd);
+      FileFd signature;
+      signature.OpenDescriptor(sigFd, FileFd::WriteOnly, true);
+      FileFd message;
+      message.OpenDescriptor(dataFd, FileFd::WriteOnly, true);

 
 

-      if (dataFd == -1 || sigFd == -1 || duppedDataFd == -1 || duppedSigFd == -1 ||
-           SplitClearSignedFile(File, duppedDataFd, &dataHeader, duppedSigFd) == false)
+      if (signature.Failed() == true || message.Failed() == true ||
+           SplitClearSignedFile(File, &message, &dataHeader, &signature) == false)

       {
       {

-        if (dataFd != -1)
-           unlink(sig);
-        if (sigFd != -1)
-           unlink(data);

         ioprintf(std::cerr, "Splitting up %s into data and signature failed", File.c_str());
         ioprintf(std::cerr, "Splitting up %s into data and signature failed", File.c_str());

-        exit(EINTERNAL);
+        local_exit(112);

       }
       }

-      lseek(dataFd, 0, SEEK_SET);
-      lseek(sigFd, 0, SEEK_SET);

       Args.push_back(sig);
       Args.push_back(data);
    }
       Args.push_back(sig);
       Args.push_back(data);
    }


@@ -155,7 +152,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
 
    if (Debug == true)
    {
 
    if (Debug == true)
    {

-      std::clog << "Preparing to exec: " << gpgvpath;
+      std::clog << "Preparing to exec: ";

       for (std::vector<const char *>::const_iterator a = Args.begin(); *a != NULL; ++a)
         std::clog << " " << *a;
       std::clog << std::endl;
       for (std::vector<const char *>::const_iterator a = Args.begin(); *a != NULL; ++a)
         std::clog << " " << *a;
       std::clog << std::endl;


@@ -163,7 +160,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
 
    if (statusfd != -1)
    {
 
    if (statusfd != -1)
    {

-      int const nullfd = open("/dev/null", O_RDONLY);
+      int const nullfd = open("/dev/null", O_WRONLY);

       close(fd[0]);
       // Redirect output to /dev/null; we read from the status fd
       if (statusfd != STDOUT_FILENO)
       close(fd[0]);
       // Redirect output to /dev/null; we read from the status fd
       if (statusfd != STDOUT_FILENO)


@@ -178,140 +175,59 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       putenv((char *)"LC_MESSAGES=");
    }
 
       putenv((char *)"LC_MESSAGES=");
    }
 

-   if (FileGPG != File)
+
+   // We have created tempfiles we have to clean up
+   // and we do an additional check, so fork yet another time …
+   pid_t pid = ExecFork();
+   if(pid < 0) {
+      ioprintf(std::cerr, "Fork failed for %s to check %s", Args[0], File.c_str());
+      local_exit(EINTERNAL);
+   }
+   if(pid == 0)

    {
    {

-      execvp(gpgvpath.c_str(), (char **) &Args[0]);
+      if (statusfd != -1)
+        dup2(fd[1], statusfd);
+      execvp(Args[0], (char **) &Args[0]);

       ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str());
       ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str());

-      exit(EINTERNAL);
+      local_exit(EINTERNAL);

    }
    }

-   else
-   {
-//#define UNLINK_EXIT(X) exit(X)
-#define UNLINK_EXIT(X) unlink(sig);unlink(data);exit(X)
-
-      // for clear-signed files we have created tempfiles we have to clean up
-      // and we do an additional check, so fork yet another time …
-      pid_t pid = ExecFork();
-      if(pid < 0) {
-        ioprintf(std::cerr, "Fork failed for %s to check %s", Args[0], File.c_str());
-        UNLINK_EXIT(EINTERNAL);
-      }
-      if(pid == 0)
-      {
-        if (statusfd != -1)
-           dup2(fd[1], statusfd);
-        execvp(gpgvpath.c_str(), (char **) &Args[0]);
-        ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str());
-        UNLINK_EXIT(EINTERNAL);
-      }
-
-      // Wait and collect the error code - taken from WaitPid as we need the exact Status
-      int Status;
-      while (waitpid(pid,&Status,0) != pid)
-      {
-        if (errno == EINTR)
-           continue;
-        ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "gpgv");
-        UNLINK_EXIT(EINTERNAL);
-      }
-#undef UNLINK_EXIT
-      // we don't need the files any longer as we have the filedescriptors still open
-      unlink(sig);
-      unlink(data);
-      free(sig);
-      free(data);
-
-      // check if it exit'ed normally …
-      if (WIFEXITED(Status) == false)
-      {
-        ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "gpgv");
-        exit(EINTERNAL);
-      }
-
-      // … and with a good exit code
-      if (WEXITSTATUS(Status) != 0)
-      {
-        ioprintf(std::cerr, _("Sub-process %s returned an error code (%u)"), "gpgv", WEXITSTATUS(Status));
-        exit(WEXITSTATUS(Status));
-      }

 
 

-      /* looks like its fine. Our caller will check the status fd,
-        but we construct a good-known clear-signed file without garbage
-        and other non-sense. In a perfect world, we get the same file,
-        but empty lines, trailing whitespaces and stuff makes it inperfect … */
-      if (RecombineToClearSignedFile(File, dataFd, dataHeader, sigFd) == false)
-      {
-        _error->DumpErrors(std::cerr);
-        exit(EINTERNAL);
-      }
+   // Wait and collect the error code - taken from WaitPid as we need the exact Status
+   int Status;
+   while (waitpid(pid,&Status,0) != pid)
+   {
+      if (errno == EINTR)
+        continue;
+      ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "apt-key");
+      local_exit(EINTERNAL);
+   }

 
 

-      // everything fine, we have a clean file now!
-      exit(0);
+   // check if it exit'ed normally …
+   if (WIFEXITED(Status) == false)
+   {
+      ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "apt-key");
+      local_exit(EINTERNAL);

    }
    }

-   exit(EINTERNAL); // unreachable safe-guard
-}
-                                                                       /*}}}*/
-// RecombineToClearSignedFile - combine data/signature to message      /*{{{*/
-bool RecombineToClearSignedFile(std::string const &OutFile, int const ContentFile,
-      std::vector<std::string> const &ContentHeader, int const SignatureFile)
-{
-   FILE *clean_file = fopen(OutFile.c_str(), "w");
-   fputs("-----BEGIN PGP SIGNED MESSAGE-----\n", clean_file);
-   for (std::vector<std::string>::const_iterator h = ContentHeader.begin(); h != ContentHeader.end(); ++h)
-      fprintf(clean_file, "%s\n", h->c_str());
-   fputs("\n", clean_file);
-
-   FILE *data_file = fdopen(ContentFile, "r");
-   FILE *sig_file = fdopen(SignatureFile, "r");
-   if (data_file == NULL || sig_file == NULL)
+
+   // … and with a good exit code
+   if (WEXITSTATUS(Status) != 0)

    {
    {

-      fclose(clean_file);
-      return _error->Error("Couldn't open splitfiles to recombine them into %s", OutFile.c_str());
+      ioprintf(std::cerr, _("Sub-process %s returned an error code (%u)"), "apt-key", WEXITSTATUS(Status));
+      local_exit(WEXITSTATUS(Status));

    }
    }

-   char *buf = NULL;
-   size_t buf_size = 0;
-   while (getline(&buf, &buf_size, data_file) != -1)
-      fputs(buf, clean_file);
-   fclose(data_file);
-   fputs("\n", clean_file);
-   while (getline(&buf, &buf_size, sig_file) != -1)
-      fputs(buf, clean_file);
-   fclose(sig_file);
-   fclose(clean_file);
-   return true;
+
+   // everything fine
+   local_exit(0);

 }
                                                                        /*}}}*/
 // SplitClearSignedFile - split message into data/signature            /*{{{*/
 }
                                                                        /*}}}*/
 // SplitClearSignedFile - split message into data/signature            /*{{{*/

-bool SplitClearSignedFile(std::string const &InFile, int const ContentFile,
-      std::vector<std::string> * const ContentHeader, int const SignatureFile)
+bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile,
+      std::vector<std::string> * const ContentHeader, FileFd * const SignatureFile)

 {
    FILE *in = fopen(InFile.c_str(), "r");
    if (in == NULL)
       return _error->Errno("fopen", "can not open %s", InFile.c_str());
 
 {
    FILE *in = fopen(InFile.c_str(), "r");
    if (in == NULL)
       return _error->Errno("fopen", "can not open %s", InFile.c_str());
 

-   FILE *out_content = NULL;
-   FILE *out_signature = NULL;
-   if (ContentFile != -1)
-   {
-      out_content = fdopen(ContentFile, "w");
-      if (out_content == NULL)
-      {
-        fclose(in);
-        return _error->Errno("fdopen", "Failed to open file to write content to from %s", InFile.c_str());
-      }
-   }
-   if (SignatureFile != -1)
-   {
-      out_signature = fdopen(SignatureFile, "w");
-      if (out_signature == NULL)
-      {
-        fclose(in);
-        if (out_content != NULL)
-           fclose(out_content);
-        return _error->Errno("fdopen", "Failed to open file to write signature to from %s", InFile.c_str());
-      }
-   }
-

    bool found_message_start = false;
    bool found_message_end = false;
    bool skip_until_empty_line = false;
    bool found_message_start = false;
    bool found_message_end = false;
    bool skip_until_empty_line = false;


@@ -345,36 +261,96 @@ bool SplitClearSignedFile(std::string const &InFile, int const ContentFile,
         {
            found_signature = true;
            found_message_end = true;
         {
            found_signature = true;
            found_message_end = true;

-           if (out_signature != NULL)
-              fprintf(out_signature, "%s\n", buf);
+           if (SignatureFile != NULL)
+           {
+              SignatureFile->Write(buf, strlen(buf));
+              SignatureFile->Write("\n", 1);
+           }

         }
         }

-        else if (found_message_end == false)
+        else if (found_message_end == false) // we are in the message block

         {
         {

-           // we are in the message block
+           // we don't have any fields which need dash-escaped,
+           // but implementations are free to encode all lines …
+           char const * dashfree = buf;
+           if (strncmp(dashfree, "- ", 2) == 0)
+              dashfree += 2;

            if(first_line == true) // first line does not need a newline
            if(first_line == true) // first line does not need a newline

-           {
-              if (out_content != NULL)
-                 fprintf(out_content, "%s", buf);

               first_line = false;
               first_line = false;

-           }
-           else if (out_content != NULL)
-              fprintf(out_content, "\n%s", buf);
+           else if (ContentFile != NULL)
+              ContentFile->Write("\n", 1);
+           else
+              continue;
+           if (ContentFile != NULL)
+              ContentFile->Write(dashfree, strlen(dashfree));

         }
       }
       else if (found_signature == true)
       {
         }
       }
       else if (found_signature == true)
       {

-        if (out_signature != NULL)
-           fprintf(out_signature, "%s\n", buf);
+        if (SignatureFile != NULL)
+        {
+           SignatureFile->Write(buf, strlen(buf));
+           SignatureFile->Write("\n", 1);
+        }

         if (strcmp(buf, "-----END PGP SIGNATURE-----") == 0)
            found_signature = false; // look for other signatures
       }
       // all the rest is whitespace, unsigned garbage or additional message blocks we ignore
    }
         if (strcmp(buf, "-----END PGP SIGNATURE-----") == 0)
            found_signature = false; // look for other signatures
       }
       // all the rest is whitespace, unsigned garbage or additional message blocks we ignore
    }

-   if (out_content != NULL)
-      fclose(out_content);
-   if (out_signature != NULL)
-      fclose(out_signature);

    fclose(in);
    fclose(in);

+   if (buf != NULL)
+      free(buf);
+
+   if (found_signature == true)
+      return _error->Error("Signature in file %s wasn't closed", InFile.c_str());
+
+   // if we haven't found any of them, this an unsigned file,
+   // so don't generate an error, but splitting was unsuccessful none-the-less
+   if (first_line == true && found_message_start == false && found_message_end == false)
+      return false;
+   // otherwise one missing indicates a syntax error
+   else if (first_line == true || found_message_start == false || found_message_end == false)
+     return _error->Error("Splitting of file %s failed as it doesn't contain all expected parts %i %i %i", InFile.c_str(), first_line, found_message_start, found_message_end);

 
    return true;
 }
 
    return true;
 }

+                                                                       /*}}}*/
+bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &MessageFile) /*{{{*/
+{
+   char * const message = GenerateTemporaryFileTemplate("fileutl.message");
+   int const messageFd = mkstemp(message);
+   if (messageFd == -1)
+   {
+      free(message);
+      return _error->Errno("mkstemp", "Couldn't create temporary file to work with %s", ClearSignedFileName.c_str());
+   }
+   // we have the fd, thats enough for us
+   unlink(message);
+   free(message);
+
+   MessageFile.OpenDescriptor(messageFd, FileFd::ReadWrite | FileFd::BufferedWrite, true);
+   if (MessageFile.Failed() == true)
+      return _error->Error("Couldn't open temporary file to work with %s", ClearSignedFileName.c_str());
+
+   _error->PushToStack();
+   bool const splitDone = SplitClearSignedFile(ClearSignedFileName, &MessageFile, NULL, NULL);
+   bool const errorDone = _error->PendingError();
+   _error->MergeWithStack();
+   if (splitDone == false)
+   {
+      MessageFile.Close();
+
+      if (errorDone == true)
+        return false;
+
+      // we deal with an unsigned file
+      MessageFile.Open(ClearSignedFileName, FileFd::ReadOnly);
+   }
+   else // clear-signed
+   {
+      if (MessageFile.Seek(0) == false)
+        return _error->Errno("lseek", "Unable to seek back in message for file %s", ClearSignedFileName.c_str());
+   }
+
+   return MessageFile.Failed() == false;
+}
+                                                                       /*}}}*/