pdf2swf/xpdf/XRef.cc

   1 //========================================================================
   2 //
   3 // XRef.cc
   4 //
   5 // Copyright 1996-2002 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #ifdef __GNUC__
  10 #pragma implementation
  11 #endif
  12
  13 #include <aconf.h>
  14 #include <stdlib.h>
  15 #include <stddef.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #include "gmem.h"
  19 #include "Object.h"
  20 #include "Stream.h"
  21 #include "Lexer.h"
  22 #include "Parser.h"
  23 #include "Dict.h"
  24 #ifndef NO_DECRYPTION
  25 #include "Decrypt.h"
  26 #endif
  27 #include "Error.h"
  28 #include "ErrorCodes.h"
  29 #include "XRef.h"
  30
  31 //------------------------------------------------------------------------
  32
  33 #define xrefSearchSize 1024     // read this many bytes at end of file
  34                                 //   to look for 'startxref'
  35
  36 #ifndef NO_DECRYPTION
  37 //------------------------------------------------------------------------
  38 // Permission bits
  39 //------------------------------------------------------------------------
  40
  41 #define permPrint    (1<<2)
  42 #define permChange   (1<<3)
  43 #define permCopy     (1<<4)
  44 #define permNotes    (1<<5)
  45 #define defPermFlags 0xfffc
  46 #endif
  47
  48 //------------------------------------------------------------------------
  49 // XRef
  50 //------------------------------------------------------------------------
  51
  52 XRef::XRef(BaseStream *strA, GString *ownerPassword, GString *userPassword) {
  53   Guint pos;
  54   int i;
  55
  56   ok = gTrue;
  57   errCode = errNone;
  58   size = 0;
  59   entries = NULL;
  60   streamEnds = NULL;
  61   streamEndsLen = 0;
  62
  63   // read the trailer
  64   str = strA;
  65   start = str->getStart();
  66   pos = readTrailer();
  67
  68   // if there was a problem with the trailer,
  69   // try to reconstruct the xref table
  70   if (pos == 0) {
  71     if (!(ok = constructXRef())) {
  72       errCode = errDamaged;
  73       return;
  74     }
  75
  76   // trailer is ok - read the xref table
  77   } else {
  78     entries = (XRefEntry *)gmalloc(size * sizeof(XRefEntry));
  79     for (i = 0; i < size; ++i) {
  80       entries[i].offset = 0xffffffff;
  81       entries[i].used = gFalse;
  82     }
  83     while (readXRef(&pos)) ;
  84
  85     // if there was a problem with the xref table,
  86     // try to reconstruct it
  87     if (!ok) {
  88       gfree(entries);
  89       size = 0;
  90       entries = NULL;
  91       if (!(ok = constructXRef())) {
  92         errCode = errDamaged;
  93         return;
  94       }
  95     }
  96   }
  97
  98   // now set the trailer dictionary's xref pointer so we can fetch
  99   // indirect objects from it
 100   trailerDict.getDict()->setXRef(this);
 101
 102   // check for encryption
 103 #ifndef NO_DECRYPTION
 104   encrypted = gFalse;
 105 #endif
 106   if (checkEncrypted(ownerPassword, userPassword)) {
 107     ok = gFalse;
 108     errCode = errEncrypted;
 109     return;
 110   }
 111 }
 112
 113 XRef::~XRef() {
 114   gfree(entries);
 115   trailerDict.free();
 116   if (streamEnds) {
 117     gfree(streamEnds);
 118   }
 119 }
 120
 121 // Read startxref position, xref table size, and root.  Returns
 122 // first xref position.
 123 Guint XRef::readTrailer() {
 124   Parser *parser;
 125   Object obj;
 126   char buf[xrefSearchSize+1];
 127   int n;
 128   Guint pos, pos1;
 129   char *p;
 130   int c;
 131   int i;
 132
 133   // read last xrefSearchSize bytes
 134   str->setPos(xrefSearchSize, -1);
 135   for (n = 0; n < xrefSearchSize; ++n) {
 136     if ((c = str->getChar()) == EOF)
 137       break;
 138     buf[n] = c;
 139   }
 140   buf[n] = '\0';
 141
 142   // find startxref
 143   for (i = n - 9; i >= 0; --i) {
 144     if (!strncmp(&buf[i], "startxref", 9))
 145       break;
 146   }
 147   if (i < 0)
 148     return 0;
 149   for (p = &buf[i+9]; isspace(*p); ++p) ;
 150   pos = lastXRefPos = strToUnsigned(p);
 151
 152   // find trailer dict by looking after first xref table
 153   // (NB: we can't just use the trailer dict at the end of the file --
 154   // this won't work for linearized files.)
 155   str->setPos(start + pos);
 156   for (i = 0; i < 4; ++i)
 157     buf[i] = str->getChar();
 158   if (strncmp(buf, "xref", 4))
 159     return 0;
 160   pos1 = pos + 4;
 161   while (1) {
 162     str->setPos(start + pos1);
 163     for (i = 0; i < 35; ++i) {
 164       if ((c = str->getChar()) == EOF)
 165         return 0;
 166       buf[i] = c;
 167     }
 168     if (!strncmp(buf, "trailer", 7))
 169       break;
 170     p = buf;
 171     while (isspace(*p)) ++p;
 172     while ('0' <= *p && *p <= '9') ++p;
 173     while (isspace(*p)) ++p;
 174     n = atoi(p);
 175     while ('0' <= *p && *p <= '9') ++p;
 176     while (isspace(*p)) ++p;
 177     if (p == buf)
 178       return 0;
 179     pos1 += (p - buf) + n * 20;
 180   }
 181   pos1 += 7;
 182
 183   // read trailer dict
 184   obj.initNull();
 185   parser = new Parser(NULL,
 186              new Lexer(NULL,
 187                str->makeSubStream(start + pos1, gFalse, 0, &obj)));
 188   parser->getObj(&trailerDict);
 189   if (trailerDict.isDict()) {
 190     trailerDict.dictLookupNF("Size", &obj);
 191     if (obj.isInt())
 192       size = obj.getInt();
 193     else
 194       pos = 0;
 195     obj.free();
 196     trailerDict.dictLookupNF("Root", &obj);
 197     if (obj.isRef()) {
 198       rootNum = obj.getRefNum();
 199       rootGen = obj.getRefGen();
 200     } else {
 201       pos = 0;
 202     }
 203     obj.free();
 204   } else {
 205     pos = 0;
 206   }
 207   delete parser;
 208
 209   // return first xref position
 210   return pos;
 211 }
 212
 213 // Read an xref table and the prev pointer from the trailer.
 214 GBool XRef::readXRef(Guint *pos) {
 215   Parser *parser;
 216   Object obj, obj2;
 217   char s[20];
 218   GBool more;
 219   int first, newSize, n, i, j;
 220   int c;
 221
 222   // seek to xref in stream
 223   str->setPos(start + *pos);
 224
 225   // make sure it's an xref table
 226   while ((c = str->getChar()) != EOF && isspace(c)) ;
 227   s[0] = (char)c;
 228   s[1] = (char)str->getChar();
 229   s[2] = (char)str->getChar();
 230   s[3] = (char)str->getChar();
 231   if (!(s[0] == 'x' && s[1] == 'r' && s[2] == 'e' && s[3] == 'f')) {
 232     goto err2;
 233   }
 234
 235   // read xref
 236   while (1) {
 237     while ((c = str->lookChar()) != EOF && isspace(c)) {
 238       str->getChar();
 239     }
 240     if (c == 't') {
 241       break;
 242     }
 243     for (i = 0; (c = str->getChar()) != EOF && isdigit(c) && i < 20; ++i) {
 244       s[i] = (char)c;
 245     }
 246     if (i == 0) {
 247       goto err2;
 248     }
 249     s[i] = '\0';
 250     first = atoi(s);
 251     while ((c = str->lookChar()) != EOF && isspace(c)) {
 252       str->getChar();
 253     }
 254     for (i = 0; (c = str->getChar()) != EOF && isdigit(c) && i < 20; ++i) {
 255       s[i] = (char)c;
 256     }
 257     if (i == 0) {
 258       goto err2;
 259     }
 260     s[i] = '\0';
 261     n = atoi(s);
 262     while ((c = str->lookChar()) != EOF && isspace(c)) {
 263       str->getChar();
 264     }
 265     // check for buggy PDF files with an incorrect (too small) xref
 266     // table size
 267     if (first + n > size) {
 268       newSize = size + 256;
 269       entries = (XRefEntry *)grealloc(entries, newSize * sizeof(XRefEntry));
 270       for (i = size; i < newSize; ++i) {
 271         entries[i].offset = 0xffffffff;
 272         entries[i].used = gFalse;
 273       }
 274       size = newSize;
 275     }
 276     for (i = first; i < first + n; ++i) {
 277       for (j = 0; j < 20; ++j) {
 278         if ((c = str->getChar()) == EOF) {
 279           goto err2;
 280         }
 281         s[j] = (char)c;
 282       }
 283       if (entries[i].offset == 0xffffffff) {
 284         s[10] = '\0';
 285         entries[i].offset = strToUnsigned(s);
 286         s[16] = '\0';
 287         entries[i].gen = atoi(&s[11]);
 288         if (s[17] == 'n') {
 289           entries[i].used = gTrue;
 290         } else if (s[17] == 'f') {
 291           entries[i].used = gFalse;
 292         } else {
 293           goto err2;
 294         }
 295         // PDF files of patents from the IBM Intellectual Property
 296         // Network have a bug: the xref table claims to start at 1
 297         // instead of 0.
 298         if (i == 1 && first == 1 &&
 299             entries[1].offset == 0 && entries[1].gen == 65535 &&
 300             !entries[1].used) {
 301           i = first = 0;
 302           entries[0] = entries[1];
 303           entries[1].offset = 0xffffffff;
 304         }
 305       }
 306     }
 307   }
 308
 309   // read prev pointer from trailer dictionary
 310   obj.initNull();
 311   parser = new Parser(NULL,
 312              new Lexer(NULL,
 313                str->makeSubStream(str->getPos(), gFalse, 0, &obj)));
 314   parser->getObj(&obj);
 315   if (!obj.isCmd("trailer")) {
 316     goto err1;
 317   }
 318   obj.free();
 319   parser->getObj(&obj);
 320   if (!obj.isDict()) {
 321     goto err1;
 322   }
 323   obj.getDict()->lookupNF("Prev", &obj2);
 324   if (obj2.isInt()) {
 325     *pos = (Guint)obj2.getInt();
 326     more = gTrue;
 327   } else {
 328     more = gFalse;
 329   }
 330   obj.free();
 331   obj2.free();
 332
 333   delete parser;
 334   return more;
 335
 336  err1:
 337   obj.free();
 338  err2:
 339   ok = gFalse;
 340   return gFalse;
 341 }
 342
 343 // Attempt to construct an xref table for a damaged file.
 344 GBool XRef::constructXRef() {
 345   Parser *parser;
 346   Object obj;
 347   char buf[256];
 348   Guint pos;
 349   int num, gen;
 350   int newSize;
 351   int streamEndsSize;
 352   char *p;
 353   int i;
 354   GBool gotRoot;
 355
 356   error(0, "PDF file is damaged - attempting to reconstruct xref table...");
 357   gotRoot = gFalse;
 358   streamEndsLen = streamEndsSize = 0;
 359
 360   str->reset();
 361   while (1) {
 362     pos = str->getPos();
 363     if (!str->getLine(buf, 256)) {
 364       break;
 365     }
 366     p = buf;
 367
 368     // got trailer dictionary
 369     if (!strncmp(p, "trailer", 7)) {
 370       obj.initNull();
 371       parser = new Parser(NULL,
 372                  new Lexer(NULL,
 373                    str->makeSubStream(start + pos + 7, gFalse, 0, &obj)));
 374       if (!trailerDict.isNone())
 375         trailerDict.free();
 376       parser->getObj(&trailerDict);
 377       if (trailerDict.isDict()) {
 378         trailerDict.dictLookupNF("Root", &obj);
 379         if (obj.isRef()) {
 380           rootNum = obj.getRefNum();
 381           rootGen = obj.getRefGen();
 382           gotRoot = gTrue;
 383         }
 384         obj.free();
 385       } else {
 386         pos = 0;
 387       }
 388       delete parser;
 389
 390     // look for object
 391     } else if (isdigit(*p)) {
 392       num = atoi(p);
 393       do {
 394         ++p;
 395       } while (*p && isdigit(*p));
 396       if (isspace(*p)) {
 397         do {
 398           ++p;
 399         } while (*p && isspace(*p));
 400         if (isdigit(*p)) {
 401           gen = atoi(p);
 402           do {
 403             ++p;
 404           } while (*p && isdigit(*p));
 405           if (isspace(*p)) {
 406             do {
 407               ++p;
 408             } while (*p && isspace(*p));
 409             if (!strncmp(p, "obj", 3)) {
 410               if (num >= size) {
 411                 newSize = (num + 1 + 255) & ~255;
 412                 entries = (XRefEntry *)
 413                             grealloc(entries, newSize * sizeof(XRefEntry));
 414                 for (i = size; i < newSize; ++i) {
 415                   entries[i].offset = 0xffffffff;
 416                   entries[i].used = gFalse;
 417                 }
 418                 size = newSize;
 419               }
 420               if (!entries[num].used || gen >= entries[num].gen) {
 421                 entries[num].offset = pos - start;
 422                 entries[num].gen = gen;
 423                 entries[num].used = gTrue;
 424               }
 425             }
 426           }
 427         }
 428       }
 429
 430     } else if (!strncmp(p, "endstream", 9)) {
 431       if (streamEndsLen == streamEndsSize) {
 432         streamEndsSize += 64;
 433         streamEnds = (Guint *)grealloc(streamEnds,
 434                                        streamEndsSize * sizeof(int));
 435       }
 436       streamEnds[streamEndsLen++] = pos;
 437     }
 438   }
 439
 440   if (gotRoot)
 441     return gTrue;
 442
 443   error(-1, "Couldn't find trailer dictionary");
 444   return gFalse;
 445 }
 446
 447 #ifndef NO_DECRYPTION
 448 GBool XRef::checkEncrypted(GString *ownerPassword, GString *userPassword) {
 449   Object encrypt, filterObj, versionObj, revisionObj, lengthObj;
 450   Object ownerKey, userKey, permissions, fileID, fileID1;
 451   GBool encrypted1;
 452   GBool ret;
 453
 454   ret = gFalse;
 455
 456   permFlags = defPermFlags;
 457   trailerDict.dictLookup("Encrypt", &encrypt);
 458   if ((encrypted1 = encrypt.isDict())) {
 459     ret = gTrue;
 460     encrypt.dictLookup("Filter", &filterObj);
 461     if (filterObj.isName("Standard")) {
 462       encrypt.dictLookup("V", &versionObj);
 463       encrypt.dictLookup("R", &revisionObj);
 464       encrypt.dictLookup("Length", &lengthObj);
 465       encrypt.dictLookup("O", &ownerKey);
 466       encrypt.dictLookup("U", &userKey);
 467       encrypt.dictLookup("P", &permissions);
 468       trailerDict.dictLookup("ID", &fileID);
 469       if (versionObj.isInt() &&
 470           revisionObj.isInt() &&
 471           ownerKey.isString() && ownerKey.getString()->getLength() == 32 &&
 472           userKey.isString() && userKey.getString()->getLength() == 32 &&
 473           permissions.isInt() &&
 474           fileID.isArray()) {
 475         encVersion = versionObj.getInt();
 476         encRevision = revisionObj.getInt();
 477         if (lengthObj.isInt()) {
 478           keyLength = lengthObj.getInt() / 8;
 479         } else {
 480           keyLength = 5;
 481         }
 482         permFlags = permissions.getInt();
 483         if (encVersion >= 1 && encVersion <= 2 &&
 484             encRevision >= 2 && encRevision <= 3) {
 485           fileID.arrayGet(0, &fileID1);
 486           if (fileID1.isString()) {
 487             if (Decrypt::makeFileKey(encVersion, encRevision, keyLength,
 488                                      ownerKey.getString(), userKey.getString(),
 489                                      permFlags, fileID1.getString(),
 490                                      ownerPassword, userPassword, fileKey,
 491                                      &ownerPasswordOk)) {
 492               if (ownerPassword && !ownerPasswordOk) {
 493                 error(-1, "Incorrect owner password");
 494               }
 495               ret = gFalse;
 496             } else {
 497               error(-1, "Incorrect password");
 498             }
 499           } else {
 500             error(-1, "Weird encryption info");
 501           }
 502           fileID1.free();
 503         } else {
 504           error(-1, "Unsupported version/revision (%d/%d) of Standard security handler",
 505                 encVersion, encRevision);
 506         }
 507       } else {
 508         error(-1, "Weird encryption info");
 509       }
 510       fileID.free();
 511       permissions.free();
 512       userKey.free();
 513       ownerKey.free();
 514       lengthObj.free();
 515       revisionObj.free();
 516       versionObj.free();
 517     } else {
 518       error(-1, "Unknown security handler '%s'",
 519             filterObj.isName() ? filterObj.getName() : "???");
 520     }
 521     filterObj.free();
 522   }
 523   encrypt.free();
 524
 525   // this flag has to be set *after* we read the O/U/P strings
 526   encrypted = encrypted1;
 527
 528   return ret;
 529 }
 530 #else
 531 GBool XRef::checkEncrypted(GString *ownerPassword, GString *userPassword) {
 532   Object obj;
 533   GBool encrypted;
 534
 535   trailerDict.dictLookup("Encrypt", &obj);
 536   if ((encrypted = !obj.isNull())) {
 537     error(-1, "PDF file is encrypted and this version of the Xpdf tools");
 538     error(-1, "was built without decryption support.");
 539   }
 540   obj.free();
 541   return encrypted;
 542 }
 543 #endif
 544
 545 GBool XRef::okToPrint(GBool ignoreOwnerPW) {
 546 #ifndef NO_DECRYPTION
 547   if ((ignoreOwnerPW || !ownerPasswordOk) && !(permFlags & permPrint)) {
 548     return gFalse;
 549   }
 550 #endif
 551   return gTrue;
 552 }
 553
 554 GBool XRef::okToChange(GBool ignoreOwnerPW) {
 555 #ifndef NO_DECRYPTION
 556   if ((ignoreOwnerPW || !ownerPasswordOk) && !(permFlags & permChange)) {
 557     return gFalse;
 558   }
 559 #endif
 560   return gTrue;
 561 }
 562
 563 GBool XRef::okToCopy(GBool ignoreOwnerPW) {
 564 #ifndef NO_DECRYPTION
 565   if ((ignoreOwnerPW || !ownerPasswordOk) && !(permFlags & permCopy)) {
 566     return gFalse;
 567   }
 568 #endif
 569   return gTrue;
 570 }
 571
 572 GBool XRef::okToAddNotes(GBool ignoreOwnerPW) {
 573 #ifndef NO_DECRYPTION
 574   if ((ignoreOwnerPW || !ownerPasswordOk) && !(permFlags & permNotes)) {
 575     return gFalse;
 576   }
 577 #endif
 578   return gTrue;
 579 }
 580
 581 Object *XRef::fetch(int num, int gen, Object *obj) {
 582   XRefEntry *e;
 583   Parser *parser;
 584   Object obj1, obj2, obj3;
 585
 586   // check for bogus ref - this can happen in corrupted PDF files
 587   if (num < 0 || num >= size) {
 588     obj->initNull();
 589     return obj;
 590   }
 591
 592   e = &entries[num];
 593   if (e->gen == gen && e->offset != 0xffffffff) {
 594     obj1.initNull();
 595     parser = new Parser(this,
 596                new Lexer(this,
 597                  str->makeSubStream(start + e->offset, gFalse, 0, &obj1)));
 598     parser->getObj(&obj1);
 599     parser->getObj(&obj2);
 600     parser->getObj(&obj3);
 601     if (obj1.isInt() && obj1.getInt() == num &&
 602         obj2.isInt() && obj2.getInt() == gen &&
 603         obj3.isCmd("obj")) {
 604 #ifndef NO_DECRYPTION
 605       parser->getObj(obj, encrypted ? fileKey : (Guchar *)NULL, keyLength,
 606                      num, gen);
 607 #else
 608       parser->getObj(obj);
 609 #endif
 610     } else {
 611       obj->initNull();
 612     }
 613     obj1.free();
 614     obj2.free();
 615     obj3.free();
 616     delete parser;
 617   } else {
 618     obj->initNull();
 619   }
 620   return obj;
 621 }
 622
 623 Object *XRef::getDocInfo(Object *obj) {
 624   return trailerDict.dictLookup("Info", obj);
 625 }
 626
 627 // Added for the pdftex project.
 628 Object *XRef::getDocInfoNF(Object *obj) {
 629   return trailerDict.dictLookupNF("Info", obj);
 630 }
 631
 632 GBool XRef::getStreamEnd(Guint streamStart, Guint *streamEnd) {
 633   int a, b, m;
 634
 635   if (streamEndsLen == 0 ||
 636       streamStart > streamEnds[streamEndsLen - 1]) {
 637     return gFalse;
 638   }
 639
 640   a = -1;
 641   b = streamEndsLen - 1;
 642   // invariant: streamEnds[a] < streamStart <= streamEnds[b]
 643   while (b - a > 1) {
 644     m = (a + b) / 2;
 645     if (streamStart <= streamEnds[m]) {
 646       b = m;
 647     } else {
 648       a = m;
 649     }
 650   }
 651   *streamEnd = streamEnds[b];
 652   return gTrue;
 653 }
 654
 655 Guint XRef::strToUnsigned(char *s) {
 656   Guint x;
 657   char *p;
 658   int i;
 659
 660   x = 0;
 661   for (p = s, i = 0; *p && isdigit(*p) && i < 10; ++p, ++i) {
 662     x = 10 * x + (*p - '0');
 663   }
 664   return x;
 665 }