library/html2pdf/fpdi/pdf_parser.php

   1 <?php
   2 //
   3 //  FPDI - Version 1.4.2
   4 //
   5 //    Copyright 2004-2011 Setasign - Jan Slabon
   6 //
   7 //  Licensed under the Apache License, Version 2.0 (the "License");
   8 //  you may not use this file except in compliance with the License.
   9 //  You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 //  Unless required by applicable law or agreed to in writing, software
  14 //  distributed under the License is distributed on an "AS IS" BASIS,
  15 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 //  See the License for the specific language governing permissions and
  17 //  limitations under the License.
  18 //
  19
  20 if (!defined ('PDF_TYPE_NULL'))
  21     define ('PDF_TYPE_NULL', 0);
  22 if (!defined ('PDF_TYPE_NUMERIC'))
  23     define ('PDF_TYPE_NUMERIC', 1);
  24 if (!defined ('PDF_TYPE_TOKEN'))
  25     define ('PDF_TYPE_TOKEN', 2);
  26 if (!defined ('PDF_TYPE_HEX'))
  27     define ('PDF_TYPE_HEX', 3);
  28 if (!defined ('PDF_TYPE_STRING'))
  29     define ('PDF_TYPE_STRING', 4);
  30 if (!defined ('PDF_TYPE_DICTIONARY'))
  31     define ('PDF_TYPE_DICTIONARY', 5);
  32 if (!defined ('PDF_TYPE_ARRAY'))
  33     define ('PDF_TYPE_ARRAY', 6);
  34 if (!defined ('PDF_TYPE_OBJDEC'))
  35     define ('PDF_TYPE_OBJDEC', 7);
  36 if (!defined ('PDF_TYPE_OBJREF'))
  37     define ('PDF_TYPE_OBJREF', 8);
  38 if (!defined ('PDF_TYPE_OBJECT'))
  39     define ('PDF_TYPE_OBJECT', 9);
  40 if (!defined ('PDF_TYPE_STREAM'))
  41     define ('PDF_TYPE_STREAM', 10);
  42 if (!defined ('PDF_TYPE_BOOLEAN'))
  43     define ('PDF_TYPE_BOOLEAN', 11);
  44 if (!defined ('PDF_TYPE_REAL'))
  45     define ('PDF_TYPE_REAL', 12);
  46
  47 require_once('pdf_context.php');
  48
  49 if (!class_exists('pdf_parser', false)) {
  50
  51     class pdf_parser {
  52
  53         /**
  54          * Filename
  55          * @var string
  56          */
  57         var $filename;
  58
  59         /**
  60          * File resource
  61          * @var resource
  62          */
  63         var $f;
  64
  65         /**
  66          * PDF Context
  67          * @var object pdf_context-Instance
  68          */
  69         var $c;
  70
  71         /**
  72          * xref-Data
  73          * @var array
  74          */
  75         var $xref;
  76
  77         /**
  78          * root-Object
  79          * @var array
  80          */
  81         var $root;
  82
  83         /**
  84          * PDF version of the loaded document
  85          * @var string
  86          */
  87         var $pdfVersion;
  88
  89         /**
  90              * For reading encrypted documents and xref/objectstreams are in use
  91              *
  92              * @var boolean
  93              */
  94             var $readPlain = true;
  95
  96         /**
  97          * Constructor
  98          *
  99          * @param string $filename  Source-Filename
 100          */
 101         function pdf_parser($filename) {
 102             $this->filename = $filename;
 103
 104             $this->f = @fopen($this->filename, 'rb');
 105
 106             if (!$this->f)
 107                 $this->error(sprintf('Cannot open %s !', $filename));
 108
 109             $this->getPDFVersion();
 110
 111             $this->c = new pdf_context($this->f);
 112
 113             // Read xref-Data
 114             $this->xref = array();
 115             $this->pdf_read_xref($this->xref, $this->pdf_find_xref());
 116
 117             // Check for Encryption
 118             $this->getEncryption();
 119
 120             // Read root
 121             $this->pdf_read_root();
 122         }
 123
 124         /**
 125          * Close the opened file
 126          */
 127         function closeFile() {
 128                 if (isset($this->f) && is_resource($this->f)) {
 129                     fclose($this->f);
 130                         unset($this->f);
 131                 }
 132         }
 133
 134         /**
 135          * Print Error and die
 136          *
 137          * @param string $msg  Error-Message
 138          */
 139         function error($msg) {
 140                 die('<b>PDF-Parser Error:</b> ' . $msg);
 141         }
 142
 143         /**
 144          * Check Trailer for Encryption
 145          */
 146         function getEncryption() {
 147             if (isset($this->xref['trailer'][1]['/Encrypt'])) {
 148                 $this->error('File is encrypted!');
 149             }
 150         }
 151
 152         /**
 153          * Find/Return /Root
 154          *
 155          * @return array
 156          */
 157         function pdf_find_root() {
 158             if ($this->xref['trailer'][1]['/Root'][0] != PDF_TYPE_OBJREF) {
 159                 $this->error('Wrong Type of Root-Element! Must be an indirect reference');
 160             }
 161
 162             return $this->xref['trailer'][1]['/Root'];
 163         }
 164
 165         /**
 166          * Read the /Root
 167          */
 168         function pdf_read_root() {
 169             // read root
 170             $this->root = $this->pdf_resolve_object($this->c, $this->pdf_find_root());
 171         }
 172
 173         /**
 174          * Get PDF-Version
 175          *
 176          * And reset the PDF Version used in FPDI if needed
 177          */
 178         function getPDFVersion() {
 179             fseek($this->f, 0);
 180             preg_match('/\d\.\d/',fread($this->f, 16), $m);
 181             if (isset($m[0]))
 182                 $this->pdfVersion = $m[0];
 183             return $this->pdfVersion;
 184         }
 185
 186         /**
 187          * Find the xref-Table
 188          */
 189         function pdf_find_xref() {
 190                 $toRead = 1500;
 191
 192             $stat = fseek ($this->f, -$toRead, SEEK_END);
 193             if ($stat === -1) {
 194                 fseek ($this->f, 0);
 195             }
 196                 $data = fread($this->f, $toRead);
 197
 198             $pos = strlen($data) - strpos(strrev($data), strrev('startxref'));
 199             $data = substr($data, $pos);
 200
 201             if (!preg_match('/\s*(\d+).*$/s', $data, $matches)) {
 202                 $this->error('Unable to find pointer to xref table');
 203                 }
 204
 205                 return (int) $matches[1];
 206         }
 207
 208         /**
 209          * Read xref-table
 210          *
 211          * @param array $result Array of xref-table
 212          * @param integer $offset of xref-table
 213          */
 214         function pdf_read_xref(&$result, $offset) {
 215             $o_pos = $offset-min(20, $offset);
 216                 fseek($this->f, $o_pos); // set some bytes backwards to fetch errorious docs
 217
 218             $data = fread($this->f, 100);
 219
 220             $xrefPos = strrpos($data, 'xref');
 221
 222             if ($xrefPos === false) {
 223                 fseek($this->f, $offset);
 224                 $c = new pdf_context($this->f);
 225                 $xrefStreamObjDec = $this->pdf_read_value($c);
 226
 227                 if (is_array($xrefStreamObjDec) && isset($xrefStreamObjDec[0]) && $xrefStreamObjDec[0] == PDF_TYPE_OBJDEC) {
 228                     $this->error(sprintf('This document (%s) probably uses a compression technique which is not supported by the free parser shipped with FPDI.', $this->filename));
 229                 } else {
 230                     $this->error('Unable to find xref table.');
 231                 }
 232             }
 233
 234             if (!isset($result['xref_location'])) {
 235                 $result['xref_location'] = $o_pos + $xrefPos;
 236                 $result['max_object'] = 0;
 237                 }
 238
 239                 $cylces = -1;
 240             $bytesPerCycle = 100;
 241
 242                 fseek($this->f, $o_pos = $o_pos + $xrefPos + 4); // set the handle directly after the "xref"-keyword
 243             $data = fread($this->f, $bytesPerCycle);
 244
 245             while (($trailerPos = strpos($data, 'trailer', max($bytesPerCycle * $cylces++, 0))) === false && !feof($this->f)) {
 246                 $data .= fread($this->f, $bytesPerCycle);
 247             }
 248
 249             if ($trailerPos === false) {
 250                 $this->error('Trailer keyword not found after xref table');
 251             }
 252
 253             $data = substr($data, 0, $trailerPos);
 254
 255             // get Line-Ending
 256             preg_match_all("/(\r\n|\n|\r)/", substr($data, 0, 100), $m); // check the first 100 bytes for linebreaks
 257
 258             $differentLineEndings = count(array_unique($m[0]));
 259             if ($differentLineEndings > 1) {
 260                 $lines = preg_split("/(\r\n|\n|\r)/", $data, -1, PREG_SPLIT_NO_EMPTY);
 261             } else {
 262                 $lines = explode($m[0][1], $data);
 263             }
 264
 265             $data = $differentLineEndings = $m = null;
 266             unset($data, $differentLineEndings, $m);
 267
 268             $linesCount = count($lines);
 269
 270             $start = 1;
 271
 272             for ($i = 0; $i < $linesCount; $i++) {
 273                 $line = trim($lines[$i]);
 274                 if ($line) {
 275                     $pieces = explode(' ', $line);
 276                     $c = count($pieces);
 277                     switch($c) {
 278                         case 2:
 279                             $start = (int)$pieces[0];
 280                             $end   = $start + (int)$pieces[1];
 281                             if ($end > $result['max_object'])
 282                                 $result['max_object'] = $end;
 283                             break;
 284                         case 3:
 285                             if (!isset($result['xref'][$start]))
 286                                 $result['xref'][$start] = array();
 287
 288                             if (!array_key_exists($gen = (int) $pieces[1], $result['xref'][$start])) {
 289                                 $result['xref'][$start][$gen] = $pieces[2] == 'n' ? (int) $pieces[0] : null;
 290                             }
 291                             $start++;
 292                             break;
 293                         default:
 294                             $this->error('Unexpected data in xref table');
 295                     }
 296                 }
 297             }
 298
 299             $lines = $pieces = $line = $start = $end = $gen = null;
 300             unset($lines, $pieces, $line, $start, $end, $gen);
 301
 302             fseek($this->f, $o_pos + $trailerPos + 7);
 303
 304             $c = new pdf_context($this->f);
 305             $trailer = $this->pdf_read_value($c);
 306
 307             $c = null;
 308             unset($c);
 309
 310             if (!isset($result['trailer'])) {
 311                 $result['trailer'] = $trailer;
 312             }
 313
 314             if (isset($trailer[1]['/Prev'])) {
 315                 $this->pdf_read_xref($result, $trailer[1]['/Prev'][1]);
 316             }
 317
 318             $trailer = null;
 319             unset($trailer);
 320
 321             return true;
 322         }
 323
 324         /**
 325          * Reads an Value
 326          *
 327          * @param object $c pdf_context
 328          * @param string $token a Token
 329          * @return mixed
 330          */
 331         function pdf_read_value(&$c, $token = null) {
 332                 if (is_null($token)) {
 333                     $token = $this->pdf_read_token($c);
 334                 }
 335
 336             if ($token === false) {
 337                     return false;
 338                 }
 339
 340                 switch ($token) {
 341                 case    '<':
 342                                 // This is a hex string.
 343                                 // Read the value, then the terminator
 344
 345                     $pos = $c->offset;
 346
 347                                 while(1) {
 348
 349                         $match = strpos ($c->buffer, '>', $pos);
 350
 351                                         // If you can't find it, try
 352                                         // reading more data from the stream
 353
 354                                         if ($match === false) {
 355                                                 if (!$c->increase_length()) {
 356                                                         return false;
 357                                                 } else {
 358                                 continue;
 359                                 }
 360                                         }
 361
 362                                         $result = substr ($c->buffer, $c->offset, $match - $c->offset);
 363                                         $c->offset = $match + 1;
 364
 365                                         return array (PDF_TYPE_HEX, $result);
 366                     }
 367
 368                     break;
 369                         case    '<<':
 370                                 // This is a dictionary.
 371
 372                                 $result = array();
 373
 374                                 // Recurse into this function until we reach
 375                                 // the end of the dictionary.
 376                                 while (($key = $this->pdf_read_token($c)) !== '>>') {
 377                                         if ($key === false) {
 378                                                 return false;
 379                                         }
 380
 381                                         if (($value =   $this->pdf_read_value($c)) === false) {
 382                                                 return false;
 383                                         }
 384
 385                                         // Catch missing value
 386                                         if ($value[0] == PDF_TYPE_TOKEN && $value[1] == '>>') {
 387                                             $result[$key] = array(PDF_TYPE_NULL);
 388                                             break;
 389                                         }
 390
 391                                         $result[$key] = $value;
 392                                 }
 393
 394                                 return array (PDF_TYPE_DICTIONARY, $result);
 395
 396                         case    '[':
 397                                 // This is an array.
 398
 399                                 $result = array();
 400
 401                                 // Recurse into this function until we reach
 402                                 // the end of the array.
 403                                 while (($token = $this->pdf_read_token($c)) !== ']') {
 404                         if ($token === false) {
 405                                                 return false;
 406                                         }
 407
 408                                         if (($value = $this->pdf_read_value($c, $token)) === false) {
 409                             return false;
 410                                         }
 411
 412                                         $result[] = $value;
 413                                 }
 414
 415                     return array (PDF_TYPE_ARRAY, $result);
 416
 417                         case    '('             :
 418                     // This is a string
 419                     $pos = $c->offset;
 420
 421                     $openBrackets = 1;
 422                                 do {
 423                         for (; $openBrackets != 0 && $pos < $c->length; $pos++) {
 424                             switch (ord($c->buffer[$pos])) {
 425                                 case 0x28: // '('
 426                                     $openBrackets++;
 427                                     break;
 428                                 case 0x29: // ')'
 429                                     $openBrackets--;
 430                                     break;
 431                                 case 0x5C: // backslash
 432                                     $pos++;
 433                             }
 434                         }
 435                                 } while($openBrackets != 0 && $c->increase_length());
 436
 437                                 $result = substr($c->buffer, $c->offset, $pos - $c->offset - 1);
 438                                 $c->offset = $pos;
 439
 440                                 return array (PDF_TYPE_STRING, $result);
 441
 442                 case 'stream':
 443                         $o_pos = ftell($c->file)-strlen($c->buffer);
 444                         $o_offset = $c->offset;
 445
 446                         $c->reset($startpos = $o_pos + $o_offset);
 447
 448                         $e = 0; // ensure line breaks in front of the stream
 449                         if ($c->buffer[0] == chr(10) || $c->buffer[0] == chr(13))
 450                                 $e++;
 451                         if ($c->buffer[1] == chr(10) && $c->buffer[0] != chr(10))
 452                                 $e++;
 453
 454                         if ($this->actual_obj[1][1]['/Length'][0] == PDF_TYPE_OBJREF) {
 455                                 $tmp_c = new pdf_context($this->f);
 456                                 $tmp_length = $this->pdf_resolve_object($tmp_c, $this->actual_obj[1][1]['/Length']);
 457                                 $length = $tmp_length[1][1];
 458                         } else {
 459                                 $length = $this->actual_obj[1][1]['/Length'][1];
 460                         }
 461
 462                         if ($length > 0) {
 463                                 $c->reset($startpos + $e,$length);
 464                                 $v = $c->buffer;
 465                         } else {
 466                             $v = '';
 467                         }
 468                         $c->reset($startpos + $e + $length + 9); // 9 = strlen("endstream")
 469
 470                         return array(PDF_TYPE_STREAM, $v);
 471
 472                 default :
 473                         if (is_numeric ($token)) {
 474                         // A numeric token. Make sure that
 475                                         // it is not part of something else.
 476                                         if (($tok2 = $this->pdf_read_token ($c)) !== false) {
 477                             if (is_numeric ($tok2)) {
 478
 479                                                         // Two numeric tokens in a row.
 480                                                         // In this case, we're probably in
 481                                                         // front of either an object reference
 482                                                         // or an object specification.
 483                                                         // Determine the case and return the data
 484                                                         if (($tok3 = $this->pdf_read_token ($c)) !== false) {
 485                                     switch ($tok3) {
 486                                                                         case 'obj':
 487                                             return array (PDF_TYPE_OBJDEC, (int) $token, (int) $tok2);
 488                                                                         case 'R':
 489                                                                                 return array (PDF_TYPE_OBJREF, (int) $token, (int) $tok2);
 490                                                                 }
 491                                                                 // If we get to this point, that numeric value up
 492                                                                 // there was just a numeric value. Push the extra
 493                                                                 // tokens back into the stack and return the value.
 494                                                                 array_push ($c->stack, $tok3);
 495                                                         }
 496                                                 }
 497
 498                                                 array_push ($c->stack, $tok2);
 499                                         }
 500
 501                                         if ($token === (string)((int)$token))
 502                                         return array (PDF_TYPE_NUMERIC, (int)$token);
 503                                         else
 504                                                 return array (PDF_TYPE_REAL, (float)$token);
 505                                 } else if ($token == 'true' || $token == 'false') {
 506                         return array (PDF_TYPE_BOOLEAN, $token == 'true');
 507                                 } else if ($token == 'null') {
 508                                    return array (PDF_TYPE_NULL);
 509                                 } else {
 510                         // Just a token. Return it.
 511                                         return array (PDF_TYPE_TOKEN, $token);
 512                                 }
 513              }
 514         }
 515
 516         /**
 517          * Resolve an object
 518          *
 519          * @param object $c pdf_context
 520          * @param array $obj_spec The object-data
 521          * @param boolean $encapsulate Must set to true, cause the parsing and fpdi use this method only without this para
 522          */
 523         function pdf_resolve_object(&$c, $obj_spec, $encapsulate = true) {
 524             // Exit if we get invalid data
 525                 if (!is_array($obj_spec)) {
 526                 $ret = false;
 527                     return $ret;
 528                 }
 529
 530                 if ($obj_spec[0] == PDF_TYPE_OBJREF) {
 531
 532                         // This is a reference, resolve it
 533                         if (isset($this->xref['xref'][$obj_spec[1]][$obj_spec[2]])) {
 534
 535                                 // Save current file position
 536                                 // This is needed if you want to resolve
 537                                 // references while you're reading another object
 538                                 // (e.g.: if you need to determine the length
 539                                 // of a stream)
 540
 541                                 $old_pos = ftell($c->file);
 542
 543                                 // Reposition the file pointer and
 544                                 // load the object header.
 545
 546                                 $c->reset($this->xref['xref'][$obj_spec[1]][$obj_spec[2]]);
 547
 548                                 $header = $this->pdf_read_value($c);
 549
 550                                 if ($header[0] != PDF_TYPE_OBJDEC || $header[1] != $obj_spec[1] || $header[2] != $obj_spec[2]) {
 551                                         $toSearchFor = $obj_spec[1] . ' ' . $obj_spec[2] . ' obj';
 552                                         if (preg_match('/' . $toSearchFor . '/', $c->buffer)) {
 553                                                 $c->offset = strpos($c->buffer, $toSearchFor) + strlen($toSearchFor);
 554                                                 // reset stack
 555                                                 $c->stack = array();
 556                                         } else {
 557                                                 $this->error("Unable to find object ({$obj_spec[1]}, {$obj_spec[2]}) at expected location");
 558                                         }
 559                                 }
 560
 561                                 // If we're being asked to store all the information
 562                                 // about the object, we add the object ID and generation
 563                                 // number for later use
 564                                 $result = array();
 565                                 $this->actual_obj =& $result;
 566                                 if ($encapsulate) {
 567                                         $result = array (
 568                                                 PDF_TYPE_OBJECT,
 569                                                 'obj' => $obj_spec[1],
 570                                                 'gen' => $obj_spec[2]
 571                                         );
 572                                 }
 573
 574                                 // Now simply read the object data until
 575                                 // we encounter an end-of-object marker
 576                                 while(1) {
 577                         $value = $this->pdf_read_value($c);
 578                                         if ($value === false || count($result) > 4) {
 579                                                 // in this case the parser coudn't find an endobj so we break here
 580                                                 break;
 581                                         }
 582
 583                                         if ($value[0] == PDF_TYPE_TOKEN && $value[1] === 'endobj') {
 584                                                 break;
 585                                         }
 586
 587                         $result[] = $value;
 588                                 }
 589
 590                                 $c->reset($old_pos);
 591
 592                     if (isset($result[2][0]) && $result[2][0] == PDF_TYPE_STREAM) {
 593                         $result[0] = PDF_TYPE_STREAM;
 594                     }
 595
 596                                 return $result;
 597                         }
 598                 } else {
 599                         return $obj_spec;
 600                 }
 601         }
 602
 603
 604
 605         /**
 606          * Reads a token from the file
 607          *
 608          * @param object $c pdf_context
 609          * @return mixed
 610          */
 611         function pdf_read_token(&$c)
 612         {
 613                 // If there is a token available
 614                 // on the stack, pop it out and
 615                 // return it.
 616
 617                 if (count($c->stack)) {
 618                         return array_pop($c->stack);
 619                 }
 620
 621                 // Strip away any whitespace
 622
 623                 do {
 624                         if (!$c->ensure_content()) {
 625                                 return false;
 626                         }
 627                         $c->offset += strspn($c->buffer, " \n\r\t", $c->offset);
 628                 } while ($c->offset >= $c->length - 1);
 629
 630                 // Get the first character in the stream
 631
 632                 $char = $c->buffer[$c->offset++];
 633
 634                 switch ($char) {
 635
 636                         case '[':
 637                         case ']':
 638                         case '(':
 639                         case ')':
 640
 641                                 // This is either an array or literal string
 642                                 // delimiter, Return it
 643
 644                                 return $char;
 645
 646                         case '<':
 647                         case '>':
 648
 649                                 // This could either be a hex string or
 650                                 // dictionary delimiter. Determine the
 651                                 // appropriate case and return the token
 652
 653                                 if ($c->buffer[$c->offset] == $char) {
 654                                         if (!$c->ensure_content()) {
 655                                             return false;
 656                                         }
 657                                         $c->offset++;
 658                                         return $char . $char;
 659                                 } else {
 660                                         return $char;
 661                                 }
 662
 663                         case '%':
 664
 665                             // This is a comment - jump over it!
 666
 667                     $pos = $c->offset;
 668                                 while(1) {
 669                                     $match = preg_match("/(\r\n|\r|\n)/", $c->buffer, $m, PREG_OFFSET_CAPTURE, $pos);
 670                         if ($match === 0) {
 671                                                 if (!$c->increase_length()) {
 672                                                         return false;
 673                                                 } else {
 674                                 continue;
 675                                 }
 676                                         }
 677
 678                                         $c->offset = $m[0][1]+strlen($m[0][0]);
 679
 680                                         return $this->pdf_read_token($c);
 681                     }
 682
 683                         default:
 684
 685                                 // This is "another" type of token (probably
 686                                 // a dictionary entry or a numeric value)
 687                                 // Find the end and return it.
 688
 689                                 if (!$c->ensure_content()) {
 690                                         return false;
 691                                 }
 692
 693                                 while(1) {
 694
 695                                         // Determine the length of the token
 696
 697                                         $pos = strcspn($c->buffer, " %[]<>()\r\n\t/", $c->offset);
 698
 699                                         if ($c->offset + $pos <= $c->length - 1) {
 700                                                 break;
 701                                         } else {
 702                                                 // If the script reaches this point,
 703                                                 // the token may span beyond the end
 704                                                 // of the current buffer. Therefore,
 705                                                 // we increase the size of the buffer
 706                                                 // and try again--just to be safe.
 707
 708                                                 $c->increase_length();
 709                                         }
 710                                 }
 711
 712                                 $result = substr($c->buffer, $c->offset - 1, $pos + 1);
 713
 714                                 $c->offset += $pos;
 715                                 return $result;
 716                 }
 717         }
 718     }
 719 }