pdfdocument.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 */

#ifndef INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX
#define INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX

#include <memory>
#include <map>
#include <vector>

#include <tools/stream.hxx>

#include <vcl/dllapi.h>

namespace com
{
namespace sun
{
namespace star
{
namespace security
{
class XCertificate;
}
}
}
}

namespace com
{
namespace sun
{
namespace star
{
namespace uno
{
template <class interface_type> class Reference;
}
}
}
}

namespace vcl
{
namespace filter
{
class PDFTrailerElement;
class PDFReferenceElement;
class PDFDocument;
class PDFDictionaryElement;
class PDFArrayElement;
class PDFStreamElement;
class PDFNumberElement;

class VCL_DLLPUBLIC PDFElement
{
    bool m_bVisiting = false;
    bool m_bParsing = false;

public:
    PDFElement() = default;
    virtual bool Read(SvStream& rStream) = 0;
    virtual ~PDFElement() = default;
    void setVisiting(bool bVisiting) { m_bVisiting = bVisiting; }
    bool alreadyVisiting() const { return m_bVisiting; }
    void setParsing(bool bParsing) { m_bParsing = bParsing; }
    bool alreadyParsing() const { return m_bParsing; }
};

class VCL_DLLPUBLIC PDFObjectElement final : public PDFElement
{
    PDFDocument& m_rDoc;
    double m_fObjectValue;
    double m_fGenerationValue;
    std::map<OString, PDFElement*> m_aDictionary;
    PDFNumberElement* m_pNumberElement;
    sal_uInt64 m_nDictionaryOffset;
    sal_uInt64 m_nDictionaryLength;
    PDFDictionaryElement* m_pDictionaryElement;
    sal_uInt64 m_nArrayOffset;
    sal_uInt64 m_nArrayLength;
    PDFArrayElement* m_pArrayElement;
    PDFStreamElement* m_pStreamElement;
    std::vector<std::unique_ptr<PDFObjectElement>> m_aStoredElements;
    std::vector<std::unique_ptr<PDFElement>> m_aElements;
    std::unique_ptr<SvMemoryStream> m_pStreamBuffer;
    std::vector<PDFReferenceElement*> m_aDictionaryReferences;

public:
    PDFObjectElement(PDFDocument& rDoc, double fObjectValue, double fGenerationValue);
    bool Read(SvStream& rStream) override;
    PDFElement* Lookup(const OString& rDictionaryKey);
    PDFObjectElement* LookupObject(const OString& rDictionaryKey);
    double GetObjectValue() const;
    void SetDictionaryOffset(sal_uInt64 nDictionaryOffset);
    sal_uInt64 GetDictionaryOffset();
    void SetDictionaryLength(sal_uInt64 nDictionaryLength);
    sal_uInt64 GetDictionaryLength();
    PDFDictionaryElement* GetDictionary();
    void SetDictionary(PDFDictionaryElement* pDictionaryElement);
    void SetNumberElement(PDFNumberElement* pNumberElement);
    PDFNumberElement* GetNumberElement() const;
    const std::map<OString, PDFElement*>& GetDictionaryItems();
    const std::vector<PDFReferenceElement*>& GetDictionaryReferences() const;
    void AddDictionaryReference(PDFReferenceElement* pReference);
    void SetArray(PDFArrayElement* pArrayElement);
    void SetStream(PDFStreamElement* pStreamElement);
    PDFStreamElement* GetStream() const;
    void SetArrayOffset(sal_uInt64 nArrayOffset);
    sal_uInt64 GetArrayOffset() const;
    void SetArrayLength(sal_uInt64 nArrayLength);
    sal_uInt64 GetArrayLength() const;
    PDFArrayElement* GetArray() const;
    void ParseStoredObjects();
    std::vector<std::unique_ptr<PDFElement>>& GetStoredElements();
    SvMemoryStream* GetStreamBuffer() const;
    void SetStreamBuffer(std::unique_ptr<SvMemoryStream>& pStreamBuffer);
    PDFDocument& GetDocument();
};

class VCL_DLLPUBLIC PDFArrayElement : public PDFElement
{
    std::vector<PDFElement*> m_aElements;
    PDFObjectElement* const m_pObject;

public:
    PDFArrayElement(PDFObjectElement* pObject);
    bool Read(SvStream& rStream) override;
    void PushBack(PDFElement* pElement);
    const std::vector<PDFElement*>& GetElements() const;
};

class VCL_DLLPUBLIC PDFReferenceElement : public PDFElement
{
    PDFDocument& m_rDoc;
    int m_fObjectValue;
    int m_fGenerationValue;
    sal_uInt64 m_nOffset = 0;
    PDFNumberElement& m_rObject;

public:
    PDFReferenceElement(PDFDocument& rDoc, PDFNumberElement& rObject,
                        PDFNumberElement const& rGeneration);
    bool Read(SvStream& rStream) override;
    double LookupNumber(SvStream& rStream) const;
    PDFObjectElement* LookupObject();
    int GetObjectValue() const;
    int GetGenerationValue() const;
    sal_uInt64 GetOffset() const;
    PDFNumberElement& GetObjectElement() const;
};

class VCL_DLLPUBLIC PDFStreamElement : public PDFElement
{
    size_t const m_nLength;
    sal_uInt64 m_nOffset;
    SvMemoryStream m_aMemory;

public:
    explicit PDFStreamElement(size_t nLength);
    bool Read(SvStream& rStream) override;
    sal_uInt64 GetOffset() const;
    SvMemoryStream& GetMemory();
};

class VCL_DLLPUBLIC PDFNameElement final : public PDFElement
{
    OString m_aValue;
    sal_uInt64 m_nLocation = 0;

public:
    PDFNameElement();
    bool Read(SvStream& rStream) override;
    const OString& GetValue() const;
    sal_uInt64 GetLocation() const;
    static sal_uInt64 GetLength() { return 0; }
};

class VCL_DLLPUBLIC PDFDictionaryElement : public PDFElement
{
    std::map<OString, PDFElement*> m_aItems;
    sal_uInt64 m_nLocation = 0;
    std::map<OString, sal_uInt64> m_aDictionaryKeyOffset;
    std::map<OString, sal_uInt64> m_aDictionaryKeyValueLength;

public:
    PDFDictionaryElement();
    bool Read(SvStream& rStream) override;

    static size_t Parse(const std::vector<std::unique_ptr<PDFElement>>& rElements,
                        PDFElement* pThis, std::map<OString, PDFElement*>& rDictionary);
    static PDFElement* Lookup(const std::map<OString, PDFElement*>& rDictionary,
                              const OString& rKey);
    void SetKeyOffset(const OString& rKey, sal_uInt64 nOffset);
    sal_uInt64 GetKeyOffset(const OString& rKey) const;
    void SetKeyValueLength(const OString& rKey, sal_uInt64 nLength);
    sal_uInt64 GetKeyValueLength(const OString& rKey) const;
    const std::map<OString, PDFElement*>& GetItems() const;
    PDFObjectElement* LookupObject(const OString& rDictionaryKey);
    PDFElement* LookupElement(const OString& rDictionaryKey);
};

enum class TokenizeMode
{
    END_OF_STREAM,
    EOF_TOKEN,
    END_OF_OBJECT,
    STORED_OBJECT
};

enum class XRefEntryType
{
    FREE,
    NOT_COMPRESSED,
    COMPRESSED
};

class XRefEntry
{
    XRefEntryType m_eType = XRefEntryType::NOT_COMPRESSED;
    sal_uInt64 m_nOffset = 0;
    bool m_bDirty = false;

public:
    XRefEntry();

    void SetType(XRefEntryType eType) { m_eType = eType; }

    XRefEntryType GetType() const { return m_eType; }

    void SetOffset(sal_uInt64 nOffset) { m_nOffset = nOffset; }

    sal_uInt64 GetOffset() const { return m_nOffset; }

    void SetDirty(bool bDirty) { m_bDirty = bDirty; }

    bool GetDirty() const { return m_bDirty; }
};

class VCL_DLLPUBLIC PDFHexStringElement final : public PDFElement
{
    OString m_aValue;

public:
    bool Read(SvStream& rStream) override;
    const OString& GetValue() const;
};

class VCL_DLLPUBLIC PDFLiteralStringElement final : public PDFElement
{
    OString m_aValue;

public:
    bool Read(SvStream& rStream) override;
    const OString& GetValue() const;
};

class VCL_DLLPUBLIC PDFNumberElement : public PDFElement
{
    sal_uInt64 m_nOffset = 0;
    sal_uInt64 m_nLength = 0;
    double m_fValue = 0;

public:
    PDFNumberElement();
    bool Read(SvStream& rStream) override;
    double GetValue() const;
    sal_uInt64 GetLocation() const;
    sal_uInt64 GetLength() const;
};

class VCL_DLLPUBLIC PDFDocument
{
    std::vector<std::unique_ptr<PDFElement>> m_aElements;
    std::map<size_t, XRefEntry> m_aXRef;
    std::map<size_t, PDFObjectElement*> m_aOffsetObjects;
    std::map<size_t, PDFObjectElement*> m_aIDObjects;
    std::vector<size_t> m_aStartXRefs;
    std::vector<size_t> m_aTrailerOffsets;
    std::map<size_t, PDFTrailerElement*> m_aOffsetTrailers;
    std::vector<size_t> m_aEOFs;
    PDFTrailerElement* m_pTrailer = nullptr;
    PDFObjectElement* m_pXRefStream = nullptr;
    SvMemoryStream m_aEditBuffer;

    sal_uInt32 GetNextSignature();
    sal_Int32 WriteSignatureObject(const OUString& rDescription, bool bAdES,
                                   sal_uInt64& rLastByteRangeOffset, sal_Int64& rContentOffset);
    sal_Int32 WriteAppearanceObject();
    sal_Int32 WriteAnnotObject(PDFObjectElement const& rFirstPage, sal_Int32 nSignatureId,
                               sal_Int32 nAppearanceId);
    bool WritePageObject(PDFObjectElement& rFirstPage, sal_Int32 nAnnotId);
    bool WriteCatalogObject(sal_Int32 nAnnotId, PDFReferenceElement*& pRoot);
    void WriteXRef(sal_uInt64 nXRefOffset, PDFReferenceElement const* pRoot);

public:
    PDFDocument();
    PDFDocument& operator=(const PDFDocument&) = delete;
    PDFDocument(const PDFDocument&) = delete;

    static std::vector<unsigned char> DecodeHexString(PDFHexStringElement const* pElement);
    static OString ReadKeyword(SvStream& rStream);
    static size_t FindStartXRef(SvStream& rStream);
    void ReadXRef(SvStream& rStream);
    void ReadXRefStream(SvStream& rStream);
    static void SkipWhitespace(SvStream& rStream);
    static void SkipLineBreaks(SvStream& rStream);
    size_t GetObjectOffset(size_t nIndex) const;
    const std::vector<std::unique_ptr<PDFElement>>& GetElements() const;
    std::vector<PDFObjectElement*> GetPages();
    void PushBackEOF(size_t nOffset);
    PDFObjectElement* LookupObject(size_t nObjectNumber);
    SvMemoryStream& GetEditBuffer();
    bool Tokenize(SvStream& rStream, TokenizeMode eMode,
                  std::vector<std::unique_ptr<PDFElement>>& rElements,
                  PDFObjectElement* pObjectElement);
    void SetIDObject(size_t nID, PDFObjectElement* pObject);


    bool Read(SvStream& rStream);
    bool Sign(const css::uno::Reference<css::security::XCertificate>& xCertificate,
              const OUString& rDescription, bool bAdES);
    bool Write(SvStream& rStream);
    std::vector<PDFObjectElement*> GetSignatureWidgets();
    bool RemoveSignature(size_t nPosition);
};

} // namespace pdfio
} // namespace xmlsecurity

#endif // INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */