cmdline/apt-cdrom.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-cdrom.cc,v 1.45 2003/11/19 23:50:51 mdz Exp $
   4 /* ######################################################################
   5
   6    APT CDROM - Tool for handling APT's CDROM database.
   7
   8    Currently the only option is 'add' which will take the current CD
   9    in the drive and add it into the database.
  10
  11    ##################################################################### */
  12                                                                         /*}}}*/
  13 // Include Files                                                        /*{{{*/
  14 #include<config.h>
  15
  16 #include <apt-pkg/cmndline.h>
  17 #include <apt-pkg/error.h>
  18 #include <apt-pkg/init.h>
  19 #include <apt-pkg/fileutl.h>
  20 #include <apt-pkg/progress.h>
  21 #include <apt-pkg/cdromutl.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/acquire.h>
  24 #include <apt-pkg/acquire-item.h>
  25 #include <apt-pkg/cdrom.h>
  26 #include <apt-pkg/configuration.h>
  27 #include <apt-pkg/pkgsystem.h>
  28
  29 #include <locale.h>
  30 #include <iostream>
  31 #include <fstream>
  32 #include <vector>
  33 #include <algorithm>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <unistd.h>
  38 #include <stdio.h>
  39
  40 #include <apt-private/private-cmndline.h>
  41
  42 #include <apti18n.h>
  43                                                                         /*}}}*/
  44 static const char *W_NO_CDROM_FOUND = \
  45    N_("No CD-ROM could be auto-detected or found using "
  46       "the default mount point.\n"
  47       "You may try the --cdrom option to set the CD-ROM mount point. "
  48       "See 'man apt-cdrom' for more "
  49       "information about the CD-ROM auto-detection and mount point.");
  50
  51 using namespace std;
  52
  53 class pkgCdromTextStatus : public pkgCdromStatus                        /*{{{*/
  54 {
  55 protected:
  56    OpTextProgress Progress;
  57    void Prompt(const char *Text);
  58    string PromptLine(const char *Text);
  59    bool AskCdromName(string &name);
  60
  61 public:
  62    virtual void Update(string text, int current);
  63    virtual bool ChangeCdrom();
  64    virtual OpProgress* GetOpProgress();
  65 };
  66
  67 void pkgCdromTextStatus::Prompt(const char *Text)
  68 {
  69    char C;
  70    cout << Text << ' ' << flush;
  71    if (read(STDIN_FILENO,&C,1) < 0)
  72       _error->Errno("pkgCdromTextStatus::Prompt",
  73                     "Failed to read from standard input (not a terminal?)");
  74    if (C != '\n')
  75       cout << endl;
  76 }
  77
  78 string pkgCdromTextStatus::PromptLine(const char *Text)
  79 {
  80    cout << Text << ':' << endl;
  81
  82    string Res;
  83    getline(cin,Res);
  84    return Res;
  85 }
  86
  87 bool pkgCdromTextStatus::AskCdromName(string &name)
  88 {
  89    cout << _("Please provide a name for this Disc, such as 'Debian 5.0.3 Disk 1'") << flush;
  90    name = PromptLine("");
  91
  92    return true;
  93 }
  94
  95
  96 void pkgCdromTextStatus::Update(string text, int /*current*/)
  97 {
  98    if(text.size() > 0)
  99       cout << text << flush;
 100 }
 101
 102 bool pkgCdromTextStatus::ChangeCdrom()
 103 {
 104    Prompt(_("Please insert a Disc in the drive and press enter"));
 105    return true;
 106 }
 107
 108 OpProgress* pkgCdromTextStatus::GetOpProgress()
 109 {
 110    return &Progress;
 111 }
 112                                                                         /*}}}*/
 113 // SetupAutoDetect                                                      /*{{{*/
 114 static bool AutoDetectCdrom(pkgUdevCdromDevices &UdevCdroms, unsigned int &i, bool &automounted)
 115 {
 116    bool Debug =  _config->FindB("Debug::Acquire::cdrom", false);
 117
 118    automounted = false;
 119
 120    vector<struct CdromDevice> v = UdevCdroms.Scan();
 121    if (i >= v.size())
 122       return false;
 123
 124    if (Debug)
 125       clog << "Looking at devce " << i
 126            << " DeviveName: " << v[i].DeviceName
 127            << " IsMounted: '" << v[i].Mounted << "'"
 128            << " MountPoint: '" << v[i].MountPath << "'"
 129            << endl;
 130
 131    if (v[i].Mounted)
 132    {
 133       // set the right options
 134       _config->Set("Acquire::cdrom::mount", v[i].MountPath);
 135       _config->Set("APT::CDROM::NoMount", true);
 136    } else {
 137       string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
 138       if (!FileExists(AptMountPoint))
 139          mkdir(AptMountPoint.c_str(), 0750);
 140       if(MountCdrom(AptMountPoint, v[i].DeviceName) == false)
 141          _error->Warning(_("Failed to mount '%s' to '%s'"), v[i].DeviceName.c_str(), AptMountPoint.c_str());
 142       else
 143          automounted = true;
 144       _config->Set("Acquire::cdrom::mount", AptMountPoint);
 145       _config->Set("APT::CDROM::NoMount", true);
 146    }
 147    i++;
 148
 149    return true;
 150 }
 151                                                                         /*}}}*/
 152 // DoAdd - Add a new CDROM                                              /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* This does the main add bit.. We show some status and things. The
 155    sequence is to mount/umount the CD, Ident it then scan it for package
 156    files and reduce that list. Then we copy over the package files and
 157    verify them. Then rewrite the database files */
 158 static bool DoAdd(CommandLine &)
 159 {
 160    pkgUdevCdromDevices UdevCdroms;
 161    pkgCdromTextStatus log;
 162    pkgCdrom cdrom;
 163    bool res = true;
 164
 165    bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect", true);
 166    unsigned int count = 0;
 167    string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
 168    bool automounted = false;
 169    if (AutoDetect && UdevCdroms.Dlopen())
 170       while (AutoDetectCdrom(UdevCdroms, count, automounted)) {
 171          if (count == 1) {
 172             // begin loop with res false to detect any success using OR
 173             res = false;
 174          }
 175
 176          // dump any warnings/errors from autodetect
 177          if (_error->empty() == false)
 178             _error->DumpErrors();
 179
 180          res |= cdrom.Add(&log);
 181
 182          if (automounted)
 183             UnmountCdrom(AptMountPoint);
 184
 185          // dump any warnings/errors from add/unmount
 186          if (_error->empty() == false)
 187             _error->DumpErrors();
 188       }
 189
 190    if (count == 0)
 191       res = cdrom.Add(&log);
 192
 193    if (res == false)
 194       _error->Error("%s", _(W_NO_CDROM_FOUND));
 195    else
 196       cout << _("Repeat this process for the rest of the CDs in your set.") << endl;
 197
 198    return res;
 199 }
 200                                                                         /*}}}*/
 201 // DoIdent - Ident a CDROM                                              /*{{{*/
 202 // ---------------------------------------------------------------------
 203 /* */
 204 static bool DoIdent(CommandLine &)
 205 {
 206    pkgUdevCdromDevices UdevCdroms;
 207    string ident;
 208    pkgCdromTextStatus log;
 209    pkgCdrom cdrom;
 210    bool res = true;
 211
 212    bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect", true);
 213
 214    unsigned int count = 0;
 215    string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
 216    bool automounted = false;
 217    if (AutoDetect && UdevCdroms.Dlopen())
 218       while (AutoDetectCdrom(UdevCdroms, count, automounted)) {
 219          if (count == 1) {
 220             // begin loop with res false to detect any success using OR
 221             res = false;
 222          }
 223
 224          // dump any warnings/errors from autodetect
 225          if (_error->empty() == false)
 226             _error->DumpErrors();
 227
 228          res |= cdrom.Ident(ident, &log);
 229
 230          if (automounted)
 231             UnmountCdrom(AptMountPoint);
 232
 233          // dump any warnings/errors from add/unmount
 234          if (_error->empty() == false)
 235             _error->DumpErrors();
 236       }
 237
 238    if (count == 0)
 239       res = cdrom.Ident(ident, &log);
 240
 241    if (res == false)
 242       _error->Error("%s", _(W_NO_CDROM_FOUND));
 243
 244    return res;
 245 }
 246                                                                         /*}}}*/
 247 // ShowHelp - Show the help screen                                      /*{{{*/
 248 // ---------------------------------------------------------------------
 249 /* */
 250 static bool ShowHelp(CommandLine &)
 251 {
 252    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
 253             COMMON_ARCH,__DATE__,__TIME__);
 254    if (_config->FindB("version") == true)
 255       return true;
 256
 257    cout <<
 258       "Usage: apt-cdrom [options] command\n"
 259       "\n"
 260       "apt-cdrom is a tool to add CDROM's to APT's source list. The\n"
 261       "CDROM mount point and device information is taken from apt.conf\n"
 262       "and /etc/fstab.\n"
 263       "\n"
 264       "Commands:\n"
 265       "   add - Add a CDROM\n"
 266       "   ident - Report the identity of a CDROM\n"
 267       "\n"
 268       "Options:\n"
 269       "  -h   This help text\n"
 270       "  -d   CD-ROM mount point\n"
 271       "  -r   Rename a recognized CD-ROM\n"
 272       "  -m   No mounting\n"
 273       "  -f   Fast mode, don't check package files\n"
 274       "  -a   Thorough scan mode\n"
 275       "  --no-auto-detect Do not try to auto detect drive and mount point\n"
 276       "  -c=? Read this configuration file\n"
 277       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
 278       "See fstab(5)\n";
 279    return true;
 280 }
 281                                                                         /*}}}*/
 282 int main(int argc,const char *argv[])                                   /*{{{*/
 283 {
 284    CommandLine::Dispatch Cmds[] = {
 285       {"add",&DoAdd},
 286       {"ident",&DoIdent},
 287       {"help",&ShowHelp},
 288       {0,0}};
 289
 290    std::vector<CommandLine::Args> Args = getCommandArgs("apt-cdrom", CommandLine::GetCommand(Cmds, argc, argv));
 291
 292    // Set up gettext support
 293    setlocale(LC_ALL,"");
 294    textdomain(PACKAGE);
 295
 296    // Parse the command line and initialize the package library
 297    CommandLine CmdL(Args.data(),_config);
 298    if (pkgInitConfig(*_config) == false ||
 299        CmdL.Parse(argc,argv) == false ||
 300        pkgInitSystem(*_config,_system) == false)
 301    {
 302       _error->DumpErrors();
 303       return 100;
 304    }
 305
 306    // See if the help should be shown
 307    if (_config->FindB("help") == true || _config->FindB("version") == true ||
 308        CmdL.FileSize() == 0)
 309       return ShowHelp(CmdL);
 310
 311    // Deal with stdout not being a tty
 312    if (isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
 313       _config->Set("quiet","1");
 314
 315    // Match the operation
 316    CmdL.DispatchArg(Cmds);
 317
 318    // Print any errors or warnings found during parsing
 319    bool const Errors = _error->PendingError();
 320    if (_config->FindI("quiet",0) > 0)
 321       _error->DumpErrors();
 322    else
 323       _error->DumpErrors(GlobalError::DEBUG);
 324    return Errors == true ? 100 : 0;
 325 }
 326                                                                         /*}}}*/