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