methods/rred.cc

   1 // Copyright (c) 2014 Anthony Towns
   2 //
   3 // This program is free software; you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation; either version 2 of the License, or
   6 // (at your option) any later version.
   7
   8 #include <config.h>
   9
  10 #include <apt-pkg/init.h>
  11 #include <apt-pkg/fileutl.h>
  12 #include <apt-pkg/error.h>
  13 #include <apt-pkg/acquire-method.h>
  14 #include <apt-pkg/strutl.h>
  15 #include <apt-pkg/hashes.h>
  16 #include <apt-pkg/configuration.h>
  17 #include "aptmethod.h"
  18
  19 #include <stddef.h>
  20 #include <iostream>
  21 #include <string>
  22 #include <list>
  23 #include <vector>
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32
  33 #include <apti18n.h>
  34
  35 #define BLOCK_SIZE (512*1024)
  36
  37 class MemBlock {
  38    char *start;
  39    size_t size;
  40    char *free;
  41    MemBlock *next;
  42
  43    explicit MemBlock(size_t size) : size(size), next(NULL)
  44    {
  45       free = start = new char[size];
  46    }
  47
  48    size_t avail(void) { return size - (free - start); }
  49
  50    public:
  51
  52    MemBlock(void) {
  53       free = start = new char[BLOCK_SIZE];
  54       size = BLOCK_SIZE;
  55       next = NULL;
  56    }
  57
  58    ~MemBlock() {
  59       delete [] start;
  60       delete next;
  61    }
  62
  63    void clear(void) {
  64       free = start;
  65       if (next)
  66          next->clear();
  67    }
  68
  69    char *add_easy(char *src, size_t len, char *last)
  70    {
  71       if (last) {
  72          for (MemBlock *k = this; k; k = k->next) {
  73             if (k->free == last) {
  74                if (len <= k->avail()) {
  75                   char *n = k->add(src, len);
  76                   assert(last == n);
  77                   if (last == n)
  78                      return NULL;
  79                   return n;
  80                } else {
  81                   break;
  82                }
  83             } else if (last >= start && last < free) {
  84                break;
  85             }
  86          }
  87       }
  88       return add(src, len);
  89    }
  90
  91    char *add(char *src, size_t len) {
  92       if (len > avail()) {
  93          if (!next) {
  94             if (len > BLOCK_SIZE)  {
  95                next = new MemBlock(len);
  96             } else {
  97                next = new MemBlock;
  98             }
  99          }
 100          return next->add(src, len);
 101       }
 102       char *dst = free;
 103       free += len;
 104       memcpy(dst, src, len);
 105       return dst;
 106    }
 107 };
 108
 109 struct Change {
 110    /* Ordering:
 111     *
 112     *   1. write out <offset> lines unchanged
 113     *   2. skip <del_cnt> lines from source
 114     *   3. write out <add_cnt> lines (<add>/<add_len>)
 115     */
 116    size_t offset;
 117    size_t del_cnt;
 118    size_t add_cnt; /* lines */
 119    size_t add_len; /* bytes */
 120    char *add;
 121
 122    explicit Change(size_t off)
 123    {
 124       offset = off;
 125       del_cnt = add_cnt = add_len = 0;
 126       add = NULL;
 127    }
 128
 129    /* actually, don't write <lines> lines from <add> */
 130    void skip_lines(size_t lines)
 131    {
 132       while (lines > 0) {
 133          char *s = (char*) memchr(add, '\n', add_len);
 134          assert(s != NULL);
 135          s++;
 136          add_len -= (s - add);
 137          add_cnt--;
 138          lines--;
 139          if (add_len == 0) {
 140             add = NULL;
 141             assert(add_cnt == 0);
 142             assert(lines == 0);
 143          } else {
 144             add = s;
 145             assert(add_cnt > 0);
 146          }
 147       }
 148    }
 149 };
 150
 151 class FileChanges {
 152    std::list<struct Change> changes;
 153    std::list<struct Change>::iterator where;
 154    size_t pos; // line number is as far left of iterator as possible
 155
 156    bool pos_is_okay(void) const
 157    {
 158 #ifdef POSDEBUG
 159       size_t cpos = 0;
 160       std::list<struct Change>::const_iterator x;
 161       for (x = changes.begin(); x != where; ++x) {
 162          assert(x != changes.end());
 163          cpos += x->offset + x->add_cnt;
 164       }
 165       return cpos == pos;
 166 #else
 167       return true;
 168 #endif
 169    }
 170
 171    public:
 172    FileChanges() {
 173       where = changes.end();
 174       pos = 0;
 175    }
 176
 177    std::list<struct Change>::iterator begin(void) { return changes.begin(); }
 178    std::list<struct Change>::iterator end(void) { return changes.end(); }
 179
 180    std::list<struct Change>::reverse_iterator rbegin(void) { return changes.rbegin(); }
 181    std::list<struct Change>::reverse_iterator rend(void) { return changes.rend(); }
 182
 183    void add_change(Change c) {
 184       assert(pos_is_okay());
 185       go_to_change_for(c.offset);
 186       assert(pos + where->offset == c.offset);
 187       if (c.del_cnt > 0)
 188          delete_lines(c.del_cnt);
 189       assert(pos + where->offset == c.offset);
 190       if (c.add_len > 0) {
 191          assert(pos_is_okay());
 192          if (where->add_len > 0)
 193             new_change();
 194          assert(where->add_len == 0 && where->add_cnt == 0);
 195
 196          where->add_len = c.add_len;
 197          where->add_cnt = c.add_cnt;
 198          where->add = c.add;
 199       }
 200       assert(pos_is_okay());
 201       merge();
 202       assert(pos_is_okay());
 203    }
 204
 205    private:
 206    void merge(void)
 207    {
 208       while (where->offset == 0 && where != changes.begin()) {
 209          left();
 210       }
 211       std::list<struct Change>::iterator next = where;
 212       ++next;
 213
 214       while (next != changes.end() && next->offset == 0) {
 215          where->del_cnt += next->del_cnt;
 216          next->del_cnt = 0;
 217          if (next->add == NULL) {
 218             next = changes.erase(next);
 219          } else if (where->add == NULL) {
 220             where->add = next->add;
 221             where->add_len = next->add_len;
 222             where->add_cnt = next->add_cnt;
 223             next = changes.erase(next);
 224          } else {
 225             ++next;
 226          }
 227       }
 228    }
 229
 230    void go_to_change_for(size_t line)
 231    {
 232       while(where != changes.end()) {
 233          if (line < pos) {
 234             left();
 235             continue;
 236          }
 237          if (pos + where->offset + where->add_cnt <= line) {
 238             right();
 239             continue;
 240          }
 241          // line is somewhere in this slot
 242          if (line < pos + where->offset) {
 243             break;
 244          } else if (line == pos + where->offset) {
 245             return;
 246          } else {
 247             split(line - pos);
 248             right();
 249             return;
 250          }
 251       }
 252       /* it goes before this patch */
 253       insert(line-pos);
 254    }
 255
 256    void new_change(void) { insert(where->offset); }
 257
 258    void insert(size_t offset)
 259    {
 260       assert(pos_is_okay());
 261       assert(where == changes.end() || offset <= where->offset);
 262       if (where != changes.end())
 263          where->offset -= offset;
 264       changes.insert(where, Change(offset));
 265       --where;
 266       assert(pos_is_okay());
 267    }
 268
 269    void split(size_t offset)
 270    {
 271       assert(pos_is_okay());
 272
 273       assert(where->offset < offset);
 274       assert(offset < where->offset + where->add_cnt);
 275
 276       size_t keep_lines = offset - where->offset;
 277
 278       Change before(*where);
 279
 280       where->del_cnt = 0;
 281       where->offset = 0;
 282       where->skip_lines(keep_lines);
 283
 284       before.add_cnt = keep_lines;
 285       before.add_len -= where->add_len;
 286
 287       changes.insert(where, before);
 288       --where;
 289       assert(pos_is_okay());
 290    }
 291
 292    void delete_lines(size_t cnt)
 293    {
 294       std::list<struct Change>::iterator x = where;
 295       assert(pos_is_okay());
 296       while (cnt > 0)
 297       {
 298          size_t del;
 299          del = x->add_cnt;
 300          if (del > cnt)
 301             del = cnt;
 302          x->skip_lines(del);
 303          cnt -= del;
 304
 305          ++x;
 306          if (x == changes.end()) {
 307             del = cnt;
 308          } else {
 309             del = x->offset;
 310             if (del > cnt)
 311                del = cnt;
 312             x->offset -= del;
 313          }
 314          where->del_cnt += del;
 315          cnt -= del;
 316       }
 317       assert(pos_is_okay());
 318    }
 319
 320    void left(void) {
 321       assert(pos_is_okay());
 322       --where;
 323       pos -= where->offset + where->add_cnt;
 324       assert(pos_is_okay());
 325    }
 326
 327    void right(void) {
 328       assert(pos_is_okay());
 329       pos += where->offset + where->add_cnt;
 330       ++where;
 331       assert(pos_is_okay());
 332    }
 333 };
 334
 335 class Patch {
 336    FileChanges filechanges;
 337    MemBlock add_text;
 338
 339    static bool retry_fwrite(char *b, size_t l, FileFd &f, Hashes * const start_hash, Hashes * const end_hash = nullptr)
 340    {
 341       if (f.Write(b, l) == false)
 342          return false;
 343       if (start_hash)
 344          start_hash->Add((unsigned char*)b, l);
 345       if (end_hash)
 346          end_hash->Add((unsigned char*)b, l);
 347       return true;
 348    }
 349
 350    static void dump_rest(FileFd &o, FileFd &i,
 351          Hashes * const start_hash, Hashes * const end_hash)
 352    {
 353       char buffer[BLOCK_SIZE];
 354       unsigned long long l = 0;
 355       while (i.Read(buffer, sizeof(buffer), &l)) {
 356          if (l ==0  || !retry_fwrite(buffer, l, o, start_hash, end_hash))
 357             break;
 358       }
 359    }
 360
 361    static void dump_lines(FileFd &o, FileFd &i, size_t n,
 362          Hashes * const start_hash, Hashes * const end_hash)
 363    {
 364       char buffer[BLOCK_SIZE];
 365       while (n > 0) {
 366          if (i.ReadLine(buffer, sizeof(buffer)) == NULL)
 367             buffer[0] = '\0';
 368          size_t const l = strlen(buffer);
 369          if (l == 0 || buffer[l-1] == '\n')
 370             n--;
 371          retry_fwrite(buffer, l, o, start_hash, end_hash);
 372       }
 373    }
 374
 375    static void skip_lines(FileFd &i, int n, Hashes * const start_hash)
 376    {
 377       char buffer[BLOCK_SIZE];
 378       while (n > 0) {
 379          if (i.ReadLine(buffer, sizeof(buffer)) == NULL)
 380             buffer[0] = '\0';
 381          size_t const l = strlen(buffer);
 382          if (l == 0 || buffer[l-1] == '\n')
 383             n--;
 384          if (start_hash)
 385             start_hash->Add((unsigned char*)buffer, l);
 386       }
 387    }
 388
 389    static void dump_mem(FileFd &o, char *p, size_t s, Hashes *hash) {
 390       retry_fwrite(p, s, o, hash);
 391    }
 392
 393    public:
 394
 395    bool read_diff(FileFd &f, Hashes * const h)
 396    {
 397       char buffer[BLOCK_SIZE];
 398       bool cmdwanted = true;
 399
 400       Change ch(std::numeric_limits<size_t>::max());
 401       if (f.ReadLine(buffer, sizeof(buffer)) == NULL)
 402          return _error->Error("Reading first line of patchfile %s failed", f.Name().c_str());
 403       do {
 404          if (h != NULL)
 405             h->Add(buffer);
 406          if (cmdwanted) {
 407             char *m, *c;
 408             size_t s, e;
 409             errno = 0;
 410             s = strtoul(buffer, &m, 10);
 411             if (unlikely(m == buffer || s == std::numeric_limits<unsigned long>::max() || errno != 0))
 412                return _error->Error("Parsing patchfile %s failed: Expected an effected line start", f.Name().c_str());
 413             else if (*m == ',') {
 414                ++m;
 415                e = strtol(m, &c, 10);
 416                if (unlikely(m == c || e == std::numeric_limits<unsigned long>::max() || errno != 0))
 417                   return _error->Error("Parsing patchfile %s failed: Expected an effected line end", f.Name().c_str());
 418                if (unlikely(e < s))
 419                   return _error->Error("Parsing patchfile %s failed: Effected lines end %lu is before start %lu", f.Name().c_str(), e, s);
 420             } else {
 421                e = s;
 422                c = m;
 423             }
 424             if (s > ch.offset)
 425                return _error->Error("Parsing patchfile %s failed: Effected line is after previous effected line", f.Name().c_str());
 426             switch(*c) {
 427                case 'a':
 428                   cmdwanted = false;
 429                   ch.add = NULL;
 430                   ch.add_cnt = 0;
 431                   ch.add_len = 0;
 432                   ch.offset = s;
 433                   ch.del_cnt = 0;
 434                   break;
 435                case 'c':
 436                   if (unlikely(s == 0))
 437                      return _error->Error("Parsing patchfile %s failed: Change command can't effect line zero", f.Name().c_str());
 438                   cmdwanted = false;
 439                   ch.add = NULL;
 440                   ch.add_cnt = 0;
 441                   ch.add_len = 0;
 442                   ch.offset = s - 1;
 443                   ch.del_cnt = e - s + 1;
 444                   break;
 445                case 'd':
 446                   if (unlikely(s == 0))
 447                      return _error->Error("Parsing patchfile %s failed: Delete command can't effect line zero", f.Name().c_str());
 448                   ch.offset = s - 1;
 449                   ch.del_cnt = e - s + 1;
 450                   ch.add = NULL;
 451                   ch.add_cnt = 0;
 452                   ch.add_len = 0;
 453                   filechanges.add_change(ch);
 454                   break;
 455                default:
 456                   return _error->Error("Parsing patchfile %s failed: Unknown command", f.Name().c_str());
 457             }
 458          } else { /* !cmdwanted */
 459             if (strcmp(buffer, ".\n") == 0) {
 460                cmdwanted = true;
 461                filechanges.add_change(ch);
 462             } else {
 463                char *last = NULL;
 464                char *add;
 465                size_t l;
 466                if (ch.add)
 467                   last = ch.add + ch.add_len;
 468                l = strlen(buffer);
 469                add = add_text.add_easy(buffer, l, last);
 470                if (!add) {
 471                   ch.add_len += l;
 472                   ch.add_cnt++;
 473                } else {
 474                   if (ch.add) {
 475                      filechanges.add_change(ch);
 476                      ch.del_cnt = 0;
 477                   }
 478                   ch.offset += ch.add_cnt;
 479                   ch.add = add;
 480                   ch.add_len = l;
 481                   ch.add_cnt = 1;
 482                }
 483             }
 484          }
 485       } while(f.ReadLine(buffer, sizeof(buffer)));
 486       return true;
 487    }
 488
 489    void write_diff(FileFd &f)
 490    {
 491       unsigned long long line = 0;
 492       std::list<struct Change>::reverse_iterator ch;
 493       for (ch = filechanges.rbegin(); ch != filechanges.rend(); ++ch) {
 494          line += ch->offset + ch->del_cnt;
 495       }
 496
 497       for (ch = filechanges.rbegin(); ch != filechanges.rend(); ++ch) {
 498          std::list<struct Change>::reverse_iterator mg_i, mg_e = ch;
 499          while (ch->del_cnt == 0 && ch->offset == 0)
 500          {
 501             ++ch;
 502             if (unlikely(ch == filechanges.rend()))
 503                return;
 504          }
 505          line -= ch->del_cnt;
 506          std::string buf;
 507          if (ch->add_cnt > 0) {
 508             if (ch->del_cnt == 0) {
 509                strprintf(buf, "%llua\n", line);
 510             } else if (ch->del_cnt == 1) {
 511                strprintf(buf, "%lluc\n", line+1);
 512             } else {
 513                strprintf(buf, "%llu,%lluc\n", line+1, line+ch->del_cnt);
 514             }
 515             f.Write(buf.c_str(), buf.length());
 516
 517             mg_i = ch;
 518             do {
 519                dump_mem(f, mg_i->add, mg_i->add_len, NULL);
 520             } while (mg_i-- != mg_e);
 521
 522             buf = ".\n";
 523             f.Write(buf.c_str(), buf.length());
 524          } else if (ch->del_cnt == 1) {
 525             strprintf(buf, "%llud\n", line+1);
 526             f.Write(buf.c_str(), buf.length());
 527          } else if (ch->del_cnt > 1) {
 528             strprintf(buf, "%llu,%llud\n", line+1, line+ch->del_cnt);
 529             f.Write(buf.c_str(), buf.length());
 530          }
 531          line -= ch->offset;
 532       }
 533    }
 534
 535    void apply_against_file(FileFd &out, FileFd &in,
 536          Hashes * const start_hash = nullptr, Hashes * const end_hash = nullptr)
 537    {
 538       std::list<struct Change>::iterator ch;
 539       for (ch = filechanges.begin(); ch != filechanges.end(); ++ch) {
 540          dump_lines(out, in, ch->offset, start_hash, end_hash);
 541          skip_lines(in, ch->del_cnt, start_hash);
 542          dump_mem(out, ch->add, ch->add_len, end_hash);
 543       }
 544       dump_rest(out, in, start_hash, end_hash);
 545       out.Flush();
 546    }
 547 };
 548
 549 class RredMethod : public aptMethod {
 550    private:
 551       bool Debug;
 552
 553       struct PDiffFile {
 554          std::string FileName;
 555          HashStringList ExpectedHashes;
 556          PDiffFile(std::string const &FileName, HashStringList const &ExpectedHashes) :
 557             FileName(FileName), ExpectedHashes(ExpectedHashes) {}
 558       };
 559
 560       HashStringList ReadExpectedHashesForPatch(unsigned int const patch, std::string const &Message)
 561       {
 562          HashStringList ExpectedHashes;
 563          for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
 564          {
 565             std::string tagname;
 566             strprintf(tagname, "Patch-%d-%s-Hash", patch, *type);
 567             std::string const hashsum = LookupTag(Message, tagname.c_str());
 568             if (hashsum.empty() == false)
 569                ExpectedHashes.push_back(HashString(*type, hashsum));
 570          }
 571          return ExpectedHashes;
 572       }
 573
 574    protected:
 575       virtual bool URIAcquire(std::string const &Message, FetchItem *Itm) APT_OVERRIDE {
 576          Debug = _config->FindB("Debug::pkgAcquire::RRed", false);
 577          URI Get = Itm->Uri;
 578          std::string Path = Get.Host + Get.Path; // rred:/path - no host
 579
 580          FetchResult Res;
 581          Res.Filename = Itm->DestFile;
 582          if (Itm->Uri.empty())
 583          {
 584             Path = Itm->DestFile;
 585             Itm->DestFile.append(".result");
 586          } else
 587             URIStart(Res);
 588
 589          std::vector<PDiffFile> patchfiles;
 590          Patch patch;
 591
 592          HashStringList StartHashes;
 593          for (char const * const * type = HashString::SupportedHashes(); *type != nullptr; ++type)
 594          {
 595             std::string tagname;
 596             strprintf(tagname, "Start-%s-Hash", *type);
 597             std::string const hashsum = LookupTag(Message, tagname.c_str());
 598             if (hashsum.empty() == false)
 599                StartHashes.push_back(HashString(*type, hashsum));
 600          }
 601
 602          if (FileExists(Path + ".ed") == true)
 603          {
 604             HashStringList const ExpectedHashes = ReadExpectedHashesForPatch(0, Message);
 605             std::string const FileName = Path + ".ed";
 606             if (ExpectedHashes.usable() == false)
 607                return _error->Error("No hashes found for uncompressed patch: %s", FileName.c_str());
 608             patchfiles.push_back(PDiffFile(FileName, ExpectedHashes));
 609          }
 610          else
 611          {
 612             _error->PushToStack();
 613             std::vector<std::string> patches = GetListOfFilesInDir(flNotFile(Path), "gz", true, false);
 614             _error->RevertToStack();
 615
 616             std::string const baseName = Path + ".ed.";
 617             unsigned int seen_patches = 0;
 618             for (std::vector<std::string>::const_iterator p = patches.begin();
 619                   p != patches.end(); ++p)
 620             {
 621                if (p->compare(0, baseName.length(), baseName) == 0)
 622                {
 623                   HashStringList const ExpectedHashes = ReadExpectedHashesForPatch(seen_patches, Message);
 624                   if (ExpectedHashes.usable() == false)
 625                      return _error->Error("No hashes found for uncompressed patch %d: %s", seen_patches, p->c_str());
 626                   patchfiles.push_back(PDiffFile(*p, ExpectedHashes));
 627                   ++seen_patches;
 628                }
 629             }
 630          }
 631
 632          std::string patch_name;
 633          for (std::vector<PDiffFile>::iterator I = patchfiles.begin();
 634                I != patchfiles.end();
 635                ++I)
 636          {
 637             patch_name = I->FileName;
 638             if (Debug == true)
 639                std::clog << "Patching " << Path << " with " << patch_name
 640                   << std::endl;
 641
 642             FileFd p;
 643             Hashes patch_hash(I->ExpectedHashes);
 644             // all patches are compressed, even if the name doesn't reflect it
 645             if (p.Open(patch_name, FileFd::ReadOnly, FileFd::Gzip) == false ||
 646                   patch.read_diff(p, &patch_hash) == false)
 647             {
 648                _error->DumpErrors(std::cerr, GlobalError::DEBUG, false);
 649                return false;
 650             }
 651             p.Close();
 652             HashStringList const hsl = patch_hash.GetHashStringList();
 653             if (hsl != I->ExpectedHashes)
 654                return _error->Error("Hash Sum mismatch for uncompressed patch %s", patch_name.c_str());
 655          }
 656
 657          if (Debug == true)
 658             std::clog << "Applying patches against " << Path
 659                << " and writing results to " << Itm->DestFile
 660                << std::endl;
 661
 662          FileFd inp, out;
 663          if (inp.Open(Path, FileFd::ReadOnly, FileFd::Extension) == false)
 664          {
 665             std::cerr << "FAILED to open inp " << Path << std::endl;
 666             return _error->Error("Failed to open inp %s", Path.c_str());
 667          }
 668          if (out.Open(Itm->DestFile, FileFd::WriteOnly | FileFd::Create | FileFd::Empty | FileFd::BufferedWrite, FileFd::Extension) == false)
 669          {
 670             std::cerr << "FAILED to open out " << Itm->DestFile << std::endl;
 671             return _error->Error("Failed to open out %s", Itm->DestFile.c_str());
 672          }
 673
 674          Hashes end_hash(Itm->ExpectedHashes);
 675          if (StartHashes.usable())
 676          {
 677             Hashes start_hash(StartHashes);
 678             patch.apply_against_file(out, inp, &start_hash, &end_hash);
 679             if (start_hash.GetHashStringList() != StartHashes)
 680                _error->Error("The input file hadn't the expected hash!");
 681          }
 682          else
 683             patch.apply_against_file(out, inp, nullptr, &end_hash);
 684
 685          out.Close();
 686          inp.Close();
 687
 688          if (_error->PendingError() == true) {
 689             std::cerr << "FAILED to read or write files" << std::endl;
 690             return false;
 691          }
 692
 693          if (Debug == true) {
 694             std::clog << "rred: finished file patching of " << Path  << "." << std::endl;
 695          }
 696
 697          struct stat bufbase, bufpatch;
 698          if (stat(Path.c_str(), &bufbase) != 0 ||
 699                stat(patch_name.c_str(), &bufpatch) != 0)
 700             return _error->Errno("stat", _("Failed to stat %s"), Path.c_str());
 701
 702          struct timeval times[2];
 703          times[0].tv_sec = bufbase.st_atime;
 704          times[1].tv_sec = bufpatch.st_mtime;
 705          times[0].tv_usec = times[1].tv_usec = 0;
 706          if (utimes(Itm->DestFile.c_str(), times) != 0)
 707             return _error->Errno("utimes",_("Failed to set modification time"));
 708
 709          if (stat(Itm->DestFile.c_str(), &bufbase) != 0)
 710             return _error->Errno("stat", _("Failed to stat %s"), Itm->DestFile.c_str());
 711
 712          Res.LastModified = bufbase.st_mtime;
 713          Res.Size = bufbase.st_size;
 714          Res.TakeHashes(end_hash);
 715          URIDone(Res);
 716
 717          return true;
 718       }
 719
 720    public:
 721       RredMethod() : aptMethod("rred", "2.0", SendConfig), Debug(false) {}
 722 };
 723
 724 int main(int argc, char **argv)
 725 {
 726    int i;
 727    bool just_diff = true;
 728    bool test = false;
 729    Patch patch;
 730
 731    if (argc <= 1) {
 732       RredMethod Mth;
 733       return Mth.Run();
 734    }
 735
 736    // Usage: rred -t input output diff ...
 737    if (argc > 1 && strcmp(argv[1], "-t") == 0) {
 738       // Read config files so we see compressors.
 739       pkgInitConfig(*_config);
 740       just_diff = false;
 741       test = true;
 742       i = 4;
 743    } else if (argc > 1 && strcmp(argv[1], "-f") == 0) {
 744       just_diff = false;
 745       i = 2;
 746    } else {
 747       i = 1;
 748    }
 749
 750    for (; i < argc; i++) {
 751       FileFd p;
 752       if (p.Open(argv[i], FileFd::ReadOnly) == false) {
 753          _error->DumpErrors(std::cerr);
 754          exit(1);
 755       }
 756       if (patch.read_diff(p, NULL) == false)
 757       {
 758          _error->DumpErrors(std::cerr);
 759          exit(2);
 760       }
 761    }
 762
 763    if (test) {
 764       FileFd out, inp;
 765       std::cerr << "Patching " << argv[2] << " into " << argv[3] << "\n";
 766       inp.Open(argv[2], FileFd::ReadOnly,FileFd::Extension);
 767       out.Open(argv[3], FileFd::WriteOnly | FileFd::Create | FileFd::Empty | FileFd::BufferedWrite, FileFd::Extension);
 768       patch.apply_against_file(out, inp);
 769       out.Close();
 770    } else if (just_diff) {
 771       FileFd out;
 772       out.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly | FileFd::Create);
 773       patch.write_diff(out);
 774       out.Close();
 775    } else {
 776       FileFd out, inp;
 777       out.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly | FileFd::Create | FileFd::BufferedWrite);
 778       inp.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly);
 779       patch.apply_against_file(out, inp);
 780       out.Close();
 781    }
 782    return 0;
 783 }