cmdline/apt-helper.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* #####################################################################
   4    apt-helper - cmdline helpers
   5    ##################################################################### */
   6                                                                         /*}}}*/
   7 // Include Files                                                        /*{{{*/
   8 #include <config.h>
   9
  10 #include <apt-pkg/configuration.h>
  11 #include <apt-pkg/cmndline.h>
  12 #include <apt-pkg/error.h>
  13 #include <apt-pkg/init.h>
  14 #include <apt-pkg/strutl.h>
  15 #include <apt-pkg/pkgsystem.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/acquire.h>
  18 #include <apt-pkg/acquire-item.h>
  19 #include <apt-pkg/proxy.h>
  20
  21 #include <apt-private/acqprogress.h>
  22 #include <apt-private/private-output.h>
  23 #include <apt-private/private-download.h>
  24 #include <apt-private/private-cmndline.h>
  25 #include <apt-private/private-main.h>
  26 #include <apt-pkg/srvrec.h>
  27
  28 #include <iostream>
  29 #include <string>
  30 #include <vector>
  31
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34
  35 #include <apti18n.h>
  36                                                                         /*}}}*/
  37
  38 static bool DoAutoDetectProxy(CommandLine &CmdL)                        /*{{{*/
  39 {
  40    if (CmdL.FileSize() != 2)
  41       return _error->Error(_("Need one URL as argument"));
  42    URI ServerURL(CmdL.FileList[1]);
  43    if (AutoDetectProxy(ServerURL) == false)
  44       return false;
  45    std::string SpecificProxy = _config->Find("Acquire::"+ServerURL.Access+"::Proxy::" + ServerURL.Host);
  46    ioprintf(std::cout, "Using proxy '%s' for URL '%s'\n",
  47             SpecificProxy.c_str(), std::string(ServerURL).c_str());
  48
  49    return true;
  50 }
  51                                                                         /*}}}*/
  52 static bool DoDownloadFile(CommandLine &CmdL)                           /*{{{*/
  53 {
  54    if (CmdL.FileSize() <= 2)
  55       return _error->Error(_("Must specify at least one pair url/filename"));
  56
  57    aptAcquireWithTextStatus Fetcher;
  58    size_t fileind = 0;
  59    std::vector<std::string> targetfiles;
  60    while (fileind + 2 <= CmdL.FileSize())
  61    {
  62       std::string download_uri = CmdL.FileList[fileind + 1];
  63       std::string targetfile = CmdL.FileList[fileind + 2];
  64       std::string hash;
  65       if (CmdL.FileSize() > fileind + 3)
  66          hash = CmdL.FileList[fileind + 3];
  67       // we use download_uri as descr and targetfile as short-descr
  68       new pkgAcqFile(&Fetcher, download_uri, hash, 0, download_uri, targetfile,
  69             "dest-dir-ignored", targetfile);
  70       targetfiles.push_back(targetfile);
  71       fileind += 3;
  72    }
  73
  74    bool Failed = false;
  75    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
  76       return _error->Error(_("Download Failed"));
  77    if (targetfiles.empty() == false)
  78       for (std::vector<std::string>::const_iterator f = targetfiles.begin(); f != targetfiles.end(); ++f)
  79          if (FileExists(*f) == false)
  80             return _error->Error(_("Download Failed"));
  81
  82    return true;
  83 }
  84                                                                         /*}}}*/
  85 static bool DoSrvLookup(CommandLine &CmdL)                              /*{{{*/
  86 {
  87    if (CmdL.FileSize() <= 1)
  88       return _error->Error("Must specify at least one SRV record");
  89
  90    for(size_t i = 1; CmdL.FileList[i] != NULL; ++i)
  91    {
  92       std::vector<SrvRec> srv_records;
  93       std::string const name = CmdL.FileList[i];
  94       c0out << "# Target\tPriority\tWeight\tPort # for " << name << std::endl;
  95       size_t const found = name.find(":");
  96       if (found != std::string::npos)
  97       {
  98          std::string const host = name.substr(0, found);
  99          size_t const port = atoi(name.c_str() + found + 1);
 100          if(GetSrvRecords(host, port, srv_records) == false)
 101             _error->Error(_("GetSrvRec failed for %s"), name.c_str());
 102       }
 103       else if(GetSrvRecords(name, srv_records) == false)
 104          _error->Error(_("GetSrvRec failed for %s"), name.c_str());
 105
 106       for (SrvRec const &I : srv_records)
 107          ioprintf(c1out, "%s\t%d\t%d\t%d\n", I.target.c_str(), I.priority, I.weight, I.port);
 108    }
 109    return true;
 110 }
 111                                                                         /*}}}*/
 112 static const APT::Configuration::Compressor *FindCompressor(std::vector<APT::Configuration::Compressor> const & compressors, std::string name)                          /*{{{*/
 113 {
 114    APT::Configuration::Compressor const * compressor = NULL;
 115    for (auto const & c : compressors)
 116    {
 117       if (compressor != NULL && c.Cost >= compressor->Cost)
 118          continue;
 119       if (c.Name == name || c.Extension == name || (!c.Extension.empty() && c.Extension.substr(1) == name))
 120          compressor = &c;
 121    }
 122
 123    return compressor;
 124 }
 125                                                                         /*}}}*/
 126 static bool DoCatFile(CommandLine &CmdL)                                /*{{{*/
 127 {
 128    FileFd fd;
 129    FileFd out;
 130    std::string const compressorName = _config->Find("Apt-Helper::Cat-File::Compress", "");
 131
 132    if (compressorName.empty() == false)
 133    {
 134
 135       auto const compressors = APT::Configuration::getCompressors();
 136       auto const compressor = FindCompressor(compressors, compressorName);
 137
 138       if (compressor == NULL)
 139          return _error->Error("Could not find compressor: %s", compressorName.c_str());
 140
 141       if (out.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly, *compressor) == false)
 142          return false;
 143    } else
 144    {
 145       if (out.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly) == false)
 146          return false;
 147    }
 148
 149    if (CmdL.FileSize() <= 1)
 150    {
 151       if (fd.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly) == false)
 152          return false;
 153       if (CopyFile(fd, out) == false)
 154          return false;
 155       return true;
 156    }
 157
 158    for(size_t i = 1; CmdL.FileList[i] != NULL; ++i)
 159    {
 160       std::string const name = CmdL.FileList[i];
 161
 162       if (name != "-")
 163       {
 164          if (fd.Open(name, FileFd::ReadOnly, FileFd::Extension) == false)
 165             return false;
 166       }
 167       else
 168       {
 169          if (fd.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly) == false)
 170             return false;
 171       }
 172
 173       if (CopyFile(fd, out) == false)
 174          return false;
 175    }
 176    return true;
 177 }
 178                                                                         /*}}}*/
 179 static bool ShowHelp(CommandLine &)                                     /*{{{*/
 180 {
 181    std::cout <<
 182       _("Usage: apt-helper [options] command\n"
 183             "       apt-helper [options] cat-file file ...\n"
 184             "       apt-helper [options] download-file uri target-path\n"
 185             "\n"
 186             "apt-helper bundles a variety of commands for shell scripts to use\n"
 187             "e.g. the same proxy configuration or acquire system as APT would.\n");
 188    return true;
 189 }
 190                                                                         /*}}}*/
 191 static std::vector<aptDispatchWithHelp> GetCommands()                   /*{{{*/
 192 {
 193    return {
 194       {"download-file", &DoDownloadFile, _("download the given uri to the target-path")},
 195       {"srv-lookup", &DoSrvLookup, _("lookup a SRV record (e.g. _http._tcp.ftp.debian.org)")},
 196       {"cat-file", &DoCatFile, _("concatenate files, with automatic decompression")},
 197       {"auto-detect-proxy", &DoAutoDetectProxy, _("detect proxy using apt.conf")},
 198       {nullptr, nullptr, nullptr}
 199    };
 200 }
 201                                                                         /*}}}*/
 202 int main(int argc,const char *argv[])                                   /*{{{*/
 203 {
 204    CommandLine CmdL;
 205    auto const Cmds = ParseCommandLine(CmdL, APT_CMD::APT_HELPER, &_config, &_system, argc, argv, &ShowHelp, &GetCommands);
 206
 207    InitOutput();
 208
 209    return DispatchCommandLine(CmdL, Cmds);
 210 }
 211                                                                         /*}}}*/