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 <apti18n.h>
  33                                                                         /*}}}*/
  34
  35 static bool DoAutoDetectProxy(CommandLine &CmdL)                        /*{{{*/
  36 {
  37    if (CmdL.FileSize() != 2)
  38       return _error->Error(_("Need one URL as argument"));
  39    URI ServerURL(CmdL.FileList[1]);
  40    AutoDetectProxy(ServerURL);
  41    std::string SpecificProxy = _config->Find("Acquire::"+ServerURL.Access+"::Proxy::" + ServerURL.Host);
  42    ioprintf(std::cout, "Using proxy '%s' for URL '%s'\n",
  43             SpecificProxy.c_str(), std::string(ServerURL).c_str());
  44
  45    return true;
  46 }
  47                                                                         /*}}}*/
  48 static bool DoDownloadFile(CommandLine &CmdL)                           /*{{{*/
  49 {
  50    if (CmdL.FileSize() <= 2)
  51       return _error->Error(_("Must specify at least one pair url/filename"));
  52
  53    aptAcquireWithTextStatus Fetcher;
  54    size_t fileind = 0;
  55    std::vector<std::string> targetfiles;
  56    while (fileind + 2 <= CmdL.FileSize())
  57    {
  58       std::string download_uri = CmdL.FileList[fileind + 1];
  59       std::string targetfile = CmdL.FileList[fileind + 2];
  60       std::string hash;
  61       if (CmdL.FileSize() > fileind + 3)
  62          hash = CmdL.FileList[fileind + 3];
  63       // we use download_uri as descr and targetfile as short-descr
  64       new pkgAcqFile(&Fetcher, download_uri, hash, 0, download_uri, targetfile,
  65             "dest-dir-ignored", targetfile);
  66       targetfiles.push_back(targetfile);
  67       fileind += 3;
  68    }
  69
  70    bool Failed = false;
  71    if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)
  72       return _error->Error(_("Download Failed"));
  73    if (targetfiles.empty() == false)
  74       for (std::vector<std::string>::const_iterator f = targetfiles.begin(); f != targetfiles.end(); ++f)
  75          if (FileExists(*f) == false)
  76             return _error->Error(_("Download Failed"));
  77
  78    return true;
  79 }
  80                                                                         /*}}}*/
  81 static bool DoSrvLookup(CommandLine &CmdL)                              /*{{{*/
  82 {
  83    if (CmdL.FileSize() <= 1)
  84       return _error->Error("Must specify at least one SRV record");
  85
  86    for(size_t i = 1; CmdL.FileList[i] != NULL; ++i)
  87    {
  88       std::vector<SrvRec> srv_records;
  89       std::string const name = CmdL.FileList[i];
  90       c0out << "# Target\tPriority\tWeight\tPort # for " << name << std::endl;
  91       size_t const found = name.find(":");
  92       if (found != std::string::npos)
  93       {
  94          std::string const host = name.substr(0, found);
  95          size_t const port = atoi(name.c_str() + found + 1);
  96          if(GetSrvRecords(host, port, srv_records) == false)
  97             _error->Error(_("GetSrvRec failed for %s"), name.c_str());
  98       }
  99       else if(GetSrvRecords(name, srv_records) == false)
 100          _error->Error(_("GetSrvRec failed for %s"), name.c_str());
 101
 102       for (SrvRec const &I : srv_records)
 103          c1out << I.target << "\t" << I.priority << "\t" << I.weight << "\t" << I.port << std::endl;
 104    }
 105    return true;
 106 }
 107                                                                         /*}}}*/
 108 bool ShowHelp(CommandLine &, aptDispatchWithHelp const  * Cmds)         /*{{{*/
 109 {
 110    ioprintf(std::cout, "%s %s (%s)\n", PACKAGE, PACKAGE_VERSION, COMMON_ARCH);
 111
 112    if (_config->FindB("version") == true)
 113      return true;
 114
 115    std::cout <<
 116     _("Usage: apt-helper [options] command\n"
 117       "       apt-helper [options] download-file uri target-path\n"
 118       "\n"
 119       "apt-helper is a internal helper for apt\n")
 120     << std::endl
 121     << _("Commands:") << std::endl;
 122
 123    for (; Cmds->Handler != nullptr; ++Cmds)
 124    {
 125       if (Cmds->Help == nullptr)
 126          continue;
 127       std::cout << "  " << Cmds->Match << " - " << Cmds->Help << std::endl;
 128    }
 129
 130    std::cout << std::endl <<
 131       _("This APT helper has Super Meep Powers.") << std::endl;
 132    return true;
 133 }
 134                                                                         /*}}}*/
 135 std::vector<aptDispatchWithHelp> GetCommands()                          /*{{{*/
 136 {
 137    return {
 138       {"download-file", &DoDownloadFile, _("download the given uri to the target-path")},
 139       {"srv-lookup", &DoSrvLookup, _("lookup a SRV record (e.g. _http._tcp.ftp.debian.org)")},
 140       {"auto-detect-proxy", &DoAutoDetectProxy, _("detect proxy using apt.conf")},
 141       {nullptr, nullptr, nullptr}
 142    };
 143 }
 144                                                                         /*}}}*/
 145 int main(int argc,const char *argv[])                                   /*{{{*/
 146 {
 147    InitLocale();
 148
 149    CommandLine CmdL;
 150    auto const Cmds = ParseCommandLine(CmdL, APT_CMD::APT_HELPER, &_config, &_system, argc, argv);
 151
 152    InitOutput();
 153
 154    return DispatchCommandLine(CmdL, Cmds);
 155 }
 156                                                                         /*}}}*/