LCOV - code coverage report
Current view: top level - sdext/source/pdfimport/pdfparse - pdfentries.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 102 802 12.7 %
Date: 2015-06-13 12:38:46 Functions: 35 95 36.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <pdfparse.hxx>
      22             : 
      23             : #include <rtl/strbuf.hxx>
      24             : #include <rtl/ustring.hxx>
      25             : #include <rtl/ustrbuf.hxx>
      26             : #include <rtl/alloc.h>
      27             : #include <rtl/digest.h>
      28             : #include <rtl/cipher.h>
      29             : 
      30             : #include <zlib.h>
      31             : 
      32             : #include <math.h>
      33             : #include <map>
      34             : 
      35             : #include <string.h>
      36             : 
      37             : 
      38             : 
      39             : namespace pdfparse
      40             : {
      41             : 
      42             : struct EmitImplData
      43             : {
      44             :     // xref table: maps object number to a pair of (generation, buffer offset)
      45             :     typedef std::map< unsigned int, std::pair< unsigned int, unsigned int > > XRefTable;
      46             :     XRefTable m_aXRefTable;
      47             :     // container of all indirect objects (usually a PDFFile*)
      48             :     const PDFContainer* m_pObjectContainer;
      49             :     unsigned int m_nDecryptObject;
      50             :     unsigned int m_nDecryptGeneration;
      51             : 
      52             :     // returns true if the xref table was updated
      53           0 :     bool insertXref( unsigned int nObject, unsigned int nGeneration, unsigned int nOffset )
      54             :     {
      55           0 :         XRefTable::iterator it = m_aXRefTable.find( nObject );
      56           0 :         if( it == m_aXRefTable.end() )
      57             :         {
      58             :             // new entry
      59           0 :             m_aXRefTable[ nObject ] = std::pair<unsigned int, unsigned int>(nGeneration,nOffset);
      60           0 :             return true;
      61             :         }
      62             :         // update old entry, if generation number is higher
      63           0 :         if( it->second.first < nGeneration )
      64             :         {
      65           0 :             it->second = std::pair<unsigned int, unsigned int>(nGeneration,nOffset);
      66           0 :             return true;
      67             :         }
      68           0 :         return false;
      69             :     }
      70             : 
      71           0 :     EmitImplData( const PDFContainer* pTopContainer ) :
      72             :         m_pObjectContainer( pTopContainer ),
      73             :         m_nDecryptObject( 0 ),
      74           0 :         m_nDecryptGeneration( 0 )
      75           0 :     {}
      76           0 :     ~EmitImplData() {}
      77           0 :     bool decrypt( const sal_uInt8* pInBuffer, sal_uInt32 nLen, sal_uInt8* pOutBuffer,
      78             :                   unsigned int nObject, unsigned int nGeneration ) const
      79             :     {
      80           0 :         const PDFFile* pFile = dynamic_cast<const PDFFile*>(m_pObjectContainer);
      81           0 :         return pFile && pFile->decrypt( pInBuffer, nLen, pOutBuffer, nObject, nGeneration );
      82             :     }
      83             : 
      84           0 :     void setDecryptObject( unsigned int nObject, unsigned int nGeneration )
      85             :     {
      86           0 :         m_nDecryptObject = nObject;
      87           0 :         m_nDecryptGeneration = nGeneration;
      88           0 :     }
      89             : };
      90             : 
      91             : }
      92             : 
      93             : using namespace pdfparse;
      94             : 
      95           0 : EmitContext::EmitContext( const PDFContainer* pTop ) :
      96             :     m_bDeflate( false ),
      97             :     m_bDecrypt( false ),
      98           0 :     m_pImplData( NULL )
      99             : {
     100           0 :     if( pTop )
     101           0 :         m_pImplData = new EmitImplData( pTop );
     102           0 : }
     103             : 
     104           0 : EmitContext::~EmitContext()
     105             : {
     106           0 :     delete m_pImplData;
     107           0 : }
     108             : 
     109        1590 : PDFEntry::~PDFEntry()
     110             : {
     111        1590 : }
     112             : 
     113           0 : EmitImplData* PDFEntry::getEmitData( EmitContext& rContext )
     114             : {
     115           0 :     return rContext.m_pImplData;
     116             : }
     117             : 
     118           0 : void PDFEntry::setEmitData( EmitContext& rContext, EmitImplData* pNewEmitData )
     119             : {
     120           0 :     if( rContext.m_pImplData && rContext.m_pImplData != pNewEmitData )
     121           0 :         delete rContext.m_pImplData;
     122           0 :     rContext.m_pImplData = pNewEmitData;
     123           0 : }
     124             : 
     125        1264 : PDFValue::~PDFValue()
     126             : {
     127        1264 : }
     128             : 
     129          10 : PDFComment::~PDFComment()
     130             : {
     131          10 : }
     132             : 
     133           0 : bool PDFComment::emit( EmitContext& rWriteContext ) const
     134             : {
     135           0 :     return rWriteContext.write( m_aComment.getStr(), m_aComment.getLength() );
     136             : }
     137             : 
     138           0 : PDFEntry* PDFComment::clone() const
     139             : {
     140           0 :     return new PDFComment( m_aComment );
     141             : }
     142             : 
     143        1380 : PDFName::~PDFName()
     144             : {
     145        1380 : }
     146             : 
     147           0 : bool PDFName::emit( EmitContext& rWriteContext ) const
     148             : {
     149           0 :     if( ! rWriteContext.write( " /", 2 ) )
     150           0 :         return false;
     151           0 :     return rWriteContext.write( m_aName.getStr(), m_aName.getLength() );
     152             : }
     153             : 
     154           0 : PDFEntry* PDFName::clone() const
     155             : {
     156           0 :     return new PDFName( m_aName );
     157             : }
     158             : 
     159           0 : OUString PDFName::getFilteredName() const
     160             : {
     161           0 :     OStringBuffer aFilter( m_aName.getLength() );
     162           0 :     const sal_Char* pStr = m_aName.getStr();
     163           0 :     unsigned int nLen = m_aName.getLength();
     164           0 :     for( unsigned int i = 0; i < nLen; i++ )
     165             :     {
     166           0 :         if( (i < nLen - 3) && pStr[i] == '#' )
     167             :         {
     168           0 :             sal_Char rResult = 0;
     169           0 :             i++;
     170           0 :             if( pStr[i] >= '0' && pStr[i] <= '9' )
     171           0 :                 rResult = sal_Char( pStr[i]-'0' ) << 4;
     172           0 :             else if( pStr[i] >= 'a' && pStr[i] <= 'f' )
     173           0 :                 rResult = sal_Char( pStr[i]-'a' + 10 ) << 4;
     174           0 :             else if( pStr[i] >= 'A' && pStr[i] <= 'F' )
     175           0 :                 rResult = sal_Char( pStr[i]-'A' + 10 ) << 4;
     176           0 :             i++;
     177           0 :             if( pStr[i] >= '0' && pStr[i] <= '9' )
     178           0 :                 rResult |= sal_Char( pStr[i]-'0' );
     179           0 :             else if( pStr[i] >= 'a' && pStr[i] <= 'f' )
     180           0 :                 rResult |= sal_Char( pStr[i]-'a' + 10 );
     181           0 :             else if( pStr[i] >= 'A' && pStr[i] <= 'F' )
     182           0 :                 rResult |= sal_Char( pStr[i]-'A' + 10 );
     183           0 :             aFilter.append( rResult );
     184             :         }
     185             :         else
     186           0 :             aFilter.append( pStr[i] );
     187             :     }
     188           0 :     return OStringToOUString( aFilter.makeStringAndClear(), RTL_TEXTENCODING_UTF8 );
     189             : }
     190             : 
     191          60 : PDFString::~PDFString()
     192             : {
     193          60 : }
     194             : 
     195           0 : bool PDFString::emit( EmitContext& rWriteContext ) const
     196             : {
     197           0 :     if( ! rWriteContext.write( " ", 1 ) )
     198           0 :         return false;
     199           0 :     EmitImplData* pEData = getEmitData( rWriteContext );
     200           0 :     if( rWriteContext.m_bDecrypt && pEData && pEData->m_nDecryptObject )
     201             :     {
     202           0 :         OString aFiltered( getFilteredString() );
     203             :         // decrypt inplace (evil since OString is supposed to be const
     204             :         // however in this case we know that getFilteredString returned a singular string instance
     205           0 :         pEData->decrypt( reinterpret_cast<sal_uInt8 const *>(aFiltered.getStr()), aFiltered.getLength(),
     206           0 :                          reinterpret_cast<sal_uInt8 *>(const_cast<char *>(aFiltered.getStr())),
     207           0 :                          pEData->m_nDecryptObject, pEData->m_nDecryptGeneration );
     208             :         // check for string or hex string
     209           0 :         const sal_Char* pStr = aFiltered.getStr();
     210           0 :         if( aFiltered.getLength() > 1 &&
     211           0 :            ( ((unsigned char)pStr[0] == 0xff && (unsigned char)pStr[1] == 0xfe) ||
     212           0 :              ((unsigned char)pStr[0] == 0xfe && (unsigned char)pStr[1] == 0xff) ) )
     213             :         {
     214             :             static const char pHexTab[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
     215             :                                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
     216           0 :             if( ! rWriteContext.write( "<", 1 ) )
     217           0 :                 return false;
     218           0 :             for( sal_Int32 i = 0; i < aFiltered.getLength(); i++ )
     219             :             {
     220           0 :                 if( ! rWriteContext.write( pHexTab + ((sal_uInt32(pStr[i]) >> 4) & 0x0f), 1 ) )
     221           0 :                     return false;
     222           0 :                 if( ! rWriteContext.write( pHexTab + (sal_uInt32(pStr[i]) & 0x0f), 1 ) )
     223           0 :                     return false;
     224             :             }
     225           0 :             if( ! rWriteContext.write( ">", 1 ) )
     226           0 :                 return false;
     227             :         }
     228             :         else
     229             :         {
     230           0 :             if( ! rWriteContext.write( "(", 1 ) )
     231           0 :                 return false;
     232           0 :             if( ! rWriteContext.write( aFiltered.getStr(), aFiltered.getLength() ) )
     233           0 :                 return false;
     234           0 :             if( ! rWriteContext.write( ")", 1 ) )
     235           0 :                 return false;
     236             :         }
     237           0 :         return true;
     238             :     }
     239           0 :     return rWriteContext.write( m_aString.getStr(), m_aString.getLength() );
     240             : }
     241             : 
     242           0 : PDFEntry* PDFString::clone() const
     243             : {
     244           0 :     return new PDFString( m_aString );
     245             : }
     246             : 
     247           5 : OString PDFString::getFilteredString() const
     248             : {
     249           5 :     int nLen = m_aString.getLength();
     250           5 :     OStringBuffer aBuf( nLen );
     251             : 
     252           5 :     const sal_Char* pStr = m_aString.getStr();
     253           5 :     if( *pStr == '(' )
     254             :     {
     255           0 :         const sal_Char* pRun = pStr+1;
     256           0 :         while( pRun - pStr < nLen-1 )
     257             :         {
     258           0 :             if( *pRun == '\\' )
     259             :             {
     260           0 :                 pRun++;
     261           0 :                 if( pRun - pStr < nLen )
     262             :                 {
     263           0 :                     sal_Char aEsc = 0;
     264           0 :                     if( *pRun == 'n' )
     265           0 :                         aEsc = '\n';
     266           0 :                     else if( *pRun == 'r' )
     267           0 :                         aEsc = '\r';
     268           0 :                     else if( *pRun == 't' )
     269           0 :                         aEsc = '\t';
     270           0 :                     else if( *pRun == 'b' )
     271           0 :                         aEsc = '\b';
     272           0 :                     else if( *pRun == 'f' )
     273           0 :                         aEsc = '\f';
     274           0 :                     else if( *pRun == '(' )
     275           0 :                         aEsc = '(';
     276           0 :                     else if( *pRun == ')' )
     277           0 :                         aEsc = ')';
     278           0 :                     else if( *pRun == '\\' )
     279           0 :                         aEsc = '\\';
     280           0 :                     else if( *pRun == '\n' )
     281             :                     {
     282           0 :                         pRun++;
     283           0 :                         continue;
     284             :                     }
     285           0 :                     else if( *pRun == '\r' )
     286             :                     {
     287           0 :                         pRun++;
     288           0 :                         if( *pRun == '\n' )
     289           0 :                             pRun++;
     290           0 :                         continue;
     291             :                     }
     292             :                     else
     293             :                     {
     294           0 :                         int i = 0;
     295           0 :                         while( i++ < 3 && *pRun >= '0' && *pRun <= '7' )
     296           0 :                             aEsc = 8*aEsc + (*pRun++ - '0');
     297             :                         // move pointer back to last character of octal sequence
     298           0 :                         pRun--;
     299             :                     }
     300           0 :                     aBuf.append( aEsc );
     301             :                 }
     302             :             }
     303             :             else
     304           0 :                 aBuf.append( *pRun );
     305             :             // move pointer to next character
     306           0 :             pRun++;
     307             :         }
     308             :     }
     309           5 :     else if( *pStr == '<' )
     310             :     {
     311           5 :         const sal_Char* pRun = pStr+1;
     312          90 :         while( *pRun != '>' && pRun - pStr < nLen )
     313             :         {
     314          80 :             sal_Char rResult = 0;
     315          80 :             if( *pRun >= '0' && *pRun <= '9' )
     316          53 :                 rResult = sal_Char( *pRun-'0' ) << 4;
     317          27 :             else if( *pRun >= 'a' && *pRun <= 'f' )
     318           0 :                 rResult = sal_Char( *pRun-'a' + 10 ) << 4;
     319          27 :             else if( *pRun >= 'A' && *pRun <= 'F' )
     320          27 :                 rResult = sal_Char( *pRun-'A' + 10 ) << 4;
     321          80 :             pRun++;
     322          80 :             if( *pRun != '>' && pRun - pStr < nLen )
     323             :             {
     324          80 :                 if( *pRun >= '0' && *pRun <= '9' )
     325          56 :                     rResult |= sal_Char( *pRun-'0' );
     326          24 :                 else if( *pRun >= 'a' && *pRun <= 'f' )
     327           0 :                     rResult |= sal_Char( *pRun-'a' + 10 );
     328          24 :                 else if( *pRun >= 'A' && *pRun <= 'F' )
     329          24 :                     rResult |= sal_Char( *pRun-'A' + 10 );
     330             :             }
     331          80 :             pRun++;
     332          80 :             aBuf.append( rResult );
     333             :         }
     334             :     }
     335             : 
     336           5 :     return aBuf.makeStringAndClear();
     337             : }
     338             : 
     339         814 : PDFNumber::~PDFNumber()
     340             : {
     341         814 : }
     342             : 
     343           0 : bool PDFNumber::emit( EmitContext& rWriteContext ) const
     344             : {
     345           0 :     OStringBuffer aBuf( 32 );
     346           0 :     aBuf.append( ' ' );
     347             : 
     348           0 :     double fValue = m_fValue;
     349           0 :     bool bNeg = false;
     350           0 :     int nPrecision = 5;
     351           0 :     if( fValue < 0.0 )
     352             :     {
     353           0 :         bNeg = true;
     354           0 :         fValue=-fValue;
     355             :     }
     356             : 
     357           0 :     sal_Int64 nInt = (sal_Int64)fValue;
     358           0 :     fValue -= (double)nInt;
     359             :     // optimizing hardware may lead to a value of 1.0 after the subtraction
     360           0 :     if( fValue == 1.0 || log10( 1.0-fValue ) <= -nPrecision )
     361             :     {
     362           0 :         nInt++;
     363           0 :         fValue = 0.0;
     364             :     }
     365           0 :     sal_Int64 nFrac = 0;
     366           0 :     if( fValue )
     367             :     {
     368           0 :         fValue *= pow( 10.0, (double)nPrecision );
     369           0 :         nFrac = (sal_Int64)fValue;
     370             :     }
     371           0 :     if( bNeg && ( nInt || nFrac ) )
     372           0 :         aBuf.append( '-' );
     373           0 :     aBuf.append( nInt );
     374           0 :     if( nFrac )
     375             :     {
     376             :         int i;
     377           0 :         aBuf.append( '.' );
     378           0 :         sal_Int64 nBound = (sal_Int64)(pow( 10.0, nPrecision - 1.0 )+0.5);
     379           0 :         for ( i = 0; ( i < nPrecision ) && nFrac; i++ )
     380             :         {
     381           0 :             sal_Int64 nNumb = nFrac / nBound;
     382           0 :             nFrac -= nNumb * nBound;
     383           0 :             aBuf.append( nNumb );
     384           0 :             nBound /= 10;
     385             :         }
     386             :     }
     387             : 
     388           0 :     return rWriteContext.write( aBuf.getStr(), aBuf.getLength() );
     389             : }
     390             : 
     391           0 : PDFEntry* PDFNumber::clone() const
     392             : {
     393           0 :     return new PDFNumber( m_fValue );
     394             : }
     395             : 
     396             : 
     397          10 : PDFBool::~PDFBool()
     398             : {
     399          10 : }
     400             : 
     401           0 : bool PDFBool::emit( EmitContext& rWriteContext ) const
     402             : {
     403           0 :     return m_bValue ? rWriteContext.write( " true", 5 ) : rWriteContext.write( " false", 6 );
     404             : }
     405             : 
     406           0 : PDFEntry* PDFBool::clone() const
     407             : {
     408           0 :     return new PDFBool( m_bValue );
     409             : }
     410             : 
     411          20 : PDFNull::~PDFNull()
     412             : {
     413          20 : }
     414             : 
     415           0 : bool PDFNull::emit( EmitContext& rWriteContext ) const
     416             : {
     417           0 :     return rWriteContext.write( " null", 5 );
     418             : }
     419             : 
     420           0 : PDFEntry* PDFNull::clone() const
     421             : {
     422           0 :     return new PDFNull();
     423             : }
     424             : 
     425             : 
     426         244 : PDFObjectRef::~PDFObjectRef()
     427             : {
     428         244 : }
     429             : 
     430           0 : bool PDFObjectRef::emit( EmitContext& rWriteContext ) const
     431             : {
     432           0 :     OStringBuffer aBuf( 16 );
     433           0 :     aBuf.append( ' ' );
     434           0 :     aBuf.append( sal_Int32( m_nNumber ) );
     435           0 :     aBuf.append( ' ' );
     436           0 :     aBuf.append( sal_Int32( m_nGeneration ) );
     437           0 :     aBuf.append( " R", 2 );
     438           0 :     return rWriteContext.write( aBuf.getStr(), aBuf.getLength() );
     439             : }
     440             : 
     441           0 : PDFEntry* PDFObjectRef::clone() const
     442             : {
     443           0 :     return new PDFObjectRef( m_nNumber, m_nGeneration );
     444             : }
     445             : 
     446         574 : PDFContainer::~PDFContainer()
     447             : {
     448         287 :     int nEle = m_aSubElements.size();
     449        1872 :     for( int i = 0; i < nEle; i++ )
     450        1585 :         delete m_aSubElements[i];
     451         287 : }
     452             : 
     453           0 : bool PDFContainer::emitSubElements( EmitContext& rWriteContext ) const
     454             : {
     455           0 :     int nEle = m_aSubElements.size();
     456           0 :     for( int i = 0; i < nEle; i++ )
     457             :     {
     458           0 :         if( rWriteContext.m_bDecrypt )
     459             :         {
     460           0 :             const PDFName* pName = dynamic_cast<PDFName*>(m_aSubElements[i]);
     461           0 :             if (pName && pName->m_aName == "Encrypt")
     462             :             {
     463           0 :                 i++;
     464           0 :                 continue;
     465             :             }
     466             :         }
     467           0 :         if( ! m_aSubElements[i]->emit( rWriteContext ) )
     468           0 :             return false;
     469             :     }
     470           0 :     return true;
     471             : }
     472             : 
     473           0 : void PDFContainer::cloneSubElements( std::vector<PDFEntry*>& rNewSubElements ) const
     474             : {
     475           0 :     int nEle = m_aSubElements.size();
     476           0 :     for( int i = 0; i < nEle; i++ )
     477           0 :         rNewSubElements.push_back( m_aSubElements[i]->clone() );
     478           0 : }
     479             : 
     480           0 : PDFObject* PDFContainer::findObject( unsigned int nNumber, unsigned int nGeneration ) const
     481             : {
     482           0 :     unsigned int nEle = m_aSubElements.size();
     483           0 :     for( unsigned int i = 0; i < nEle; i++ )
     484             :     {
     485           0 :         PDFObject* pObject = dynamic_cast<PDFObject*>(m_aSubElements[i]);
     486           0 :         if( pObject &&
     487           0 :             pObject->m_nNumber == nNumber &&
     488           0 :             pObject->m_nGeneration == nGeneration )
     489             :         {
     490           0 :             return pObject;
     491             :         }
     492             :     }
     493           0 :     return NULL;
     494             : }
     495             : 
     496         126 : PDFArray::~PDFArray()
     497             : {
     498         126 : }
     499             : 
     500           0 : bool PDFArray::emit( EmitContext& rWriteContext ) const
     501             : {
     502           0 :     if( ! rWriteContext.write( "[", 1 ) )
     503           0 :         return false;
     504           0 :     if( ! emitSubElements( rWriteContext ) )
     505           0 :         return false;
     506           0 :     return rWriteContext.write( "]", 1 );
     507             : }
     508             : 
     509           0 : PDFEntry* PDFArray::clone() const
     510             : {
     511           0 :     PDFArray* pNewAr = new PDFArray();
     512           0 :     cloneSubElements( pNewAr->m_aSubElements );
     513           0 :     return pNewAr;
     514             : }
     515             : 
     516         214 : PDFDict::~PDFDict()
     517             : {
     518         214 : }
     519             : 
     520           0 : bool PDFDict::emit( EmitContext& rWriteContext ) const
     521             : {
     522           0 :     if( ! rWriteContext.write( "<<\n", 3 ) )
     523           0 :         return false;
     524           0 :     if( ! emitSubElements( rWriteContext ) )
     525           0 :         return false;
     526           0 :     return rWriteContext.write( "\n>>\n", 4 );
     527             : }
     528             : 
     529           0 : void PDFDict::insertValue( const OString& rName, PDFEntry* pValue )
     530             : {
     531           0 :     if( ! pValue )
     532           0 :         eraseValue( rName );
     533             : 
     534           0 :     std::unordered_map<OString,PDFEntry*,OStringHash>::iterator it = m_aMap.find( rName );
     535           0 :     if( it == m_aMap.end() )
     536             :     {
     537             :         // new name/value, pair, append it
     538           0 :         m_aSubElements.push_back( new PDFName( rName ) );
     539           0 :         m_aSubElements.push_back( pValue );
     540             :     }
     541             :     else
     542             :     {
     543           0 :         unsigned int nSub = m_aSubElements.size();
     544           0 :         for( unsigned int i = 0; i < nSub; i++ )
     545           0 :             if( m_aSubElements[i] == it->second )
     546           0 :                 m_aSubElements[i] = pValue;
     547           0 :         delete it->second;
     548             :     }
     549           0 :     m_aMap[ rName ] = pValue;
     550           0 : }
     551             : 
     552           0 : void PDFDict::eraseValue( const OString& rName )
     553             : {
     554           0 :     unsigned int nEle = m_aSubElements.size();
     555           0 :     for( unsigned int i = 0; i < nEle; i++ )
     556             :     {
     557           0 :         PDFName* pName = dynamic_cast<PDFName*>(m_aSubElements[i]);
     558           0 :         if( pName && pName->m_aName.equals( rName ) )
     559             :         {
     560           0 :             for( unsigned int j = i+1; j < nEle; j++ )
     561             :             {
     562           0 :                 if( dynamic_cast<PDFComment*>(m_aSubElements[j]) == NULL )
     563             :                 {
     564             :                     // free name and value
     565           0 :                     delete m_aSubElements[j];
     566           0 :                     delete m_aSubElements[i];
     567             :                     // remove subelements from vector
     568           0 :                     m_aSubElements.erase( m_aSubElements.begin()+j );
     569           0 :                     m_aSubElements.erase( m_aSubElements.begin()+i );
     570           0 :                     buildMap();
     571           0 :                     return;
     572             :                 }
     573             :             }
     574             :         }
     575             :     }
     576             : }
     577             : 
     578         107 : PDFEntry* PDFDict::buildMap()
     579             : {
     580             :     // clear map
     581         107 :     m_aMap.clear();
     582             :     // build map
     583         107 :     unsigned int nEle = m_aSubElements.size();
     584         107 :     PDFName* pName = NULL;
     585        1123 :     for( unsigned int i = 0; i < nEle; i++ )
     586             :     {
     587        1016 :         if( dynamic_cast<PDFComment*>(m_aSubElements[i]) == NULL )
     588             :         {
     589        1016 :             if( pName )
     590             :             {
     591         508 :                 m_aMap[ pName->m_aName ] = m_aSubElements[i];
     592         508 :                 pName = NULL;
     593             :             }
     594         508 :             else if( (pName = dynamic_cast<PDFName*>(m_aSubElements[i])) == NULL )
     595           0 :                 return m_aSubElements[i];
     596             :         }
     597             :     }
     598         107 :     return pName;
     599             : }
     600             : 
     601           0 : PDFEntry* PDFDict::clone() const
     602             : {
     603           0 :     PDFDict* pNewDict = new PDFDict();
     604           0 :     cloneSubElements( pNewDict->m_aSubElements );
     605           0 :     pNewDict->buildMap();
     606           0 :     return pNewDict;
     607             : }
     608             : 
     609          68 : PDFStream::~PDFStream()
     610             : {
     611          68 : }
     612             : 
     613           0 : bool PDFStream::emit( EmitContext& rWriteContext ) const
     614             : {
     615           0 :     return rWriteContext.copyOrigBytes( m_nBeginOffset, m_nEndOffset-m_nBeginOffset );
     616             : }
     617             : 
     618           0 : PDFEntry* PDFStream::clone() const
     619             : {
     620           0 :     return new PDFStream( m_nBeginOffset, m_nEndOffset, NULL );
     621             : }
     622             : 
     623           0 : unsigned int PDFStream::getDictLength( const PDFContainer* pContainer ) const
     624             : {
     625           0 :     if( ! m_pDict )
     626           0 :         return 0;
     627             :     // find /Length entry, can either be a direct or indirect number object
     628             :     std::unordered_map<OString,PDFEntry*,OStringHash>::const_iterator it =
     629           0 :         m_pDict->m_aMap.find( "Length" );
     630           0 :     if( it == m_pDict->m_aMap.end() )
     631           0 :         return 0;
     632           0 :     PDFNumber* pNum = dynamic_cast<PDFNumber*>(it->second);
     633           0 :     if( ! pNum && pContainer )
     634             :     {
     635           0 :         PDFObjectRef* pRef = dynamic_cast<PDFObjectRef*>(it->second);
     636           0 :         if( pRef )
     637             :         {
     638           0 :             int nEle = pContainer->m_aSubElements.size();
     639           0 :             for( int i = 0; i < nEle && ! pNum; i++ )
     640             :             {
     641           0 :                 PDFObject* pObj = dynamic_cast<PDFObject*>(pContainer->m_aSubElements[i]);
     642           0 :                 if( pObj &&
     643           0 :                     pObj->m_nNumber == pRef->m_nNumber &&
     644           0 :                     pObj->m_nGeneration == pRef->m_nGeneration )
     645             :                 {
     646           0 :                     if( pObj->m_pObject )
     647           0 :                         pNum = dynamic_cast<PDFNumber*>(pObj->m_pObject);
     648           0 :                     break;
     649             :                 }
     650             :             }
     651             :         }
     652             :     }
     653           0 :     return pNum ? static_cast<unsigned int>(pNum->m_fValue) : 0;
     654             : }
     655             : 
     656         214 : PDFObject::~PDFObject()
     657             : {
     658         214 : }
     659             : 
     660           0 : bool PDFObject::getDeflatedStream( char** ppStream, unsigned int* pBytes, const PDFContainer* pObjectContainer, EmitContext& rContext ) const
     661             : {
     662           0 :     bool bIsDeflated = false;
     663           0 :     if( m_pStream && m_pStream->m_pDict &&
     664           0 :         m_pStream->m_nEndOffset > m_pStream->m_nBeginOffset+15
     665             :         )
     666             :     {
     667           0 :         unsigned int nOuterStreamLen = m_pStream->m_nEndOffset - m_pStream->m_nBeginOffset;
     668           0 :         *ppStream = static_cast<char*>(rtl_allocateMemory( nOuterStreamLen ));
     669           0 :         unsigned int nRead = rContext.readOrigBytes( m_pStream->m_nBeginOffset, nOuterStreamLen, *ppStream );
     670           0 :         if( nRead != nOuterStreamLen )
     671             :         {
     672           0 :             rtl_freeMemory( *ppStream );
     673           0 :             *ppStream = NULL;
     674           0 :             *pBytes = 0;
     675           0 :             return false;
     676             :         }
     677             :         // is there a filter entry ?
     678             :         std::unordered_map<OString,PDFEntry*,OStringHash>::const_iterator it =
     679           0 :             m_pStream->m_pDict->m_aMap.find( "Filter" );
     680           0 :         if( it != m_pStream->m_pDict->m_aMap.end() )
     681             :         {
     682           0 :             PDFName* pFilter = dynamic_cast<PDFName*>(it->second);
     683           0 :             if( ! pFilter )
     684             :             {
     685           0 :                 PDFArray* pArray = dynamic_cast<PDFArray*>(it->second);
     686           0 :                 if( pArray && ! pArray->m_aSubElements.empty() )
     687             :                 {
     688           0 :                     pFilter = dynamic_cast<PDFName*>(pArray->m_aSubElements.front());
     689             :                 }
     690             :             }
     691             : 
     692             :             // is the (first) filter FlateDecode ?
     693           0 :             if (pFilter && pFilter->m_aName == "FlateDecode")
     694             :             {
     695           0 :                 bIsDeflated = true;
     696             :             }
     697             :         }
     698             :         // prepare compressed data section
     699           0 :         char* pStream = *ppStream;
     700           0 :         if( pStream[0] == 's' )
     701           0 :             pStream += 6; // skip "stream"
     702             :         // skip line end after "stream"
     703           0 :         while( *pStream == '\r' || *pStream == '\n' )
     704           0 :             pStream++;
     705             :         // get the compressed length
     706           0 :         *pBytes = m_pStream->getDictLength( pObjectContainer );
     707           0 :         if( pStream != *ppStream )
     708           0 :             memmove( *ppStream, pStream, *pBytes );
     709           0 :         if( rContext.m_bDecrypt )
     710             :         {
     711           0 :             EmitImplData* pEData = getEmitData( rContext );
     712             :             pEData->decrypt( reinterpret_cast<const sal_uInt8*>(*ppStream),
     713             :                              *pBytes,
     714             :                              reinterpret_cast<sal_uInt8*>(*ppStream),
     715             :                              m_nNumber,
     716             :                              m_nGeneration
     717           0 :                              ); // decrypt inplace
     718           0 :         }
     719             :     }
     720             :     else
     721           0 :         *ppStream = NULL, *pBytes = 0;
     722           0 :     return bIsDeflated;
     723             : }
     724             : 
     725           0 : static void unzipToBuffer( char* pBegin, unsigned int nLen,
     726             :                            sal_uInt8** pOutBuf, sal_uInt32* pOutLen )
     727             : {
     728             :     z_stream aZStr;
     729           0 :     aZStr.next_in       = reinterpret_cast<Bytef *>(pBegin);
     730           0 :     aZStr.avail_in      = nLen;
     731           0 :     aZStr.zalloc        = nullptr;
     732           0 :     aZStr.zfree         = nullptr;
     733           0 :     aZStr.opaque        = nullptr;
     734             : 
     735           0 :     int err = inflateInit(&aZStr);
     736             : 
     737           0 :     const unsigned int buf_increment_size = 16384;
     738             : 
     739           0 :     *pOutBuf = static_cast<sal_uInt8*>(rtl_reallocateMemory( *pOutBuf, buf_increment_size ));
     740           0 :     aZStr.next_out      = reinterpret_cast<Bytef*>(*pOutBuf);
     741           0 :     aZStr.avail_out     = buf_increment_size;
     742           0 :     *pOutLen = buf_increment_size;
     743           0 :     while( err != Z_STREAM_END && err >= Z_OK && aZStr.avail_in )
     744             :     {
     745           0 :         err = inflate( &aZStr, Z_NO_FLUSH );
     746           0 :         if( aZStr.avail_out == 0 )
     747             :         {
     748           0 :             if( err != Z_STREAM_END )
     749             :             {
     750           0 :                 const int nNewAlloc = *pOutLen + buf_increment_size;
     751           0 :                 *pOutBuf = static_cast<sal_uInt8*>(rtl_reallocateMemory( *pOutBuf, nNewAlloc ));
     752           0 :                 aZStr.next_out = reinterpret_cast<Bytef*>(*pOutBuf + *pOutLen);
     753           0 :                 aZStr.avail_out = buf_increment_size;
     754           0 :                 *pOutLen = nNewAlloc;
     755             :             }
     756             :         }
     757             :     }
     758           0 :     if( err == Z_STREAM_END )
     759             :     {
     760           0 :         if( aZStr.avail_out > 0 )
     761           0 :             *pOutLen -= aZStr.avail_out;
     762             :     }
     763           0 :     inflateEnd(&aZStr);
     764           0 :     if( err < Z_OK )
     765             :     {
     766           0 :         rtl_freeMemory( *pOutBuf );
     767           0 :         *pOutBuf = NULL;
     768           0 :         *pOutLen = 0;
     769             :     }
     770           0 : }
     771             : 
     772           0 : bool PDFObject::writeStream( EmitContext& rWriteContext, const PDFFile* pParsedFile ) const
     773             : {
     774           0 :     bool bSuccess = false;
     775           0 :     if( m_pStream )
     776             :     {
     777           0 :         char* pStream = NULL;
     778           0 :         unsigned int nBytes = 0;
     779           0 :         if( getDeflatedStream( &pStream, &nBytes, pParsedFile, rWriteContext ) && nBytes && rWriteContext.m_bDeflate )
     780             :         {
     781           0 :             sal_uInt8* pOutBytes = NULL;
     782           0 :             sal_uInt32 nOutBytes = 0;
     783           0 :             unzipToBuffer( pStream, nBytes, &pOutBytes, &nOutBytes );
     784           0 :             rWriteContext.write( pOutBytes, nOutBytes );
     785           0 :             rtl_freeMemory( pOutBytes );
     786             :         }
     787           0 :         else if( pStream && nBytes )
     788           0 :             rWriteContext.write( pStream, nBytes );
     789           0 :         rtl_freeMemory( pStream );
     790             :     }
     791           0 :     return bSuccess;
     792             : }
     793             : 
     794           0 : bool PDFObject::emit( EmitContext& rWriteContext ) const
     795             : {
     796           0 :     if( ! rWriteContext.write( "\n", 1 ) )
     797           0 :         return false;
     798             : 
     799           0 :     EmitImplData* pEData = getEmitData( rWriteContext );
     800           0 :     if( pEData )
     801           0 :         pEData->insertXref( m_nNumber, m_nGeneration, rWriteContext.getCurPos() );
     802             : 
     803           0 :     OStringBuffer aBuf( 32 );
     804           0 :     aBuf.append( sal_Int32( m_nNumber ) );
     805           0 :     aBuf.append( ' ' );
     806           0 :     aBuf.append( sal_Int32( m_nGeneration ) );
     807           0 :     aBuf.append( " obj\n" );
     808           0 :     if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
     809           0 :         return false;
     810             : 
     811           0 :     if( pEData )
     812           0 :         pEData->setDecryptObject( m_nNumber, m_nGeneration );
     813           0 :     if( (rWriteContext.m_bDeflate || rWriteContext.m_bDecrypt) && pEData )
     814             :     {
     815           0 :         char* pStream = NULL;
     816           0 :         unsigned int nBytes = 0;
     817           0 :         bool bDeflate = getDeflatedStream( &pStream, &nBytes, pEData->m_pObjectContainer, rWriteContext );
     818           0 :         if( pStream && nBytes )
     819             :         {
     820             :             // unzip the stream
     821           0 :             sal_uInt8* pOutBytes = NULL;
     822           0 :             sal_uInt32 nOutBytes = 0;
     823           0 :             if( bDeflate && rWriteContext.m_bDeflate )
     824           0 :                 unzipToBuffer( pStream, nBytes, &pOutBytes, &nOutBytes );
     825             :             else
     826             :             {
     827             :                 // nothing to deflate, but decryption has happened
     828           0 :                 pOutBytes = reinterpret_cast<sal_uInt8*>(pStream);
     829           0 :                 nOutBytes = (sal_uInt32)nBytes;
     830             :             }
     831             : 
     832           0 :             if( nOutBytes )
     833             :             {
     834             :                 // clone this object
     835           0 :                 PDFObject* pClone = static_cast<PDFObject*>(clone());
     836             :                 // set length in the dictionary to new stream length
     837           0 :                 PDFNumber* pNewLen = new PDFNumber( double(nOutBytes) );
     838           0 :                 pClone->m_pStream->m_pDict->insertValue( "Length", pNewLen );
     839             : 
     840           0 :                 if( bDeflate && rWriteContext.m_bDeflate )
     841             :                 {
     842             :                     // delete flatedecode filter
     843             :                     std::unordered_map<OString,PDFEntry*,OStringHash>::const_iterator it =
     844           0 :                     pClone->m_pStream->m_pDict->m_aMap.find( "Filter" );
     845           0 :                     if( it != pClone->m_pStream->m_pDict->m_aMap.end() )
     846             :                     {
     847           0 :                         PDFName* pFilter = dynamic_cast<PDFName*>(it->second);
     848           0 :                         if (pFilter && pFilter->m_aName == "FlateDecode")
     849           0 :                             pClone->m_pStream->m_pDict->eraseValue( "Filter" );
     850             :                         else
     851             :                         {
     852           0 :                             PDFArray* pArray = dynamic_cast<PDFArray*>(it->second);
     853           0 :                             if( pArray && ! pArray->m_aSubElements.empty() )
     854             :                             {
     855           0 :                                 pFilter = dynamic_cast<PDFName*>(pArray->m_aSubElements.front());
     856           0 :                                 if (pFilter && pFilter->m_aName == "FlateDecode")
     857             :                                 {
     858           0 :                                     delete pFilter;
     859           0 :                                     pArray->m_aSubElements.erase( pArray->m_aSubElements.begin() );
     860             :                                 }
     861             :                             }
     862             :                         }
     863             :                     }
     864             :                 }
     865             : 
     866             :                 // write sub elements except stream
     867           0 :                 bool bRet = true;
     868           0 :                 unsigned int nEle = pClone->m_aSubElements.size();
     869           0 :                 for( unsigned int i = 0; i < nEle && bRet; i++ )
     870             :                 {
     871           0 :                     if( pClone->m_aSubElements[i] != pClone->m_pStream )
     872           0 :                         bRet = pClone->m_aSubElements[i]->emit( rWriteContext );
     873             :                 }
     874           0 :                 delete pClone;
     875             :                 // write stream
     876           0 :                 if( bRet )
     877           0 :                     rWriteContext.write( "stream\n", 7 );
     878           0 :                 if( bRet )
     879           0 :                     bRet = rWriteContext.write( pOutBytes, nOutBytes );
     880           0 :                 if( bRet )
     881           0 :                     bRet = rWriteContext.write( "\nendstream\nendobj\n", 18 );
     882           0 :                 if( pOutBytes != reinterpret_cast<sal_uInt8*>(pStream) )
     883           0 :                     rtl_freeMemory( pOutBytes );
     884           0 :                 rtl_freeMemory( pStream );
     885           0 :                 if( pEData )
     886           0 :                     pEData->setDecryptObject( 0, 0 );
     887           0 :                 return bRet;
     888             :             }
     889           0 :             if( pOutBytes != reinterpret_cast<sal_uInt8*>(pStream) )
     890           0 :                 rtl_freeMemory( pOutBytes );
     891             :         }
     892           0 :         rtl_freeMemory( pStream );
     893             :     }
     894             : 
     895           0 :     bool bRet = emitSubElements( rWriteContext ) &&
     896           0 :                 rWriteContext.write( "\nendobj\n", 8 );
     897           0 :     if( pEData )
     898           0 :         pEData->setDecryptObject( 0, 0 );
     899           0 :     return bRet;
     900             : }
     901             : 
     902           0 : PDFEntry* PDFObject::clone() const
     903             : {
     904           0 :     PDFObject* pNewOb = new PDFObject( m_nNumber, m_nGeneration );
     905           0 :     cloneSubElements( pNewOb->m_aSubElements );
     906           0 :     unsigned int nEle = m_aSubElements.size();
     907           0 :     for( unsigned int i = 0; i < nEle; i++ )
     908             :     {
     909           0 :         if( m_aSubElements[i] == m_pObject )
     910           0 :             pNewOb->m_pObject = pNewOb->m_aSubElements[i];
     911           0 :         else if( m_aSubElements[i] == m_pStream && pNewOb->m_pObject )
     912             :         {
     913           0 :             pNewOb->m_pStream = dynamic_cast<PDFStream*>(pNewOb->m_aSubElements[i]);
     914           0 :             PDFDict* pNewDict = dynamic_cast<PDFDict*>(pNewOb->m_pObject);
     915           0 :             if (pNewDict && pNewOb->m_pStream)
     916           0 :                 pNewOb->m_pStream->m_pDict = pNewDict;
     917             :         }
     918             :     }
     919           0 :     return pNewOb;
     920             : }
     921             : 
     922          10 : PDFTrailer::~PDFTrailer()
     923             : {
     924          10 : }
     925             : 
     926           0 : bool PDFTrailer::emit( EmitContext& rWriteContext ) const
     927             : {
     928             :     // get xref offset
     929           0 :     unsigned int nXRefPos = rWriteContext.getCurPos();
     930             :     // begin xref section, object 0 is always free
     931           0 :     if( ! rWriteContext.write( "xref\r\n"
     932             :                                "0 1\r\n"
     933           0 :                                "0000000000 65535 f\r\n", 31 ) )
     934           0 :         return false;
     935             :     // check if we are emitting a complete PDF file
     936           0 :     EmitImplData* pEData = getEmitData( rWriteContext );
     937           0 :     if( pEData )
     938             :     {
     939             :         // emit object xrefs
     940           0 :         const EmitImplData::XRefTable& rXRefs = pEData->m_aXRefTable;
     941           0 :         EmitImplData::XRefTable::const_iterator section_begin, section_end;
     942           0 :         section_begin = rXRefs.begin();
     943           0 :         while( section_begin != rXRefs.end() )
     944             :         {
     945             :             // find end of continuous object numbers
     946           0 :             section_end = section_begin;
     947           0 :             unsigned int nLast = section_begin->first;
     948           0 :             while( (++section_end) != rXRefs.end() &&
     949           0 :                    section_end->first == nLast+1 )
     950           0 :                 nLast = section_end->first;
     951             :             // write first object number and number of following entries
     952           0 :             OStringBuffer aBuf( 21 );
     953           0 :             aBuf.append( sal_Int32( section_begin->first ) );
     954           0 :             aBuf.append( ' ' );
     955           0 :             aBuf.append( sal_Int32(nLast - section_begin->first + 1) );
     956           0 :             aBuf.append( "\r\n" );
     957           0 :             if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
     958           0 :                 return false;
     959           0 :             while( section_begin != section_end )
     960             :             {
     961             :                 // write 20 char entry of form
     962             :                 // 0000offset 00gen n\r\n
     963           0 :                 aBuf.setLength( 0 );
     964           0 :                 OString aOffset( OString::number( section_begin->second.second ) );
     965           0 :                 int nPad = 10 - aOffset.getLength();
     966           0 :                 for( int i = 0; i < nPad; i++ )
     967           0 :                     aBuf.append( '0' );
     968           0 :                 aBuf.append( aOffset );
     969           0 :                 aBuf.append( ' ' );
     970           0 :                 OString aGeneration( OString::number( section_begin->second.first ) );
     971           0 :                 nPad = 5 - aGeneration.getLength();
     972           0 :                 for( int i = 0; i < nPad; i++ )
     973           0 :                     aBuf.append( '0' );
     974           0 :                 aBuf.append( aGeneration );
     975           0 :                 aBuf.append( " n\r\n" );
     976           0 :                 if( ! rWriteContext.write( aBuf.getStr(), 20 ) )
     977           0 :                     return false;
     978           0 :                 ++section_begin;
     979           0 :             }
     980           0 :         }
     981             :     }
     982           0 :     if( ! rWriteContext.write( "trailer\n", 8 ) )
     983           0 :         return false;
     984           0 :     if( ! emitSubElements( rWriteContext ) )
     985           0 :         return false;
     986           0 :     if( ! rWriteContext.write( "startxref\n", 10 ) )
     987           0 :         return false;
     988           0 :     OString aOffset( OString::number( nXRefPos ) );
     989           0 :     if( ! rWriteContext.write( aOffset.getStr(), aOffset.getLength() ) )
     990           0 :         return false;
     991           0 :     return rWriteContext.write( "\n%%EOF\n", 7 );
     992             : }
     993             : 
     994           0 : PDFEntry* PDFTrailer::clone() const
     995             : {
     996           0 :     PDFTrailer* pNewTr = new PDFTrailer();
     997           0 :     cloneSubElements( pNewTr->m_aSubElements );
     998           0 :     unsigned int nEle = m_aSubElements.size();
     999           0 :     for( unsigned int i = 0; i < nEle; i++ )
    1000             :     {
    1001           0 :         if( m_aSubElements[i] == m_pDict )
    1002             :         {
    1003           0 :             pNewTr->m_pDict = dynamic_cast<PDFDict*>(pNewTr->m_aSubElements[i]);
    1004           0 :             break;
    1005             :         }
    1006             :     }
    1007           0 :     return pNewTr;
    1008             : }
    1009             : 
    1010             : #define ENCRYPTION_KEY_LEN 16
    1011             : #define ENCRYPTION_BUF_LEN 32
    1012             : 
    1013             : namespace pdfparse {
    1014             : struct PDFFileImplData
    1015             : {
    1016             :     bool        m_bIsEncrypted;
    1017             :     bool        m_bStandardHandler;
    1018             :     sal_uInt32  m_nAlgoVersion;
    1019             :     sal_uInt32  m_nStandardRevision;
    1020             :     sal_uInt32  m_nKeyLength;
    1021             :     sal_uInt8   m_aOEntry[32];
    1022             :     sal_uInt8   m_aUEntry[32];
    1023             :     sal_uInt32  m_nPEntry;
    1024             :     OString     m_aDocID;
    1025             :     rtlCipher   m_aCipher;
    1026             :     rtlDigest   m_aDigest;
    1027             : 
    1028             :     sal_uInt8   m_aDecryptionKey[ENCRYPTION_KEY_LEN+5]; // maximum handled key length
    1029             : 
    1030           5 :     PDFFileImplData() :
    1031             :         m_bIsEncrypted( false ),
    1032             :         m_bStandardHandler( false ),
    1033             :         m_nAlgoVersion( 0 ),
    1034             :         m_nStandardRevision( 0 ),
    1035             :         m_nKeyLength( 0 ),
    1036             :         m_nPEntry( 0 ),
    1037             :         m_aCipher( NULL ),
    1038           5 :         m_aDigest( NULL )
    1039             :     {
    1040           5 :         memset( m_aOEntry, 0, sizeof( m_aOEntry ) );
    1041           5 :         memset( m_aUEntry, 0, sizeof( m_aUEntry ) );
    1042           5 :         memset( m_aDecryptionKey, 0, sizeof( m_aDecryptionKey ) );
    1043           5 :     }
    1044             : 
    1045           5 :     ~PDFFileImplData()
    1046           5 :     {
    1047           5 :         if( m_aCipher )
    1048           0 :             rtl_cipher_destroyARCFOUR( m_aCipher );
    1049           5 :         if( m_aDigest )
    1050           0 :             rtl_digest_destroyMD5( m_aDigest );
    1051           5 :     }
    1052             : };
    1053             : }
    1054             : 
    1055          15 : PDFFile::~PDFFile()
    1056             : {
    1057           5 :     if( m_pData )
    1058           5 :         delete m_pData;
    1059          10 : }
    1060             : 
    1061           5 : bool PDFFile::isEncrypted() const
    1062             : {
    1063           5 :     return impl_getData()->m_bIsEncrypted;
    1064             : }
    1065             : 
    1066           0 : bool PDFFile::decrypt( const sal_uInt8* pInBuffer, sal_uInt32 nLen, sal_uInt8* pOutBuffer,
    1067             :                        unsigned int nObject, unsigned int nGeneration ) const
    1068             : {
    1069           0 :     if( ! isEncrypted() )
    1070           0 :         return false;
    1071             : 
    1072           0 :     if( ! m_pData->m_aCipher )
    1073           0 :         m_pData->m_aCipher = rtl_cipher_createARCFOUR( rtl_Cipher_ModeStream );
    1074             : 
    1075             :     // modify encryption key
    1076           0 :     sal_uInt32 i = m_pData->m_nKeyLength;
    1077           0 :     m_pData->m_aDecryptionKey[i++] = sal_uInt8(nObject&0xff);
    1078           0 :     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nObject>>8)&0xff);
    1079           0 :     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nObject>>16)&0xff);
    1080           0 :     m_pData->m_aDecryptionKey[i++] = sal_uInt8(nGeneration&0xff);
    1081           0 :     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nGeneration>>8)&0xff);
    1082             : 
    1083             :     sal_uInt8 aSum[ENCRYPTION_KEY_LEN];
    1084           0 :     rtl_digest_updateMD5( m_pData->m_aDigest, m_pData->m_aDecryptionKey, i );
    1085           0 :     rtl_digest_getMD5( m_pData->m_aDigest, aSum, sizeof( aSum ) );
    1086             : 
    1087           0 :     if( i > 16 )
    1088           0 :         i = 16;
    1089             : 
    1090             :     rtlCipherError aErr = rtl_cipher_initARCFOUR( m_pData->m_aCipher,
    1091             :                                                   rtl_Cipher_DirectionDecode,
    1092             :                                                   aSum, i,
    1093           0 :                                                   NULL, 0 );
    1094           0 :     if( aErr == rtl_Cipher_E_None )
    1095             :         aErr = rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
    1096             :                                          pInBuffer, nLen,
    1097           0 :                                          pOutBuffer, nLen );
    1098           0 :     return aErr == rtl_Cipher_E_None;
    1099             : }
    1100             : 
    1101             : static const sal_uInt8 nPadString[32] =
    1102             : {
    1103             :     0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
    1104             :     0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A
    1105             : };
    1106             : 
    1107           0 : static void pad_or_truncate_to_32( const OString& rStr, sal_Char* pBuffer )
    1108             : {
    1109           0 :     int nLen = rStr.getLength();
    1110           0 :     if( nLen > 32 )
    1111           0 :         nLen = 32;
    1112           0 :     const sal_Char* pStr = rStr.getStr();
    1113           0 :     memcpy( pBuffer, pStr, nLen );
    1114           0 :     int i = 0;
    1115           0 :     while( nLen < 32 )
    1116           0 :         pBuffer[nLen++] = nPadString[i++];
    1117           0 : }
    1118             : 
    1119             : // pass at least pData->m_nKeyLength bytes in
    1120           0 : static sal_uInt32 password_to_key( const OString& rPwd, sal_uInt8* pOutKey, PDFFileImplData* pData, bool bComputeO )
    1121             : {
    1122             :     // see PDF reference 1.4 Algorithm 3.2
    1123             :     // encrypt pad string
    1124             :     sal_Char aPadPwd[ENCRYPTION_BUF_LEN];
    1125           0 :     pad_or_truncate_to_32( rPwd, aPadPwd );
    1126           0 :     rtl_digest_updateMD5( pData->m_aDigest, aPadPwd, sizeof( aPadPwd ) );
    1127           0 :     if( ! bComputeO )
    1128             :     {
    1129           0 :         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aOEntry, 32 );
    1130             :         sal_uInt8 aPEntry[4];
    1131           0 :         aPEntry[0] = static_cast<sal_uInt8>(pData->m_nPEntry & 0xff);
    1132           0 :         aPEntry[1] = static_cast<sal_uInt8>((pData->m_nPEntry >> 8 ) & 0xff);
    1133           0 :         aPEntry[2] = static_cast<sal_uInt8>((pData->m_nPEntry >> 16) & 0xff);
    1134           0 :         aPEntry[3] = static_cast<sal_uInt8>((pData->m_nPEntry >> 24) & 0xff);
    1135           0 :         rtl_digest_updateMD5( pData->m_aDigest, aPEntry, sizeof(aPEntry) );
    1136           0 :         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aDocID.getStr(), pData->m_aDocID.getLength() );
    1137             :     }
    1138             :     sal_uInt8 nSum[RTL_DIGEST_LENGTH_MD5];
    1139           0 :     rtl_digest_getMD5( pData->m_aDigest, nSum, sizeof(nSum) );
    1140           0 :     if( pData->m_nStandardRevision == 3 )
    1141             :     {
    1142           0 :         for( int i = 0; i < 50; i++ )
    1143             :         {
    1144           0 :             rtl_digest_updateMD5( pData->m_aDigest, nSum, sizeof(nSum) );
    1145           0 :             rtl_digest_getMD5( pData->m_aDigest, nSum, sizeof(nSum) );
    1146             :         }
    1147             :     }
    1148           0 :     sal_uInt32 nLen = pData->m_nKeyLength;
    1149           0 :     if( nLen > RTL_DIGEST_LENGTH_MD5 )
    1150           0 :         nLen = RTL_DIGEST_LENGTH_MD5;
    1151           0 :     memcpy( pOutKey, nSum, nLen );
    1152           0 :     return nLen;
    1153             : }
    1154             : 
    1155           0 : static bool check_user_password( const OString& rPwd, PDFFileImplData* pData )
    1156             : {
    1157             :     // see PDF reference 1.4 Algorithm 3.6
    1158           0 :     bool bValid = false;
    1159             :     sal_uInt8 aKey[ENCRYPTION_KEY_LEN];
    1160             :     sal_uInt8 nEncryptedEntry[ENCRYPTION_BUF_LEN];
    1161           0 :     memset( nEncryptedEntry, 0, sizeof(nEncryptedEntry) );
    1162           0 :     sal_uInt32 nKeyLen = password_to_key( rPwd, aKey, pData, false );
    1163             :     // save (at this time potential) decryption key for later use
    1164           0 :     memcpy( pData->m_aDecryptionKey, aKey, nKeyLen );
    1165           0 :     if( pData->m_nStandardRevision == 2 )
    1166             :     {
    1167             :         // see PDF reference 1.4 Algorithm 3.4
    1168             :         // encrypt pad string
    1169             :         rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
    1170             :                                 aKey, nKeyLen,
    1171           0 :                                 NULL, 0 );
    1172             :         rtl_cipher_encodeARCFOUR( pData->m_aCipher, nPadString, sizeof( nPadString ),
    1173           0 :                                   nEncryptedEntry, sizeof( nEncryptedEntry ) );
    1174           0 :         bValid = (memcmp( nEncryptedEntry, pData->m_aUEntry, 32 ) == 0);
    1175             :     }
    1176           0 :     else if( pData->m_nStandardRevision == 3 )
    1177             :     {
    1178             :         // see PDF reference 1.4 Algorithm 3.5
    1179           0 :         rtl_digest_updateMD5( pData->m_aDigest, nPadString, sizeof( nPadString ) );
    1180           0 :         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aDocID.getStr(), pData->m_aDocID.getLength() );
    1181           0 :         rtl_digest_getMD5( pData->m_aDigest, nEncryptedEntry, sizeof(nEncryptedEntry) );
    1182             :         rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
    1183           0 :                                 aKey, sizeof(aKey), NULL, 0 );
    1184             :         rtl_cipher_encodeARCFOUR( pData->m_aCipher,
    1185             :                                   nEncryptedEntry, 16,
    1186           0 :                                   nEncryptedEntry, 16 ); // encrypt in place
    1187           0 :         for( int i = 1; i <= 19; i++ ) // do it 19 times, start with 1
    1188             :         {
    1189             :             sal_uInt8 aTempKey[ENCRYPTION_KEY_LEN];
    1190           0 :             for( sal_uInt32 j = 0; j < sizeof(aTempKey); j++ )
    1191           0 :                 aTempKey[j] = static_cast<sal_uInt8>( aKey[j] ^ i );
    1192             : 
    1193             :             rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
    1194           0 :                                     aTempKey, sizeof(aTempKey), NULL, 0 );
    1195             :             rtl_cipher_encodeARCFOUR( pData->m_aCipher,
    1196             :                                       nEncryptedEntry, 16,
    1197           0 :                                       nEncryptedEntry, 16 ); // encrypt in place
    1198             :         }
    1199           0 :         bValid = (memcmp( nEncryptedEntry, pData->m_aUEntry, 16 ) == 0);
    1200             :     }
    1201           0 :     return bValid;
    1202             : }
    1203             : 
    1204           0 : bool PDFFile::usesSupportedEncryptionFormat() const
    1205             : {
    1206           0 :     return m_pData->m_bStandardHandler &&
    1207           0 :         m_pData->m_nAlgoVersion >= 1 &&
    1208           0 :         m_pData->m_nAlgoVersion <= 2 &&
    1209           0 :         m_pData->m_nStandardRevision >= 2 &&
    1210           0 :         m_pData->m_nStandardRevision <= 3;
    1211             : }
    1212             : 
    1213           0 : bool PDFFile::setupDecryptionData( const OString& rPwd ) const
    1214             : {
    1215           0 :     if( !impl_getData()->m_bIsEncrypted )
    1216           0 :         return rPwd.isEmpty();
    1217             : 
    1218             :     // check if we can handle this encryption at all
    1219           0 :     if( ! usesSupportedEncryptionFormat() )
    1220           0 :         return false;
    1221             : 
    1222           0 :     if( ! m_pData->m_aCipher )
    1223           0 :         m_pData->m_aCipher = rtl_cipher_createARCFOUR(rtl_Cipher_ModeStream);
    1224           0 :     if( ! m_pData->m_aDigest )
    1225           0 :         m_pData->m_aDigest = rtl_digest_createMD5();
    1226             : 
    1227             :     // first try user password
    1228           0 :     bool bValid = check_user_password( rPwd, m_pData );
    1229             : 
    1230           0 :     if( ! bValid )
    1231             :     {
    1232             :         // try owner password
    1233             :         // see PDF reference 1.4 Algorithm 3.7
    1234             :         sal_uInt8 aKey[ENCRYPTION_KEY_LEN];
    1235             :         sal_uInt8 nPwd[ENCRYPTION_BUF_LEN];
    1236           0 :         memset( nPwd, 0, sizeof(nPwd) );
    1237           0 :         sal_uInt32 nKeyLen = password_to_key( rPwd, aKey, m_pData, true );
    1238           0 :         if( m_pData->m_nStandardRevision == 2 )
    1239             :         {
    1240             :             rtl_cipher_initARCFOUR( m_pData->m_aCipher, rtl_Cipher_DirectionDecode,
    1241           0 :                                     aKey, nKeyLen, NULL, 0 );
    1242             :             rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
    1243             :                                       m_pData->m_aOEntry, 32,
    1244           0 :                                       nPwd, 32 );
    1245             :         }
    1246           0 :         else if( m_pData->m_nStandardRevision == 3 )
    1247             :         {
    1248           0 :             memcpy( nPwd, m_pData->m_aOEntry, 32 );
    1249           0 :             for( int i = 19; i >= 0; i-- )
    1250             :             {
    1251             :                 sal_uInt8 nTempKey[ENCRYPTION_KEY_LEN];
    1252           0 :                 for( unsigned int j = 0; j < sizeof(nTempKey); j++ )
    1253           0 :                     nTempKey[j] = sal_uInt8(aKey[j] ^ i);
    1254             :                 rtl_cipher_initARCFOUR( m_pData->m_aCipher, rtl_Cipher_DirectionDecode,
    1255           0 :                                         nTempKey, nKeyLen, NULL, 0 );
    1256             :                 rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
    1257             :                                           nPwd, 32,
    1258           0 :                                           nPwd, 32 ); // decrypt inplace
    1259             :             }
    1260             :         }
    1261           0 :         bValid = check_user_password( OString( reinterpret_cast<char*>(nPwd), 32 ), m_pData );
    1262             :     }
    1263             : 
    1264           0 :     return bValid;
    1265             : }
    1266             : 
    1267           0 : OUString PDFFile::getDecryptionKey() const
    1268             : {
    1269           0 :     OUStringBuffer aBuf( ENCRYPTION_KEY_LEN * 2 );
    1270           0 :     if( impl_getData()->m_bIsEncrypted )
    1271             :     {
    1272           0 :         for( sal_uInt32 i = 0; i < m_pData->m_nKeyLength; i++ )
    1273             :         {
    1274             :             static const sal_Unicode pHexTab[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
    1275             :                                                      '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    1276           0 :             aBuf.append( pHexTab[(m_pData->m_aDecryptionKey[i] >> 4) & 0x0f] );
    1277           0 :             aBuf.append( pHexTab[(m_pData->m_aDecryptionKey[i] & 0x0f)] );
    1278             :         }
    1279             : 
    1280             :     }
    1281           0 :     return aBuf.makeStringAndClear();
    1282             : }
    1283             : 
    1284           5 : PDFFileImplData* PDFFile::impl_getData() const
    1285             : {
    1286           5 :     if( m_pData )
    1287           0 :         return m_pData;
    1288           5 :     m_pData = new PDFFileImplData();
    1289             :     // check for encryption dict in a trailer
    1290           5 :     unsigned int nElements = m_aSubElements.size();
    1291         127 :     while( nElements-- > 0 )
    1292             :     {
    1293         117 :         PDFTrailer* pTrailer = dynamic_cast<PDFTrailer*>(m_aSubElements[nElements]);
    1294         117 :         if( pTrailer && pTrailer->m_pDict )
    1295             :         {
    1296             :             // search doc id
    1297           5 :             PDFDict::Map::iterator doc_id = pTrailer->m_pDict->m_aMap.find( "ID" );
    1298           5 :             if( doc_id != pTrailer->m_pDict->m_aMap.end() )
    1299             :             {
    1300           5 :                 PDFArray* pArr = dynamic_cast<PDFArray*>(doc_id->second);
    1301           5 :                 if( pArr && pArr->m_aSubElements.size() > 0 )
    1302             :                 {
    1303           5 :                     PDFString* pStr = dynamic_cast<PDFString*>(pArr->m_aSubElements[0]);
    1304           5 :                     if( pStr )
    1305           5 :                         m_pData->m_aDocID = pStr->getFilteredString();
    1306             : #if OSL_DEBUG_LEVEL > 1
    1307             :                     OUString aTmp;
    1308             :                     for( int i = 0; i < m_pData->m_aDocID.getLength(); i++ )
    1309             :                         aTmp += OUString::number((unsigned int)sal_uInt8(m_pData->m_aDocID[i]), 16);
    1310             :                     SAL_INFO("sdext.pdfimport.pdfparse", "DocId is <" << OUStringToOString(aTmp, RTL_TEXTENCODING_UTF8).getStr() << ">");
    1311             : #endif
    1312             :                 }
    1313             :             }
    1314             :             // search Encrypt entry
    1315             :             PDFDict::Map::iterator enc =
    1316           5 :                 pTrailer->m_pDict->m_aMap.find( "Encrypt" );
    1317           5 :             if( enc != pTrailer->m_pDict->m_aMap.end() )
    1318             :             {
    1319           0 :                 PDFDict* pDict = dynamic_cast<PDFDict*>(enc->second);
    1320           0 :                 if( ! pDict )
    1321             :                 {
    1322           0 :                     PDFObjectRef* pRef = dynamic_cast<PDFObjectRef*>(enc->second);
    1323           0 :                     if( pRef )
    1324             :                     {
    1325           0 :                         PDFObject* pObj = findObject( pRef );
    1326           0 :                         if( pObj && pObj->m_pObject )
    1327           0 :                             pDict = dynamic_cast<PDFDict*>(pObj->m_pObject);
    1328             :                     }
    1329             :                 }
    1330           0 :                 if( pDict )
    1331             :                 {
    1332           0 :                     PDFDict::Map::iterator filter = pDict->m_aMap.find( "Filter" );
    1333           0 :                     PDFDict::Map::iterator version = pDict->m_aMap.find( "V" );
    1334           0 :                     PDFDict::Map::iterator len = pDict->m_aMap.find( "Length" );
    1335           0 :                     PDFDict::Map::iterator o_ent = pDict->m_aMap.find( "O" );
    1336           0 :                     PDFDict::Map::iterator u_ent = pDict->m_aMap.find( "U" );
    1337           0 :                     PDFDict::Map::iterator r_ent = pDict->m_aMap.find( "R" );
    1338           0 :                     PDFDict::Map::iterator p_ent = pDict->m_aMap.find( "P" );
    1339           0 :                     if( filter != pDict->m_aMap.end() )
    1340             :                     {
    1341           0 :                         m_pData->m_bIsEncrypted = true;
    1342           0 :                         m_pData->m_nKeyLength = 5;
    1343           0 :                         if( version != pDict->m_aMap.end() )
    1344             :                         {
    1345           0 :                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(version->second);
    1346           0 :                             if( pNum )
    1347           0 :                                 m_pData->m_nAlgoVersion = static_cast<sal_uInt32>(pNum->m_fValue);
    1348             :                         }
    1349           0 :                         if( m_pData->m_nAlgoVersion >= 3 )
    1350           0 :                             m_pData->m_nKeyLength = 16;
    1351           0 :                         if( len != pDict->m_aMap.end() )
    1352             :                         {
    1353           0 :                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(len->second);
    1354           0 :                             if( pNum )
    1355           0 :                                 m_pData->m_nKeyLength = static_cast<sal_uInt32>(pNum->m_fValue) / 8;
    1356             :                         }
    1357           0 :                         PDFName* pFilter = dynamic_cast<PDFName*>(filter->second);
    1358           0 :                         if( pFilter && pFilter->getFilteredName() == "Standard" )
    1359           0 :                             m_pData->m_bStandardHandler = true;
    1360           0 :                         if( o_ent != pDict->m_aMap.end() )
    1361             :                         {
    1362           0 :                             PDFString* pString = dynamic_cast<PDFString*>(o_ent->second);
    1363           0 :                             if( pString )
    1364             :                             {
    1365           0 :                                 OString aEnt = pString->getFilteredString();
    1366           0 :                                 if( aEnt.getLength() == 32 )
    1367           0 :                                     memcpy( m_pData->m_aOEntry, aEnt.getStr(), 32 );
    1368             : #if OSL_DEBUG_LEVEL > 1
    1369             :                                 else
    1370             :                                 {
    1371             :                                     OUString aTmp;
    1372             :                                     for( int i = 0; i < aEnt.getLength(); i++ )
    1373             :                                         aTmp += " " + OUString::number((unsigned int)sal_uInt8(aEnt[i]), 16);
    1374             :                                     SAL_WARN("sdext.pdfimport.pdfparse",
    1375             :                                              "O entry has length " << (int)aEnt.getLength() << ", should be 32 <" << OUStringToOString(aTmp, RTL_TEXTENCODING_UTF8).getStr() << ">" );
    1376             :                                 }
    1377             : #endif
    1378             :                             }
    1379             :                         }
    1380           0 :                         if( u_ent != pDict->m_aMap.end() )
    1381             :                         {
    1382           0 :                             PDFString* pString = dynamic_cast<PDFString*>(u_ent->second);
    1383           0 :                             if( pString )
    1384             :                             {
    1385           0 :                                 OString aEnt = pString->getFilteredString();
    1386           0 :                                 if( aEnt.getLength() == 32 )
    1387           0 :                                     memcpy( m_pData->m_aUEntry, aEnt.getStr(), 32 );
    1388             : #if OSL_DEBUG_LEVEL > 1
    1389             :                                 else
    1390             :                                 {
    1391             :                                     OUString aTmp;
    1392             :                                     for( int i = 0; i < aEnt.getLength(); i++ )
    1393             :                                         aTmp += " " + OUString::number((unsigned int)sal_uInt8(aEnt[i]), 16);
    1394             :                                     SAL_WARN("sdext.pdfimport.pdfparse",
    1395             :                                              "U entry has length " << (int)aEnt.getLength() << ", should be 32 <" << OUStringToOString(aTmp, RTL_TEXTENCODING_UTF8).getStr() << ">" );
    1396             :                                 }
    1397             : #endif
    1398             :                             }
    1399             :                         }
    1400           0 :                         if( r_ent != pDict->m_aMap.end() )
    1401             :                         {
    1402           0 :                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(r_ent->second);
    1403           0 :                             if( pNum )
    1404           0 :                                 m_pData->m_nStandardRevision = static_cast<sal_uInt32>(pNum->m_fValue);
    1405             :                         }
    1406           0 :                         if( p_ent != pDict->m_aMap.end() )
    1407             :                         {
    1408           0 :                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(p_ent->second);
    1409           0 :                             if( pNum )
    1410           0 :                                 m_pData->m_nPEntry = static_cast<sal_uInt32>(static_cast<sal_Int32>(pNum->m_fValue));
    1411             :                             SAL_INFO("sdext.pdfimport.pdfparse", "p entry is " << m_pData->m_nPEntry );
    1412             :                         }
    1413             : 
    1414             :                         SAL_INFO("sdext.pdfimport.pdfparse", "Encryption dict: sec handler: " << (pFilter ? OUStringToOString( pFilter->getFilteredName(), RTL_TEXTENCODING_UTF8 ).getStr() : "<unknown>") << ", version = " << (int)m_pData->m_nAlgoVersion << ", revision = " << (int)m_pData->m_nStandardRevision << ", key length = " << m_pData->m_nKeyLength );
    1415           0 :                         break;
    1416             :                     }
    1417             :                 }
    1418             :             }
    1419             :         }
    1420             :     }
    1421             : 
    1422           5 :     return m_pData;
    1423             : }
    1424             : 
    1425           0 : bool PDFFile::emit( EmitContext& rWriteContext ) const
    1426             : {
    1427           0 :     setEmitData(  rWriteContext, new EmitImplData( this ) );
    1428             : 
    1429           0 :     OStringBuffer aBuf( 32 );
    1430           0 :     aBuf.append( "%PDF-" );
    1431           0 :     aBuf.append( sal_Int32( m_nMajor ) );
    1432           0 :     aBuf.append( '.' );
    1433           0 :     aBuf.append( sal_Int32( m_nMinor ) );
    1434           0 :     aBuf.append( "\n" );
    1435           0 :     if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
    1436           0 :         return false;
    1437           0 :     return emitSubElements( rWriteContext );
    1438             : }
    1439             : 
    1440           0 : PDFEntry* PDFFile::clone() const
    1441             : {
    1442           0 :     PDFFile* pNewFl = new PDFFile();
    1443           0 :     pNewFl->m_nMajor = m_nMajor;
    1444           0 :     pNewFl->m_nMinor = m_nMinor;
    1445           0 :     cloneSubElements( pNewFl->m_aSubElements );
    1446           0 :     return pNewFl;
    1447             : }
    1448             : 
    1449           0 : PDFPart::~PDFPart()
    1450             : {
    1451           0 : }
    1452             : 
    1453           0 : bool PDFPart::emit( EmitContext& rWriteContext ) const
    1454             : {
    1455           0 :     return emitSubElements( rWriteContext );
    1456             : }
    1457             : 
    1458           0 : PDFEntry* PDFPart::clone() const
    1459             : {
    1460           0 :     PDFPart* pNewPt = new PDFPart();
    1461           0 :     cloneSubElements( pNewPt->m_aSubElements );
    1462           0 :     return pNewPt;
    1463             : }
    1464             : 
    1465             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11