] see pdfk help
112 |
113 | var $needAppearancesTrue = false; //boolean, indicates if /NeedAppearances is already set to true
114 | var $isUTF8 = false; //boolean (true for UTF-8, false for ISO-8859-1)
115 |
116 | /**
117 | * Constructor
118 | *
119 | *@example Common use:
120 | *@param string $pdf_source Source-Filename
121 | *@param string $fdf_source Source-Filename
122 | *@param boolean $verbose , optional false per default
123 | */
124 | function __construct() {
125 | //==============
126 |
127 | $args=func_get_args();
128 | $num_args=func_num_args();
129 |
130 | $FDF_FILE=($num_args>=FPDM_COMMON);
131 | $VERBOSE_FLAG=($num_args>=FPDM_VERBOSE);
132 |
133 | $verbose=false;
134 |
135 | //We are not joking here, let's have a polymorphic constructor!
136 | switch($num_args) {
137 | case FPDM_INVALID:
138 | $this->Error("Invalid instantiation of FPDM, requires at least one param");
139 | break;
140 | case FPDM_STATIC:
141 | if($args[0] =='[_STATIC_]') break; //static use, caller is anonymous function defined in _set_field_value
142 | //else this is the pdf_source then, fdf content is loaded using Load() function
143 | default:
144 | case FPDM_VERBOSE: //Use the verbose value provided
145 | if($VERBOSE_FLAG) $verbose=$args[2];
146 | case FPDM_COMMON: //Common use
147 | $this->pdf_source = $args[0];//Blank pdf form
148 |
149 | if($FDF_FILE) {
150 | $this->fdf_source = $args[1];//Holds the data of the fields to fill the form
151 | $this->fdf_parse_needed=true;
152 | }
153 |
154 | //calculation and map
155 | $this->offsets=array();
156 | $this->pointer=0;
157 | $this->shift=0;
158 | $this->shifts=array();
159 | $this->n=0;
160 |
161 | //Stream filters
162 | $filters=$this->getFilters("|");
163 | $this->streams_filter="/(\/($filters))+/";
164 | //$this->dumpContent($this->streams_filter);
165 |
166 | $this->info=array();
167 |
168 | //Debug modes
169 | $this->verbose=$verbose;
170 | $this->verbose_level=($verbose&&is_int($verbose)) ? $verbose : 1;
171 | $this->safe_mode=false;
172 | $this->check_mode=false; //script will takes much more time if you do so
173 | $this->halt_mode=true;
174 |
175 | $this->support='native'; //may ne overriden
176 | $this->security=array('password'=>array('owner'=>null,'user'=>null),'encrypt'=>0,'allow'=>array());
177 |
178 | //echo "
filesize:".filesize($this->pdf_source);
179 | $this->load_file('PDF');
180 |
181 | if($FDF_FILE) $this->load_file('FDF');
182 |
183 | }
184 | }
185 |
186 | /**
187 | *Loads a form data to be merged
188 | *
189 | *@note this overrides fdf input source if it was previously defined
190 | *@access public
191 | *@param string|array $fdf_data a FDF file content or $pdf_data an array containing the values for the fields to change
192 | **/
193 | function Load($data,$isUTF8=false) {
194 | //------------------------
195 | $this->isUTF8 = $isUTF8;
196 | $this->load_file('FDF',$data);
197 | }
198 |
199 | /**
200 | *Loads a file according to its type
201 | *
202 | *@access private
203 | *@param string type 'PDF' or 'FDF'
204 | *@param String|array content the data content of FDF files only or directly the fields values as array
205 | **/
206 | function load_file($type,$content=NULL) {
207 | //------------------------------------
208 | switch($type) {
209 | case "PDF" :
210 | if($content)
211 | $this->Error("load_file do not accept PDF content, only FDF content sorry");
212 | else
213 | $this->pdf_entries = $this->getEntries($this->pdf_source,'PDF');
214 | break;
215 | case "FDF" :
216 | if(!is_null($content)) {
217 | if(is_array($content)) {
218 | $this->fields=$content;
219 | $this->fdf_parse_needed=false;
220 | //$this->dumpEntries($content,"PDF fields content");
221 | } else if(is_string($content)){ //String
222 | $this->fdf_content = $content; //TODO: check content
223 | $this->fdf_parse_needed=true;
224 | } else
225 | $this->Error('Invalid content type for this FDF file!');
226 | } else {
227 | $this->fdf_content = $this->getContent($this->fdf_source,'FDF');
228 | $this->fdf_parse_needed=true;
229 | }
230 | break;
231 | default:
232 | $this->Error("Invalid file type $type");
233 | }
234 | }
235 |
236 | /**
237 | *Set a mode and play with your power debug toys
238 | *
239 | *@access public
240 | *@note for big boys only coz it may hurt
241 | *@param string $mode a choice between 'safe','check','verbose','halt' or 'verbose_level'
242 | *@param string|int $value an integer for verbose_level
243 | **/
244 | function set_modes($mode,$value) {
245 | //-------------------------------
246 | switch($mode) {
247 | case 'safe':
248 | $this->safe_mode=$value;
249 | break;
250 | case 'check':
251 | $this->check_mode=$value;
252 | break;
253 | case 'flatten':
254 | $this->flatten_mode=$value;
255 | break;
256 | case 'compress_mode':
257 | $this->compress_mode=$value;
258 | if($value) $this->uncompress_mode=false;
259 | break;
260 | case 'uncompress_mode':
261 | $this->uncompress_mode=$value;
262 | if($value) $this->compress_mode=false;
263 | break;
264 | case 'verbose':
265 | $this->verbose=$value;
266 | break;
267 | case 'halt':
268 | $this->halt_mode=$value;
269 | break;
270 | case 'verbose_level':
271 | $this->verbose_level=$value;
272 | break;
273 | default:
274 | $this->Error("set_modes error, Invalid mode '$mode'");
275 | }
276 | }
277 |
278 | /**
279 | *Retrieves informations of the pdf
280 | *
281 | *@access public
282 | *@note To track PDF versions and so on...
283 | *@param Boolean output
284 | **/
285 | function Info($asArray=false) {
286 | //----------------------
287 | $info=$this->info;
288 | $info["Reader"]=($this->support == "native") ? 'FPDF-Merge '.FPDM_VERSION: $this->support;
289 | $info["Fields"]=$this->fields;
290 | $info["Modes"]=array(
291 | 'safe'=>($this->safe_mode)? 'Yes' :'No',
292 | 'check'=>($this->check_mode) ? 'Yes': 'No',
293 | 'flatten'=>($this->flatten_mode) ? 'Yes': 'No',
294 | 'compress_mode'=>($this->compress_mode) ? 'Yes': 'No',
295 | 'uncompress_mode'=>($this->uncompress_mode) ? 'Yes': 'No',
296 | 'verbose'=>$this->verbose,
297 | 'verbose_level'=>$this->verbose_level,
298 | 'halt'=>$this->halt_mode
299 | );
300 | if($asArray) {
301 | return $info;
302 | } else {
303 | $this->dumpEntries($info);
304 | }
305 | }
306 |
307 | /**
308 | *Changes the support
309 | *
310 | *@access public
311 | *@internal fixes xref table offsets
312 | *@note special playskool toy for Christmas dedicated to my impatient fanclub (Grant, Kris, nejck,...)
313 | *@param String support Allow to use external support that has more advanced features (ie 'pdftk')
314 | **/
315 | function Plays($cool) {
316 | //----------------------
317 | if($cool=='pdftk') //Use a coolest support as ..
318 | $this->support='pdftk';//..Per DeFinition This is Kool!
319 | else
320 | $this->support='native';
321 | }
322 |
323 | /**
324 | *Fixes a corrupted PDF file
325 | *
326 | *@access public
327 | *@internal fixes xref table offsets
328 | *@note Real work is not made here but by Merge that should be launched after to complete the work
329 | **/
330 | function Fix() {
331 | //---------------
332 | if(!$this->fields) $this->fields=array(); //Default: No field data
333 | $this->set_modes('check',true); //Compare xref table offsets with objects offsets in the pdf file
334 | $this->set_modes('halt',false); //Do no stop on errors so fix is applied during merge process
335 | }
336 |
337 | //######## pdftk's output configuration #######
338 |
339 | /**
340 | *Decides to use the compress filter to restore compression.
341 | *@note This is only useful when you want to repack PDF that was previously edited in a text editor like vim or emacs.
342 | **/
343 | function Compress() {
344 | //-------------------
345 | $this->set_modes('compress',true);
346 | $this->support="pdftk";
347 | }
348 |
349 | /**
350 | *Decides to remove PDF page stream compression by applying the uncompress filter.
351 | *@note This is only useful when you want to edit PDF code in a text editor like vim or emacs.
352 | **/
353 | function Uncompress() {
354 | //---------------------
355 | $this->set_modes('uncompress',true);
356 | $this->support="pdftk";
357 | }
358 | /**
359 | *Activates the flatten output to remove form from pdf file keeping field datas.
360 | **/
361 | function Flatten() {
362 | //-----------------
363 | $this->set_modes('flatten',true);
364 | $this->support="pdftk";
365 | }
366 |
367 | /***
368 | *Defines a password type
369 | *@param String type , 'owner' or 'user'
370 | **/
371 | function Password($type,$code) {
372 | //------------------------------
373 | switch($type) {
374 | case 'owner':
375 | case 'user':
376 | $this->security["password"]["$type"]=$code;
377 | break;
378 | default:
379 | $this->Error("Unsupported password type ($type), specify 'owner' or 'user' instead.");
380 | }
381 | $this->support="pdftk";
382 | }
383 |
384 |
385 | /**
386 | *Defines the encrytion to the given bits
387 | *@param integer $bits 0, 40 or 128
388 | **/
389 | function Encrypt($bits) {
390 | //-----------------------
391 | switch($bits) {
392 | case 0:
393 | case 40:
394 | case 128:
395 | $this->security["encrypt"]=$bits;
396 | break;
397 | default:
398 | $this->Error("Unsupported encrypt value of $bits, only 0, 40 and 128 are supported");
399 | }
400 | $this->support="pdftk";
401 | }
402 |
403 | /**
404 | *Allow permissions
405 | *
406 | *@param Array permmissions If no arg is given, show help.
407 | * Permissions are applied to the output PDF only if an encryption
408 | * strength is specified or an owner or user password is given. If
409 | * permissions are not specified, they default to 'none,' which
410 | * means all of the following features are disabled.
411 | *
412 | * The permissions section may include one or more of the following
413 | * features:
414 | *
415 | * Printing
416 | * Top Quality Printing
417 | *
418 | * DegradedPrinting
419 | * Lower Quality Printing
420 | *
421 | * ModifyContents
422 | * Also allows Assembly
423 | *
424 | * Assembly
425 | *
426 | * CopyContents
427 | * Also allows ScreenReaders
428 | *
429 | * ScreenReaders
430 | *
431 | * ModifyAnnotations
432 | * Also allows FillIn
433 | *
434 | * FillIn
435 | *
436 | * AllFeatures
437 | * Allows the user to perform all of the above, and top
438 | * quality printing.
439 | **/
440 | function Allow($permissions=null) {
441 | //--------------------------
442 | $perms_help=array(
443 | 'Printing'=>'Top Quality Printing',
444 | 'DegradedPrinting'=>'Lower Quality Printing',
445 | 'ModifyContents' =>'Also allows Assembly',
446 | 'Assembly' => '',
447 | 'CopyContents' => 'Also allows ScreenReaders',
448 | 'ScreenReaders' => '',
449 | 'ModifyAnnotations'=>'Also allows FillIn',
450 | 'FillIn'=>'',
451 | 'AllFeatures'=> "All above"
452 | );
453 | if(is_null($permissions)) {
454 | echo '
Info Allow permissions:
';
455 | print_r($perms_help);
456 | }else {
457 | if(is_string($permissions)) $permissions=array($permissions);
458 | $perms=array_keys($perms_help);
459 | $this->security["allow"]=array_intersect($permissions, $perms);
460 | $this->support="pdftk";
461 | }
462 | }
463 |
464 | //#############################
465 |
466 | /**
467 | *Merge FDF file with a PDF file
468 | *
469 | *@access public
470 | *@note files has been provided during the instantiation of this class
471 | *@internal flatten mode is not yet supported
472 | *@param Boolean flatten Optional, false by default, if true will use pdftk (requires a shell) to flatten the pdf form
473 | **/
474 | function Merge($flatten=false) {
475 | //------------------------------
476 |
477 | if($flatten) $this->Flatten();
478 |
479 |
480 | if($this->support == "native") {
481 |
482 | if($this->fdf_parse_needed) {
483 | $fields=$this->parseFDFContent();
484 | }else {
485 | $fields=$this->fields;
486 | }
487 |
488 | $count_fields=count($fields);
489 |
490 | if($this->verbose&&($count_fields==0))
491 | $this->dumpContent("The FDF content has either no field data or parsing may failed","FDF parser: ");
492 |
493 | $fields_value_definition_lines=array();
494 |
495 | $count_entries=$this->parsePDFEntries($fields_value_definition_lines);
496 |
497 |
498 | if($count_entries) {
499 |
500 | $this->value_entries=$fields_value_definition_lines;
501 | if($this->verbose) {
502 | $this->dumpContent("$count_entries Field entry values found for $count_fields field values to fill","Merge info: ");
503 | }
504 | //==== Alterate work is made here: change values ============
505 | if($count_fields) {
506 | foreach($fields as $name => $value) {
507 | $this->set_field_value("current",$name,$value);
508 | // $value=''; //Strategy applies only to current value, clear others
509 | // $this->set_field_value("default",$name,$value);
510 | // $this->set_field_value("tooltip",$name,$value);
511 | }
512 | }
513 | //===========================================================
514 |
515 | //===== Cross refs/size fixes (offsets calculations for objects have been previously be done in set_field_value) =======
516 |
517 | //Update cross reference table to match object size changes
518 | $this->fix_xref_table();
519 |
520 | //update the pointer to the cross reference table
521 | $this->fix_xref_start();
522 |
523 | }else
524 | $this->Error("PDF file is empty!");
525 |
526 | } //else pdftk's job is done in Output, not here.
527 | }
528 |
529 | /**
530 | *Warns verbose/output conflicts
531 | *
532 | *@access private
533 | *@param string $dest a output destination
534 | **/
535 | function Close($dest) {
536 | //----------------
537 | $this->Error("Output: Verbose mode should be desactivated, it is incompatible with this output mode $dest");
538 | }
539 |
540 | /**
541 | *Get current pdf content (without any offset fixes)
542 | *
543 | *@access private
544 | *@param String pdf_file, if given , use the content as buffer (note file will be deleted after!)
545 | *@return string buffer the pdf content
546 | **/
547 | function get_buffer($pdf_file=''){
548 | //---------------------
549 | if($pdf_file == '') {
550 | $buffer=implode("\n",$this->pdf_entries);
551 | }else {
552 | $buffer=$this->getContent($pdf_file,'PDF');
553 | //@unlink($pdf_file);
554 | }
555 | return $buffer;
556 | }
557 |
558 |
559 | /**
560 | *Output PDF to some destination
561 | *
562 | *@access public
563 | *@note reproduces the fpdf's behavior
564 | *@param string dest the destination
565 | *@param string name the filename
566 | **/
567 | function Output($dest='', $name=''){
568 | //-----------------------------------
569 |
570 | $pdf_file='';
571 |
572 | if($this->support == "pdftk") {
573 | //As PDFTK can only merge FDF files not data directly,
574 | require_once("lib/url.php"); //we will need a url support because relative urls for pdf inside fdf files are not supported by PDFTK...
575 | require_once("export/fdf/fdf.php"); //...conjointly with my patched/bridged forge_fdf that provides fdf file generation support from array data.
576 | require_once("export/pdf/pdftk.php");//Of course don't forget to bridge to PDFTK!
577 |
578 | $tmp_file=false;
579 | $pdf_file=resolve_path(fix_path(dirname(__FILE__).'/'.$this->pdf_source)); //string: full pathname to the input pdf , a form file
580 |
581 | if($this->fdf_source) { //FDF file provided
582 | $fdf_file=resolve_path(fix_path(dirname(__FILE__).'/'.$this->fdf_source));
583 | }else {
584 |
585 | $pdf_url=getUrlfromDir($pdf_file); //Normaly http scheme not local file
586 |
587 | if($this->fdf_parse_needed) { //fdf source was provided
588 | $pdf_data=$this->parseFDFContent();
589 | }else { //fields data was provided as an array, we have to generate the fdf file
590 | $pdf_data=$this->fields;
591 | }
592 |
593 | $fdf_file=fix_path(FPDM_CACHE)."fields".rnunid().".fdf";
594 | $tmp_file=true;
595 | $ret=output_fdf($pdf_url,$pdf_data,$fdf_file);
596 | if(!$ret["success"])
597 | $this->Error("Output failed as something goes wrong (Pdf was $pdf_url)
during internal FDF generation of file $fdf_file,
Reason is given by {$ret['return']}");
598 | }
599 |
600 | //Serializes security options (not deeply tested)
601 | $security='';
602 | if(!is_null($this->security["password"]["owner"])) $security.=' owner_pw "'.substr($this->security["password"]["owner"],0,FPDM_PASSWORD_MAX_LEN).'"';
603 | if(!is_null($this->security["password"]["user"])) $security.=' user_pw "'.substr($this->security["password"]["user"],0,FPDM_PASSWORD_MAX_LEN).'"';
604 | if($this->security["encrypt"]!=0) $security.=' encrypt_'.$this->security["encrypt"].'bit';
605 | if(count($this->security["allow"])>0) {
606 | $permissions=$this->security["allow"];
607 | $security.=' allow ';
608 | foreach($permissions as $permission)
609 | $security.=' '.$permission;
610 | }
611 |
612 | //Serialize output modes
613 | $output_modes='';
614 | if($this->flatten_mode) $output_modes.=' flatten';
615 | if($this->compress_mode) $output_modes.=' compress';
616 | if($this->uncompress_mode) $output_modes.=' uncompress';
617 |
618 |
619 | $ret=pdftk($pdf_file,$fdf_file,array("security"=>$security,"output_modes"=>$output_modes));
620 |
621 | if($tmp_file) @unlink($fdf_file); //Clear cache
622 |
623 | if($ret["success"]) {
624 | $pdf_file=$ret["return"];
625 | }else
626 | $this->Error($ret["return"]);
627 | }
628 |
629 | //$this->buffer=$this->get_buffer($pdf_file);
630 |
631 |
632 | $dest=strtoupper($dest);
633 | if($dest=='')
634 | {
635 | if($name=='')
636 | {
637 | $name='doc.pdf';
638 | $dest='I';
639 | }
640 | else
641 | $dest='F';
642 | }
643 |
644 | //Abort to avoid to polluate output
645 | if($this->verbose&&(($dest=='I')||($dest=='D'))) {
646 | $this->Close($dest);
647 | }
648 |
649 | switch($dest)
650 | {
651 | case 'I':
652 | //Send to standard output
653 | if(ob_get_length())
654 | $this->Error('Some data has already been output, can\'t send PDF file');
655 | if(php_sapi_name()!='cli')
656 | {
657 | //We send to a browser
658 | header('Content-Type: application/pdf');
659 | if(headers_sent())
660 | $this->Error('Some data has already been output, can\'t send PDF file');
661 | header('Content-Length: '.strlen($this->get_buffer()));
662 | header('Content-Disposition: inline; filename="'.$name.'"');
663 | header('Cache-Control: private, max-age=0, must-revalidate');
664 | header('Pragma: public');
665 | ini_set('zlib.output_compression','0');
666 | }
667 | echo $this->get_buffer();
668 | break;
669 | case 'D':
670 | //Download file
671 | if(ob_get_length())
672 | $this->Error('Some data has already been output, can\'t send PDF file');
673 | header('Content-Type: application/x-download');
674 | if(headers_sent())
675 | $this->Error('Some data has already been output, can\'t send PDF file');
676 | header('Content-Length: '.strlen($this->get_buffer()));
677 | header('Content-Disposition: attachment; filename="'.$name.'"');
678 |
679 | header("Expires: Mon, 26 Jul 1997 05:00:00 GMT"); // Date in the past
680 | header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT"); // always modified
681 | header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0"); // HTTP/1.1
682 | header("Cache-Control: post-check=0, pre-check=0", false);
683 | //header("Pragma: "); // HTTP/1.0
684 |
685 | header('Cache-Control: private, max-age=0, must-revalidate');
686 | header('Pragma: public,no-cache');
687 | ini_set('zlib.output_compression','0');
688 | echo $this->get_buffer();
689 | break;
690 | case 'F':
691 | //Save to local file
692 | if($this->verbose) $this->dumpContent("Write file $name","Output");
693 | $f=fopen($name,'wb');
694 | if(!$f)
695 | $this->Error('Unable to create output file: '.$name.' (currently opened under Acrobat Reader?)');
696 |
697 | fwrite($f,$this->get_buffer(),strlen($this->get_buffer()));
698 | fclose($f);
699 | break;
700 | case 'S':
701 | //Return as a string
702 | return $this->get_buffer();
703 | default:
704 | $this->Error('Incorrect output destination: '.$dest);
705 | }
706 | return '';
707 | }
708 |
709 |
710 | /**
711 | *Decodes and returns the binary form of a field hexified value
712 | *
713 | *@note static method due to callback..
714 | *@param string value the hexified string
715 | *@return string call the binary string
716 | **/
717 | function pdf_decode_field_value($value) {
718 | //----------------------------------------
719 | $call=$this->static_method_call('_hex2bin',$value);
720 | return $call;
721 | }
722 |
723 | /**
724 | *Encodes and returns the headecimal form of a field binary value
725 | *
726 | *@note static method due to callback..
727 | *@param string value the binary string
728 | *@return string call the hexified string
729 | **/
730 | function pdf_encode_field_value($value) {
731 | //---------------------------------------
732 | $value=$this->static_method_call('_bin2hex',$value);
733 | return $value;
734 | }
735 |
736 |
737 | /**
738 | *Universal Php4/5 static call helper
739 | *
740 | *@param String $method a name of a method belonging to this class
741 | *@return mixed the return value of the called method
742 | **/
743 | function static_method_call($method) {
744 | //---------------------------------------------
745 |
746 | $params_call=func_get_args();
747 | array_shift($params_call);
748 | //var_dump($params_call);
749 |
750 | return call_user_func_array(array($this,$method),$params_call);
751 | }
752 |
753 | /**
754 | *Changes a field value that can be in hex <> or binary form ()
755 | *
756 | *@param $matches the regexp matches of the line that contains the value to change
757 | *@param String $value the new value for the field property
758 | **/
759 | function replace_value($matches,$value) {
760 | //----------------------------------------------
761 |
762 | array_shift($matches);
763 |
764 | if(($value!='')&&($matches[1]=="<")) //Value must be hexified..
765 | $value=$this->pdf_encode_field_value($value);
766 |
767 | $matches[2]=$value;
768 | $value_type_code=$matches[0]; //Should be V, DV or TU
769 | $matches[0]="/".$value_type_code." ";
770 |
771 | $value=implode("",$matches);
772 | //echo(htmlentities($value));
773 | return $value;
774 | }
775 |
776 | /**
777 | *Core to change the value of a field property, inline.
778 | *
779 | *@access private
780 | *@param int $line the lien where the field property value is defined in the pdf file
781 | *@param string $value the new value to set
782 | *@return int $shift the size change of the field property value
783 | **/
784 | function _set_field_value($line,$value) {
785 | //----------------------------------------
786 |
787 | $verbose_set=($this->verbose&&($this->verbose_level>1));
788 | //get the line content
789 | $CurLine =$this->pdf_entries[$line];
790 |
791 | $OldLen=strlen($CurLine);
792 |
793 | //My PHP4/5 static call hack, only to make the callback $this->replace_value($matches,"$value") possible!
794 | $callback_code='$THIS=new FPDM("[_STATIC_]");return $THIS->replace_value($matches,"'.$value.'");';
795 |
796 | $field_regexp='/^\/(\w+)\s?(\<|\()([^\)\>]*)(\)|\>)/';
797 |
798 | if(preg_match($field_regexp,$CurLine)) {
799 | //modify it according to the new value $value
800 | $CurLine = preg_replace_callback(
801 | $field_regexp,
802 | create_function('$matches',$callback_code),
803 | $CurLine
804 | );
805 | }else {
806 | if($verbose_set) echo("
WARNING:".htmlentities("Can not access to the value: $CurLine using regexp $field_regexp"));
807 | }
808 |
809 |
810 | $NewLen=strlen($CurLine);
811 | $Shift=$NewLen-$OldLen;
812 | $this->shift=$this->shift+$Shift;
813 |
814 | //Saves
815 | $this->pdf_entries[$line]=$CurLine;
816 |
817 | return $Shift;
818 | }
819 |
820 | function _encode_value($str) {
821 | if($this->isUTF8)
822 | $str="\xFE\xFF".iconv('UTF-8','UTF-16BE',$str);
823 | return $this->_bin2hex($str);
824 | }
825 |
826 | function _set_field_value2($line,$value,$append) {
827 | $CurLine=$this->pdf_entries[$line];
828 | $OldLen=strlen($CurLine);
829 |
830 | if($append)
831 | {
832 | $CurLine .= ' /V <'.$this->_encode_value($value).'>';
833 | }
834 | else
835 | {
836 | if(preg_match('#/V\s?[<(]([^>)]*)[>)]#', $CurLine, $a, PREG_OFFSET_CAPTURE))
837 | {
838 | $len=strlen($a[1][0]);
839 | $pos1=$a[1][1];
840 | $pos2=$pos1+$len;
841 | $CurLine=substr($CurLine,0,$pos1-1).'<'.$this->_encode_value($value).'>'.substr($CurLine,$pos2+1);
842 | }
843 | else
844 | $this->Error('/V not found');
845 | }
846 |
847 | $NewLen=strlen($CurLine);
848 | $Shift=$NewLen-$OldLen;
849 | $this->shift=$this->shift+$Shift;
850 | $this->pdf_entries[$line]=$CurLine;
851 | return $Shift;
852 | }
853 |
854 |
855 | /**
856 | *Changes the value of a field property, inline.
857 | *
858 | *@param string $type supported values for type are 'default' , 'current' or 'tooltip'
859 | *@param string $name name of the field annotation to change the value
860 | *@param string $value the new value to set
861 | **/
862 | function set_field_value($type,$name,$value) {
863 | //------------------------------------
864 | $verbose_set=($this->verbose&&($this->verbose_level>1));
865 |
866 | //Get the line(s) of the misc field values
867 | if(isset($this->value_entries["$name"])) {
868 |
869 | $object_id=$this->value_entries["$name"]["infos"]["object"];
870 |
871 | if($type=="tooltip") {
872 |
873 | $offset_shift=$this->set_field_tooltip($name,$value);
874 |
875 | } elseif ($this->useCheckboxParser && isset($this->value_entries["$name"]['infos']['checkbox_state'])) { //FIX: set checkbox value
876 | $offset_shift=$this->set_field_checkbox($name, $value);
877 | //ENDFIX
878 | } else {//if(isset($this->value_entries["$name"]["values"]["$type"])) {
879 | // echo $this->value_entries["$name"]["values"]["$type"];
880 | /* $field_value_line=$this->value_entries["$name"]["values"]["$type"];
881 | $field_value_maxlen=$this->value_entries["$name"]["constraints"]["maxlen"];
882 |
883 | if($field_value_maxlen) //Truncates the size if needed
884 | $value=substr($value, 0, $field_value_maxlen);
885 |
886 | if($verbose_set) echo "
Change $type value of the field $name at line $field_value_line to '$value'";
887 | $offset_shift=$this->_set_field_value($field_value_line,$value);*/
888 | if(isset($this->value_entries[$name]["values"]["current"]))
889 | $offset_shift=$this->_set_field_value2($this->value_entries[$name]["values"]["current"],$value,false);
890 | else
891 | $offset_shift=$this->_set_field_value2($this->value_entries[$name]["infos"]["name_line"],$value,true);
892 | }
893 | // }else
894 | // $this->Error("set_field_value failed as invalid valuetype $type for object $object_id");
895 |
896 |
897 | //offset size shift will affect the next objects offsets taking into accound the order they appear in the file--
898 | $this->apply_offset_shift_from_object($object_id,$offset_shift);
899 |
900 | } else
901 | $this->Error("field $name not found");
902 |
903 | }
904 |
905 |
906 | /**
907 | *Changes the tooltip value of a field property, inline.
908 | *
909 | *@param string $name name of the field annotation to change the value
910 | *@param string $value the new value to set
911 | *@return int offset_shift the size variation
912 | **/
913 | function set_field_tooltip($name,$value) {
914 | //------------------------------------
915 | $offset_shift=0;
916 | $verbose_set=($this->verbose&&($this->verbose_level>1));
917 |
918 | //Get the line(s) of the misc field values
919 | if(isset($this->value_entries["$name"])) {
920 | $field_tooltip_line=$this->value_entries["$name"]["infos"]["tooltip"];
921 | if($field_tooltip_line) {
922 | if($verbose_set) echo "
Change tooltip of the field $name at line $field_tooltip_line to value [$value]";
923 | $offset_shift=$this->_set_field_value($field_tooltip_line,$value);
924 | }else {
925 | if($verbose_set) echo "
Change toolpip value aborted, the field $name has no tooltip definition.";
926 | }
927 | } else
928 | $this->Error("set_field_tooltip failed as the field $name does not exist");
929 | return $offset_shift;
930 | }
931 |
932 | //FIX: parse checkbox definition
933 | /**
934 | *Changes the checkbox state.
935 | *
936 | *@param string $name name of the field to change the state
937 | *@param string $value the new state to set
938 | *@return int offset_shift the size variation
939 | **/
940 | public function set_field_checkbox($name, $value)
941 | {
942 | //------------------------------------
943 | $offset_shift=0;
944 | $verbose_set=($this->verbose&&($this->verbose_level>1));
945 | //Get the line(s) of the misc field values
946 | if (isset($this->value_entries["$name"])) {
947 | if (isset($this->value_entries["$name"]["infos"]["checkbox_state_line"])
948 | && isset($this->value_entries["$name"]["infos"]["checkbox_no"])
949 | && isset($this->value_entries["$name"]["infos"]["checkbox_yes"])) {
950 | $field_checkbox_line=$this->value_entries["$name"]["infos"]["checkbox_state_line"];
951 | if ($field_checkbox_line) {
952 | if ($verbose_set) {
953 | echo "
Change checkbox of the field $name at line $field_checkbox_line to value [$value]";
954 | }
955 | $state = $this->value_entries["$name"]["infos"]["checkbox_no"];
956 | if ($value) {
957 | $state = $this->value_entries["$name"]["infos"]["checkbox_yes"];
958 | }
959 | $CurLine =$this->pdf_entries[$field_checkbox_line];
960 | $OldLen=strlen($CurLine);
961 | $CurLine = '/AS /'.$state;
962 | $NewLen=strlen($CurLine);
963 | $Shift=$NewLen-$OldLen;
964 | $this->shift=$this->shift+$Shift;
965 | //Saves
966 | $this->pdf_entries[$field_checkbox_line]=$CurLine;
967 | return $Shift;
968 | // $offset_shift=$this->_set_field_value($field_checkbox_line, $state);
969 | } else {
970 | if ($verbose_set) {
971 | echo "
Change checkbox value aborted, parsed checkbox definition incomplete.";
972 | }
973 | }
974 | } else {
975 | if ($verbose_set) {
976 | echo "
Change checkbox value aborted, the field $name has no checkbox definition.";
977 | }
978 | }
979 | } else {
980 | $this->Error("set_field_checkbox failed as the field $name does not exist");
981 | }
982 | return $offset_shift;
983 | }
984 | //ENDFIX
985 |
986 | /**
987 | *Dumps the line entries
988 | *
989 | *@note for debug purposes
990 | *@access private
991 | *@param array entries the content to dump
992 | *@param string tag an optional tag to highlight
993 | *@param boolean halt decides to stop or not this script
994 | **/
995 | function dumpEntries($entries,$tag="",$halt=false) {
996 | //------------------------------------------------------------
997 | if($tag) echo "
$tag
";
998 | if($entries) {
999 | echo "";
1000 | echo htmlentities(print_r($entries,true));
1001 | echo "
";
1002 | }
1003 | if($halt) exit();
1004 | }
1005 |
1006 |
1007 | /**
1008 | *Dumps the string content
1009 | *
1010 | *@note for debug purposes
1011 | *@access private
1012 | *@param string content the content to dump
1013 | *@param string tag an optional tag to highlight
1014 | *@param boolean halt decides to stop or not this script
1015 | **/
1016 | function dumpContent($content,$tag="",$halt=false) {
1017 | //--------------------------------------------------
1018 | if($tag) echo "$tag
";
1019 | if($content) {
1020 | echo "";
1021 | echo htmlentities($content);
1022 | echo "
";
1023 | }
1024 | if($halt) exit();
1025 | }
1026 |
1027 | /**
1028 | *Retrieves the content of a file as a string
1029 | *
1030 | *@access private
1031 | *@param string $filename the filename of the file
1032 | *@param string $filetype the type of file as info
1033 | *@return string $content
1034 | **/
1035 | function getContent($filename,$filetype) {
1036 | //----------------------------------------
1037 | //$content = file_get_contents($filename);
1038 | $handle=fopen($filename,'rb');
1039 | $content = fread($handle, filesize($filename));
1040 | fclose($handle);
1041 |
1042 | if (!$content)
1043 | $this->Error(sprintf('Cannot open '.$filetype.' file %s !', $filename));
1044 |
1045 | if($filetype=='PDF')
1046 | {
1047 | $start = substr($content, 0, 2048);
1048 | if(strpos($start, '/ObjStm')!==false)
1049 | $this->Error('Object streams are not supported');
1050 | if(strpos($start, '/Linearized')!==false)
1051 | $this->Error('Fast Web View mode is not supported');
1052 | $end = substr($content, -512);
1053 | if(strpos($end, '/Prev')!==false)
1054 | $this->Error('Incremental updates are not supported');
1055 | $this->needAppearancesTrue = (strpos($content, '/NeedAppearances true')!==false);
1056 | }
1057 |
1058 | /* if($this->verbose) {
1059 | $this->dumpContent($content,"$filetype file content read");
1060 | }*/
1061 | return $content;
1062 | }
1063 |
1064 | /**
1065 | *Retrieves the content of a file as an array of lines entries
1066 | *
1067 | *@access private
1068 | *@param string $filename the filename of the file
1069 | *@param string $filetype the type of file as info
1070 | *@return array $entries
1071 | **/
1072 | function getEntries($filename,$filetype) {
1073 | //----------------------------------------
1074 | $content=$this->getContent($filename,$filetype);
1075 | $entries=explode("\n",$content);
1076 |
1077 | /* if($this->verbose) {
1078 | $this->dumpEntries($entries,"$filetype file entries");
1079 | }*/
1080 | return $entries;
1081 | }
1082 |
1083 |
1084 | /**
1085 | *Retrieves a binary string from its hexadecimal representation
1086 | *
1087 | *@access private
1088 | *@note Function was written because PHP has a bin2hex, but not a hex2bin!
1089 | *@internal note pack(“C”,hexdec(substr($data,$i,2))) DOES NOT WORK
1090 | *@param string $hexString the hexified string
1091 | *@return string $bin a binary string
1092 | **/
1093 | function _hex2bin ($hexString)
1094 | {
1095 | //echo "
_hex2bin($hexString)";
1096 | $BinStr = '';
1097 |
1098 | $hexLength=strlen($hexString);
1099 | // only hex numbers is allowed
1100 | if ($hexLength % 2 != 0 || preg_match("/[^\da-fA-F]/",$hexString)) return FALSE;
1101 |
1102 |
1103 | //Loop through the input and convert it
1104 | for ($i = 0; $i < $hexLength; $i += 2)
1105 | $BinStr .= '%'.substr ($hexString, $i, 2);
1106 |
1107 |
1108 | // Raw url-decode and return the result
1109 | return rawurldecode ($BinStr);//chr(hexdec())
1110 | }
1111 |
1112 |
1113 | /**
1114 | *Encodes a binary string to its hexadecimal representation
1115 | *
1116 | *@access private
1117 | *@internal dechex(ord($str{$i})); is buggy because for hex value of 0-15 heading 0 is missing! Using sprintf() to get it right.
1118 | *@param string $str a binary string
1119 | *@return string $hex the hexified string
1120 | **/
1121 | function _bin2hex($str) {
1122 | //----------------------
1123 | $hex = "";
1124 | $i = 0;
1125 | do {
1126 | $hex .= sprintf("%02X", ord($str[$i]));
1127 | $i++;
1128 | } while ($i < strlen($str));
1129 | return $hex;
1130 | }
1131 |
1132 |
1133 | /**
1134 | * Extracts the map object for the xref table
1135 | * @note PDF lines should have been previouly been parsed to make this work
1136 | * @return array a map that holds the xrefstart infos and values
1137 | */
1138 | function get_xref_table() {
1139 | //------------------------
1140 | return $this->value_entries['$_XREF_$'];
1141 | }
1142 |
1143 | /**
1144 | * Extracts the offset of the xref table
1145 | * @note PDF lines should have been previouly been parsed to make this work
1146 | * @return int the xrefstart value
1147 | */
1148 | function get_xref_start() {
1149 | //------------------------
1150 | return $this->value_entries['$_XREF_$']["infos"]["start"]["pointer"];
1151 | }
1152 |
1153 |
1154 | /**
1155 | * Extracts the line where the offset of the xref table is stored
1156 | * @note PDF lines should have been previouly been parsed to make this work
1157 | * @return int the wished line number
1158 | */
1159 | function get_xref_start_line() {
1160 | //-------------------------------
1161 | return $this->value_entries['$_XREF_$']["infos"]["start"]["line"];
1162 | }
1163 |
1164 | /**
1165 | * Calculates the offset of the xref table
1166 | *
1167 | * @return int the wished xrefstart offset value
1168 | */
1169 | function get_xref_start_value() {
1170 | //-------------------------------
1171 | $size_shift=$this->shift;
1172 | $xref_start=$this->get_xref_start();
1173 | return $xref_start+$size_shift;
1174 | }
1175 |
1176 |
1177 | /**
1178 | * Read the offset of the xref table directly from file content
1179 | *
1180 | * @note content has been previously been defined in $this->get_buffer()
1181 | * @param int $object_id an object id, a integer value starting from 1
1182 | * @return int the wished xrefstart offset value
1183 | */
1184 | function read_xref_start_value() {
1185 | //------------------------------
1186 | $buffer=$this->get_buffer();
1187 | $chunks = preg_split('/\bxref\b/', $buffer, -1, PREG_SPLIT_OFFSET_CAPTURE);
1188 | return intval($chunks[1][1])-4; //-4 , relative to end of xref
1189 | }
1190 |
1191 |
1192 | /**
1193 | * Calculates the new offset/xref for this object id by applying the offset_shift due to value changes
1194 | *
1195 | * @note uses internally precalculated $offsets,$positions and $shifts
1196 | * @param int $object_id an object id, a integer value starting from 1
1197 | * @return int the wished offset
1198 | */
1199 | function get_offset_object_value($object_id) {
1200 | //--------------------------------------------
1201 |
1202 | //Static is to keep forever...
1203 | static $offsets=null;
1204 | static $positions=null;
1205 | static $shifts=null;
1206 |
1207 | //if(is_null($offsets)) { //...variables content set once. This is the beauty of php :)
1208 |
1209 | //!NOTE: xref table is ordered by object id (position's object is not defined linearly in the pdf !)
1210 | $positions=$this->_get_positions_ordered();
1211 | //Makes it 0 indexed as object id starts from 1 and positions starts from 0
1212 | $offsets=$this->_get_offsets_starting_from_zero();
1213 | //Shifts are already 0 indexed, don't change.
1214 | $shifts=$this->shifts;
1215 | //}
1216 |
1217 | $p=$positions[$object_id];
1218 | $offset=$offsets[$p];
1219 | $shift=$shifts[$p]; //size shift of the object due to value changes
1220 | return $offset+$shift;
1221 | }
1222 |
1223 |
1224 | /**
1225 | * Reads the offset of the xref table directly from file content
1226 | *
1227 | * @note content has been previously been defined in $this->get_buffer()
1228 | * @param int $object_id an object id, a integer value starting from 1
1229 | * @return int the wished offset
1230 | */
1231 | function read_offset_object_value($object_id) {
1232 | //------------------------------
1233 | $buffer=$this->get_buffer();
1234 | $previous_object_footer='';//'endobj' or comment;
1235 | $object_header=$previous_object_footer.'\n'.$object_id.' 0 obj';
1236 | $chars = preg_split('/'.$object_header.'/', $buffer, -1, PREG_SPLIT_OFFSET_CAPTURE);
1237 | $offset=intval($chars[1][1])-strlen($object_header)+strlen($previous_object_footer)+2;
1238 | return $offset;
1239 | }
1240 |
1241 |
1242 | /**
1243 | * Fix the offset of the xref table
1244 | *
1245 | */
1246 | function fix_xref_start() {
1247 | //-------------------------
1248 |
1249 | $pdf_entries=&$this->pdf_entries;
1250 | $verbose_fix=($this->verbose&&($this->verbose_level>1));
1251 | $calculate_xrefstart_value=((!$this->safe_mode)||$this->check_mode);
1252 | $extract_xrefstart_value_from_file=($this->safe_mode||$this->check_mode);
1253 |
1254 | if($calculate_xrefstart_value) {
1255 | $xref_start_value_calculated=$this->get_xref_start_value(); //get computed value from old one
1256 | if(!$this->safe_mode) $xref_start_value=$xref_start_value_calculated;
1257 | }
1258 |
1259 | if($extract_xrefstart_value_from_file) {
1260 | $xref_start_value_safe=$this->read_xref_start_value();//read direct from new file content
1261 | if($this->safe_mode) $xref_start_value=$xref_start_value_safe;
1262 | }
1263 |
1264 | if($this->check_mode) { //Compared calculated value with position value read direct from file
1265 | if($xref_start_value_calculated != $xref_start_value_safe) {
1266 | if($verbose_fix) echo "
xrefstart's value must be $xref_start_value_safe calculated is $xref_start_value_calculated.Don't worry, FPDFM-merge will fix it for you.
";
1267 | $xref_start_value=$xref_start_value_safe; //Overrides with the good value
1268 | if($this->halt_mode)
1269 | $this->Error("Halt on error mode enabled, aborting. Use \$pdf->set_modes('halt',false); to disable this mode and go further fixing corrupted pdf.");
1270 | } else {
1271 | if($verbose_fix) echo "
xrefstart's value for the file is correct and vaults $xref_start_value";
1272 | }
1273 | }
1274 |
1275 | //updates xrefstart's value
1276 | $xref_start_line=$this->get_xref_start_line();
1277 | $pdf_entries[$xref_start_line]="$xref_start_value";
1278 | }
1279 |
1280 | /**
1281 | * Get the offsets table 0 indexed
1282 | *
1283 | * @return array $offsets
1284 | */
1285 | function _get_offsets_starting_from_zero() {
1286 | //-------------------------------------------
1287 | $offsets=$this->offsets;
1288 | return array_values($offsets);
1289 | }
1290 |
1291 | /**
1292 | * Sorts the position array by key
1293 | *
1294 | * @return array $positions the ordered positions
1295 | */
1296 | function _get_positions_ordered() {
1297 | //--------------------------------
1298 | $positions=$this->positions;
1299 | ksort($positions);
1300 | return $positions;
1301 | }
1302 |
1303 | /**
1304 | * Fix the xref table by rebuilding its offsets entries
1305 | *
1306 | */
1307 | function fix_xref_table() {
1308 | //------------------------
1309 |
1310 | $xref_table=$this->get_xref_table();
1311 | $xLen=$xref_table["infos"]["count"];
1312 | $pdf_entries=&$this->pdf_entries;
1313 |
1314 | //Do some checks
1315 | $offsets=$this->offsets;
1316 | //$offsets=array_values($offsets);
1317 | $oLen=count($offsets);
1318 |
1319 |
1320 | if($xLen == $oLen) { //...to rectify xref entries
1321 |
1322 | //jump over len and header, this is the first entry with n
1323 | $first_xref_entry_line=$xref_table["infos"]["line"]+3;
1324 |
1325 | //echo "xREF:{$pdf_entries[$first_xref_entry_line]}";
1326 |
1327 | //!NOTE: xref table is ordered by object id (position's object is not defined linearly in the pdf !)
1328 | //$positions=$this->positions;
1329 | //ksort($positions);
1330 | $verbose_fix=($this->verbose&&($this->verbose>1));
1331 | $calculate_offset_value=((!$this->safe_mode)||$this->check_mode);
1332 | $extract_offset_value_from_file=($this->safe_mode||$this->check_mode);
1333 |
1334 | //Get new file content (ie with values changed)
1335 | //$this->get_buffer()=$this->get_buffer();
1336 |
1337 | for($i=0;$i<$xLen;$i++) {
1338 |
1339 | $obj_id=$i+1;
1340 |
1341 | //Try two way to retrieve xref offset value of an object of the given id
1342 |
1343 | if($calculate_offset_value) {
1344 | $offset_value_calculated=$this->get_offset_object_value($obj_id);;
1345 | if(!$this->safe_mode) $offset_value=$offset_value_calculated;
1346 | }
1347 |
1348 | if($extract_offset_value_from_file) {
1349 | $offset_value_read=$this->read_offset_object_value($obj_id);
1350 | if($this->safe_mode) $offset_value=$offset_value_read;
1351 | }
1352 |
1353 | if($this->check_mode) {
1354 | if($offset_value_calculated != $offset_value_read) {
1355 | if($verbose_fix) echo "
Offset for object $obj_id read is $offset_value_read, calculated $offset_value_calculated";
1356 | $offset_value=$offset_value_read; //overrides to fix bad values
1357 | if($this->halt_mode) $this->Error("
Offset for object $obj_id read is $offset_value_read, calculated $offset_value_calculated");
1358 | }else {
1359 | if($verbose_fix) echo "
Offset for object $obj_id is correct and vaults $offset_value";
1360 | }
1361 | }
1362 | $pdf_entries[$first_xref_entry_line+$i]=sprintf('%010d 00000 n ',$offset_value);
1363 | }
1364 |
1365 | }else {
1366 | //Congratulations you won the corrupted Error Prize
1367 | $this->Error("Number of objects ($oLen) differs with number of xrefs ($xLen), something , pdf xref table is corrupted :(");
1368 | }
1369 |
1370 |
1371 | }
1372 |
1373 |
1374 | /**
1375 | * Applies a shift offset $shift from the object whose id is given as param
1376 | *
1377 | * @note offset shift will affect the next objects taking into accound the order they appear in the file
1378 | * @access public
1379 | * @param int object_id the id whose size shift has changed
1380 | * @param int offset_shift the shift value to use
1381 | */
1382 | function apply_offset_shift_from_object($object_id,$offset_shift) {
1383 | //---------------------------------------------------------
1384 | //get the position of object
1385 | $object_pos=$this->positions[$object_id];
1386 | //get the next object position
1387 | $next_object_pos=$object_pos+1;
1388 | //Applies offset change to next following objects
1389 | $this->_apply_offset_shift($next_object_pos,$offset_shift);
1390 | }
1391 |
1392 | /**
1393 | * Applies a shift offset $shift starting at the index $from to the shifts array
1394 | *
1395 | * @access private
1396 | * @param int from the index to start apply the shift
1397 | * @param int shift the shift value to use
1398 | */
1399 | function _apply_offset_shift($from,$shift) {
1400 | //------------------------------------------
1401 | $offsets=&$this->shifts;
1402 | $params=array($from,$shift);
1403 |
1404 | foreach($offsets as $key=>$value) {
1405 | if($key>=$from) {
1406 | $offset=$offsets[$key]+$shift;
1407 | $offsets[$key]=$offset;
1408 | }
1409 | }
1410 |
1411 | }
1412 |
1413 | /**
1414 | * Decodes a PDF value according to the encoding
1415 | *
1416 | * @access public
1417 | * @param string $encoding the encoding to use for decoding the value, only 'hex' is supported
1418 | * @param string value a value to decode
1419 | * @return string the value decoded
1420 | */
1421 | function decodeValue($encoding,$value) {
1422 | //----------------------------------------------
1423 | //echo "Decoding $encoding value($value)";
1424 | if($encoding=="hex")
1425 | $value=$this->pdf_decode_field_value($value);
1426 | return $value;
1427 | }
1428 |
1429 | /**
1430 | *Retrieve the list of supported filters
1431 | *
1432 | *@note Uses $FPDM_FILTERS array built dynamically
1433 | *@param String $sep a separator to merge filter names, default is '|'
1434 | *@return String the suported filters
1435 | **/
1436 | function getFilters($sep="|") {
1437 | //---------------------
1438 | global $FPDM_FILTERS;
1439 | return implode($sep,$FPDM_FILTERS);
1440 | }
1441 |
1442 |
1443 | /**
1444 | *Get a filter by name
1445 | *
1446 | *@param name a string matching one of the supported default filters (marked with +) *
1447 | *Without parameters:
1448 | *+ ASCIIHexDecode : Decodes data encoded in an ASCII hexadecimal representation, reproducing the original binary data.
1449 | *+ ASCII85Decode : Decodes data encoded in an ASCII base-85 representation, reproducing the original binary data.
1450 | * RunLengthDecode : Decompresses data encoded using a byte-oriented run-length encoding algorithm, reproducing the original text or binary data (typically monochrome image data, or any data that contains frequent long runs of a single byte value).
1451 | * JPXDecode : (PDF 1.5) Decompresses data encoded using the wavelet-based JPEG2000 standard, reproducing the original image data.
1452 | *With parameter(s):
1453 | *+ LZWDecode : Decompresses data encoded using the LZW (Lempel-Ziv-Welch) adaptive compression method, reproducing the original text or binary data.
1454 | *+ FlateDecode (PDF 1.2): Decompresses data encoded using the zlib/deflate compression method, reproducing the original text or binary data.
1455 | * CCITTFaxDecode : Decompresses data encoded using the CCITT facsimile standard, reproducing the original data (typically monochrome image data at 1 bit per pixel).
1456 | * JBIG2Decode (PDF 1.4) :Decompresses data encoded using the JBIG2 standard, reproducing the original monochrome (1 bit per pixel) image data (or an approximation of that data).
1457 | * DCTDecode : Decompresses data encoded using a DCT (discrete cosine transform) technique based on the JPEG standard, reproducing image sample data that approximates the original data.
1458 | * Crypt (PDF 1.5) :Decrypts data encrypted by a security handler, reproducing the data as it was before encryption.
1459 | *@return the wished filter class to access the stream
1460 | **/
1461 | function getFilter($name) {
1462 | //---------------------
1463 |
1464 | switch($name) {
1465 | case "LZWDecode":
1466 | $filter=new FilterLZW();
1467 | break;
1468 | case "ASCIIHexDecode":
1469 | $filter=new FilterASCIIHex();
1470 | break;
1471 | case "ASCII85Decode":
1472 | $filter=new FilterASCII85();
1473 | break;
1474 | case "FlateDecode":
1475 | $filter=new FilterFlate();
1476 | break;
1477 | case "Standard": //Raw
1478 | $filter=new FilterStandard();
1479 | break;
1480 | default:
1481 | $this->Error("getFilter cannot open stream of object because filter '{$name}' is not supported, sorry.");
1482 | }
1483 |
1484 |
1485 | return $filter;
1486 | }
1487 |
1488 |
1489 | //========= Stream manipulation stuff (alpha, not used by now!) ================
1490 |
1491 | /**
1492 | * Detect if the stream has a textual content
1493 | *
1494 | * @access public
1495 | * @param string $stream the string content of the stream
1496 | * @return boolean
1497 | */
1498 | function is_text_stream($stream_content) {
1499 | //--------------------------------------
1500 | return preg_match("/(\s*Td\s+[\<\(])([^\>\)]+)([\>\)]\s+Tj)/",$stream_content);
1501 | }
1502 |
1503 | /**
1504 | * changes the text value of a text stream
1505 | *
1506 | * @access public
1507 | * @param array $stream the stream defintion retrieved during PDF parsing
1508 | * @param string $value the new text value
1509 | */
1510 | function change_stream_value($stream,$value) {
1511 | //--------------------------------------------
1512 |
1513 | $entries=&$this->pdf_entries;
1514 |
1515 | $verbose_parsing=($this->verbose&&($this->verbose_level>3));
1516 |
1517 | if($is_text_stream) {
1518 |
1519 | $OldLen=$stream["length"]["value"];
1520 | $lMin=$stream["start"];
1521 | $lMax=$stream["end"];
1522 |
1523 | $stream_content=$this->_set_text_value($stream_content,$value);
1524 | $NewLen=strlen($stream_content);
1525 |
1526 | for($l=$lMin;$l<=$lMax;$l++) {
1527 |
1528 | if($l==$lMin) {
1529 | $entries[$lMin]=$stream_content;
1530 |
1531 | //Update the length
1532 | $stream_def_line=$stream["length"]["line"];
1533 | $stream_def=$entries[$stream_def_line];
1534 |
1535 | $stream_def=preg_replace("/\/Length\s*(\d+)/",'/Length '.$NewLen,$stream_def);
1536 |
1537 | $entries[$stream_def_line]=$stream_def;
1538 |
1539 | //update the filter type...
1540 | $stream_def_line=$stream["filters"]["line"];
1541 | $stream_def=$entries[$stream_def_line];
1542 | if($verbose_parsing) {
1543 | echo "";
1544 | echo htmlentities(print_r($stream_def,true));
1545 | echo "
";
1546 | }
1547 |
1548 | //...to filter Standard
1549 | $stream_def=preg_replace($this->streams_filter,'/Standard ',$stream_def);
1550 |
1551 | $entries[$stream_def_line]=$stream_def;
1552 |
1553 | //Update the shift
1554 | $size_shift=$NewLen-$OldLen;
1555 | $this->apply_offset_shift_from_object($obj,$size_shift);
1556 |
1557 | }else if($lmin!=$lMax) {
1558 | unset($entries[$l]);
1559 | }
1560 | }
1561 |
1562 | if($verbose_parsing) {
1563 | var_dump($stream_content);
1564 | }
1565 | }
1566 | }
1567 |
1568 | /**
1569 | * Overrides value between Td and TJ, ommiting <>
1570 | *
1571 | * @note core method
1572 | * @access private
1573 | * @param array $stream the stream defintion retrieved during PDF parsing
1574 | * @param string $value the new text value
1575 | */
1576 | function _set_text_value($stream,$value) {
1577 | //---------------------------------------
1578 | $chunks=preg_split("/(\s*Td\s+[\<\(])([^\>\)]+)([\>\)]\s+Tj)/",$stream,0,PREG_SPLIT_DELIM_CAPTURE);
1579 | $chunks[2]=$value;
1580 | $stream=implode($chunks,'');
1581 | return $stream;
1582 | }
1583 |
1584 |
1585 | //================================
1586 |
1587 | function _extract_pdf_definition_value($name,$line,&$match) {
1588 | //-----------------------------------------------------------
1589 | global $FPDM_REGEXPS;
1590 | $value=preg_match($FPDM_REGEXPS["$name"],$line,$match);
1591 | if(!$value) { //value is concatained with name: /name/value
1592 | $value=preg_match("/".preg_quote($name,'/')."\/(\w+)/",$line,$match);
1593 | }
1594 | return $value;
1595 | }
1596 |
1597 | function extract_pdf_definition_value($name,$line,&$match) {
1598 | //-----------------------------------------------------------
1599 | global $FPDM_REGEXPS;
1600 | if(array_key_exists($name,$FPDM_REGEXPS)) {
1601 | $value=$this->_extract_pdf_definition_value($name,$line,$match);
1602 | }else
1603 | $this->Error("extract_pdf_definition_value() does not support definition '$name'");
1604 |
1605 | /*if($name=="/Type") {
1606 | if(preg_match("/\//",$line,$foo)) {
1607 | var_dump($match);
1608 | die("Decoding $name value in line ".htmlentities($line));
1609 | }
1610 | }*/
1611 | return $value;
1612 | }
1613 |
1614 |
1615 | /**
1616 | * Parses the lines entries of a PDF
1617 | *
1618 | * @access public
1619 | * @param array $lines the FDF content as an array of lines
1620 | * @return integer the number of lines the PDF has
1621 | */
1622 | function parsePDFEntries(&$lines){
1623 | //--------------------------------
1624 |
1625 | $entries=&$this->pdf_entries;
1626 |
1627 | $CountLines = count($entries);
1628 |
1629 | $Counter=0;
1630 | $obj=0; //this is an invalid object id, we use it to know if we are into an object
1631 | //FIX: parse checkbox definition
1632 | $ap_d_yes='';
1633 | $ap_d_no='';
1634 | $ap_line=0;
1635 | $ap_d_line=0;
1636 | $as='';
1637 | //ENDFIX
1638 | $type='';
1639 | $subtype='';
1640 | $name='';
1641 | $value='';
1642 | $default_maxLen=0; //No limit
1643 | $default_tooltip_line=0; //Tooltip is optional as it may not be defined
1644 | $xref_table=0;
1645 | $trailer_table=0;
1646 | $n=0; //Position of an object, in the order it is declared in the pdf file
1647 | $stream=array();
1648 | $id_def=false; //true when parsing/decoding trailer ID
1649 | $id_single_line_def=false; //true when the two ID chunks are one the same line
1650 | $id_multi_line_def=false; //true or OpenOffice 3.2
1651 | $creator='';
1652 | $producer='';
1653 | $creationDate='';
1654 |
1655 | $verbose_parsing=($this->verbose&&($this->verbose_level>3));
1656 | $verbose_decoding=($this->verbose&&($this->verbose_level>4));
1657 |
1658 | if($this->verbose) $this->dumpContent("Starting to parse $CountLines entries","PDF parse");
1659 |
1660 | while ( $Counter < $CountLines ){
1661 |
1662 | $CurLine = $entries[$Counter];
1663 |
1664 | if($verbose_parsing) $this->dumpContent($CurLine,"====Parsing Line($Counter)");
1665 | if(!$xref_table) {
1666 |
1667 | //Header of an object?
1668 | if(preg_match("/^(\d+) (\d+) obj/",$CurLine,$match)) {
1669 | $obj=intval($match[1]);
1670 | $this->offsets[$obj]=$this->pointer;
1671 | $this->positions[$obj]=$n;
1672 | $this->shifts[$n]=0;
1673 | $n++;
1674 | if($verbose_parsing) $this->dumpContent($CurLine,"====Opening object($obj) at line $Counter");
1675 | $object=array();
1676 | $object["values"]=array();
1677 | $object["constraints"]=array();
1678 | $object["constraints"]["maxlen"]=$default_maxLen;
1679 | $object["infos"]=array();
1680 | $object["infos"]["object"]=intval($obj);
1681 | $object["infos"]["tooltip"]=$default_tooltip_line;
1682 |
1683 | } else {
1684 |
1685 | //Object has been opened
1686 | if($obj) {
1687 |
1688 | //Footer of an object?
1689 | if(preg_match("/endobj/",$CurLine,$match)) {
1690 | if($verbose_parsing) $this->dumpContent("","====Closing object($obj) at line $Counter");
1691 |
1692 | //We process fields here, save only Annotations texts that are supported by now
1693 | if($subtype=="Widget") {
1694 |
1695 | if($name != '') {
1696 | $lines["$name"]=$object;
1697 | if($verbose_parsing) $this->dumpContent("$type $subtype (obj id=$obj) is a text annotation of name '$name', saves it.");
1698 | }//else
1699 | // $this->Error("$type $subtype (obj id=$obj) is a text annotation without a name, this cannot be.");
1700 |
1701 |
1702 | $values=$object["values"];
1703 |
1704 | //Sanity values checks, watchdog.
1705 | // if(!array_key_exists("current",$values)) $this->Error("Cannot find value (/V) for field $name");
1706 | // if(!array_key_exists("default",$values)) $this->Error("Cannot find default value (/DV) for field $name");
1707 |
1708 | }else
1709 | if($verbose_parsing) $this->dumpContent("Object $type $subtype (obj id=$obj) is not supported");
1710 |
1711 |
1712 | $object=null;
1713 | $obj=0;
1714 | //FIX: parse checkbox definition
1715 | $ap_d_yes='';
1716 | $ap_d_no='';
1717 | $ap_line=0;
1718 | $ap_d_line=0;
1719 | $as='';
1720 | //ENDFIX
1721 | $type='';
1722 | $subtype='';
1723 | $name='';
1724 | $value='';
1725 | $maxLen=0;
1726 |
1727 | } else {
1728 |
1729 | if(preg_match("/\/Length\s*(\d+)/",$CurLine,$match)) {
1730 | $stream["length"]=array("line"=>$Counter,"value"=>$match[1]);
1731 | $stream["start"]=0;
1732 | $stream["end"]=0;
1733 | $stream["content"]='';
1734 | if($verbose_parsing) $this->dumpContent($CurLine,"->Stream filter length definition({$match[1]}) for object($obj) at line $Counter");
1735 | }
1736 |
1737 | //Handles single filter /Filter /filter_type as well as well as filter chains such as /Filter [/filter_type1 /filter_type2 .../filter_typeN]
1738 | if(preg_match_all($this->streams_filter,$CurLine,$matches)) {
1739 |
1740 | //$this->dumpContent($this->streams_filter);
1741 | /*$stream_filter=$match[1];
1742 | $stream_filter=trim(preg_replace('/(<<|\/Length\s*\d+|>>)/', '', $stream_filter),' ');
1743 | $stream_filters=preg_split('/\s*\//',$stream_filter);
1744 | array_shift($stream_filters);*/
1745 | $stream_filters=$matches[2];
1746 | $stream["filters"]=array("line"=>$Counter, "type"=>$stream_filters);
1747 | if($verbose_parsing) {
1748 | //var_dump($stream_filters);
1749 | $stream_filter=implode(" ",$stream_filters);
1750 | $this->dumpContent($CurLine,"->Stream filter type definition($stream_filter) for object($obj) at line $Counter");
1751 | }
1752 | }
1753 |
1754 | if(array_key_exists("length",$stream)) { //length is mandatory
1755 |
1756 | if(preg_match("/\b(stream|endstream)\b/",$CurLine,$match)) {
1757 |
1758 | if(!array_key_exists("filters",$stream)) {//filter type is optional, if none is given, its standard
1759 |
1760 | $stream["filters"]=array("type"=>array("Standard"));
1761 | if($verbose_parsing) {
1762 | var_dump($stream);
1763 | $this->dumpContent($CurLine,"->No stream filter type definition for object($obj) was found, setting it to 'Standard'");
1764 | }
1765 | }
1766 |
1767 |
1768 | if($match[1] == "stream") {
1769 | if($verbose_parsing) $this->dumpContent($CurLine,"->Opening stream for object($obj) at line $Counter");
1770 | $stream["start"]=$Counter+1;
1771 | }else {
1772 | $stream["end"]=$Counter-1;
1773 |
1774 | $stream["content"]=implode("\n",array_slice($entries,$stream["start"],$stream["end"]-$stream["start"]+1));
1775 |
1776 |
1777 |
1778 | $filters=$stream["filters"]["type"];
1779 | $f=count($filters);
1780 | $stream_content=$stream["content"];
1781 |
1782 | //var_dump($filters);
1783 |
1784 | //$filters_type=$filters["type"];
1785 |
1786 | //now process the stream, ie unpack it if needed
1787 | //by decoding in the reverse order the streams have been encoded
1788 | //This is done by applying decode using the filters in the order given by /Filter.
1789 | foreach($filters as $filter_name) {
1790 |
1791 | $stream_filter=$this->getFilter($filter_name);
1792 | $stream_content=$stream_filter->decode($stream_content);
1793 | if($verbose_decoding) {
1794 | echo "
Stream decoded using filter '$filter_name':[";
1795 | var_dump($stream_content); //todo : manipulate this content and adjust offsets.
1796 | echo "
]";
1797 | }
1798 | }
1799 |
1800 | if($verbose_parsing) {
1801 | $this->dumpEntries($stream);
1802 |
1803 | echo "";
1804 | if($this->is_text_stream($stream_content)) {
1805 | echo "Stream text unfiltered:[";
1806 | } else {
1807 | echo "Stream unfiltered:[";
1808 | }
1809 | var_dump($stream_content);
1810 | echo "
]";
1811 | $this->dumpContent($CurLine,"->Closing stream for object($obj) at line $Counter");
1812 | }
1813 |
1814 | $stream=array();
1815 | }
1816 | }else if($stream["start"]>0){
1817 | //stream content line that will be processed on endstream...
1818 | }
1819 |
1820 | } else {
1821 |
1822 | /*
1823 | Producer
1824 | /CreationDate (D:20101225151810+01'00')>>
1825 | */
1826 | if(($creator=='')&&preg_match("/\/Creator\<([^\>]+)\>/",$CurLine,$values)) {
1827 | $creator=$this->decodeValue("hex",$values[1]);
1828 | if($verbose_parsing) echo("Creator read ($creator)");
1829 | $this->info["Creator"]=$creator;
1830 | }
1831 |
1832 | if(($producer=='')&&preg_match("/\/Producer\<([^\>]+)\>/",$CurLine,$values)) {
1833 | $producer=$this->decodeValue("hex",$values[1]);
1834 | if($verbose_parsing) echo("Producer read ($producer)");
1835 | $this->info["Producer"]=$producer;
1836 | }
1837 |
1838 | if(($creationDate=='')&&preg_match("/\/CreationDate\(([^\)]+)\)/",$CurLine,$values)) {
1839 | $creationDate=$values[1];
1840 | if($verbose_parsing) echo("Creation date read ($creationDate)");
1841 | $this->info["CreationDate"]=$creationDate;
1842 | }
1843 |
1844 | //=== DEFINITION ====
1845 | //preg_match("/^\/Type\s+\/(\w+)$/",$CurLine,$match)
1846 | $match=array();
1847 | //FIX: parse checkbox definition
1848 | if($this->useCheckboxParser && ('' == $ap_d_yes || '' == $ap_d_no || '' == $as)) {
1849 | if (!$ap_line && '/AP' == substr($CurLine, 0, 3)) {
1850 | if ($verbose_parsing) {
1851 | echo("
Found AP Line '$Counter'");
1852 | }
1853 | $ap_line = $Counter;
1854 | } elseif (!$ap_d_line && '/D' == substr($CurLine, 0, 2)) {
1855 | if ($verbose_parsing) {
1856 | echo("
Found D Line '$Counter'");
1857 | }
1858 | $ap_d_line = $Counter;
1859 | } elseif (($ap_line==$Counter-4)&&($ap_d_line==$Counter-2)&&($ap_d_yes=='')&&$this->extract_pdf_definition_value("name", $CurLine, $match)) {
1860 | $ap_d_yes=$match[1];
1861 | if ($verbose_parsing) {
1862 | echo("
Object's checkbox_yes is '$ap_d_yes'");
1863 | }
1864 | $object["infos"]["checkbox_yes"]=$ap_d_yes;
1865 | } elseif (($ap_line==$Counter-5)&&($ap_d_line==$Counter-3)&&($ap_d_no=='')&&$this->extract_pdf_definition_value("name", $CurLine, $match)) {
1866 | $ap_d_no=$match[1];
1867 | if ($verbose_parsing) {
1868 | echo("
Object's checkbox_no is '$ap_d_no'");
1869 | }
1870 | $object["infos"]["checkbox_no"]=$ap_d_no;
1871 | } elseif (($as=='')&&$this->extract_pdf_definition_value("/AS", $CurLine, $match)) {
1872 | $as=$match[1];
1873 | if ($verbose_parsing) {
1874 | echo("
Object's AS is '$as'");
1875 | }
1876 | $object["infos"]["checkbox_state"]=$as;
1877 | $object["infos"]["checkbox_state_line"]=$Counter;
1878 | }
1879 | }
1880 | //ENDFIX
1881 | if(($type=='')||($subtype=='')||($name=="")) {
1882 |
1883 | if(($type=='')&&$this->extract_pdf_definition_value("/Type",$CurLine,$match)) {
1884 |
1885 | if($match[1]!='Border') {
1886 | $type=$match[1];
1887 | if($verbose_parsing) echo("
Object's type is '$type'");
1888 | }
1889 |
1890 | }
1891 | if(($subtype=='')&&$this->extract_pdf_definition_value("/Subtype",$CurLine,$match)) {
1892 |
1893 | $subtype=$match[1];
1894 | if($verbose_parsing) echo("
Object's subType is '$subtype'");
1895 |
1896 | }
1897 | if(($name=="")&&preg_match("/^\/T\s?\((.+)\)\s*$/",$this->_protectContentValues($CurLine),$match)) {
1898 |
1899 | $name=$this->_unprotectContentValues($match[1]);
1900 | //FIX: convert ASCII object names to utf-8
1901 | // don't use utf8_encode($name) yet, it's core function since php 7.2
1902 | $name = mb_convert_encoding($name, 'UTF-8', 'ASCII');
1903 | //ENDFIX
1904 | if($verbose_parsing) echo ("Object's name is '$name'");
1905 |
1906 | $object["infos"]["name"]=$name; //Keep a track
1907 | $object["infos"]["name_line"]=$Counter;
1908 |
1909 | //$this->dumpContent(" Name [$name]");
1910 | }
1911 |
1912 | }// else {
1913 |
1914 | //=== CONTENT ====
1915 |
1916 | //$this->dumpContent($CurLine);
1917 | //=== Now, start the serious work , read DV, V Values and eventually TU
1918 | //note if(preg_match_all("/^\/(V|DV)\s+(\<|\))([^\)\>]+)(\)|\>)/",$CurLine,$matches)) {
1919 | //do not work as all is encoded on the same line...
1920 | if(preg_match("/^\/(V|DV|TU)\s+([\<\(])/",$CurLine,$def)) {
1921 |
1922 | //get an human readable format of value type and encoding
1923 |
1924 | if($def[1] == "TU") {
1925 | $valuetype="info";
1926 | $object["infos"]["tooltip"]=$Counter;
1927 | } else {
1928 | $valuetype=($def[1] == "DV") ? "default" : "current";
1929 | $object["values"]["$valuetype"]=$Counter; //Set a marker to process lately
1930 | }
1931 |
1932 | $encoding=($def[2]=="<") ? "hex" : "plain";
1933 |
1934 | if(preg_match("/^\/(V|DV|TU)\s+(\<|\)|\()([^\)\>]*)(\)|\>\))/",$CurLine,$values)) {
1935 | $value=$values[3];
1936 | $value=$this->decodeValue($encoding,$value);
1937 | }else
1938 | $value='';
1939 |
1940 | if($verbose_parsing)
1941 | $this->dumpContent("$type $subtype (obj id=$obj) has $encoding $valuetype value [$value] at line $Counter");
1942 |
1943 |
1944 | }else if(preg_match("/^\/MaxLen\s+(\d+)/",$CurLine,$values)) {
1945 | $maxLen=$values[1];
1946 | $object["constraints"]["maxlen"]=intval($maxLen);
1947 | } else
1948 | if($verbose_parsing) echo("WARNING: definition ignored");
1949 |
1950 | if(substr($CurLine,0,7)=='/Fields' && !$this->needAppearancesTrue) {
1951 | $CurLine='/NeedAppearances true '.$CurLine;
1952 | $entries[$Counter]=$CurLine;
1953 | }
1954 |
1955 | //TODO: Fetch the XObject..and change Td <> Tj
1956 | /* if(preg_match("/^\/AP/",$CurLine,$values)) {
1957 | //die("stop");
1958 | $CurLine=''; //clear link to Xobject
1959 | $entries[$Counter]=$CurLine;
1960 | }*/
1961 |
1962 | // }
1963 |
1964 | }
1965 |
1966 |
1967 | }
1968 |
1969 | }
1970 |
1971 | //~~~~~Xref table header? ~~~~~~
1972 | if(preg_match("/\bxref\b/",$CurLine,$match)) {
1973 |
1974 | $xref_table=1;
1975 | if($verbose_parsing) $this->dumpContent("->Starting xref table at line $Counter:[$CurLine]");
1976 | $lines['$_XREF_$']=array();
1977 | $lines['$_XREF_$']["entries"]=array();
1978 | $lines['$_XREF_$']["infos"]=array();
1979 | $lines['$_XREF_$']["infos"]["line"]=$Counter;
1980 | $lines['$_XREF_$']["infos"]["start"]=array();
1981 | $start_pointer=$this->pointer+strpos($CurLine,"xref"); //HACK for PDFcreator 1.0.0
1982 | $lines['$_XREF_$']["infos"]["start"]["pointer"]=$start_pointer;
1983 | }
1984 |
1985 | }
1986 | $obj_header=false;
1987 | } else {
1988 | //We are inside the xref table
1989 | //$this->dumpContent($CurLine,"");
1990 | $xref_table=$xref_table+1;
1991 | switch($xref_table) {
1992 | case 2:
1993 | if(preg_match("/^(\d+) (\d+)/",$CurLine,$match)) {
1994 | $refs_count=intval($match[2]);//xref_table length+1 (includes this line)
1995 | $lines['$_XREF_$']["infos"]["count"]=$refs_count-1;
1996 | if($verbose_parsing) $this->dumpContent("Xref table length is $refs_count");
1997 | }else
1998 | if($verbose_parsing) $this->dumpContent("WARNING: Xref table length ignored!");
1999 | break;
2000 | case 3:
2001 | //Should be 0000000000 65535 f
2002 | if($verbose_parsing) $this->dumpContent("this is Xref table header, should be 0000000000 65535 f ");
2003 | break;
2004 | default:
2005 | //xref entries
2006 | if($refs_count>0) {
2007 | $xref=$xref_table-3;
2008 |
2009 | if($refs_count == 1) {//Last one , due to the shift, is the trailer
2010 | if(!preg_match("/^trailer/",$CurLine)) //if not, Houston we have a problem
2011 | $this->Error("xref_table length corrupted?: Trailer not found at expected!");
2012 | else
2013 | $trailer_table=1;
2014 | }else {
2015 | $lines['$_XREF_$']["entries"][$xref]=$CurLine;
2016 | if($verbose_parsing) $this->dumpContent("Xref table entry for object $xref found.");
2017 | }
2018 | $refs_count--;
2019 | } else { //We are inside the trailer
2020 |
2021 | if($trailer_table==1) { //should be <<
2022 |
2023 | if(trim($CurLine) != '') { //HACK: PDFCreator Version 1.0.0 has an extra CR after trailer
2024 | if(!preg_match("/<Error("trailer_table corrupted?; missing start delimiter << ");
2026 | $trailer_table++;
2027 | }
2028 |
2029 |
2030 | }else if(($trailer_table>0)&&((!is_null($id_def))||preg_match("/^\/(Size|Root|Info|ID|DocChecksum)/",$CurLine,$match))) {
2031 |
2032 | //Value can be extracted using (\d+|\[[^\]]+\])
2033 | if(preg_match("/\/Size (\d+)/",$CurLine,$match)) {
2034 | //Seems to match with xref entries count..
2035 | $size_read=$match[1];
2036 | $this->info["size"]=$size_read;
2037 | if($verbose_parsing) $this->dumpContent("Size read ($size_read) for pdf found.");
2038 | }
2039 |
2040 | if(preg_match("/^\/ID\s*\[\s*<([\da-fA-F]+)/",$CurLine,$match)) {
2041 | $oid=$match[1];
2042 | $id_def=true;
2043 | if($verbose_parsing) $this->dumpContent("ID chunk one ($oid) for pdf found.");
2044 |
2045 | //Determines if the ID definition is one line...
2046 | if(preg_match("/\>\s?\.*$/",$CurLine,$match)) {
2055 | $tid=$match[1];
2056 | $this->info["ID"]=array($oid,$tid);
2057 | if($verbose_parsing) $this->dumpContent("ID chunk two ($tid) for pdf found.");
2058 | $id_def=false;
2059 | }else
2060 | $this->Error("trailer_table corrupted?; ID chunk two can not be decoded ");
2061 | } else
2062 | $id_multi_line_def=true;
2063 | }
2064 |
2065 | if(preg_match("/^\/DocChecksum \/([\da-fA-F]+)/",$CurLine,$match)) {
2066 | $checksum=$match[1];
2067 | $this->info["checksum"]=$checksum;
2068 | if($verbose_parsing) $this->dumpContent("Checksum read ($checksum) for pdf found.");
2069 | }
2070 |
2071 | if(preg_match("/>>/",$CurLine,$match))
2072 | $trailer_table=-1;//negative value: expects startxref to follow
2073 |
2074 |
2075 | } else {
2076 |
2077 | switch($trailer_table) {
2078 | case -1://startxref
2079 | if(!preg_match("/^startxref/",$CurLine,$match))
2080 | $this->Error("startxref tag expected, read $CurLine");
2081 | break;
2082 | case -2://startxref's value
2083 | if(preg_match("/^(\d+)/",$CurLine,$match)) {
2084 | $lines['$_XREF_$']["infos"]["start"]["value"]=intval($match[1]);
2085 | $lines['$_XREF_$']["infos"]["start"]["line"]=$Counter;
2086 | }else
2087 | $this->Error("startxref value expected, read $CurLine");
2088 | break;
2089 | default://%%EOF
2090 | }
2091 | $trailer_table--;
2092 |
2093 | }
2094 |
2095 | }
2096 | }
2097 |
2098 | }
2099 |
2100 | $this->pointer=$this->pointer+strlen($CurLine)+1; //+1 due to \n
2101 | $Counter++;
2102 | }
2103 |
2104 | if($this->verbose) {
2105 |
2106 | $refs=(array_key_exists('$_XREF_$',$lines)) ? $lines['$_XREF_$']["infos"]["count"] : 0;
2107 | if($refs) {
2108 | $this->dumpContent("PDF parse retrieved $refs refs");
2109 | }else {
2110 | $this->dumpContent("PDF parse retrieved no refs, seems the xref table is broken or inacessible, this is bad!");
2111 | }
2112 | }
2113 |
2114 | return count($lines);
2115 | }
2116 |
2117 | /**
2118 | * Protect ( ) that may be in value or names
2119 | *
2120 | * @access protected
2121 | * @param string $content the FDF content to protect values
2122 | * @return string the content protected
2123 | */
2124 | function _protectContentValues($content) {
2125 | //-------------------------------------------------
2126 | $content=str_replace("\\(","$@#",$content);
2127 | $content=str_replace("\\)","#@$",$content);
2128 | return $content;
2129 | }
2130 |
2131 | /**
2132 | * Unprotect ( ) that may be in value or names
2133 | *
2134 | * @access protected
2135 | * @param string $content the FDF content with protected values
2136 | * @return string the content unprotected
2137 | */
2138 | function _unprotectContentValues($content) {
2139 | //--------------------------------------------------
2140 | $content=str_replace("$@#","\\(",$content);
2141 | $content=str_replace("#@$","\\)",$content);
2142 | $content=stripcslashes($content);
2143 | return $content;
2144 | }
2145 |
2146 | /**
2147 | * Parses the content of a FDF file and saved extracted field data
2148 | *
2149 | *@access public
2150 | *@return array $fields the data of the fields parsed
2151 | */
2152 | function parseFDFContent(){
2153 | //-------------------------
2154 |
2155 | $content=$this->fdf_content;
2156 | $content=$this->_protectContentValues($content);//protect ( ) that may be in value or names...
2157 |
2158 | if($this->verbose) $this->dumpEntries($content,"FDF parse");
2159 |
2160 | //..so that this regexp can do its job without annoyances
2161 | if(preg_match_all("/(T|V)\s*\(([^\)]+)\)\s*\/(T|V)\s*\(([^\)]+)\)/", $content,$matches, PREG_PATTERN_ORDER)) {
2162 |
2163 | $fMax=count($matches[0]);
2164 | $fields=array();
2165 | for($f=0;$f<$fMax;$f++) {
2166 | $value='';
2167 | $name='';
2168 | if($matches[1][$f]=="V") {
2169 | $value=$matches[2][$f];
2170 | if($matches[3][$f]=="T")
2171 | $name=$matches[4][$f];
2172 | else
2173 | $this->Error("Field $f ignored , incomplete field declaration, name is expected");
2174 | } else {
2175 | if($matches[1][$f]=="T") {
2176 | $name=$matches[2][$f];
2177 | if($matches[3][$f]=="V")
2178 | $value=$matches[4][$f];
2179 | else
2180 | $this->Error("Field $f ignored , incomplete field declaration, value is expected");
2181 | } else
2182 | $this->Error("Field $f ignored , Invalid field keys ({$matches[0][$f]})");
2183 | }
2184 | if($name!='') {
2185 | if(array_key_exists($name,$fields))
2186 | $this->Error("Field $f ignored , already defined");
2187 | else {
2188 | $name=$this->_unprotectContentValues($name);
2189 | $value=$this->_unprotectContentValues($value);
2190 | if($this->verbose)
2191 | $this->dumpContent("FDF field [$name] has its value set to \"$value\"");
2192 | $fields[$name]=$value;
2193 | }
2194 | } else
2195 | $this->Error("Field $f ignored , no name");
2196 |
2197 | }
2198 | } else
2199 | if($this->verbose) $this->dumpContent($fields,"FDF has no fields",false);
2200 |
2201 | if($this->verbose) $this->dumpContent($fields,"FDF parsed",false);
2202 |
2203 | return $fields;
2204 | }
2205 |
2206 |
2207 | /**
2208 | * Close the opened file
2209 | */
2210 | function closeFile() {
2211 | //--------------------
2212 | if (isset($this->f) && is_resource($this->f)) {
2213 | fclose($this->f);
2214 | unset($this->f);
2215 | }
2216 | }
2217 |
2218 | /**
2219 | * Print Error and die
2220 | *
2221 | * @param string $msg Error-Message
2222 | */
2223 | function Error($msg) {
2224 | //--------------------
2225 | die('FPDF-Merge Error: '.$msg);
2226 | }
2227 |
2228 |
2229 | }
2230 |
2231 | }
2232 |
2233 | unset($__tmp);
2234 |
--------------------------------------------------------------------------------
/src/lib/url.php:
--------------------------------------------------------------------------------
1 | 0) ? func_get_arg(0) : $_SERVER["SERVER_PORT"];
22 | $schemes=array(
23 | 'http'=> 80,// default for http
24 | 'https'=> 443, // default for https
25 | 'ftp' => 21, // default for ftp
26 | 'ftps'=> 990 // default for ftps
27 | );
28 | $ports=array_flip($schemes);
29 | return (array_key_exists($port,$ports)) ? $ports[$port] : 0;
30 | }
31 |
32 | function getHost() {
33 | //------------------
34 | return $_SERVER["HTTP_HOST"];// [SERVER_NAME]
35 | }
36 |
37 |
38 | if (!function_exists('fix_path')) {
39 | // fixes windows paths...
40 | // (windows accepts forward slashes and backwards slashes, so why does PHP use backwards?
41 | function fix_path($path) {
42 | //-------------------------
43 | return str_replace('\\','/',$path);
44 | }
45 | }
46 |
47 | function getWebDir($local_dir) {
48 | //----------------------------
49 | $local_root=$_SERVER["DOCUMENT_ROOT"];
50 | $server_dir=str_replace($local_root,'',$local_dir);
51 | return $server_dir;
52 | }
53 |
54 | //Local dir may be:
55 | // the main script dir: dirname($_SERVER['PHP_SELF'])
56 | // the current script dir fix_path(dirname(__FILE__))
57 | //return the full url with ending /
58 | function getUrlfromDir($local_dir) {
59 | //-------------------------------
60 | $server_dir=getWebDir($local_dir);
61 | $server_scheme=getScheme();
62 | $server_host=getHost();
63 | return "{$server_scheme}://{$server_host}/$server_dir";
64 | }
65 |
66 | /**
67 | * Compiles url out of array of it's pieces
68 | * 'query' is ignored if 'query_params' is present
69 | *
70 | * @param Array $aUrl Array of url pieces
71 | */
72 | function build_url($aUrl) {
73 | //-------------------------
74 | //[scheme]://[user]:[pass]@[host]/[path]?[query]#[fragment]
75 |
76 | if (!is_array($aUrl)) {
77 | return "";
78 | }
79 |
80 | $sQuery = '';
81 |
82 | // Compile query
83 | if (isset($aUrl['query_params']) && is_array($aUrl['query_params'])) {
84 | $aPairs = array();
85 | foreach ($aUrl['query_params'] as $sKey=>$sValue) {
86 | $aPairs[] = $sKey.'='.urlencode($sValue);
87 | }
88 | $sQuery = implode('&', $aPairs);
89 | } else {
90 | if(isset($aUrl['query'])) $sQuery = $aUrl['query'];
91 | }
92 |
93 | // Compile url
94 | $sUrl =
95 | $aUrl['scheme'] . '://' . (
96 | isset($aUrl['user']) && $aUrl['user'] != '' && isset($aUrl['pass'])
97 | ? $aUrl['user'] . ':' . $aUrl['pass'] . '@'
98 | : ''
99 | ) .
100 | $aUrl['host'] . (
101 | isset($aUrl['path']) && $aUrl['path'] != ''
102 | ? $aUrl['path']
103 | : ''
104 | ) . (
105 | $sQuery != ''
106 | ? '?' . $sQuery
107 | : ''
108 | ) . (
109 | isset($aUrl['fragment']) && $aUrl['fragment'] != ''
110 | ? '#' . $aUrl['fragment']
111 | : ''
112 | );
113 | return $sUrl;
114 | }
115 |
116 | function resolve_url($relative_url) {
117 | //-----------------------------
118 | $url=parse_url($relative_url);
119 | $url["path"]=resolve_path($url["path"]); //fix this
120 | $absolute_url=build_url($url);
121 | return $absolute_url;
122 | }
123 |
124 |
125 | //Get realpath without checking existence of file like php function does..
126 | function resolve_path($path) {
127 | //----------------------------------
128 | $out=array();
129 | foreach(explode('/', $path) as $i=>$fold){
130 | if ($fold=='' || $fold=='.') continue;
131 | if ($fold=='..' && $i>0 && end($out)!='..') array_pop($out);
132 | else $out[]= $fold;
133 | } return ($path{0}=='/'?'/':'').join('/', $out);
134 | }
135 |
136 |
137 | //This part is from http://fr2.php.net/manual/en/function.parse-url.php
138 | function j_parseUrl($url) {
139 | //--------------------------
140 | $r = "(?:([a-z0-9+-._]+)://)?";
141 | $r .= "(?:";
142 | $r .= "(?:((?:[a-z0-9-._~!$&'()*+,;=:]|%[0-9a-f]{2})*)@)?";
143 | $r .= "(?:\[((?:[a-z0-9:])*)\])?";
144 | $r .= "((?:[a-z0-9-._~!$&'()*+,;=]|%[0-9a-f]{2})*)";
145 | $r .= "(?::(\d*))?";
146 | $r .= "(/(?:[a-z0-9-._~!$&'()*+,;=:@/]|%[0-9a-f]{2})*)?";
147 | $r .= "|";
148 | $r .= "(/?";
149 | $r .= "(?:[a-z0-9-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+";
150 | $r .= "(?:[a-z0-9-._~!$&'()*+,;=:@\/]|%[0-9a-f]{2})*";
151 | $r .= ")?";
152 | $r .= ")";
153 | $r .= "(?:\?((?:[a-z0-9-._~!$&'()*+,;=:\/?@]|%[0-9a-f]{2})*))?";
154 | $r .= "(?:#((?:[a-z0-9-._~!$&'()*+,;=:\/?@]|%[0-9a-f]{2})*))?";
155 | preg_match("`$r`i", $url, $match);
156 | $parts = array(
157 | "scheme"=>'',
158 | "userinfo"=>'',
159 | "authority"=>'',
160 | "host"=> '',
161 | "port"=>'',
162 | "path"=>'',
163 | "query"=>'',
164 | "fragment"=>'');
165 | switch (count ($match)) {
166 | case 10: $parts['fragment'] = $match[9];
167 | case 9: $parts['query'] = $match[8];
168 | case 8: $parts['path'] = $match[7];
169 | case 7: $parts['path'] = $match[6] . $parts['path'];
170 | case 6: $parts['port'] = $match[5];
171 | case 5: $parts['host'] = $match[3]?"[".$match[3]."]":$match[4];
172 | case 4: $parts['userinfo'] = $match[2];
173 | case 3: $parts['scheme'] = $match[1];
174 | }
175 | $parts['authority'] = ($parts['userinfo']?$parts['userinfo']."@":"").
176 | $parts['host'].
177 | ($parts['port']?":".$parts['port']:"");
178 | return $parts;
179 | }
180 |
181 | define('URL_TOOLBOX',1);
182 |
183 | }//End of URL_TOOLBOX
184 | ?>
--------------------------------------------------------------------------------
/src/template.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codeshell/fpdm/08aabe1706ebda5e2ef14357ea7869f67bb4ecb7/src/template.pdf
--------------------------------------------------------------------------------