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    string StartDir = SafeGetCWD();
 161    if (chdir(CD.c_str()) != 0)
 162       return _error->Errno("chdir",_("Unable to change to %s"),CD.c_str());
 163
 164    DIR *D = opendir(".");
 165    if (D == 0)
 166       return _error->Errno("opendir",_("Unable to read %s"),CD.c_str());
 167
 168    /* Run over the directory, we assume that the reader order will never
 169       change as the media is read-only. In theory if the kernel did
 170       some sort of wacked caching this might not be true.. */
 171    char S[300];
 172    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 173    {
 174       // Skip some files..
 175       if (strcmp(Dir->d_name,".") == 0 ||
 176           strcmp(Dir->d_name,"..") == 0)
 177          continue;
 178
 179       if (Version <= 1)
 180       {
 181          sprintf(S,"%lu",(unsigned long)Dir->d_ino);
 182       }
 183       else
 184       {
 185          struct stat Buf;
 186          if (stat(Dir->d_name,&Buf) != 0)
 187             continue;
 188          sprintf(S,"%lu",(unsigned long)Buf.st_mtime);
 189       }
 190
 191       Hash.Add(S);
 192       Hash.Add(Dir->d_name);
 193    };
 194
 195    if (chdir(StartDir.c_str()) != 0)
 196       return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());
 197    closedir(D);
 198
 199    // Some stats from the fsys
 200    if (_config->FindB("Debug::identcdrom",false) == false)
 201    {
 202       struct statvfs Buf;
 203       if (statvfs(CD.c_str(),&Buf) != 0)
 204          return _error->Errno("statfs",_("Failed to stat the cdrom"));
 205
 206       // We use a kilobyte block size to advoid overflow
 207       sprintf(S,"%lu %lu",(long)(Buf.f_blocks*(Buf.f_bsize/1024)),
 208               (long)(Buf.f_bfree*(Buf.f_bsize/1024)));
 209       Hash.Add(S);
 210       sprintf(S,"-%u",Version);
 211    }
 212    else
 213       sprintf(S,"-%u.debug",Version);
 214
 215    Res = Hash.Result().Value() + S;
 216    return true;
 217 }
 218                                                                         /*}}}*/