[apt.git] / methods / rred.cc

#include <apt-pkg/fileutl.h>
#include <apt-pkg/error.h>
#include <apt-pkg/acquire-method.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/hashes.h>

#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>
#include <stdio.h>
#include <errno.h>
#include <apti18n.h>

/* this method implements a patch functionality similar to "patch --ed" that is
 * used by the "tiffany" incremental packages download stuff. it differs from 
 * "ed" insofar that it is way more restricted (and therefore secure). in the
 * moment only the "c", "a" and "d" commands of ed are implemented (diff 
 * doesn't output any other). additionally the records must be reverse sorted 
 * by line number and may not overlap (diff *seems* to produce this kind of 
 * output). 
 * */

const char *Prog;

class RredMethod : public pkgAcqMethod
{
   bool Debug;
   // the size of this doesn't really matter (except for performance)    
   const static int BUF_SIZE = 1024;
   // the ed commands
   enum Mode {MODE_CHANGED, MODE_DELETED, MODE_ADDED};
   // return values
   enum State {ED_OK, ED_ORDERING, ED_PARSER, ED_FAILURE};
   // this applies a single hunk, it uses a tail recursion to 
   // reverse the hunks in the file
   int ed_rec(FILE *ed_cmds, FILE *in_file, FILE *out_file, int line, 
      char *buffer, unsigned int bufsize, Hashes *hash);
   // apply a patch file
   int ed_file(FILE *ed_cmds, FILE *in_file, FILE *out_file, Hashes *hash);
   // the methods main method
   virtual bool Fetch(FetchItem *Itm);
   
   public:
   
   RredMethod() : pkgAcqMethod("1.1",SingleInstance | SendConfig) {};
};

int RredMethod::ed_rec(FILE *ed_cmds, FILE *in_file, FILE *out_file, int line, 
      char *buffer, unsigned int bufsize, Hashes *hash) {
   int pos;
   int startline;
   int stopline;
   int mode;
   int written;
   char *idx;

   /* get the current command and parse it*/
   if (fgets(buffer, bufsize, ed_cmds) == NULL) {
      return line;
   }
   startline = strtol(buffer, &idx, 10);
   if (startline < line) {
      return ED_ORDERING;
   }
   if (*idx == ',') {
      idx++;
      stopline = strtol(idx, &idx, 10);
   }
   else {
      stopline = startline;
   }
   if (*idx == 'c') {
      mode = MODE_CHANGED;
	   if (Debug == true) {
		   std::clog << "changing from line " << startline 
			     << " to " << stopline << std::endl;
	   }
   }
   else if (*idx == 'a') {
      mode = MODE_ADDED;
	   if (Debug == true) {
		   std::clog << "adding after line " << startline << std::endl;
	   }
   }
   else if (*idx == 'd') {
      mode = MODE_DELETED;
	   if (Debug == true) {
		   std::clog << "deleting from line " << startline 
			     <<  " to " << stopline << std::endl;
	   }
   }
   else {
      return ED_PARSER;
   }
   /* get the current position */
   pos = ftell(ed_cmds);
   /* if this is add or change then go to the next full stop */
   if ((mode == MODE_CHANGED) || (mode == MODE_ADDED)) {
      do {
         fgets(buffer, bufsize, ed_cmds);
         while ((strlen(buffer) == (bufsize - 1)) 
               && (buffer[bufsize - 2] != '\n')) {
            fgets(buffer, bufsize, ed_cmds);
            buffer[0] = ' ';
         }
      } while (strncmp(buffer, ".", 1) != 0);
   }
   /* do the recursive call */
   line = ed_rec(ed_cmds, in_file, out_file, line, buffer, bufsize, 
         hash);
   /* pass on errors */
   if (line < 0) {
      return line;
   }
   /* apply our hunk */
   fseek(ed_cmds, pos, SEEK_SET); 
   /* first wind to the current position */
   if (mode != MODE_ADDED) {
      startline -= 1;
   }
   while (line < startline) {
      fgets(buffer, bufsize, in_file);
      written = fwrite(buffer, 1, strlen(buffer), out_file);
      hash->Add((unsigned char*)buffer, written);
      while ((strlen(buffer) == (bufsize - 1)) 
            && (buffer[bufsize - 2] != '\n')) {
         fgets(buffer, bufsize, in_file);
         written = fwrite(buffer, 1, strlen(buffer), out_file);
         hash->Add((unsigned char*)buffer, written);
      }
      line++;
   }
   /* include from ed script */
   if ((mode == MODE_ADDED) || (mode == MODE_CHANGED)) {
      do {
         fgets(buffer, bufsize, ed_cmds);
         if (strncmp(buffer, ".", 1) != 0) {
            written = fwrite(buffer, 1, strlen(buffer), out_file);
            hash->Add((unsigned char*)buffer, written);
            while ((strlen(buffer) == (bufsize - 1)) 
                  && (buffer[bufsize - 2] != '\n')) {
               fgets(buffer, bufsize, ed_cmds);
               written = fwrite(buffer, 1, strlen(buffer), out_file);
               hash->Add((unsigned char*)buffer, written);
            }
         }
         else {
            break;
         }
      } while (1);
   }
   /* ignore the corresponding number of lines from input */
   if ((mode == MODE_DELETED) || (mode == MODE_CHANGED)) {
      while (line < stopline) {
         fgets(buffer, bufsize, in_file);
         while ((strlen(buffer) == (bufsize - 1)) 
               && (buffer[bufsize - 2] != '\n')) {
            fgets(buffer, bufsize, in_file);
         }
         line++;
      }
   }
   return line;
}

int RredMethod::ed_file(FILE *ed_cmds, FILE *in_file, FILE *out_file, 
      Hashes *hash) {
   char buffer[BUF_SIZE];
   int result;
   int written;
   
   /* we do a tail recursion to read the commands in the right order */
   result = ed_rec(ed_cmds, in_file, out_file, 0, buffer, BUF_SIZE, 
         hash);
   
   /* read the rest from infile */
   if (result >= 0) {
      while (fgets(buffer, BUF_SIZE, in_file) != NULL) {
         written = fwrite(buffer, 1, strlen(buffer), out_file);
         hash->Add((unsigned char*)buffer, written);
      }
   }
   else {
      return ED_FAILURE;
   }
   return ED_OK;
}


bool RredMethod::Fetch(FetchItem *Itm)
{
   Debug = _config->FindB("Debug::pkgAcquire::RRed",false);
   URI Get = Itm->Uri;
   string Path = Get.Host + Get.Path; // To account for relative paths
   // Path contains the filename to patch
   FetchResult Res;
   Res.Filename = Itm->DestFile;
   URIStart(Res);
   // Res.Filename the destination filename

   if (Debug == true) 
      std::clog << "Patching " << Path << " with " << Path 
         << ".ed and putting result into " << Itm->DestFile << std::endl;
   // Open the source and destination files (the d'tor of FileFd will do 
   // the cleanup/closing of the fds)
   FileFd From(Path,FileFd::ReadOnly);
   FileFd Patch(Path+".ed",FileFd::ReadOnly);
   FileFd To(Itm->DestFile,FileFd::WriteEmpty);   
   To.EraseOnFailure();
   if (_error->PendingError() == true)
      return false;
   
   Hashes Hash;
   FILE* fFrom = fdopen(From.Fd(), "r");
   FILE* fPatch = fdopen(Patch.Fd(), "r");
   FILE* fTo = fdopen(To.Fd(), "w");
   // now do the actual patching
   if (ed_file(fPatch, fFrom, fTo, &Hash) != ED_OK) {
     _error->Errno("rred", _("Could not patch file"));  
      return false;
   }

   // write out the result
   fflush(fFrom);
   fflush(fPatch);
   fflush(fTo);
   From.Close();
   Patch.Close();
   To.Close();

   // Transfer the modification times
   struct stat Buf;
   if (stat(Path.c_str(),&Buf) != 0)
      return _error->Errno("stat",_("Failed to stat"));

   struct utimbuf TimeBuf;
   TimeBuf.actime = Buf.st_atime;
   TimeBuf.modtime = Buf.st_mtime;
   if (utime(Itm->DestFile.c_str(),&TimeBuf) != 0)
      return _error->Errno("utime",_("Failed to set modification time"));

   if (stat(Itm->DestFile.c_str(),&Buf) != 0)
      return _error->Errno("stat",_("Failed to stat"));

   // return done
   Res.LastModified = Buf.st_mtime;
   Res.Size = Buf.st_size;
   Res.TakeHashes(Hash);
   URIDone(Res);

   return true;
}

int main(int argc, char *argv[])
{
   RredMethod Mth;

   Prog = strrchr(argv[0],'/');
   Prog++;
   
   return Mth.Run();
}
Commit	Line	Data
2e178d1c MV	1	#include <apt-pkg/fileutl.h>
	2	#include <apt-pkg/error.h>
	3	#include <apt-pkg/acquire-method.h>
	4	#include <apt-pkg/strutl.h>
	5	#include <apt-pkg/hashes.h>
	6
	7	#include <sys/stat.h>
	8	#include <unistd.h>
	9	#include <utime.h>
	10	#include <stdio.h>
	11	#include <errno.h>
	12	#include <apti18n.h>
	13
d84cd865 MV	14	/* this method implements a patch functionality similar to "patch --ed" that is
	15	* used by the "tiffany" incremental packages download stuff. it differs from
	16	* "ed" insofar that it is way more restricted (and therefore secure). in the
	17	* moment only the "c", "a" and "d" commands of ed are implemented (diff
	18	* doesn't output any other). additionally the records must be reverse sorted
	19	* by line number and may not overlap (diff seems to produce this kind of
	20	* output).
	21	* */
	22
2e178d1c MV	23	const char *Prog;
	24
	25	class RredMethod : public pkgAcqMethod
	26	{
6040f589	27	bool Debug;
d84cd865 MV	28	// the size of this doesn't really matter (except for performance)
	29	const static int BUF_SIZE = 1024;
	30	// the ed commands
	31	enum Mode {MODE_CHANGED, MODE_DELETED, MODE_ADDED};
	32	// return values
	33	enum State {ED_OK, ED_ORDERING, ED_PARSER, ED_FAILURE};
	34	// this applies a single hunk, it uses a tail recursion to
	35	// reverse the hunks in the file
	36	int ed_rec(FILE ed_cmds, FILE in_file, FILE *out_file, int line,
	37	char buffer, unsigned int bufsize, Hashes hash);
	38	// apply a patch file
	39	int ed_file(FILE ed_cmds, FILE in_file, FILE out_file, Hashes hash);
	40	// the methods main method
2e178d1c MV	41	virtual bool Fetch(FetchItem *Itm);
	42
	43	public:
	44
	45	RredMethod() : pkgAcqMethod("1.1",SingleInstance \| SendConfig) {};
2e178d1c MV	46	};
2e178d1c MV	47
d84cd865 MV	48	int RredMethod::ed_rec(FILE ed_cmds, FILE in_file, FILE *out_file, int line,
	49	char buffer, unsigned int bufsize, Hashes hash) {
	50	int pos;
	51	int startline;
	52	int stopline;
	53	int mode;
	54	int written;
	55	char *idx;
	56
	57	/* get the current command and parse it*/
	58	if (fgets(buffer, bufsize, ed_cmds) == NULL) {
	59	return line;
	60	}
	61	startline = strtol(buffer, &idx, 10);
	62	if (startline < line) {
	63	return ED_ORDERING;
	64	}
	65	if (*idx == ',') {
	66	idx++;
	67	stopline = strtol(idx, &idx, 10);
	68	}
	69	else {
	70	stopline = startline;
	71	}
	72	if (*idx == 'c') {
	73	mode = MODE_CHANGED;
6040f589 MV	74	if (Debug == true) {
	75	std::clog << "changing from line " << startline
	76	<< " to " << stopline << std::endl;
	77	}
d84cd865 MV	78	}
	79	else if (*idx == 'a') {
	80	mode = MODE_ADDED;
6040f589 MV	81	if (Debug == true) {
	82	std::clog << "adding after line " << startline << std::endl;
	83	}
d84cd865 MV	84	}
	85	else if (*idx == 'd') {
	86	mode = MODE_DELETED;
6040f589 MV	87	if (Debug == true) {
	88	std::clog << "deleting from line " << startline
	89	<< " to " << stopline << std::endl;
	90	}
d84cd865 MV	91	}
	92	else {
	93	return ED_PARSER;
	94	}
	95	/* get the current position */
	96	pos = ftell(ed_cmds);
	97	/* if this is add or change then go to the next full stop */
	98	if ((mode == MODE_CHANGED) \|\| (mode == MODE_ADDED)) {
	99	do {
	100	fgets(buffer, bufsize, ed_cmds);
	101	while ((strlen(buffer) == (bufsize - 1))
	102	&& (buffer[bufsize - 2] != '\n')) {
	103	fgets(buffer, bufsize, ed_cmds);
	104	buffer[0] = ' ';
	105	}
	106	} while (strncmp(buffer, ".", 1) != 0);
	107	}
	108	/* do the recursive call */
	109	line = ed_rec(ed_cmds, in_file, out_file, line, buffer, bufsize,
	110	hash);
	111	/* pass on errors */
	112	if (line < 0) {
	113	return line;
	114	}
	115	/* apply our hunk */
	116	fseek(ed_cmds, pos, SEEK_SET);
	117	/* first wind to the current position */
	118	if (mode != MODE_ADDED) {
	119	startline -= 1;
	120	}
	121	while (line < startline) {
	122	fgets(buffer, bufsize, in_file);
	123	written = fwrite(buffer, 1, strlen(buffer), out_file);
	124	hash->Add((unsigned char*)buffer, written);
	125	while ((strlen(buffer) == (bufsize - 1))
	126	&& (buffer[bufsize - 2] != '\n')) {
	127	fgets(buffer, bufsize, in_file);
	128	written = fwrite(buffer, 1, strlen(buffer), out_file);
	129	hash->Add((unsigned char*)buffer, written);
	130	}
	131	line++;
	132	}
	133	/* include from ed script */
	134	if ((mode == MODE_ADDED) \|\| (mode == MODE_CHANGED)) {
	135	do {
	136	fgets(buffer, bufsize, ed_cmds);
	137	if (strncmp(buffer, ".", 1) != 0) {
	138	written = fwrite(buffer, 1, strlen(buffer), out_file);
	139	hash->Add((unsigned char*)buffer, written);
	140	while ((strlen(buffer) == (bufsize - 1))
	141	&& (buffer[bufsize - 2] != '\n')) {
	142	fgets(buffer, bufsize, ed_cmds);
	143	written = fwrite(buffer, 1, strlen(buffer), out_file);
	144	hash->Add((unsigned char*)buffer, written);
	145	}
	146	}
	147	else {
	148	break;
	149	}
	150	} while (1);
	151	}
	152	/* ignore the corresponding number of lines from input */
	153	if ((mode == MODE_DELETED) \|\| (mode == MODE_CHANGED)) {
	154	while (line < stopline) {
155	fgets(buffer, bufsize, in_file);
156	while ((strlen(buffer) == (bufsize - 1))
157	&& (buffer[bufsize - 2] != '\n')) {
158	fgets(buffer, bufsize, in_file);
159	}
160	line++;
161	}
162	}
163	return line;
2e178d1c MV	164	}
2e178d1c MV	165
d84cd865 MV	166	int RredMethod::ed_file(FILE ed_cmds, FILE in_file, FILE *out_file,
	167	Hashes *hash) {
	168	char buffer[BUF_SIZE];
	169	int result;
	170	int written;
	171
	172	/* we do a tail recursion to read the commands in the right order */
	173	result = ed_rec(ed_cmds, in_file, out_file, 0, buffer, BUF_SIZE,
	174	hash);
	175
	176	/* read the rest from infile */
ebf2e25b	177	if (result >= 0) {
d84cd865 MV	178	while (fgets(buffer, BUF_SIZE, in_file) != NULL) {
	179	written = fwrite(buffer, 1, strlen(buffer), out_file);
	180	hash->Add((unsigned char*)buffer, written);
	181	}
	182	}
	183	else {
	184	return ED_FAILURE;
	185	}
	186	return ED_OK;
2e178d1c MV	187	}
	188
	189
2e178d1c MV	190	bool RredMethod::Fetch(FetchItem *Itm)
2e178d1c MV	191	{
6040f589	192	Debug = _config->FindB("Debug::pkgAcquire::RRed",false);
2e178d1c MV	193	URI Get = Itm->Uri;
	194	string Path = Get.Host + Get.Path; // To account for relative paths
	195	// Path contains the filename to patch
	196	FetchResult Res;
	197	Res.Filename = Itm->DestFile;
	198	URIStart(Res);
	199	// Res.Filename the destination filename
4a0a786f	200
6040f589 MV	201	if (Debug == true)
	202	std::clog << "Patching " << Path << " with " << Path
	203	<< ".ed and putting result into " << Itm->DestFile << std::endl;
59a704f0 MV	204	// Open the source and destination files (the d'tor of FileFd will do
59a704f0 MV	205	// the cleanup/closing of the fds)
2e178d1c MV	206	FileFd From(Path,FileFd::ReadOnly);
	207	FileFd Patch(Path+".ed",FileFd::ReadOnly);
	208	FileFd To(Itm->DestFile,FileFd::WriteEmpty);
	209	To.EraseOnFailure();
	210	if (_error->PendingError() == true)
	211	return false;
	212
	213	Hashes Hash;
	214	FILE* fFrom = fdopen(From.Fd(), "r");
	215	FILE* fPatch = fdopen(Patch.Fd(), "r");
	216	FILE* fTo = fdopen(To.Fd(), "w");
	217	// now do the actual patching
3de9ff77	218	if (ed_file(fPatch, fFrom, fTo, &Hash) != ED_OK) {
d84cd865	219	_error->Errno("rred", _("Could not patch file"));
3de9ff77 MV	220	return false;
	221	}
	222
	223	// write out the result
	224	fflush(fFrom);
	225	fflush(fPatch);
	226	fflush(fTo);
	227	From.Close();
	228	Patch.Close();
	229	To.Close();
	230
	231	// Transfer the modification times
	232	struct stat Buf;
	233	if (stat(Path.c_str(),&Buf) != 0)
	234	return _error->Errno("stat",_("Failed to stat"));
	235
	236	struct utimbuf TimeBuf;
	237	TimeBuf.actime = Buf.st_atime;
	238	TimeBuf.modtime = Buf.st_mtime;
	239	if (utime(Itm->DestFile.c_str(),&TimeBuf) != 0)
	240	return _error->Errno("utime",_("Failed to set modification time"));
	241
	242	if (stat(Itm->DestFile.c_str(),&Buf) != 0)
	243	return _error->Errno("stat",_("Failed to stat"));
	244
	245	// return done
	246	Res.LastModified = Buf.st_mtime;
	247	Res.Size = Buf.st_size;
2e178d1c MV	248	Res.TakeHashes(Hash);
2e178d1c MV	249	URIDone(Res);
3de9ff77	250
2e178d1c MV	251	return true;
2e178d1c MV	252	}
2e178d1c MV	253
	254	int main(int argc, char *argv[])
	255	{
	256	RredMethod Mth;
	257
	258	Prog = strrchr(argv[0],'/');
	259	Prog++;
	260
	261	return Mth.Run();
	262	}