[ntk/apt.git] / cmdline / apt-cdrom.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: apt-cdrom.cc,v 1.1 1998/11/27 01:52:56 jgg Exp $
/* ######################################################################
   
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/cmndline.h>
#include <apt-pkg/error.h>
#include <apt-pkg/init.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/tagfile.h>
#include <strutl.h>
#include <config.h>

#include <iostream>
#include <vector>
#include <algorithm>
#include <sys/wait.h>
#include <sys/errno.h>
#include <sys/vfs.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>
									/*}}}*/

// UnmountCdrom - Unmount a cdrom					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool UnmountCdrom(string Path)
{
   int Child = fork();
   if (Child < -1)
      return _error->Errno("fork","Failed to fork");

   // The child
   if (Child == 0)
   {
      // Make all the fds /dev/null
      for (int I = 0; I != 10;)
	 close(I);
      for (int I = 0; I != 3;)
	 dup2(open("/dev/null",O_RDWR),I);
      
      const char *Args[10];
      Args[0] = "umount";
      Args[1] = Path.c_str();
      Args[2] = 0;
      execvp(Args[0],(char **)Args);      
      exit(100);
   }

   // Wait for mount
   int Status = 0;
   while (waitpid(Child,&Status,0) != Child)
   {
      if (errno == EINTR)
	 continue;
      return _error->Errno("waitpid","Couldn't wait for subprocess");
   }
   
   // Check for an error code.
   if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
      return false;
   return true;
}
									/*}}}*/
// MountCdrom - Mount a cdrom						/*{{{*/
// ---------------------------------------------------------------------
/* We fork mount.. */
bool MountCdrom(string Path)
{
   int Child = fork();
   if (Child < -1)
      return _error->Errno("fork","Failed to fork");

   // The child
   if (Child == 0)
   {
      // Make all the fds /dev/null
      for (int I = 0; I != 10;)
	 close(I);      
      for (int I = 0; I != 3;)
	 dup2(open("/dev/null",O_RDWR),I);
      
      const char *Args[10];
      Args[0] = "mount";
      Args[1] = Path.c_str();
      Args[2] = 0;
      execvp(Args[0],(char **)Args);      
      exit(100);
   }

   // Wait for mount
   int Status = 0;
   while (waitpid(Child,&Status,0) != Child)
   {
      if (errno == EINTR)
	 continue;
      return _error->Errno("waitpid","Couldn't wait for subprocess");
   }
   
   // Check for an error code.
   if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
      return false;
   return true;
}
									/*}}}*/
// IdentCdrom - Generate a unique string for this CD			/*{{{*/
// ---------------------------------------------------------------------
/* We convert everything we hash into a string, this prevents byte size/order
   from effecting the outcome. */
bool IdentCdrom(string CD,string &Res)
{
   MD5Summation Hash;

   string StartDir = SafeGetCWD();
   if (chdir(CD.c_str()) != 0)
      return _error->Errno("chdir","Unable to change to %s",CD.c_str());
   
   DIR *D = opendir(".");
   if (D == 0)
      return _error->Errno("opendir","Unable to read %s",CD.c_str());
      
   // Run over the directory
   char S[300];
   for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
   {
      // Skip some files..
      if (strcmp(Dir->d_name,".") == 0 ||
	  strcmp(Dir->d_name,"..") == 0)
	 continue;
   
      sprintf(S,"%lu",Dir->d_ino);
      Hash.Add(S);
      Hash.Add(Dir->d_name);
   };
   
   chdir(StartDir.c_str());
   closedir(D);
   
   // Some stats from the fsys
   struct statfs Buf;
   if (statfs(CD.c_str(),&Buf) != 0)
      return _error->Errno("statfs","Failed to stat the cdrom");
   
   sprintf(S,"%u %u",Buf.f_blocks,Buf.f_bfree);
   Hash.Add(S);
   
   Res = Hash.Result().Value();
   return true;   
}
									/*}}}*/

// FindPackage - Find the package files on the CDROM			/*{{{*/
// ---------------------------------------------------------------------
/* We look over the cdrom for package files. This is a recursive
   search that short circuits when it his a package file in the dir.
   This speeds it up greatly as the majority of the size is in the
   binary-* sub dirs. */
bool FindPackages(string CD,vector<string> &List, int Depth = 0)
{
   if (Depth >= 5)
      return true;

   if (CD[CD.length()-1] != '/')
      CD += '/';   
   
   if (chdir(CD.c_str()) != 0)
      return _error->Errno("chdir","Unable to change to %s",CD.c_str());

   /* Aha! We found some package files. We assume that everything under 
      this dir is controlled by those package files so we don't look down
      anymore */
   struct stat Buf;
   if (stat("Packages",&Buf) == 0 ||
       stat("Packages.gz",&Buf) == 0)
   {
      List.push_back(CD);
      return true;
   }

   DIR *D = opendir(".");
   if (D == 0)
      return _error->Errno("opendir","Unable to read %s",CD.c_str());
   
   // Run over the directory
   for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
   {
      // Skip some files..
      if (strcmp(Dir->d_name,".") == 0 ||
	  strcmp(Dir->d_name,"..") == 0 ||
	  strcmp(Dir->d_name,"source") == 0 ||
	  strcmp(Dir->d_name,"experimental") == 0 ||
	  strcmp(Dir->d_name,"binary-all") == 0)
	 continue;

      // See if the name is a sub directory
      struct stat Buf;
      if (stat(Dir->d_name,&Buf) != 0)
      {
	 _error->Errno("Stat","Stat failed for %s",Dir->d_name);
	 break;
      }
      
      if (S_ISDIR(Buf.st_mode) == 0)
	 continue;
      
      // Descend
      if (FindPackages(CD + Dir->d_name,List,Depth+1) == false)
	 break;

      if (chdir(CD.c_str()) != 0)
	 return _error->Errno("chdir","Unable to change to ",CD.c_str());
   };

   closedir(D);
   
   return !_error->PendingError();
}
									/*}}}*/
// CopyPackages - Copy the package files from the CD			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool CopyPackages(string CDROM,string Name,vector<string> &List)
{
   OpTextProgress Progress;
   
   bool NoStat = _config->FindB("APT::CDROM::Fast",false);
   
   // Prepare the progress indicator
   unsigned long TotalSize = 0;
   for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
   {
      struct stat Buf;
      if (stat(string(*I + "Packages").c_str(),&Buf) != 0)
	 return _error->Errno("stat","Stat failed for %s",
			      string(*I + "Packages").c_str());
      TotalSize += Buf.st_size;
   }	

   unsigned long CurrentSize = 0;
   unsigned int NotFound = 0;
   unsigned int WrongSize = 0;
   unsigned int Packages = 0;
   for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
   {
      // Open the package file 
      FileFd Pkg(*I + "Packages",FileFd::ReadOnly);
      pkgTagFile Parser(Pkg);
      if (_error->PendingError() == true)
	 return false;
      
      // Open the output file
      char S[400];
      sprintf(S,"cdrom:%s/%sPackages",Name.c_str(),(*I).c_str() + CDROM.length());
      string TargetF = _config->FindDir("Dir::State::lists") + "partial/";
      FileFd Target(TargetF + URItoFileName(S),FileFd::WriteEmpty);      
      if (_error->PendingError() == true)
	 return false;
      
      // Setup the progress meter
      Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),
			       "Reading Package Lists");

      // Parse
      Progress.SubProgress(Pkg.Size());
      pkgTagSection Section;
      while (Parser.Step(Section) == true)
      {
	 Progress.Progress(Parser.Offset());
	 
	 string File = Section.FindS("Filename");
	 unsigned long Size = Section.FindI("Size");
	 if (File.empty() || Size == 0)
	    return _error->Error("Cannot find filename or size tag");
	 
	 // See if the file exists
	 if (NoStat == false)
	 {
	    struct stat Buf;
	    File = CDROM + File; 
	    if (stat(File.c_str(),&Buf) != 0)
	    {
	       NotFound++;
	       continue;
	    }
	 
	    // Size match
	    if ((unsigned)Buf.st_size != Size)
	    {
	       WrongSize++;
	       continue;
	    }
	 }
	 
	 Packages++;
	 
	 // Copy it to the target package file
	 const char *Start;
	 const char *Stop;
	 Section.GetSection(Start,Stop);
	 if (Target.Write(Start,Stop-Start) == false)
	    return false;
      }
      
      CurrentSize += Pkg.Size();
   }   
   Progress.Done();
   
   // Some stats
   cout << "Wrote " << Packages << " package records" ;
   if (NotFound != 0)
      cout << " with " << NotFound << " missing files";
   if (NotFound != 0 && WrongSize != 0)
      cout << " and"; 
   if (WrongSize != 0)
      cout << " with " << WrongSize << " mismatched files";
   cout << '.' << endl;
   if (NotFound + WrongSize > 10)
      cout << "Alot of package entires were discarded, perhaps this CD is funny?" << endl;
}
									/*}}}*/
// DropBinaryArch - Dump dirs with a string like /binary-<foo>/		/*{{{*/
// ---------------------------------------------------------------------
/* Here we drop everything that is not this machines arch */
bool DropBinaryArch(vector<string> &List)
{
   char S[300];
   sprintf(S,"/binary-%s/",_config->Find("Apt::Architecture").c_str());
   
   for (unsigned int I = 0; I < List.size(); I++)
   {
      const char *Str = List[I].c_str();
      
      const char *Res;
      if ((Res = strstr(Str,"/binary-")) == 0)
	 continue;

      // Weird, remove it.
      if (strlen(Res) < strlen(S))
      {
	 List.erase(List.begin() + I);
	 I--;
	 continue;
      }
	  
      // See if it is our arch
      if (stringcmp(Res,Res + strlen(S),S) == 0)
	 continue;
      
      // Erase it
      List.erase(List.begin() + I);
      I--;
   }
   
   return true;
}
									/*}}}*/
// Score - We compute a 'score' for a path				/*{{{*/
// ---------------------------------------------------------------------
/* Paths are scored based on how close they come to what I consider
   normal. That is ones that have 'dist' 'stable' 'frozen' will score
   higher than ones without. */
int Score(string Path)
{
   int Res = 0;
   if (Path.find("stable/") != string::npos)
      Res += 2;
   if (Path.find("frozen/") != string::npos)
      Res += 2;
   if (Path.find("/dists/") != string::npos)
      Res += 4;
   if (Path.find("/main/") != string::npos)
      Res += 2;
   if (Path.find("/contrib/") != string::npos)
      Res += 2;
   if (Path.find("/non-free/") != string::npos)
      Res += 2;
   if (Path.find("/non-US/") != string::npos)
      Res += 2;
   return Res;
}
									/*}}}*/
// DropRepeats - Drop repeated files resulting from symlinks		/*{{{*/
// ---------------------------------------------------------------------
/* Here we go and stat every file that we found and strip dup inodes. */
bool DropRepeats(vector<string> &List)
{
   // Get a list of all the inodes
   ino_t *Inodes = new ino_t[List.size()];
   for (unsigned int I = 0; I != List.size(); I++)
   {
      struct stat Buf;
      if (stat(List[I].c_str(),&Buf) != 0)
	 _error->Errno("stat","Failed to stat %s",List[I].c_str());
      Inodes[I] = Buf.st_ino;
   }
   
   // Look for dups
   for (unsigned int I = 0; I != List.size(); I++)
   {
      for (unsigned int J = I+1; J < List.size(); J++)
      {
	 // No match
	 if (Inodes[J] != Inodes[I])
	    continue;
	 
	 // We score the two paths.. and erase one
	 int ScoreA = Score(List[I]);
	 int ScoreB = Score(List[J]);
	 if (ScoreA < ScoreB)
	 {
	    List[I] = string();
	    break;
	 }
	 
	 List[J] = string();
      }
   }  
 
   // Wipe erased entries
   for (unsigned int I = 0; I < List.size();)
   {
      if (List[I].empty() == false)
	 I++;
      else
	 List.erase(List.begin()+I);
   }
   
   return true;
}
									/*}}}*/
// ConvertToSourceList - Takes the path list and converts it		/*{{{*/
// ---------------------------------------------------------------------
/* This looks at each element and decides if it can be expressed using
   dists/ form or if it requires an absolute specficiation. It also 
   strips the leading CDROM path from the paths. */
bool ConvertToSourcelist(string CD,vector<string> &List)
{
   char S[300];
   sprintf(S,"binary-%s",_config->Find("Apt::Architecture").c_str());

   sort(List.begin(),List.end());
   
   // Convert to source list notation
   for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
   {      
      // Strip the cdrom base path
      *I = string(*I,CD.length());
   
      // Too short to be a dists/ type
      if ((*I).length() < strlen("dists/"))
	 continue;
   
      // Not a dists type.
      if (stringcmp((*I).begin(),(*I).begin()+strlen("dists/"),"dists/") != 0)
	 continue;

      // Isolate the dist
      string::size_type Slash = strlen("dists/");
      string::size_type Slash2 = (*I).find('/',Slash + 1);
      if (Slash2 == string::npos || Slash2 + 2 >= (*I).length())
	 continue;
      string Dist = string(*I,Slash,Slash2 - Slash);

      // Isolate the component
      Slash = (*I).find('/',Slash2+1);
      if (Slash == string::npos || Slash + 2 >= (*I).length())
	 continue;
      string Comp = string(*I,Slash2+1,Slash - Slash2-1);
      
      // Verify the trailing binar - bit
      Slash2 = (*I).find('/',Slash + 1);
      if (Slash == string::npos)
	 continue;
      string Binary = string(*I,Slash+1,Slash2 - Slash-1);
      
      if (Binary != S)
	 continue;
      
      *I = Dist + ' ' + Comp;
   }
   
   // Collect similar entries
   for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
   {
      // Find a space..
      string::size_type Space = (*I).find(' ');
      if (Space == string::npos)
	 continue;
      
      string Word1 = string(*I,0,Space);
      for (vector<string>::iterator J = List.begin(); J != I; J++)
      {
	 // Find a space..
	 string::size_type Space2 = (*J).find(' ');
	 if (Space2 == string::npos)
	    continue;
	 
	 if (string(*J,0,Space2) != Word1)
	    continue;
	 
	 *J += string(*I,Space);
	 *I = string();
      }
   }   

   // Wipe erased entries
   for (unsigned int I = 0; I < List.size();)
   {
      if (List[I].empty() == false)
	 I++;
      else
	 List.erase(List.begin()+I);
   }
}
									/*}}}*/

// Prompt - Simple prompt						/*{{{*/
// ---------------------------------------------------------------------
/* */
void Prompt(const char *Text)
{
   char C;
   cout << Text << ' ' << flush;
   read(STDIN_FILENO,&C,1);
   if (C != '\n')
      cout << endl;
}
									/*}}}*/
// PromptLine - Prompt for an input line				/*{{{*/
// ---------------------------------------------------------------------
/* */
string PromptLine(const char *Text)
{
   cout << Text << ':' << endl;
   
   string Res;
   getline(cin,Res);
   return Res;
}
									/*}}}*/

// DoAdd - Add a new CDROM						/*{{{*/
// ---------------------------------------------------------------------
/* */
bool DoAdd(CommandLine &)
{
   // Startup
   string CDROM = _config->FindDir("Acquire::cdrom::mount","/cdrom/");
   cout << "Using CD-ROM mount point " << CDROM << endl;
   
   // Read the database
   Configuration Database;
   string DFile = _config->FindFile("Dir::State::cdroms");
   if (FileExists(DFile) == true)
   {
      if (ReadConfigFile(Database,DFile) == false)
	 return _error->Error("Unable to read the cdrom database %s",
			      DFile.c_str());
   }
   
   // Unmount the CD and get the user to put in the one they want
   if (_config->FindB("APT::CDROM::NoMount",false) == false)
   {
      cout << "Unmounting CD-ROM" << endl;
      UnmountCdrom(CDROM);
   
      // Mount the new CDROM
      Prompt("Please insert a CD-ROM and press any key");
      cout << "Mounting CD-ROM" << endl;
      if (MountCdrom(CDROM) == false)
      {
	 cout << "Failed to mount the cdrom." << endl;
	 return false;
      }
   }
   
   // Hash the CD to get an ID
   cout << "Indentifying.. " << flush;
   string ID;
   if (IdentCdrom(CDROM,ID) == false)
      return false;
   cout << '[' << ID << ']' << endl;

   cout << "Scanning Disc for index files..  " << flush;
   // Get the CD structure
   vector<string> List;
   string StartDir = SafeGetCWD();
   if (FindPackages(CDROM,List) == false)
      return false;
   chdir(StartDir.c_str());
   
   // Fix up the list
   DropBinaryArch(List);
   DropRepeats(List);
   cout << "Found " << List.size() << " package index files." << endl;

   if (List.size() == 0)
      return _error->Error("Unable to locate any package files, perhaps this is not a debian CD-ROM");
   
   // Check if the CD is in the database
   string Name;
   if (Database.Exists("CD::" + ID) == false ||
       _config->FindB("APT::CDROM::Rename",false) == true)
   {
      cout << "Please provide a name for this CD-ROM, such as 'Debian 2.1r1 Disk 1'";
      Name = PromptLine("");
   }
   else
      Name = Database.Find("CD::" + ID);
   cout << "This Disc is called '" << Name << "'" << endl;
   
   // Copy the package files to the state directory
   if (CopyPackages(CDROM,Name,List) == false)
      return false;
   
   ConvertToSourcelist(CDROM,List);

   // Print the sourcelist entries
   cout << "Source List entires for this Disc are:" << endl;
   for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
      cout << "deb \"cdrom:" << Name << "/\" " << *I << endl;
   
   return true;
}
									/*}}}*/

// ShowHelp - Show the help screen					/*{{{*/
// ---------------------------------------------------------------------
/* */
int ShowHelp()
{
   cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
       " compiled on " << __DATE__ << "  " << __TIME__ << endl;
   
   cout << "Usage: apt-cdrom [options] command" << endl;
   cout << endl;
   cout << "apt-cdrom is a tool to add CDROM's to APT's source list. The " << endl;
   cout << "CDROM mount point and device information is taken from apt.conf" << endl;
   cout << "and /etc/fstab." << endl;
   cout << endl;
   cout << "Commands:" << endl;
   cout << "   add - Add a CDROM" << endl;
   cout << endl;
   cout << "Options:" << endl;
   cout << "  -h   This help text" << endl;
   cout << "  -d   CD-ROM mount point" << endl;
   cout << "  -r   Rename a recognized CD-ROM" << endl;
   cout << "  -m   No mounting" << endl;
   cout << "  -c=? Read this configuration file" << endl;
   cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
   cout << "See fstab(5)" << endl;
   return 100;
}
									/*}}}*/

int main(int argc,const char *argv[])
{
   CommandLine::Args Args[] = {
      {'h',"help","help",0},
      {'d',"cdrom","Acquire::cdrom::mount",CommandLine::HasArg},
      {'r',"rename","APT::CDROM::Rename",0},
      {'m',"no-mount","APT::CDROM::NoMount",0},
      {'f',"fast","APT::CDROM::Fast",0},
      {'c',"config-file",0,CommandLine::ConfigFile},
      {'o',"option",0,CommandLine::ArbItem},
      {0,0,0,0}};
   CommandLine::Dispatch Cmds[] = {
      {"add",&DoAdd},
      {0,0}};
	 
   // Parse the command line and initialize the package library
   CommandLine CmdL(Args,_config);
   if (pkgInitialize(*_config) == false ||
       CmdL.Parse(argc,argv) == false)
   {
      _error->DumpErrors();
      return 100;
   }

   // See if the help should be shown
   if (_config->FindB("help") == true ||
       CmdL.FileSize() == 0)
      return ShowHelp();
   
   // Match the operation
   CmdL.DispatchArg(Cmds);

   // Print any errors or warnings found during parsing
   if (_error->empty() == false)
   {
      bool Errors = _error->PendingError();
      _error->DumpErrors();
      return Errors == true?100:0;
   }
   
   return 0;
}
Commit	Line	Data
83d89a9f AL	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	// $Id: apt-cdrom.cc,v 1.1 1998/11/27 01:52:56 jgg Exp $
	4	/* ######################################################################
	5
	6
	7	##################################################################### */
	8	/}}}/
	9	// Include Files /{{{/
	10	#include <apt-pkg/cmndline.h>
	11	#include <apt-pkg/error.h>
	12	#include <apt-pkg/init.h>
	13	#include <apt-pkg/md5.h>
	14	#include <apt-pkg/fileutl.h>
	15	#include <apt-pkg/progress.h>
	16	#include <apt-pkg/tagfile.h>
	17	#include <strutl.h>
	18	#include <config.h>
	19
	20	#include <iostream>
	21	#include <vector>
	22	#include <algorithm>
	23	#include <sys/wait.h>
	24	#include <sys/errno.h>
	25	#include <sys/vfs.h>
	26	#include <sys/stat.h>
	27	#include <fcntl.h>
	28	#include <dirent.h>
	29	#include <unistd.h>
	30	#include <stdio.h>
	31	/}}}/
	32
	33	// UnmountCdrom - Unmount a cdrom /{{{/
	34	// ---------------------------------------------------------------------
	35	/* */
	36	bool UnmountCdrom(string Path)
	37	{
	38	int Child = fork();
	39	if (Child < -1)
	40	return _error->Errno("fork","Failed to fork");
	41
	42	// The child
	43	if (Child == 0)
	44	{
	45	// Make all the fds /dev/null
	46	for (int I = 0; I != 10;)
	47	close(I);
	48	for (int I = 0; I != 3;)
	49	dup2(open("/dev/null",O_RDWR),I);
	50
	51	const char *Args[10];
	52	Args[0] = "umount";
	53	Args[1] = Path.c_str();
	54	Args[2] = 0;
	55	execvp(Args[0],(char **)Args);
	56	exit(100);
	57	}
	58
	59	// Wait for mount
	60	int Status = 0;
	61	while (waitpid(Child,&Status,0) != Child)
	62	{
	63	if (errno == EINTR)
	64	continue;
65	return _error->Errno("waitpid","Couldn't wait for subprocess");
66	}
67
68	// Check for an error code.
69	if (WIFEXITED(Status) == 0 \|\| WEXITSTATUS(Status) != 0)
70	return false;
71	return true;
72	}
73	/}}}/
74	// MountCdrom - Mount a cdrom /{{{/
75	// ---------------------------------------------------------------------
76	/* We fork mount.. */
77	bool MountCdrom(string Path)
78	{
79	int Child = fork();
80	if (Child < -1)
81	return _error->Errno("fork","Failed to fork");
82
83	// The child
84	if (Child == 0)
85	{
86	// Make all the fds /dev/null
87	for (int I = 0; I != 10;)
88	close(I);
89	for (int I = 0; I != 3;)
90	dup2(open("/dev/null",O_RDWR),I);
91
92	const char *Args[10];
93	Args[0] = "mount";
94	Args[1] = Path.c_str();
95	Args[2] = 0;
96	execvp(Args[0],(char **)Args);
97	exit(100);
98	}
99
100	// Wait for mount
101	int Status = 0;
102	while (waitpid(Child,&Status,0) != Child)
103	{
104	if (errno == EINTR)
105	continue;
106	return _error->Errno("waitpid","Couldn't wait for subprocess");
107	}
108
109	// Check for an error code.
110	if (WIFEXITED(Status) == 0 \|\| WEXITSTATUS(Status) != 0)
111	return false;
112	return true;
113	}
114	/}}}/
115	// IdentCdrom - Generate a unique string for this CD /{{{/
116	// ---------------------------------------------------------------------
117	/* We convert everything we hash into a string, this prevents byte size/order
118	from effecting the outcome. */
119	bool IdentCdrom(string CD,string &Res)
120	{
121	MD5Summation Hash;
122
123	string StartDir = SafeGetCWD();
124	if (chdir(CD.c_str()) != 0)
125	return _error->Errno("chdir","Unable to change to %s",CD.c_str());
126
127	DIR *D = opendir(".");
128	if (D == 0)
129	return _error->Errno("opendir","Unable to read %s",CD.c_str());
130
131	// Run over the directory
132	char S[300];
133	for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
134	{
135	// Skip some files..
136	if (strcmp(Dir->d_name,".") == 0 \|\|
137	strcmp(Dir->d_name,"..") == 0)
138	continue;
139
140	sprintf(S,"%lu",Dir->d_ino);
141	Hash.Add(S);
142	Hash.Add(Dir->d_name);
143	};
144
145	chdir(StartDir.c_str());
146	closedir(D);
147
148	// Some stats from the fsys
149	struct statfs Buf;
150	if (statfs(CD.c_str(),&Buf) != 0)
151	return _error->Errno("statfs","Failed to stat the cdrom");
152
153	sprintf(S,"%u %u",Buf.f_blocks,Buf.f_bfree);
154	Hash.Add(S);
155
156	Res = Hash.Result().Value();
157	return true;
158	}
159	/}}}/
160
161	// FindPackage - Find the package files on the CDROM /{{{/
162	// ---------------------------------------------------------------------
163	/* We look over the cdrom for package files. This is a recursive
164	search that short circuits when it his a package file in the dir.
165	This speeds it up greatly as the majority of the size is in the
166	binary-* sub dirs. */
167	bool FindPackages(string CD,vector<string> &List, int Depth = 0)
168	{
169	if (Depth >= 5)
170	return true;
171
172	if (CD[CD.length()-1] != '/')
173	CD += '/';
174
175	if (chdir(CD.c_str()) != 0)
176	return _error->Errno("chdir","Unable to change to %s",CD.c_str());
177
178	/* Aha! We found some package files. We assume that everything under
179	this dir is controlled by those package files so we don't look down
180	anymore */
181	struct stat Buf;
182	if (stat("Packages",&Buf) == 0 \|\|
183	stat("Packages.gz",&Buf) == 0)
184	{
185	List.push_back(CD);
186	return true;
187	}
188
189	DIR *D = opendir(".");
190	if (D == 0)
191	return _error->Errno("opendir","Unable to read %s",CD.c_str());
192
193	// Run over the directory
194	for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
195	{
196	// Skip some files..
197	if (strcmp(Dir->d_name,".") == 0 \|\|
198	strcmp(Dir->d_name,"..") == 0 \|\|
199	strcmp(Dir->d_name,"source") == 0 \|\|
200	strcmp(Dir->d_name,"experimental") == 0 \|\|
201	strcmp(Dir->d_name,"binary-all") == 0)
202	continue;
203
204	// See if the name is a sub directory
205	struct stat Buf;
206	if (stat(Dir->d_name,&Buf) != 0)
207	{
208	_error->Errno("Stat","Stat failed for %s",Dir->d_name);
209	break;
210	}
211
212	if (S_ISDIR(Buf.st_mode) == 0)
213	continue;
214
215	// Descend
216	if (FindPackages(CD + Dir->d_name,List,Depth+1) == false)
217	break;
218
219	if (chdir(CD.c_str()) != 0)
220	return _error->Errno("chdir","Unable to change to ",CD.c_str());
221	};
222
223	closedir(D);
224
225	return !_error->PendingError();
226	}
227	/}}}/
228	// CopyPackages - Copy the package files from the CD /{{{/
229	// ---------------------------------------------------------------------
230	/* */
231	bool CopyPackages(string CDROM,string Name,vector<string> &List)
232	{
233	OpTextProgress Progress;
234
235	bool NoStat = _config->FindB("APT::CDROM::Fast",false);
236
237	// Prepare the progress indicator
238	unsigned long TotalSize = 0;
239	for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
240	{
241	struct stat Buf;
242	if (stat(string(*I + "Packages").c_str(),&Buf) != 0)
243	return _error->Errno("stat","Stat failed for %s",
244	string(*I + "Packages").c_str());
245	TotalSize += Buf.st_size;
246	}
247
248	unsigned long CurrentSize = 0;
249	unsigned int NotFound = 0;
250	unsigned int WrongSize = 0;
251	unsigned int Packages = 0;
252	for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
253	{
254	// Open the package file
255	FileFd Pkg(*I + "Packages",FileFd::ReadOnly);
256	pkgTagFile Parser(Pkg);
257	if (_error->PendingError() == true)
258	return false;
259
260	// Open the output file
261	char S[400];
262	sprintf(S,"cdrom:%s/%sPackages",Name.c_str(),(*I).c_str() + CDROM.length());
263	string TargetF = _config->FindDir("Dir::State::lists") + "partial/";
264	FileFd Target(TargetF + URItoFileName(S),FileFd::WriteEmpty);
265	if (_error->PendingError() == true)
266	return false;
267
268	// Setup the progress meter
269	Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),
270	"Reading Package Lists");
271
272	// Parse
273	Progress.SubProgress(Pkg.Size());
274	pkgTagSection Section;
275	while (Parser.Step(Section) == true)
276	{
277	Progress.Progress(Parser.Offset());
278
279	string File = Section.FindS("Filename");
280	unsigned long Size = Section.FindI("Size");
281	if (File.empty() \|\| Size == 0)
282	return _error->Error("Cannot find filename or size tag");
283
284	// See if the file exists
285	if (NoStat == false)
286	{
287	struct stat Buf;
288	File = CDROM + File;
289	if (stat(File.c_str(),&Buf) != 0)
290	{
291	NotFound++;
292	continue;
293	}
294
295	// Size match
296	if ((unsigned)Buf.st_size != Size)
297	{
298	WrongSize++;
299	continue;
300	}
301	}
302
303	Packages++;
304
305	// Copy it to the target package file
306	const char *Start;
307	const char *Stop;
308	Section.GetSection(Start,Stop);
309	if (Target.Write(Start,Stop-Start) == false)
310	return false;
311	}
312
313	CurrentSize += Pkg.Size();
314	}
315	Progress.Done();
316
317	// Some stats
318	cout << "Wrote " << Packages << " package records" ;
319	if (NotFound != 0)
320	cout << " with " << NotFound << " missing files";
321	if (NotFound != 0 && WrongSize != 0)
322	cout << " and";
323	if (WrongSize != 0)
324	cout << " with " << WrongSize << " mismatched files";
325	cout << '.' << endl;
326	if (NotFound + WrongSize > 10)
327	cout << "Alot of package entires were discarded, perhaps this CD is funny?" << endl;
328	}
329	/}}}/
330	// DropBinaryArch - Dump dirs with a string like /binary-<foo>/ /{{{/
331	// ---------------------------------------------------------------------
332	/* Here we drop everything that is not this machines arch */
333	bool DropBinaryArch(vector<string> &List)
334	{
335	char S[300];
336	sprintf(S,"/binary-%s/",_config->Find("Apt::Architecture").c_str());
337
338	for (unsigned int I = 0; I < List.size(); I++)
339	{
340	const char *Str = List[I].c_str();
341
342	const char *Res;
343	if ((Res = strstr(Str,"/binary-")) == 0)
344	continue;
345
346	// Weird, remove it.
347	if (strlen(Res) < strlen(S))
348	{
349	List.erase(List.begin() + I);
350	I--;
351	continue;
352	}
353
354	// See if it is our arch
355	if (stringcmp(Res,Res + strlen(S),S) == 0)
356	continue;
357
358	// Erase it
359	List.erase(List.begin() + I);
360	I--;
361	}
362
363	return true;
364	}
365	/}}}/
366	// Score - We compute a 'score' for a path /{{{/
367	// ---------------------------------------------------------------------
368	/* Paths are scored based on how close they come to what I consider
369	normal. That is ones that have 'dist' 'stable' 'frozen' will score
370	higher than ones without. */
371	int Score(string Path)
372	{
373	int Res = 0;
374	if (Path.find("stable/") != string::npos)
375	Res += 2;
376	if (Path.find("frozen/") != string::npos)
377	Res += 2;
378	if (Path.find("/dists/") != string::npos)
379	Res += 4;
380	if (Path.find("/main/") != string::npos)
381	Res += 2;
382	if (Path.find("/contrib/") != string::npos)
383	Res += 2;
384	if (Path.find("/non-free/") != string::npos)
385	Res += 2;
386	if (Path.find("/non-US/") != string::npos)
387	Res += 2;
388	return Res;
389	}
390	/}}}/
391	// DropRepeats - Drop repeated files resulting from symlinks /{{{/
392	// ---------------------------------------------------------------------
393	/* Here we go and stat every file that we found and strip dup inodes. */
394	bool DropRepeats(vector<string> &List)
395	{
396	// Get a list of all the inodes
397	ino_t *Inodes = new ino_t[List.size()];
398	for (unsigned int I = 0; I != List.size(); I++)
399	{
400	struct stat Buf;
401	if (stat(List[I].c_str(),&Buf) != 0)
402	_error->Errno("stat","Failed to stat %s",List[I].c_str());
403	Inodes[I] = Buf.st_ino;
404	}
405
406	// Look for dups
407	for (unsigned int I = 0; I != List.size(); I++)
408	{
409	for (unsigned int J = I+1; J < List.size(); J++)
410	{
411	// No match
412	if (Inodes[J] != Inodes[I])
413	continue;
414
415	// We score the two paths.. and erase one
416	int ScoreA = Score(List[I]);
417	int ScoreB = Score(List[J]);
418	if (ScoreA < ScoreB)
419	{
420	List[I] = string();
421	break;
422	}
423
424	List[J] = string();
425	}
426	}
427
428	// Wipe erased entries
429	for (unsigned int I = 0; I < List.size();)
430	{
431	if (List[I].empty() == false)
432	I++;
433	else
434	List.erase(List.begin()+I);
435	}
436
437	return true;
438	}
439	/}}}/
440	// ConvertToSourceList - Takes the path list and converts it /{{{/
441	// ---------------------------------------------------------------------
442	/* This looks at each element and decides if it can be expressed using
443	dists/ form or if it requires an absolute specficiation. It also
444	strips the leading CDROM path from the paths. */
445	bool ConvertToSourcelist(string CD,vector<string> &List)
446	{
447	char S[300];
448	sprintf(S,"binary-%s",_config->Find("Apt::Architecture").c_str());
449
450	sort(List.begin(),List.end());
451
452	// Convert to source list notation
453	for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
454	{
455	// Strip the cdrom base path
456	I = string(I,CD.length());
457
458	// Too short to be a dists/ type
459	if ((*I).length() < strlen("dists/"))
460	continue;
461
462	// Not a dists type.
463	if (stringcmp((I).begin(),(I).begin()+strlen("dists/"),"dists/") != 0)
464	continue;
465
466	// Isolate the dist
467	string::size_type Slash = strlen("dists/");
468	string::size_type Slash2 = (*I).find('/',Slash + 1);
469	if (Slash2 == string::npos \|\| Slash2 + 2 >= (*I).length())
470	continue;
471	string Dist = string(*I,Slash,Slash2 - Slash);
472
473	// Isolate the component
474	Slash = (*I).find('/',Slash2+1);
475	if (Slash == string::npos \|\| Slash + 2 >= (*I).length())
476	continue;
477	string Comp = string(*I,Slash2+1,Slash - Slash2-1);
478
479	// Verify the trailing binar - bit
480	Slash2 = (*I).find('/',Slash + 1);
481	if (Slash == string::npos)
482	continue;
483	string Binary = string(*I,Slash+1,Slash2 - Slash-1);
484
485	if (Binary != S)
486	continue;
487
488	*I = Dist + ' ' + Comp;
489	}
490
491	// Collect similar entries
492	for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
493	{
494	// Find a space..
495	string::size_type Space = (*I).find(' ');
496	if (Space == string::npos)
497	continue;
498
499	string Word1 = string(*I,0,Space);
500	for (vector<string>::iterator J = List.begin(); J != I; J++)
501	{
502	// Find a space..
503	string::size_type Space2 = (*J).find(' ');
504	if (Space2 == string::npos)
505	continue;
506
507	if (string(*J,0,Space2) != Word1)
508	continue;
509
510	J += string(I,Space);
511	*I = string();
512	}
513	}
514
515	// Wipe erased entries
516	for (unsigned int I = 0; I < List.size();)
517	{
518	if (List[I].empty() == false)
519	I++;
520	else
521	List.erase(List.begin()+I);
522	}
523	}
524	/}}}/
525
526	// Prompt - Simple prompt /{{{/
527	// ---------------------------------------------------------------------
528	/* */
529	void Prompt(const char *Text)
530	{
531	char C;
532	cout << Text << ' ' << flush;
533	read(STDIN_FILENO,&C,1);
534	if (C != '\n')
535	cout << endl;
536	}
537	/}}}/
538	// PromptLine - Prompt for an input line /{{{/
539	// ---------------------------------------------------------------------
540	/* */
541	string PromptLine(const char *Text)
542	{
543	cout << Text << ':' << endl;
544
545	string Res;
546	getline(cin,Res);
547	return Res;
548	}
549	/}}}/
550
551	// DoAdd - Add a new CDROM /{{{/
552	// ---------------------------------------------------------------------
553	/* */
554	bool DoAdd(CommandLine &)
555	{
556	// Startup
557	string CDROM = _config->FindDir("Acquire::cdrom::mount","/cdrom/");
558	cout << "Using CD-ROM mount point " << CDROM << endl;
559
560	// Read the database
561	Configuration Database;
562	string DFile = _config->FindFile("Dir::State::cdroms");
563	if (FileExists(DFile) == true)
564	{
565	if (ReadConfigFile(Database,DFile) == false)
566	return _error->Error("Unable to read the cdrom database %s",
567	DFile.c_str());
568	}
569
570	// Unmount the CD and get the user to put in the one they want
571	if (_config->FindB("APT::CDROM::NoMount",false) == false)
572	{
573	cout << "Unmounting CD-ROM" << endl;
574	UnmountCdrom(CDROM);
575
576	// Mount the new CDROM
577	Prompt("Please insert a CD-ROM and press any key");
578	cout << "Mounting CD-ROM" << endl;
579	if (MountCdrom(CDROM) == false)
580	{
581	cout << "Failed to mount the cdrom." << endl;
582	return false;
583	}
584	}
585
586	// Hash the CD to get an ID
587	cout << "Indentifying.. " << flush;
588	string ID;
589	if (IdentCdrom(CDROM,ID) == false)
590	return false;
591	cout << '[' << ID << ']' << endl;
592
593	cout << "Scanning Disc for index files.. " << flush;
594	// Get the CD structure
595	vector<string> List;
596	string StartDir = SafeGetCWD();
597	if (FindPackages(CDROM,List) == false)
598	return false;
599	chdir(StartDir.c_str());
600
601	// Fix up the list
602	DropBinaryArch(List);
603	DropRepeats(List);
604	cout << "Found " << List.size() << " package index files." << endl;
605
606	if (List.size() == 0)
607	return _error->Error("Unable to locate any package files, perhaps this is not a debian CD-ROM");
608
609	// Check if the CD is in the database
610	string Name;
611	if (Database.Exists("CD::" + ID) == false \|\|
612	_config->FindB("APT::CDROM::Rename",false) == true)
613	{
614	cout << "Please provide a name for this CD-ROM, such as 'Debian 2.1r1 Disk 1'";
615	Name = PromptLine("");
616	}
617	else
618	Name = Database.Find("CD::" + ID);
619	cout << "This Disc is called '" << Name << "'" << endl;
620
621	// Copy the package files to the state directory
622	if (CopyPackages(CDROM,Name,List) == false)
623	return false;
624
625	ConvertToSourcelist(CDROM,List);
626
627	// Print the sourcelist entries
628	cout << "Source List entires for this Disc are:" << endl;
629	for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
630	cout << "deb \"cdrom:" << Name << "/\" " << *I << endl;
631
632	return true;
633	}
634	/}}}/
635
636	// ShowHelp - Show the help screen /{{{/
637	// ---------------------------------------------------------------------
638	/* */
639	int ShowHelp()
640	{
641	cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
642	" compiled on " << __DATE__ << " " << __TIME__ << endl;
643
644	cout << "Usage: apt-cdrom [options] command" << endl;
645	cout << endl;
646	cout << "apt-cdrom is a tool to add CDROM's to APT's source list. The " << endl;
647	cout << "CDROM mount point and device information is taken from apt.conf" << endl;
648	cout << "and /etc/fstab." << endl;
649	cout << endl;
650	cout << "Commands:" << endl;
651	cout << " add - Add a CDROM" << endl;
652	cout << endl;
653	cout << "Options:" << endl;
654	cout << " -h This help text" << endl;
655	cout << " -d CD-ROM mount point" << endl;
656	cout << " -r Rename a recognized CD-ROM" << endl;
657	cout << " -m No mounting" << endl;
658	cout << " -c=? Read this configuration file" << endl;
659	cout << " -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
660	cout << "See fstab(5)" << endl;
661	return 100;
662	}
663	/}}}/
664
665	int main(int argc,const char *argv[])
666	{
667	CommandLine::Args Args[] = {
668	{'h',"help","help",0},
669	{'d',"cdrom","Acquire::cdrom::mount",CommandLine::HasArg},
670	{'r',"rename","APT::CDROM::Rename",0},
671	{'m',"no-mount","APT::CDROM::NoMount",0},
672	{'f',"fast","APT::CDROM::Fast",0},
673	{'c',"config-file",0,CommandLine::ConfigFile},
674	{'o',"option",0,CommandLine::ArbItem},
675	{0,0,0,0}};
676	CommandLine::Dispatch Cmds[] = {
677	{"add",&DoAdd},
678	{0,0}};
679
680	// Parse the command line and initialize the package library
681	CommandLine CmdL(Args,_config);
682	if (pkgInitialize(*_config) == false \|\|
683	CmdL.Parse(argc,argv) == false)
684	{
685	_error->DumpErrors();
686	return 100;
687	}
688
689	// See if the help should be shown
690	if (_config->FindB("help") == true \|\|
691	CmdL.FileSize() == 0)
692	return ShowHelp();
693
694	// Match the operation
695	CmdL.DispatchArg(Cmds);
696
697	// Print any errors or warnings found during parsing
698	if (_error->empty() == false)
699	{
700	bool Errors = _error->PendingError();
701	_error->DumpErrors();
702	return Errors == true?100:0;
703	}
704
705	return 0;
706	}