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 #include <apt-pkg/strutl.h>
  19
  20 #include <apti18n.h>
  21
  22 #include <sys/wait.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    bool writable_media = false;
 160
 161    // if we are on a writable medium (like a usb-stick) that is just
 162    // used like a cdrom don't use "." as it will constantly change,
 163    // use .disk instead
 164    if (access(CD.c_str(), W_OK) == 0 && DirectoryExists(CD+string("/.disk")))
 165    {
 166       writable_media = true;
 167       CD = CD.append("/.disk");
 168       if (_config->FindB("Debug::aptcdrom",false) == true)
 169          std::clog << "Found writable cdrom, using alternative path: " << CD
 170                    << std::endl;
 171    }
 172
 173    string StartDir = SafeGetCWD();
 174    if (chdir(CD.c_str()) != 0)
 175       return _error->Errno("chdir",_("Unable to change to %s"),CD.c_str());
 176
 177    DIR *D = opendir(".");
 178    if (D == 0)
 179       return _error->Errno("opendir",_("Unable to read %s"),CD.c_str());
 180
 181    /* Run over the directory, we assume that the reader order will never
 182       change as the media is read-only. In theory if the kernel did
 183       some sort of wacked caching this might not be true.. */
 184    char S[300];
 185    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 186    {
 187       // Skip some files..
 188       if (strcmp(Dir->d_name,".") == 0 ||
 189           strcmp(Dir->d_name,"..") == 0)
 190          continue;
 191
 192       if (Version <= 1)
 193       {
 194          sprintf(S,"%lu",(unsigned long)Dir->d_ino);
 195       }
 196       else
 197       {
 198          struct stat Buf;
 199          if (stat(Dir->d_name,&Buf) != 0)
 200             continue;
 201          sprintf(S,"%lu",(unsigned long)Buf.st_mtime);
 202       }
 203
 204       Hash.Add(S);
 205       Hash.Add(Dir->d_name);
 206    };
 207
 208    if (chdir(StartDir.c_str()) != 0) {
 209       _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 210       closedir(D);
 211       return false;
 212    }
 213    closedir(D);
 214
 215    // Some stats from the fsys
 216    if (_config->FindB("Debug::identcdrom",false) == false)
 217    {
 218       struct statvfs Buf;
 219       if (statvfs(CD.c_str(),&Buf) != 0)
 220          return _error->Errno("statfs",_("Failed to stat the cdrom"));
 221
 222       // We use a kilobyte block size to advoid overflow
 223       if (writable_media)
 224       {
 225          sprintf(S,"%lu",(long)(Buf.f_blocks*(Buf.f_bsize/1024)));
 226       } else {
 227          sprintf(S,"%lu %lu",(long)(Buf.f_blocks*(Buf.f_bsize/1024)),
 228                  (long)(Buf.f_bfree*(Buf.f_bsize/1024)));
 229       }
 230       Hash.Add(S);
 231       sprintf(S,"-%u",Version);
 232    }
 233    else
 234       sprintf(S,"-%u.debug",Version);
 235
 236    Res = Hash.Result().Value() + S;
 237    return true;
 238 }
 239                                                                         /*}}}*/
 240
 241 // FindMountPointForDevice - Find mountpoint for the given device       /*{{{*/
 242 string FindMountPointForDevice(const char *devnode)
 243 {
 244    char buf[255];
 245    char *out[10];
 246    int i=0;
 247
 248    // this is the order that mount uses as well
 249    const char *mount[] = { "/etc/mtab",
 250                            "/proc/mount",
 251                            NULL };
 252
 253    for (i=0; mount[i] != NULL; i++) {
 254       if (FileExists(mount[i])) {
 255          FILE *f=fopen(mount[i], "r");
 256          while ( fgets(buf, sizeof(buf), f) != NULL) {
 257             if (strncmp(buf, devnode, strlen(devnode)) == 0) {
 258                if(TokSplitString(' ', buf, out, 10))
 259                {
 260                   fclose(f);
 261                   // unescape the \0XXX chars in the path
 262                   string mount_point = out[1];
 263                   return DeEscapeString(mount_point);
 264                }
 265             }
 266          }
 267          fclose(f);
 268       }
 269    }
 270
 271    return string();
 272 }
 273                                                                         /*}}}*/