test if TMPDIR is accessible before using

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

diff --git a/apt-pkg/contrib/gpgv.cc b/apt-pkg/contrib/gpgv.cc
index 31db7d5feb3bdd08b964f1be5f562d830607d992..9d798cca986713faf5bbbeb9cc94ea9e799bfd24 100644 (file)
--- a/apt-pkg/contrib/gpgv.cc
+++ b/apt-pkg/contrib/gpgv.cc
@@ -2,84 +2,60 @@
 // 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<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 <unistd.h>
+#include <stddef.h>
+#include <iostream>
+#include <string>
+#include <vector>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 static char * GenerateTemporaryFileTemplate(const char *basename)      /*{{{*/
 {
 
 #include <apti18n.h>
                                                                        /*}}}*/
 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 gpgv
+   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,
              int const &statusfd, int fd[2])
 {
    #define EINTERNAL 111
 */
 void ExecGPGV(std::string const &File, std::string const &FileGPG,
              int const &statusfd, int fd[2])
 {
    #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->FindFile("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);
 

-   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)
-   {
-      // 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);
-   }
-
-   Args.push_back(gpgvpath.c_str());
-   Args.push_back("--ignore-time-conflict");
+   Args.push_back(aptkey.c_str());
+   Args.push_back("--quiet");
+   Args.push_back("--readonly");
+   Args.push_back("verify");

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


@@ -89,13 +65,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)


@@ -109,12 +78,12 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       }
    }
 
       }
    }
 

+   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());


@@ -154,7 +123,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
         if (sigFd != -1)
            unlink(data);
         ioprintf(std::cerr, "Splitting up %s into data and signature failed", File.c_str());
         if (sigFd != -1)
            unlink(data);
         ioprintf(std::cerr, "Splitting up %s into data and signature failed", File.c_str());

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

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


@@ -164,7 +133,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;


@@ -172,7 +141,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)


@@ -187,9 +156,9 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       putenv((char *)"LC_MESSAGES=");
    }
 
       putenv((char *)"LC_MESSAGES=");
    }
 

-   if (FileGPG != File)
+   if (releaseSignature == DETACHED)

    {
    {

-      execvp(gpgvpath.c_str(), (char **) &Args[0]);
+      execvp(Args[0], (char **) &Args[0]);

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


@@ -209,7 +178,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       {
         if (statusfd != -1)
            dup2(fd[1], statusfd);
       {
         if (statusfd != -1)
            dup2(fd[1], statusfd);

-        execvp(gpgvpath.c_str(), (char **) &Args[0]);
+        execvp(Args[0], (char **) &Args[0]);

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


@@ -220,7 +189,7 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       {
         if (errno == EINTR)
            continue;
       {
         if (errno == EINTR)
            continue;

-        ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "gpgv");
+        ioprintf(std::cerr, _("Waited for %s but it wasn't there"), "apt-key");

         UNLINK_EXIT(EINTERNAL);
       }
 #undef UNLINK_EXIT
         UNLINK_EXIT(EINTERNAL);
       }
 #undef UNLINK_EXIT


@@ -233,14 +202,14 @@ void ExecGPGV(std::string const &File, std::string const &FileGPG,
       // check if it exit'ed normally …
       if (WIFEXITED(Status) == false)
       {
       // check if it exit'ed normally …
       if (WIFEXITED(Status) == false)
       {

-        ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "gpgv");
+        ioprintf(std::cerr, _("Sub-process %s exited unexpectedly"), "apt-key");

         exit(EINTERNAL);
       }
 
       // … and with a good exit code
       if (WEXITSTATUS(Status) != 0)
       {
         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));
+        ioprintf(std::cerr, _("Sub-process %s returned an error code (%u)"), "apt-key", WEXITSTATUS(Status));

         exit(WEXITSTATUS(Status));
       }
 
         exit(WEXITSTATUS(Status));
       }
 


@@ -266,8 +235,7 @@ bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile,
 
    char *buf = NULL;
    size_t buf_size = 0;
 
    char *buf = NULL;
    size_t buf_size = 0;

-   ssize_t line_len = 0;
-   while ((line_len = getline(&buf, &buf_size, in)) != -1)
+   while (getline(&buf, &buf_size, in) != -1)

    {
       _strrstrip(buf);
       if (found_message_start == false)
    {
       _strrstrip(buf);
       if (found_message_start == false)


@@ -361,7 +329,7 @@ bool OpenMaybeClearSignedFile(std::string const &ClearSignedFileName, FileFd &Me
       return _error->Error("Couldn't open temporary file to work with %s", ClearSignedFileName.c_str());
 
    _error->PushToStack();
       return _error->Error("Couldn't open temporary file to work with %s", ClearSignedFileName.c_str());
 
    _error->PushToStack();

-   bool const splitDone = SplitClearSignedFile(ClearSignedFileName.c_str(), &MessageFile, NULL, NULL);
+   bool const splitDone = SplitClearSignedFile(ClearSignedFileName, &MessageFile, NULL, NULL);

    bool const errorDone = _error->PendingError();
    _error->MergeWithStack();
    if (splitDone == false)
    bool const errorDone = _error->PendingError();
    _error->MergeWithStack();
    if (splitDone == false)