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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: apt-cdrom.cc,v 1.45 2003/11/19 23:50:51 mdz Exp $
/* ######################################################################
   
   APT CDROM - Tool for handling APT's CDROM database.
   
   Currently the only option is 'add' which will take the current CD
   in the drive and add it into the database.
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/cmndline.h>
#include <apt-pkg/error.h>
#include <apt-pkg/init.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/cdromutl.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/acquire.h>
#include <apt-pkg/acquire-item.h>
#include <apt-pkg/cdrom.h>
#include <config.h>
#include <apti18n.h>
    
//#include "indexcopy.h"

#include <locale.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>
									/*}}}*/

using namespace std;

class pkgCdromTextStatus : public pkgCdromStatus			/*{{{*/
{
protected:
   OpTextProgress Progress;
   void Prompt(const char *Text); 
   string PromptLine(const char *Text);
   bool AskCdromName(string &name);

public:
   virtual void Update(string text, int current);
   virtual bool ChangeCdrom();
   virtual OpProgress* GetOpProgress();
};

void pkgCdromTextStatus::Prompt(const char *Text) 
{
   char C;
   cout << Text << ' ' << flush;
   read(STDIN_FILENO,&C,1);
   if (C != '\n')
      cout << endl;
}

string pkgCdromTextStatus::PromptLine(const char *Text)
{
   cout << Text << ':' << endl;
   
   string Res;
   getline(cin,Res);
   return Res;
}

bool pkgCdromTextStatus::AskCdromName(string &name) 
{
   cout << _("Please provide a name for this Disc, such as 'Debian 5.0.3 Disk 1'") << flush;
   name = PromptLine("");
	 
   return true;
}
   

void pkgCdromTextStatus::Update(string text, int current) 
{
   if(text.size() > 0)
      cout << text << flush;
}

bool pkgCdromTextStatus::ChangeCdrom() 
{
   Prompt(_("Please insert a Disc in the drive and press enter"));
   return true;
}

OpProgress* pkgCdromTextStatus::GetOpProgress() 
{ 
   return &Progress; 
};
									/*}}}*/
// SetupAutoDetect       						/*{{{*/
bool AutoDetectCdrom(pkgUdevCdromDevices &UdevCdroms, unsigned int &i)
{
   bool Debug =  _config->FindB("Debug::Acquire::cdrom", false);

   vector<struct CdromDevice> v = UdevCdroms.Scan();
   if (i >= v.size())
      return false;

   if (Debug)
      clog << "Looking at devce " << i
	   << " DeviveName: " << v[i].DeviceName 
	   << " IsMounted: '" << v[i].Mounted << "'"
	   << " MountPoint: '" << v[i].MountPath << "'"
	   << endl;

   if (v[i].Mounted)
   {
      // set the right options
      _config->Set("Acquire::cdrom::mount", v[i].MountPath);
      _config->Set("APT::CDROM::NoMount", true);
   } else {
      string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
      if (!FileExists(AptMountPoint))
	 mkdir(AptMountPoint.c_str(), 0750);
      if(MountCdrom(AptMountPoint, v[i].DeviceName) == false)
	 _error->Warning(_("Failed to mount '%s' to '%s'"), v[i].DeviceName.c_str(), AptMountPoint.c_str());
      _config->Set("Acquire::cdrom::mount", AptMountPoint);
      _config->Set("APT::CDROM::NoMount", true);
   }
   i++;

   return true;
}
									/*}}}*/

// DoAdd - Add a new CDROM						/*{{{*/
// ---------------------------------------------------------------------
/* This does the main add bit.. We show some status and things. The
   sequence is to mount/umount the CD, Ident it then scan it for package 
   files and reduce that list. Then we copy over the package files and
   verify them. Then rewrite the database files */
bool DoAdd(CommandLine &)
{
   pkgUdevCdromDevices UdevCdroms;
   pkgCdromTextStatus log;
   pkgCdrom cdrom;
   bool res = true;

   bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect");
   unsigned int count = 0;
   
   if (AutoDetect && UdevCdroms.Dlopen())
   {
      while (AutoDetectCdrom(UdevCdroms, count))
	 res &= cdrom.Add(&log);
   } else {
      res = cdrom.Add(&log);
   }

   if(res)
      cout << _("Repeat this process for the rest of the CDs in your set.") << endl;

   return res;
}
									/*}}}*/
// DoIdent - Ident a CDROM						/*{{{*/
// ---------------------------------------------------------------------
/* */
bool DoIdent(CommandLine &)
{
   pkgUdevCdromDevices UdevCdroms;
   string ident;
   pkgCdromTextStatus log;
   pkgCdrom cdrom;
   bool res = true;

   bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect");
   unsigned int count = 0;
   
   if (AutoDetect && UdevCdroms.Dlopen())
   {
      while (AutoDetectCdrom(UdevCdroms, count))
	 res &= cdrom.Ident(ident, &log);
   } else {
      return cdrom.Ident(ident, &log);
   }
 
   return res;
}
									/*}}}*/
// ShowHelp - Show the help screen					/*{{{*/
// ---------------------------------------------------------------------
/* */
int ShowHelp()
{
   ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
	    COMMON_ARCH,__DATE__,__TIME__);
   if (_config->FindB("version") == true)
      return 0;
   
   cout << 
      "Usage: apt-cdrom [options] command\n"
      "\n"
      "apt-cdrom is a tool to add CDROM's to APT's source list. The\n"
      "CDROM mount point and device information is taken from apt.conf\n"
      "and /etc/fstab.\n"
      "\n"
      "Commands:\n"
      "   add - Add a CDROM\n"
      "   ident - Report the identity of a CDROM\n"
      "\n"
      "Options:\n"
      "  -h   This help text\n"
      "  -d   CD-ROM mount point\n"
      "  -r   Rename a recognized CD-ROM\n"
      "  -m   No mounting\n"
      "  -f   Fast mode, don't check package files\n"
      "  -a   Thorough scan mode\n"
      "  --auto-detect Auto detect drive and mount point\n"
      "  -c=? Read this configuration file\n"
      "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
      "See fstab(5)\n";
   return 0;
}
									/*}}}*/
int main(int argc,const char *argv[])					/*{{{*/
{
   CommandLine::Args Args[] = {
      {'h',"help","help",0},
      {  0,"auto-detect","Acquire::cdrom::AutoDetect",0},
      {'v',"version","version",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},
      {'n',"just-print","APT::CDROM::NoAct",0},
      {'n',"recon","APT::CDROM::NoAct",0},      
      {'n',"no-act","APT::CDROM::NoAct",0},
      {'a',"thorough","APT::CDROM::Thorough",0},
      {'c',"config-file",0,CommandLine::ConfigFile},
      {'o',"option",0,CommandLine::ArbItem},
      {0,0,0,0}};
   CommandLine::Dispatch Cmds[] = {
      {"add",&DoAdd},
      {"ident",&DoIdent},
      {0,0}};

   // Set up gettext support
   setlocale(LC_ALL,"");
   textdomain(PACKAGE);

   // Parse the command line and initialize the package library
   CommandLine CmdL(Args,_config);
   if (pkgInitConfig(*_config) == false ||
       CmdL.Parse(argc,argv) == false ||
       pkgInitSystem(*_config,_system) == false)
   {
      _error->DumpErrors();
      return 100;
   }

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

   // Deal with stdout not being a tty
   if (isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
      _config->Set("quiet","1");
   
   // 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
da6ee469 JF	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	// $Id: apt-cdrom.cc,v 1.45 2003/11/19 23:50:51 mdz Exp $
	4	/* ######################################################################
	5
	6	APT CDROM - Tool for handling APT's CDROM database.
	7
	8	Currently the only option is 'add' which will take the current CD
	9	in the drive and add it into the database.
	10
	11	##################################################################### */
	12	/}}}/
	13	// Include Files /{{{/
	14	#include <apt-pkg/cmndline.h>
	15	#include <apt-pkg/error.h>
	16	#include <apt-pkg/init.h>
	17	#include <apt-pkg/fileutl.h>
	18	#include <apt-pkg/progress.h>
	19	#include <apt-pkg/cdromutl.h>
	20	#include <apt-pkg/strutl.h>
	21	#include <apt-pkg/acquire.h>
	22	#include <apt-pkg/acquire-item.h>
	23	#include <apt-pkg/cdrom.h>
	24	#include <config.h>
	25	#include <apti18n.h>
	26
	27	//#include "indexcopy.h"
	28
	29	#include <locale.h>
	30	#include <iostream>
	31	#include <fstream>
	32	#include <vector>
	33	#include <algorithm>
	34	#include <sys/stat.h>
	35	#include <fcntl.h>
	36	#include <dirent.h>
	37	#include <unistd.h>
	38	#include <stdio.h>
	39	/}}}/
	40
	41	using namespace std;
	42
0e5943eb	43	class pkgCdromTextStatus : public pkgCdromStatus /{{{/
da6ee469 JF	44	{
	45	protected:
	46	OpTextProgress Progress;
	47	void Prompt(const char *Text);
	48	string PromptLine(const char *Text);
	49	bool AskCdromName(string &name);
	50
	51	public:
	52	virtual void Update(string text, int current);
	53	virtual bool ChangeCdrom();
	54	virtual OpProgress* GetOpProgress();
	55	};
	56
	57	void pkgCdromTextStatus::Prompt(const char *Text)
	58	{
	59	char C;
	60	cout << Text << ' ' << flush;
	61	read(STDIN_FILENO,&C,1);
	62	if (C != '\n')
	63	cout << endl;
	64	}
	65
	66	string pkgCdromTextStatus::PromptLine(const char *Text)
	67	{
	68	cout << Text << ':' << endl;
	69
	70	string Res;
	71	getline(cin,Res);
	72	return Res;
	73	}
	74
	75	bool pkgCdromTextStatus::AskCdromName(string &name)
	76	{
0e5943eb	77	cout << _("Please provide a name for this Disc, such as 'Debian 5.0.3 Disk 1'") << flush;
da6ee469 JF	78	name = PromptLine("");
	79
	80	return true;
	81	}
	82
	83
	84	void pkgCdromTextStatus::Update(string text, int current)
	85	{
	86	if(text.size() > 0)
	87	cout << text << flush;
	88	}
	89
	90	bool pkgCdromTextStatus::ChangeCdrom()
	91	{
	92	Prompt(_("Please insert a Disc in the drive and press enter"));
	93	return true;
	94	}
	95
	96	OpProgress* pkgCdromTextStatus::GetOpProgress()
	97	{
	98	return &Progress;
	99	};
0e5943eb JF	100	/}}}/
	101	// SetupAutoDetect /{{{/
	102	bool AutoDetectCdrom(pkgUdevCdromDevices &UdevCdroms, unsigned int &i)
	103	{
	104	bool Debug = _config->FindB("Debug::Acquire::cdrom", false);
	105
	106	vector<struct CdromDevice> v = UdevCdroms.Scan();
	107	if (i >= v.size())
	108	return false;
	109
	110	if (Debug)
	111	clog << "Looking at devce " << i
	112	<< " DeviveName: " << v[i].DeviceName
	113	<< " IsMounted: '" << v[i].Mounted << "'"
	114	<< " MountPoint: '" << v[i].MountPath << "'"
	115	<< endl;
	116
	117	if (v[i].Mounted)
	118	{
	119	// set the right options
	120	_config->Set("Acquire::cdrom::mount", v[i].MountPath);
	121	_config->Set("APT::CDROM::NoMount", true);
	122	} else {
	123	string AptMountPoint = _config->FindDir("Dir::Media::MountPath");
	124	if (!FileExists(AptMountPoint))
	125	mkdir(AptMountPoint.c_str(), 0750);
	126	if(MountCdrom(AptMountPoint, v[i].DeviceName) == false)
	127	_error->Warning(_("Failed to mount '%s' to '%s'"), v[i].DeviceName.c_str(), AptMountPoint.c_str());
	128	_config->Set("Acquire::cdrom::mount", AptMountPoint);
	129	_config->Set("APT::CDROM::NoMount", true);
	130	}
	131	i++;
da6ee469	132
0e5943eb JF	133	return true;
0e5943eb JF	134	}
da6ee469 JF	135	/}}}/
	136
	137	// DoAdd - Add a new CDROM /{{{/
	138	// ---------------------------------------------------------------------
	139	/* This does the main add bit.. We show some status and things. The
	140	sequence is to mount/umount the CD, Ident it then scan it for package
	141	files and reduce that list. Then we copy over the package files and
	142	verify them. Then rewrite the database files */
	143	bool DoAdd(CommandLine &)
	144	{
0e5943eb	145	pkgUdevCdromDevices UdevCdroms;
da6ee469 JF	146	pkgCdromTextStatus log;
da6ee469 JF	147	pkgCdrom cdrom;
0e5943eb JF	148	bool res = true;
	149
	150	bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect");
	151	unsigned int count = 0;
	152
	153	if (AutoDetect && UdevCdroms.Dlopen())
	154	{
	155	while (AutoDetectCdrom(UdevCdroms, count))
	156	res &= cdrom.Add(&log);
	157	} else {
	158	res = cdrom.Add(&log);
	159	}
	160
da6ee469 JF	161	if(res)
da6ee469 JF	162	cout << _("Repeat this process for the rest of the CDs in your set.") << endl;
0e5943eb	163
da6ee469 JF	164	return res;
	165	}
	166	/}}}/
	167	// DoIdent - Ident a CDROM /{{{/
	168	// ---------------------------------------------------------------------
	169	/* */
	170	bool DoIdent(CommandLine &)
	171	{
0e5943eb	172	pkgUdevCdromDevices UdevCdroms;
da6ee469 JF	173	string ident;
	174	pkgCdromTextStatus log;
	175	pkgCdrom cdrom;
0e5943eb JF	176	bool res = true;
	177
	178	bool AutoDetect = _config->FindB("Acquire::cdrom::AutoDetect");
	179	unsigned int count = 0;
	180
	181	if (AutoDetect && UdevCdroms.Dlopen())
	182	{
	183	while (AutoDetectCdrom(UdevCdroms, count))
	184	res &= cdrom.Ident(ident, &log);
	185	} else {
	186	return cdrom.Ident(ident, &log);
	187	}
	188
	189	return res;
da6ee469 JF	190	}
da6ee469 JF	191	/}}}/
da6ee469 JF	192	// ShowHelp - Show the help screen /{{{/
	193	// ---------------------------------------------------------------------
	194	/* */
	195	int ShowHelp()
	196	{
00ec24d0 JF	197	ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
00ec24d0 JF	198	COMMON_ARCH,__DATE__,__TIME__);
da6ee469 JF	199	if (_config->FindB("version") == true)
	200	return 0;
	201
	202	cout <<
	203	"Usage: apt-cdrom [options] command\n"
	204	"\n"
	205	"apt-cdrom is a tool to add CDROM's to APT's source list. The\n"
	206	"CDROM mount point and device information is taken from apt.conf\n"
	207	"and /etc/fstab.\n"
	208	"\n"
	209	"Commands:\n"
	210	" add - Add a CDROM\n"
	211	" ident - Report the identity of a CDROM\n"
	212	"\n"
	213	"Options:\n"
	214	" -h This help text\n"
	215	" -d CD-ROM mount point\n"
	216	" -r Rename a recognized CD-ROM\n"
	217	" -m No mounting\n"
	218	" -f Fast mode, don't check package files\n"
	219	" -a Thorough scan mode\n"
0e5943eb	220	" --auto-detect Auto detect drive and mount point\n"
da6ee469 JF	221	" -c=? Read this configuration file\n"
	222	" -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
	223	"See fstab(5)\n";
	224	return 0;
	225	}
	226	/}}}/
0e5943eb	227	int main(int argc,const char argv[]) /{{{*/
da6ee469 JF	228	{
	229	CommandLine::Args Args[] = {
	230	{'h',"help","help",0},
0e5943eb	231	{ 0,"auto-detect","Acquire::cdrom::AutoDetect",0},
da6ee469 JF	232	{'v',"version","version",0},
	233	{'d',"cdrom","Acquire::cdrom::mount",CommandLine::HasArg},
	234	{'r',"rename","APT::CDROM::Rename",0},
	235	{'m',"no-mount","APT::CDROM::NoMount",0},
	236	{'f',"fast","APT::CDROM::Fast",0},
	237	{'n',"just-print","APT::CDROM::NoAct",0},
	238	{'n',"recon","APT::CDROM::NoAct",0},
	239	{'n',"no-act","APT::CDROM::NoAct",0},
	240	{'a',"thorough","APT::CDROM::Thorough",0},
	241	{'c',"config-file",0,CommandLine::ConfigFile},
	242	{'o',"option",0,CommandLine::ArbItem},
	243	{0,0,0,0}};
	244	CommandLine::Dispatch Cmds[] = {
	245	{"add",&DoAdd},
	246	{"ident",&DoIdent},
	247	{0,0}};
	248
	249	// Set up gettext support
	250	setlocale(LC_ALL,"");
acdafb44	251	textdomain(PACKAGE);
da6ee469 JF	252
	253	// Parse the command line and initialize the package library
	254	CommandLine CmdL(Args,_config);
	255	if (pkgInitConfig(*_config) == false \|\|
	256	CmdL.Parse(argc,argv) == false \|\|
	257	pkgInitSystem(*_config,_system) == false)
	258	{
	259	_error->DumpErrors();
	260	return 100;
	261	}
	262
	263	// See if the help should be shown
	264	if (_config->FindB("help") == true \|\| _config->FindB("version") == true \|\|
	265	CmdL.FileSize() == 0)
	266	return ShowHelp();
	267
	268	// Deal with stdout not being a tty
	269	if (isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
	270	_config->Set("quiet","1");
	271
	272	// Match the operation
	273	CmdL.DispatchArg(Cmds);
	274
	275	// Print any errors or warnings found during parsing
	276	if (_error->empty() == false)
	277	{
	278	bool Errors = _error->PendingError();
	279	_error->DumpErrors();
	280	return Errors == true?100:0;
	281	}
	282
	283	return 0;
	284	}
0e5943eb	285	/}}}/