apt-pkg/contrib/cdromutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cdromutl.cc,v 1.12 2001/02/20 07:03:17 jgg Exp $
   4 /* ######################################################################
   5
   6    CDROM Utilities - Some functions to manipulate CDROM mounts.
   7
   8    These are here for the cdrom method and apt-cdrom.
   9
  10    ##################################################################### */
  11                                                                         /*}}}*/
  12 // Include Files                                                        /*{{{*/
  13 #include <apt-pkg/cdromutl.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/md5.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/configuration.h>
  18
  19 #include <apti18n.h>
  20
  21 #include <sys/wait.h>
  22 #include <sys/errno.h>
  23 #include <sys/statvfs.h>
  24 #include <dirent.h>
  25 #include <fcntl.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28 #include <stdio.h>
  29                                                                         /*}}}*/
  30
  31 // IsMounted - Returns true if the mount point is mounted               /*{{{*/
  32 // ---------------------------------------------------------------------
  33 /* This is a simple algorithm that should always work, we stat the mount point
  34    and the '..' file in the mount point and see if they are on the same device.
  35    By definition if they are the same then it is not mounted. This should
  36    account for symlinked mount points as well. */
  37 bool IsMounted(string &Path)
  38 {
  39    if (Path.empty() == true)
  40       return false;
  41
  42    // Need that trailing slash for directories
  43    if (Path[Path.length() - 1] != '/')
  44       Path += '/';
  45
  46    /* First we check if the path is actualy mounted, we do this by
  47       stating the path and the previous directory (carefull of links!)
  48       and comparing their device fields. */
  49    struct stat Buf,Buf2;
  50    if (stat(Path.c_str(),&Buf) != 0 ||
  51        stat((Path + "../").c_str(),&Buf2) != 0)
  52       return _error->Errno("stat",_("Unable to stat the mount point %s"),Path.c_str());
  53
  54    if (Buf.st_dev == Buf2.st_dev)
  55       return false;
  56    return true;
  57 }
  58                                                                         /*}}}*/
  59 // UnmountCdrom - Unmount a cdrom                                       /*{{{*/
  60 // ---------------------------------------------------------------------
  61 /* Forking umount works much better than the umount syscall which can
  62    leave /etc/mtab inconsitant. We drop all messages this produces. */
  63 bool UnmountCdrom(string Path)
  64 {
  65    if (IsMounted(Path) == false)
  66       return true;
  67
  68    for (int i=0;i<3;i++)
  69    {
  70
  71       int Child = ExecFork();
  72
  73       // The child
  74       if (Child == 0)
  75       {
  76          // Make all the fds /dev/null
  77          for (int I = 0; I != 3; I++)
  78             dup2(open("/dev/null",O_RDWR),I);
  79
  80          if (_config->Exists("Acquire::cdrom::"+Path+"::UMount") == true)
  81          {
  82             if (system(_config->Find("Acquire::cdrom::"+Path+"::UMount").c_str()) != 0)
  83                _exit(100);
  84             _exit(0);
  85          }
  86          else
  87          {
  88             const char *Args[10];
  89             Args[0] = "umount";
  90             Args[1] = Path.c_str();
  91             Args[2] = 0;
  92             execvp(Args[0],(char **)Args);
  93             _exit(100);
  94          }
  95       }
  96
  97       // if it can not be umounted, give it a bit more time
  98       // this can happen when auto-mount magic or fs/cdrom prober attack
  99       if (ExecWait(Child,"umount",true) == true)
 100          return true;
 101       sleep(1);
 102    }
 103
 104    return false;
 105 }
 106                                                                         /*}}}*/
 107 // MountCdrom - Mount a cdrom                                           /*{{{*/
 108 // ---------------------------------------------------------------------
 109 /* We fork mount and drop all messages */
 110 bool MountCdrom(string Path, string DeviceName)
 111 {
 112    if (IsMounted(Path) == true)
 113       return true;
 114
 115    int Child = ExecFork();
 116
 117    // The child
 118    if (Child == 0)
 119    {
 120       // Make all the fds /dev/null
 121       for (int I = 0; I != 3; I++)
 122          dup2(open("/dev/null",O_RDWR),I);
 123
 124       if (_config->Exists("Acquire::cdrom::"+Path+"::Mount") == true)
 125       {
 126          if (system(_config->Find("Acquire::cdrom::"+Path+"::Mount").c_str()) != 0)
 127             _exit(100);
 128          _exit(0);
 129       }
 130       else
 131       {
 132          const char *Args[10];
 133          Args[0] = "mount";
 134          if (DeviceName == "")
 135          {
 136             Args[1] = Path.c_str();
 137             Args[2] = 0;
 138          } else {
 139             Args[1] = DeviceName.c_str();
 140             Args[2] = Path.c_str();
 141             Args[3] = 0;
 142          }
 143          execvp(Args[0],(char **)Args);
 144          _exit(100);
 145       }
 146    }
 147
 148    // Wait for mount
 149    return ExecWait(Child,"mount",true);
 150 }
 151                                                                         /*}}}*/
 152 // IdentCdrom - Generate a unique string for this CD                    /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* We convert everything we hash into a string, this prevents byte size/order
 155    from effecting the outcome. */
 156 bool IdentCdrom(string CD,string &Res,unsigned int Version)
 157 {
 158    MD5Summation Hash;
 159
 160    // if we are on a writable medium (like a usb-stick) that is just
 161    // used like a cdrom don't use "." as it will constantly change,
 162    // use .disk instead
 163    if (access(CD.c_str(), W_OK) == 0 && DirectoryExists(CD+string("/.disk"))) {
 164       CD = CD.append("/.disk");
 165       if (_config->FindB("Debug::aptcdrom",false) == true)
 166          std::clog << "Found writable cdrom, using alternative path: " << CD
 167                    << std::endl;
 168    }
 169
 170    string StartDir = SafeGetCWD();
 171    if (chdir(CD.c_str()) != 0)
 172       return _error->Errno("chdir",_("Unable to change to %s"),CD.c_str());
 173
 174    DIR *D = opendir(".");
 175    if (D == 0)
 176       return _error->Errno("opendir",_("Unable to read %s"),CD.c_str());
 177
 178    /* Run over the directory, we assume that the reader order will never
 179       change as the media is read-only. In theory if the kernel did
 180       some sort of wacked caching this might not be true.. */
 181    char S[300];
 182    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 183    {
 184       // Skip some files..
 185       if (strcmp(Dir->d_name,".") == 0 ||
 186           strcmp(Dir->d_name,"..") == 0)
 187          continue;
 188
 189       if (Version <= 1)
 190       {
 191          sprintf(S,"%lu",(unsigned long)Dir->d_ino);
 192       }
 193       else
 194       {
 195          struct stat Buf;
 196          if (stat(Dir->d_name,&Buf) != 0)
 197             continue;
 198          sprintf(S,"%lu",(unsigned long)Buf.st_mtime);
 199       }
 200
 201       Hash.Add(S);
 202       Hash.Add(Dir->d_name);
 203    };
 204
 205    if (chdir(StartDir.c_str()) != 0)
 206       return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 207    closedir(D);
 208
 209    // Some stats from the fsys
 210    if (_config->FindB("Debug::identcdrom",false) == false)
 211    {
 212       struct statvfs Buf;
 213       if (statvfs(CD.c_str(),&Buf) != 0)
 214          return _error->Errno("statfs",_("Failed to stat the cdrom"));
 215
 216       // We use a kilobyte block size to advoid overflow
 217       sprintf(S,"%lu %lu",(long)(Buf.f_blocks*(Buf.f_bsize/1024)),
 218               (long)(Buf.f_bfree*(Buf.f_bsize/1024)));
 219       Hash.Add(S);
 220       sprintf(S,"-%u",Version);
 221    }
 222    else
 223       sprintf(S,"-%u.debug",Version);
 224
 225    Res = Hash.Result().Value() + S;
 226    return true;
 227 }
 228                                                                         /*}}}*/