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    int Child = ExecFork();
  69
  70    // The child
  71    if (Child == 0)
  72    {
  73       // Make all the fds /dev/null
  74       for (int I = 0; I != 3; I++)
  75          dup2(open("/dev/null",O_RDWR),I);
  76
  77       if (_config->Exists("Acquire::cdrom::"+Path+"::UMount") == true)
  78       {
  79          if (system(_config->Find("Acquire::cdrom::"+Path+"::UMount").c_str()) != 0)
  80             _exit(100);
  81          _exit(0);
  82       }
  83       else
  84       {
  85          const char *Args[10];
  86          Args[0] = "umount";
  87          Args[1] = Path.c_str();
  88          Args[2] = 0;
  89          execvp(Args[0],(char **)Args);
  90          _exit(100);
  91       }
  92    }
  93
  94    // Wait for mount
  95    return ExecWait(Child,"umount",true);
  96 }
  97                                                                         /*}}}*/
  98 // MountCdrom - Mount a cdrom                                           /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* We fork mount and drop all messages */
 101 bool MountCdrom(string Path)
 102 {
 103    if (IsMounted(Path) == true)
 104       return true;
 105
 106    int Child = ExecFork();
 107
 108    // The child
 109    if (Child == 0)
 110    {
 111       // Make all the fds /dev/null
 112       for (int I = 0; I != 3; I++)
 113          dup2(open("/dev/null",O_RDWR),I);
 114
 115       if (_config->Exists("Acquire::cdrom::"+Path+"::Mount") == true)
 116       {
 117          if (system(_config->Find("Acquire::cdrom::"+Path+"::Mount").c_str()) != 0)
 118             _exit(100);
 119          _exit(0);
 120       }
 121       else
 122       {
 123          const char *Args[10];
 124          Args[0] = "mount";
 125          Args[1] = Path.c_str();
 126          Args[2] = 0;
 127          execvp(Args[0],(char **)Args);
 128          _exit(100);
 129       }
 130    }
 131
 132    // Wait for mount
 133    return ExecWait(Child,"mount",true);
 134 }
 135                                                                         /*}}}*/
 136 // IdentCdrom - Generate a unique string for this CD                    /*{{{*/
 137 // ---------------------------------------------------------------------
 138 /* We convert everything we hash into a string, this prevents byte size/order
 139    from effecting the outcome. */
 140 bool IdentCdrom(string CD,string &Res,unsigned int Version)
 141 {
 142    MD5Summation Hash;
 143
 144    string StartDir = SafeGetCWD();
 145    if (chdir(CD.c_str()) != 0)
 146       return _error->Errno("chdir",_("Unable to change to %s"),CD.c_str());
 147
 148    DIR *D = opendir(".");
 149    if (D == 0)
 150       return _error->Errno("opendir",_("Unable to read %s"),CD.c_str());
 151
 152    /* Run over the directory, we assume that the reader order will never
 153       change as the media is read-only. In theory if the kernel did
 154       some sort of wacked caching this might not be true.. */
 155    char S[300];
 156    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 157    {
 158       // Skip some files..
 159       if (strcmp(Dir->d_name,".") == 0 ||
 160           strcmp(Dir->d_name,"..") == 0)
 161          continue;
 162
 163       if (Version <= 1)
 164       {
 165          sprintf(S,"%lu",(unsigned long)Dir->d_ino);
 166       }
 167       else
 168       {
 169          struct stat Buf;
 170          if (stat(Dir->d_name,&Buf) != 0)
 171             continue;
 172          sprintf(S,"%lu",(unsigned long)Buf.st_mtime);
 173       }
 174
 175       Hash.Add(S);
 176       Hash.Add(Dir->d_name);
 177    };
 178
 179    chdir(StartDir.c_str());
 180    closedir(D);
 181
 182    // Some stats from the fsys
 183    if (_config->FindB("Debug::identcdrom",false) == false)
 184    {
 185       struct statvfs Buf;
 186       if (statvfs(CD.c_str(),&Buf) != 0)
 187          return _error->Errno("statfs",_("Failed to stat the cdrom"));
 188
 189       // We use a kilobyte block size to advoid overflow
 190       sprintf(S,"%lu %lu",(long)(Buf.f_blocks*(Buf.f_bsize/1024)),
 191               (long)(Buf.f_bfree*(Buf.f_bsize/1024)));
 192       Hash.Add(S);
 193       sprintf(S,"-%u",Version);
 194    }
 195    else
 196       sprintf(S,"-%u.debug",Version);
 197
 198    Res = Hash.Result().Value() + S;
 199    return true;
 200 }
 201                                                                         /*}}}*/