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