methods/cdrom.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cdrom.cc,v 1.20.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    CDROM URI method for APT
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include <apt-pkg/acquire-method.h>
  12 #include <apt-pkg/cdrom.h>
  13 #include <apt-pkg/cdromutl.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/configuration.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/hashes.h>
  18
  19 #include <sys/stat.h>
  20 #include <unistd.h>
  21 #include <dlfcn.h>
  22
  23 #include <iostream>
  24 #include <apti18n.h>
  25                                                                         /*}}}*/
  26
  27 using namespace std;
  28
  29 class CDROMMethod : public pkgAcqMethod
  30 {
  31    bool DatabaseLoaded;
  32    bool Debug;
  33
  34    ::Configuration Database;
  35    string CurrentID;
  36    string CDROM;
  37    bool MountedByApt;
  38    pkgUdevCdromDevices UdevCdroms;
  39
  40    bool IsCorrectCD(URI want, string MountPath, string& NewID);
  41    bool AutoDetectAndMount(const URI, string &NewID);
  42    virtual bool Fetch(FetchItem *Itm);
  43    string GetID(string Name);
  44    virtual void Exit();
  45
  46    public:
  47
  48    CDROMMethod();
  49 };
  50
  51 // CDROMMethod::CDROMethod - Constructor                                /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 CDROMMethod::CDROMMethod() : pkgAcqMethod("1.0",SingleInstance | LocalOnly |
  55                                           SendConfig | NeedsCleanup |
  56                                           Removable),
  57                                           DatabaseLoaded(false),
  58                                           Debug(false),
  59                                           MountedByApt(false)
  60 {
  61    UdevCdroms.Dlopen();
  62 };
  63                                                                         /*}}}*/
  64 // CDROMMethod::Exit - Unmount the disc if necessary                    /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* */
  67 void CDROMMethod::Exit()
  68 {
  69   if (MountedByApt == true)
  70       UnmountCdrom(CDROM);
  71 }
  72                                                                         /*}}}*/
  73 // CDROMMethod::GetID - Search the database for a matching string       /*{{{*/
  74 // ---------------------------------------------------------------------
  75 /* */
  76 string CDROMMethod::GetID(string Name)
  77 {
  78    // Search for an ID
  79    const Configuration::Item *Top = Database.Tree("CD");
  80    if (Top != 0)
  81       Top = Top->Child;
  82
  83    for (; Top != 0;)
  84    {
  85       if (Top->Value == Name)
  86          return Top->Tag;
  87
  88       Top = Top->Next;
  89    }
  90    return string();
  91 }
  92                                                                         /*}}}*/
  93 // CDROMMethod::AutoDetectAndMount                                      /*{{{*/
  94 // ---------------------------------------------------------------------
  95 /* Modifies class varaiable CDROM to the mountpoint */
  96 bool CDROMMethod::AutoDetectAndMount(const URI Get, string &NewID)
  97 {
  98    vector<struct CdromDevice> v = UdevCdroms.Scan();
  99
 100    // first check if its mounted somewhere already
 101    for (unsigned int i=0; i < v.size(); i++)
 102    {
 103       if (v[i].Mounted)
 104       {
 105          if (Debug)
 106             clog << "Checking mounted cdrom device " << v[i].DeviceName << endl;
 107          if (IsCorrectCD(Get, v[i].MountPath, NewID))
 108          {
 109             CDROM = v[i].MountPath;
 110             return true;
 111          }
 112       }
 113    }
 114
 115    // we are not supposed to mount, exit
 116    if (_config->FindB("APT::CDROM::NoMount",false) == true)
 117       return false;
 118
 119    // check if we have the mount point
 120    string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
 121    if (!FileExists(AptMountPoint))
 122       mkdir(AptMountPoint.c_str(), 0750);
 123
 124    // now try mounting
 125    for (unsigned int i=0; i < v.size(); i++)
 126    {
 127       if (!v[i].Mounted)
 128       {
 129          if(MountCdrom(AptMountPoint, v[i].DeviceName))
 130          {
 131             if (IsCorrectCD(Get, AptMountPoint, NewID))
 132             {
 133                MountedByApt = true;
 134                CDROM = AptMountPoint;
 135                return true;
 136             } else {
 137                UnmountCdrom(AptMountPoint);
 138             }
 139          }
 140       }
 141    }
 142
 143    return false;
 144 }
 145                                                                         /*}}}*/
 146 // CDROMMethod::IsCorrectCD                                             /*{{{*/
 147 // ---------------------------------------------------------------------
 148 /* */
 149 bool CDROMMethod::IsCorrectCD(URI want, string MountPath, string& NewID)
 150 {
 151    for (unsigned int Version = 2; Version != 0; Version--)
 152    {
 153       if (IdentCdrom(MountPath,NewID,Version) == false)
 154          return false;
 155
 156       if (Debug)
 157          clog << "ID " << Version << " " << NewID << endl;
 158
 159       // A hit
 160       if (Database.Find("CD::" + NewID) == want.Host)
 161          return true;
 162    }
 163
 164    return false;
 165 }
 166                                                                         /*}}}*/
 167 // CDROMMethod::Fetch - Fetch a file                                    /*{{{*/
 168 // ---------------------------------------------------------------------
 169 /* */
 170 bool CDROMMethod::Fetch(FetchItem *Itm)
 171 {
 172    FetchResult Res;
 173
 174    URI Get = Itm->Uri;
 175    string File = Get.Path;
 176    Debug = _config->FindB("Debug::Acquire::cdrom", false);
 177
 178    if (Debug)
 179       clog << "CDROMMethod::Fetch " << Itm->Uri << endl;
 180
 181    /* All IMS queries are returned as a hit, CDROMs are readonly so
 182       time stamps never change */
 183    if (Itm->LastModified != 0)
 184    {
 185       Res.LastModified = Itm->LastModified;
 186       Res.IMSHit = true;
 187       Res.Filename = Itm->DestFile;
 188       URIDone(Res);
 189       return true;
 190    }
 191
 192    // Load the database
 193    if (DatabaseLoaded == false)
 194    {
 195       // Read the database
 196       string DFile = _config->FindFile("Dir::State::cdroms");
 197       if (FileExists(DFile) == true)
 198       {
 199          if (ReadConfigFile(Database,DFile) == false)
 200             return _error->Error(_("Unable to read the cdrom database %s"),
 201                           DFile.c_str());
 202       }
 203       DatabaseLoaded = true;
 204    }
 205
 206    // All non IMS queries for package files fail.
 207    if (Itm->IndexFile == true || GetID(Get.Host).empty() == true)
 208    {
 209       Fail(_("Please use apt-cdrom to make this CD-ROM recognized by APT."
 210            " apt-get update cannot be used to add new CD-ROMs"));
 211       return true;
 212    }
 213
 214    // We already have a CD inserted, but it is the wrong one
 215    if (CurrentID.empty() == false &&
 216        CurrentID != "FAIL" &&
 217        Database.Find("CD::" + CurrentID) != Get.Host)
 218    {
 219       Fail(_("Wrong CD-ROM"),true);
 220       return true;
 221    }
 222
 223    bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect", true);
 224    CDROM = _config->FindDir("Acquire::cdrom::mount");
 225    if (Debug)
 226       clog << "Looking for CDROM at " << CDROM << endl;
 227
 228    if (CDROM[0] == '.')
 229       CDROM= SafeGetCWD() + '/' + CDROM;
 230
 231    string NewID;
 232    while (CurrentID.empty() == true)
 233    {
 234       if (AutoDetect)
 235          AutoDetectAndMount(Get, NewID);
 236
 237       if(!IsMounted(CDROM))
 238          MountedByApt = MountCdrom(CDROM);
 239
 240       if (IsCorrectCD(Get, CDROM, NewID))
 241          break;
 242
 243       // I suppose this should prompt somehow?
 244       if (_config->FindB("APT::CDROM::NoMount",false) == false &&
 245           UnmountCdrom(CDROM) == false)
 246          return _error->Error(_("Unable to unmount the CD-ROM in %s, it may still be in use."),
 247                               CDROM.c_str());
 248       if (MediaFail(Get.Host,CDROM) == false)
 249       {
 250          CurrentID = "FAIL";
 251          return _error->Error(_("Disk not found."));
 252       }
 253    }
 254
 255    // Found a CD
 256    Res.Filename = CDROM + File;
 257    struct stat Buf;
 258    if (stat(Res.Filename.c_str(),&Buf) != 0)
 259       return _error->Error(_("File not found"));
 260
 261    if (NewID.empty() == false)
 262       CurrentID = NewID;
 263    Res.LastModified = Buf.st_mtime;
 264    Res.Size = Buf.st_size;
 265
 266    Hashes Hash;
 267    FileFd Fd(Res.Filename, FileFd::ReadOnly);
 268    Hash.AddFD(Fd.Fd(), Fd.Size());
 269    Res.TakeHashes(Hash);
 270
 271    URIDone(Res);
 272    return true;
 273 }
 274                                                                         /*}}}*/
 275
 276 int main()
 277 {
 278    setlocale(LC_ALL, "");
 279
 280    CDROMMethod Mth;
 281    return Mth.Run();
 282 }