Merge ee31096019 into 8f2c47cb07

- Explain pdfioObjGetSubtype and pdfioObjGetType values
- Provide example code and documentation for accessing common page object values

.gitattributes

@@ -1,2 +1,4 @@
 .git* export-ignore
+afl-pdf.dict export-ignore
+afl-input export-ignore
 makesrcdist export-ignore

.github/codeql.yml

@@ -0,0 +1,22 @@
+paths-ignore:
+  - testpdfio.c
+
+query-filters:
+  - exclude:
+      id: cpp/commented-out-code
+  - exclude:
+      id: cpp/toctou-race-condition
+  - exclude:
+      id: cpp/weak-cryptographic-algorithm
+  - exclude:
+      id: cpp/world-writable-file-creation
+  - exclude:
+      id: cpp/uncontrolled-allocation-size
+  - exclude:
+      id: cpp/path-injection
+  - exclude:
+      id: cpp/stack-address-escape
+  - exclude:
+      id: cpp/loop-variable-changed
+  - exclude:
+      id: cpp/long-switch

.github/workflows/build.yml

@@ -9,23 +9,26 @@ on:
 jobs:
   build-linux:
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: update build environment
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Update Build Environment
       run: sudo apt-get update --fix-missing -y
-    - name: install prerequisites
+    - name: Install Prerequisites
       run: sudo apt-get install -y cppcheck zlib1g-dev
-    - name: make
+    - name: Configure PDFio
+      run: ./configure --enable-debug --enable-sanitizer --enable-maintainer
+    - name: Build PDFio
       run: make "COMMONFLAGS=-g -fsanitize=address"
-    - name: test
+    - name: Test PDFio
       env:
         ASAN_OPTIONS: leak_check_at_exit=false
       run: make test
-    - name: clang static analyzer
+    - name: Run Clang Static Analyzer
       run: make CC=clang "GHA_ERROR=::error::" clang
-    - name: cppcheck
+    - name: Run cppcheck
       run: make "GHA_ERROR=::error::" cppcheck
 
   build-macos:
@@ -33,12 +36,15 @@ jobs:
     runs-on: macos-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: make
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Configure PDFio
+      run: ./configure --enable-debug --enable-sanitizer --enable-maintainer
+    - name: Build PDFio
       run: make "COMMONFLAGS=-g -fsanitize=address"
-    - name: test
+    - name: Test PDFio
       run: make test
-    - name: clang static analyzer
+    - name: Run Clang Static Analyzer
       run: make CC=clang "GHA_ERROR=::error::" clang
 
   build-windows:
@@ -46,10 +52,13 @@ jobs:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: setup-msbuild
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Setup MSBuild
       uses: microsoft/setup-msbuild@v1.0.2
-    - name: nuget restore
+    - name: Nuget Restore
       run: nuget restore pdfio.sln
-    - name: msbuild
+    - name: Build PDFio
       run: msbuild pdfio.sln
+    - name: Test PDFio
+      run: .\runtests.bat x64\Debug

.github/workflows/codeql.yml

@@ -0,0 +1,50 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: "46 3 * * 0"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ cpp ]
+
+    steps:
+      - name: Checkout PDFio sources
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Update Build Environment
+        run: sudo apt-get update --fix-missing -y
+
+      - name: Install Prerequisites
+        run: sudo apt-get install -y zlib1g-dev
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          config-file: ./.github/codeql.yml
+          queries: +security-and-quality
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{ matrix.language }}"

.github/workflows/coverity.yml

@@ -0,0 +1,43 @@
+name: Coverity Scan
+
+on: workflow_dispatch
+
+jobs:
+  coverity-scan:
+    runs-on: ubuntu-latest
+    environment: Coverity
+    steps:
+      - name: Checkout PDFio sources
+        uses: actions/checkout@v4
+      - name: Update Build Environment
+        run: sudo apt-get update --fix-missing -y
+      - name: Install Prerequisites
+        run: sudo apt-get install -y zlib1g-dev
+      - name: Download Coverity Build Tool
+        run: |
+          wget -q https://scan.coverity.com/download/linux64 --post-data token="$TOKEN&project=$GITHUB_REPOSITORY" -O cov-analysis-linux64.tar.gz
+          mkdir cov-analysis-linux64
+          tar xzf cov-analysis-linux64.tar.gz --strip 1 -C cov-analysis-linux64
+        env:
+          TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
+
+      - name: Configure PDFio
+        run: ./configure --enable-debug --enable-maintainer
+
+      - name: Build PDFio with cov-build
+        run: |
+          export PATH=`pwd`/cov-analysis-linux64/bin:$PATH
+          cov-build --dir cov-int make
+
+      - name: Submit the Result to Coverity Scan
+        run: |
+          tar czvf cov.tgz cov-int
+          curl \
+            --form token=$TOKEN \
+            --form email=michael.r.sweet@gmail.com \
+            --form file=@cov.tgz \
+            --form version="$GITHUB_REF" \
+            --form description="$GITHUB_SHA" \
+            "https://scan.coverity.com/builds?project=$GITHUB_REPOSITORY"
+        env:
+          TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}

.gitignore

@@ -4,8 +4,19 @@
 *.o
 *.so.1
 /.vs
+/afl-output
+/autom4te.cache
+/config.log
+/config.status
+/doc/pdfio.epub
+/Makefile
 /packages
+/pdfio.pc
 /pdfio.xcodeproj/xcshareddata
+/pdfio-*.tar.gz*
+/pdfio-*.zip*
+/pdfiototext
 /testpdfio
-/testpdfio-out.pdf
+/testpdfio-*.pdf
+/testttf
 /x64

.lgtm.yml

@@ -1,2 +0,0 @@
-queries:
-  - exclude: cpp/toctou-race-condition

CHANGES.md

@@ -0,0 +1,145 @@
+Changes in PDFio
+================
+
+
+v1.3.2 - YYYY-MM-DD
+-------------------
+
+- Added some more sanity checks to the TrueType font reader.
+- Updated documentation (Issue #77)
+- Fixed an issue when opening certain encrypted PDF files (Issue #62)
+
+
+v1.3.1 - 2024-08-05
+-------------------
+
+- CVE 2024-42358: Updated TrueType font reader to avoid large memory
+  allocations.
+- Fixed some documentation errors and added examples (Issue #68, Issue #69)
+
+
+v1.3.0 - 2024-06-28
+-------------------
+
+- Added `pdfioFileGetCatalog` API for accessing the root/catalog object of a
+  PDF file (Issue #67)
+- Updated number support to avoid locale issues (Issue #61)
+- Updated the PDFio private header to allow compilation with MingW; note that
+  MingW is NOT a supported toolchain for PDFio (Issue #66)
+- Optimized string pool code.
+
+
+v1.2.0 - 2024-01-24
+-------------------
+
+- Now use autoconf to configure the PDFio sources (Issue #54)
+- Added `pdfioFileCreateNumberObj` and `pdfioFileCreateStringObj` functions
+  (Issue #14)
+- Added `pdfioContentTextMeasure` function (Issue #17)
+- Added `pdfioContentTextNewLineShow` and `pdfioContentTextNewLineShowf`
+  functions (Issue #24)
+- Renamed `pdfioContentTextNextLine` to `pdfioContentTextNewLine`.
+- Updated the maximum number of object streams in a single file from 4096 to
+  8192 (Issue #58)
+- Updated the token reading code to protect against some obvious abuses of the
+  PDF format.
+- Updated the xref reading code to protect against loops.
+- Updated the object handling code to use a binary insertion algorithm -
+  provides a significant (~800x) improvement in open times.
+- Fixed handling of encrypted PDFs with per-object file IDs (Issue #42)
+- Fixed handling of of trailer dictionaries that started immediately after the
+  "trailer" keyword (Issue #58)
+- Fixed handling of invalid, but common, PDF files with a generation number of
+  65536 in the xref table (Issue #59)
+
+
+v1.1.4 - 2023-12-03
+-------------------
+
+- Fixed detection of encrypted strings that are too short (Issue #52)
+- Fixed a TrueType CMAP decoding bug.
+- Fixed a text rendering issue for Asian text.
+- Added a ToUnicode map for Unicode text to support text copying.
+
+
+v1.1.3 - 2023-11-15
+-------------------
+
+- Fixed Unicode font support (Issue #16)
+- Fixed missing initializer for 40-bit RC4 encryption (Issue #51)
+
+
+v1.1.2 - 2023-10-10
+-------------------
+
+- Updated `pdfioContentSetDashPattern` to support setting a solid (0 length)
+  dash pattern (Issue #41)
+- Fixed an issue with broken PDF files containing extra CR and/or LF separators
+  after the object stream token (Issue #40)
+- Fixed an issue with PDF files produced by Crystal Reports (Issue #45)
+- Fixed an issue with PDF files produced by Microsoft Reporting Services
+  (Issue #46)
+- Fixed support for compound filters where the filter array consists of a
+  single named filter (Issue #47)
+- Fixed builds on Windows - needed windows.h header for temporary files
+  (Issue #48)
+
+
+v1.1.1 - 2023-03-20
+-------------------
+
+- CVE-2023-28428: Fixed a potential denial-of-service with corrupt PDF files.
+- Fixed a few build issues.
+
+
+v1.1.0 - 2023-02-06
+-------------------
+
+- CVE-2023-24808: Fixed a potential denial-of-service with corrupt PDF files.
+- Added `pdfioFileCreateTemporary` function (Issue #29)
+- Added `pdfioDictIterateKeys` function (Issue #31)
+- Added `pdfioContentPathEnd` function.
+- Added protection against opening multiple streams in the same file at the
+  same time.
+- Documentation updates (Issue #37)
+- Fixed "install-shared" target (Issue #32)
+- Fixed `pdfioFileGet...` metadata APIs (Issue #33)
+- Fixed `pdfioContentMatrixRotate` function.
+
+
+v1.0.1 - 2022-03-02
+-------------------
+
+- Added missing `pdfioPageGetNumStreams` and `pdfioPageOpenStream` functions.
+- Added demo pdfiototext utility.
+- Fixed bug in `pdfioStreamGetToken`.
+
+
+v1.0.0 - 2021-12-14
+-------------------
+
+- First stable release.
+
+
+v1.0rc1 - 2021-11-30
+--------------------
+
+- Fixed a few stack/buffer overflow bugs discovered via fuzzing.
+
+
+v1.0b2 - 2021-11-07
+-------------------
+
+- Added `pdfioFileCreateOutput` API to support streaming output of PDF
+  (Issue #21)
+- Fixed `all-shared` target (Issue #22)
+- Fixed memory leaks (Issue #23)
+- Updated `pdfioContentSetDashPattern` to accept `double` values (Issue #25)
+- Added support for reading and writing encrypted PDFs (Issue #26)
+- Fixed some issues identified by a Coverity scan.
+
+
+v1.0b1 - 2021-08-30
+-------------------
+
+- Initial release

CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+Code of Conduct
+===============
+
+My goal is to provide quality open source software that everyone can use.
+While I may not be able to address every request or accept every contribution
+to this project, I will do my best to develop and maintain it for the common
+good.  As part of the open source community, I expect everyone to:
+
+- Be friendly and patient.
+- Be respectful, even if we disagree.
+- Be honest.
+- Be accepting of all people.
+- Fully explain your concerns, issues, or ideas.

CONTRIBUTING.md

@@ -0,0 +1,399 @@
+Contributing to PDFio
+=====================
+
+PDFio is developed and distributed as open source software under the Apache
+License, Version 2.0.  Contributions should be submitted as pull requests on
+the Github site:
+
+    http://github.com/michaelrsweet/pdfio/pulls
+
+
+Contents
+--------
+
+- [Build System](#build-system)
+- [Version Numbering](#version-numbering)
+- [Coding Guidelines](#coding-guidelines)
+  - [Source Files](#source-files)
+  - [Header Files](#header-files)
+  - [Comments](#comments)
+  - [Indentation](#indentation)
+  - [Spacing](#spacing)
+  - [Return Values](#return-values)
+  - [Functions](#functions)
+  - [Variables](#variables)
+  - [Types](#types)
+  - [Structures](#structures)
+  - [Constants](#constants)
+- [Shell Script Guidelines](#shell-script-guidelines)
+- [Makefile Guidelines](#makefile-guidelines)
+  - [General Organization](#general-organization)
+  - [Makefile Documentation](#makefile-documentation)
+  - [Portable Makefile Construction](#portable-makefile-construction)
+  - [Standard Variables](#standard-variables)
+  - [Standard Targets](#standard-targets)
+  - [Object Files](#object-files)
+  - [Programs](#programs)
+  - [Static Libraries](#static-libraries)
+  - [Shared Libraries](#shared-libraries)
+  - [Dependencies](#dependencies)
+  - [Install/Uninstall Support](#installuninstall-support)
+
+
+Build System
+------------
+
+The build system uses [GNU autoconf][AUTOCONF] to create a simple POSIX makefile
+to build static and/or shared libraries.  To improve portability, makefiles
+*must not* make use of features unique to GNU make.  See the
+[Makefile Guidelines](#makefile-guidelines) section for a description of the
+allowed make features and makefile guidelines.
+
+An Xcode project is provided for macOS/iOS developers, and a Visual Studio
+solution and projects for Windows developers.
+
+[AUTOCONF]: https://www.gnu.org/software/autoconf/
+
+
+Version Numbering
+-----------------
+
+PDFio uses a three-part version number separated by periods to represent the
+major, minor, and patch release numbers.  Major release numbers indicate large
+design changes or backwards-incompatible changes to the library.  Minor release
+numbers indicate new features and other smaller changes which are backwards-
+compatible with previous releases.  Patch numbers indicate bug fixes to the
+previous feature or patch release.
+
+Production releases use the plain version numbers:
+
+    MAJOR.MINOR.PATCH
+    1.0.0
+    1.0.1
+    1.0.2
+    ...
+    1.1.0
+    ...
+    2.0.0
+
+The first production release in a MAJOR.MINOR series (MAJOR.MINOR.0) is called
+a feature release.  Feature releases are the only releases that may contain new
+features.  Subsequent production releases in a MAJOR.MINOR series may only
+contain bug fixes.
+
+Beta-test releases are identified by appending the letter B to the major and
+minor version numbers followed by the beta release number:
+
+    MAJOR.MINORbNUMBER
+    1.0b1
+
+Release candidates are identified by appending the letters RC to the major and
+minor version numbers followed by the release candidate number:
+
+    MAJOR.MINORrcNUMBER
+    1.0rc1
+
+> Note: While the beta/release candidate syntax is *not* strictly compatible
+> with [Semantic Versioning](https://semver.org), it is better supported by the
+> various traditional package formats. When packaging a pre-release version of
+> PDFio in a format that requires the use of semantic version numbers, the
+> version number should simply be converted to the form "MAJOR.MINOR.0-suffix".
+
+
+Coding Guidelines
+-----------------
+
+Contributed source code must follow the guidelines below.  While the examples
+are for C source files, source code for other languages should conform to the
+same guidelines as allowed by the language.
+
+
+### Source Files
+
+All source files names must be 16 characters or less in length to ensure
+compatibility with older UNIX filesystems.  Source files containing functions
+have an extension of ".c" for C source files.  All "include" files have an
+extension of ".h".  Tabs are set to 8 characters or columns.
+
+The top of each source file contains a header giving the purpose or nature of
+the source file and the copyright and licensing notice:
+
+    //
+    // Description of file contents.
+    //
+    // Copyright © YYYY by AUTHOR.
+    //
+    // Licensed under Apache License v2.0.  See the file "LICENSE" for more
+    // information.
+    //
+
+
+### Header Files
+
+Private API header files must be named with the suffix "-private", for example
+the "pdfio.h" header file defines all of the public APIs while the
+"pdfio-private.h" header file defines all of the private APIs.  Typically a
+private API header file will include the corresponding public API header file.
+
+
+### Comments
+
+All source code utilizes block comments within functions to describe the
+operations being performed by a group of statements; avoid putting a comment
+per line unless absolutely necessary, and then consider refactoring the code
+so that it is not necessary.  C source files use the C99 comment format
+("// comment"):
+
+    // Clear the state array before we begin...
+    for (i = 0; i < (sizeof(array) / sizeof(sizeof(array[0])); i ++)
+      array[i] = PDFIO_STATE_IDLE;
+
+    // Wait for state changes on another thread...
+    do
+    {
+      for (i = 0; i < (sizeof(array) / sizeof(sizeof(array[0])); i ++)
+        if (array[i] != PDFIO_STATE_IDLE)
+          break;
+
+      if (i == (sizeof(array) / sizeof(array[0])))
+        sleep(1);
+    } while (i == (sizeof(array) / sizeof(array[0])));
+
+
+### Indentation
+
+All code blocks enclosed by brackets begin with the opening brace on a new
+line.  The code then follows starting on a new line after the brace and is
+indented 2 spaces.  The closing brace is then placed on a new line following
+the code at the original indentation:
+
+    {
+      int i; // Looping var
+
+      // Process foobar values from 0 to 999...
+      for (i = 0; i < 1000; i ++)
+      {
+        do_this(i);
+        do_that(i);
+      }
+    }
+
+Single-line statements following "do", "else", "for", "if", and "while" are
+indented 2 spaces as well.  Blocks of code in a "switch" block are indented 4
+spaces after each "case" and "default" case:
+
+    switch (array[i])
+    {
+      case PDFIO_STATE_IDLE :
+          do_this(i);
+          do_that(i);
+          break;
+
+      default :
+          do_nothing(i);
+          break;
+    }
+
+
+### Spacing
+
+A space follows each reserved word such as `if`, `while`, etc.  Spaces are not
+inserted between a function name and the arguments in parenthesis.
+
+
+### Return Values
+
+Parenthesis surround values returned from a function:
+
+    return (PDFIO_STATE_IDLE);
+
+
+### Functions
+
+Functions with a global scope have a lowercase prefix followed by capitalized
+words, e.g., `pdfioDoThis`, `pdfioDoThat`, `pdfioDoSomethingElse`, etc.  Private
+global functions begin with a leading underscore, e.g., `_pdfioDoThis`,
+`_pdfioDoThat`, etc.
+
+Functions with a local scope are declared static with lowercase names and
+underscores between words, e.g., `do_this`, `do_that`, `do_something_else`, etc.
+
+Function names follow the following pattern:
+
+- "pdfioFooCreate" to create a Foo object,
+- "pdfioFooDelete" to destroy (free) a Foo object,
+- "pdfioFooGetBar" to get data element Bar from object Foo,
+- "pdfioFooIsBar" to test condition Bar for object Foo, and
+- "pdfioFooSetBar" to set data element Bar in object Foo.
+- "pdfioFooVerb" to take an action with object Foo.
+
+Each function begins with a comment header describing what the function does,
+the possible input limits (if any), the possible output values (if any), and
+any special information needed:
+
+    //
+    // 'pdfioDoThis()' - Short description of function.
+    //
+    // Longer documentation for function with examples using a subset of
+    // markdown.  This is a bulleted list:
+    //
+    // - One fish
+    // - Two fish
+    // - Red fish
+    // - Blue fish
+    //
+    // > *Note:* Special notes for developer should be markdown block quotes.
+    //
+
+    float                  // O - Inverse power value, 0.0 <= y <= 1.1
+    pdfioDoThis(float x)   // I - Power value (0.0 <= x <= 1.1)
+    {
+      ...
+      return (y);
+    }
+
+Return/output values are indicated using an "O" prefix, input values are
+indicated using the "I" prefix, and values that are both input and output use
+the "IO" prefix for the corresponding in-line comment.
+
+The [`codedoc` documentation generator][1] also understands the following
+special text in the function description comment:
+
+    @deprecated@         - Marks the function as deprecated (not recommended
+                           for new development and scheduled for removal)
+    @since version@      - Marks the function as new in the specified version.
+    @private@            - Marks the function as private (same as starting the
+                           function name with an underscore)
+
+[1]: https://www.msweet.org/codedoc
+
+
+### Variables
+
+Variables with a global scope are capitalized, e.g., `ThisVariable`,
+`ThatVariable`, `ThisStateVariable`, etc.  Globals *must not* be used in the
+PDFio library.
+
+Variables with a local scope are lowercase with underscores between words,
+e.g., `this_variable`, `that_variable`, etc.  Any "local global" variables
+shared by functions within a source file are declared static.
+
+Each variable is declared on a separate line and is immediately followed by a
+comment block describing the variable:
+
+    int         ThisVariable;    // The current state of this
+    static int  that_variable;   // The current state of that
+
+
+### Types
+
+All type names are lowercase with underscores between words and `_t` appended
+to the end of the name, e.g., `pdfio_this_type_t`, `pdfio_that_type_t`, etc.
+Type names start with the "pdfio\_" prefix to avoid conflicts with system types.
+Private type names start with an underscore, e.g., `_pdfio_this_t`,
+`_pdfio_that_t`, etc.
+
+Each type has a comment block immediately after the typedef:
+
+    typedef int pdfio_this_type_t;  // This type is for foobar options.
+
+
+### Structures
+
+All structure names are lowercase with underscores between words and `_s`
+appended to the end of the name, e.g., `pdfio_this_s`, `pdfio_that_s`, etc.
+Structure names start with the "pdfio\_" prefix to avoid conflicts with system
+types.  Private structure names start with an underscore, e.g., `_pdfio_this_s`,
+`_pdfio_that_s`, etc.
+
+Each structure has a comment block immediately after the struct and each member
+is documented similar to the variable naming policy above:
+
+    struct pdfio_this_struct_s // This structure is for foobar options.
+    {
+      int this_member;         // Current state for this
+      int that_member;         // Current state for that
+    };
+
+One common design pattern is to define a private structure with a public
+typedef, for example:
+
+    // In public header
+    typedef struct _pdfio_foo_s pdfio_foo_t // Foo object
+
+    // In private header
+    struct _pdfio_foo_s        // Foo object
+    {
+      int this_member;         // Current state for this
+      int that_member;         // Current state for that
+    };
+
+
+### Constants
+
+All constant names are uppercase with underscores between words, e.g.,
+`PDFIO_THIS_CONSTANT`, `PDFIO_THAT_CONSTANT`, etc.  Constants begin with the
+"PDFIO\_" prefix to avoid conflicts with system constants.  Private constants
+start with an underscore, e.g., `_PDFIO_THIS_CONSTANT`,
+`_PDFIO_THAT_CONSTANT`, etc.
+
+Typed enumerations should be used whenever possible to allow for type checking
+by the compiler.  The constants for typed enumerations must match the type name
+in uppercase, for example a `pdfio_foo_e` enumeration has constant names
+starting with `PDFIO_FOO_`.
+
+Comment blocks immediately follow each constant:
+
+    typedef enum pdfio_style_e  // Style enumerations
+    {
+      PDFIO_STYLE_THIS,         // This style
+      PDFIO_STYLE_THAT          // That style
+    } pdfio_style_t;
+
+
+Shell Script Guidelines
+-----------------------
+
+All shell scripts in PDFio must conform to the [POSIX shell][POSIX-SHELL]
+command language and should restrict their dependence on non-POSIX utility
+commands.
+
+[POSIX-SHELL]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18
+
+
+Makefile Guidelines
+-------------------
+
+PDFio uses a single [POSIX makefile][POSIX-MAKE] to build it.  GNU make
+extensions MUST NOT be used.
+
+[POSIX-MAKE]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/make.html
+
+The following variables are defined in the makefile:
+
+- `AR`; the static library archiver command,
+- `ARFLAGS`; options for the static library archiver,
+- `CC`; the C compiler command,
+- `CFLAGS`; options for the C compiler,
+- `CODESIGN_IDENTITY`: the code signing identity,
+- `CPPFLAGS`; options for the C preprocessor,
+- `DESTDIR`/`DSTROOT`: the destination root directory when installing.
+- `DSO`; the shared library building command,
+- `DSOFLAGS`; options for the shared library building command,
+- `LDFLAGS`; options for the linker,
+- `LIBPDFIO`: the name of the primary (shared or static) library
+- `LIBPDFIO_STATIC`: the name of the secondary (static) library
+- `LIBS`; libraries for all programs,
+- `OPTIM`; common compiler optimization options,
+- `prefix`; the installation prefix directory,
+- `RANLIB`; the static library indexing command,
+- `SHELL`; the sh (POSIX shell) command,
+- `VERSION`: the library version number.
+
+The following standard targets are defined in the makefile:
+
+- `all`; creates the static library and unit test program.
+- `clean`; removes all target programs libraries, documentation files, and
+  object files,
+- `install`; installs all distribution files in their corresponding locations.
+- `test`; runs the unit test program, building it as needed.

FAQ.md

@@ -1,17 +0,0 @@
-Frequently Asked Questions
-==========================
-
-Why Don't You Support Writing a PDF File with Encryption?
----------------------------------------------------------
-
-PDF encryption offers very little protection:
-
-- PDF encryption keys are reused and derived from the user password (padded
-  with a standard base string) and the object numbers in the file.
-- RC4 encryption (40- and 128-bit) was broken years ago.
-- AES encryption (128- and 256-bit) is better, but PDF uses Cipher Block
-  Chaining (CBC) which enables attacks that allow the original encryption key
-  to be recovered.
-
-In addition, PDF usage controls (no print, no copy, etc.) are tied to this
-encryption, making them trivial to bypass.

Makefile

@@ -1,190 +0,0 @@
-#
-# Makefile for PDFio.
-#
-# Copyright © 2021 by Michael R Sweet.
-#
-# Licensed under Apache License v2.0.  See the file "LICENSE" for more
-# information.
-#
-
-# POSIX makefile
-.POSIX:
-
-# Variables...
-AR		=	ar
-ARFLAGS		=	cr
-CC		=	cc
-CFLAGS		=
-CODESIGN_IDENTITY =	Developer ID
-COMMONFLAGS	=	-Os -g
-CPPFLAGS	=	'-DPDFIO_VERSION="$(VERSION)"'
-DESTDIR		=	$(DSTROOT)
-DSO		=	cc
-DSOFLAGS	=
-DSONAME		=
-LDFLAGS		=
-LIBS		=	-lm -lz
-RANLIB		=	ranlib
-VERSION		=	1.0b1
-prefix		=	/usr/local
-
-
-# Base rules
-.SUFFIXES:	.c .h .o
-.c.o:
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(COMMONFLAGS) -c $<
-
-
-# Files
-PUBHEADERS	=	\
-			pdfio.h \
-			pdfio-content.h
-PUBOBJS		=	\
-			pdfio-array.o \
-			pdfio-common.o \
-			pdfio-content.o \
-			pdfio-dict.o \
-			pdfio-file.o \
-			pdfio-object.o \
-			pdfio-page.o \
-			pdfio-stream.o \
-			pdfio-string.o \
-			pdfio-token.o \
-			pdfio-value.o
-LIBOBJS		=	\
-			$(PUBOBJS) \
-			ttf.o
-OBJS		=	\
-			$(LIBOBJS) \
-			testpdfio.o
-TARGETS		=	\
-			$(DSONAME) \
-			libpdfio.a \
-			testpdfio
-
-
-# Make everything
-all:		$(TARGETS)
-
-all-shared:
-	if test `uname` = Darwin; then \
-		$(MAKE) DSONAME="libpdfio.1.dylib" -$(MAKEFLAGS) all; \
-	else
-		$(MAKE) DSONAME="libpdfio.so.1" -$(MAKEFLAGS) all; \
-	fi
-
-debug:
-	$(MAKE) -$(MAKEFLAGS) COMMONFLAGS="-g -fsanitize=address -DDEBUG=1" clean all
-
-
-# Clean everything
-clean:
-	rm -f $(TARGETS) $(OBJS)
-
-
-# Install everything
-install:	$(TARGETS)
-	-mkdir -p $(DESTDIR)$(prefix)/include
-	cp $(PUBHEADERS) $(DESTDIR)$(prefix)/include
-	-mkdir -p $(DESTDIR)$(prefix)/lib
-	cp libpdfio.a $(DESTDIR)$(prefix)/lib
-	$(RANLIB) $(DESTDIR)$(prefix)/lib/libpdfio.a
-	if test "x$(DSONAME)" = xlibpdfio.so.1; then \
-		cp $(DSONAME) $(DESTDIR)$(prefix)/lib; \
-		ln -sf libpdfio.so.1 $(DESTDIR)$(prefix)/lib/libpdfio.so; \
-	elif test "x$(DSONAME)" = xlibpdfio.1.dylib; then \
-		cp $(DSONAME) $(DESTDIR)$(prefix)/lib; \
-		codesign -s "$(CODESIGN_IDENTITY)" -o runtime --timestamp $(DESTDIR)$(prefix)/lib/libpdfio.1.dylib; \
-		ln -sf libpdfio.1.dylib $(DESTDIR)$(prefix)/lib/libpdfio.dylib; \
-	fi
-	-mkdir -p $(DESTDIR)$(prefix)/lib/pkgconfig
-	echo 'prefix="$(prefix)"' >$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	echo 'Version: $(VERSION)' >>$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	cat pdfio.pc.in >>$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	-mkdir -p $(DESTDIR)$(prefix)/share/doc/pdfio
-	cp doc/pdfio.html doc/pdfio-512.png LICENSE NOTICE $(DESTDIR)$(prefix)/share/doc/pdfio
-	-mkdir -p $(DESTDIR)$(prefix)/share/man/man3
-	cp doc/pdfio.3 $(DESTDIR)$(prefix)/share/man/man3
-
-install-shared:
-	if test `uname` = Darwin; then \
-		$(MAKE) DSONAME="libpdfio.1.dylib" -$(MAKEFLAGS) install; \
-	else
-		$(MAKE) DSONAME="libpdfio.so.1" -$(MAKEFLAGS) install; \
-	fi
-
-
-# Test everything
-test:	testpdfio
-	./testpdfio
-
-
-# pdfio library
-libpdfio.a:		$(LIBOBJS)
-	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
-	$(RANLIB) $@
-
-libpdfio.so.1:		$(LIBOBJS)
-	$(CC) $(DSOFLAGS) $(COMMONFLAGS) -shared -o $@ -Wl,soname,$@ $(LIBOBJS) $(LIBS)
-
-libpdfio.1.dylib:	$(LIBOBJS)
-	$(CC) $(DSOFLAGS) $(COMMONFLAGS) -dynamiclib -o $@ -install_name $(prefix)/lib/$@ -current_version $(VERSION) -compatibility_version 1.0 $(LIBOBJS) $(LIBS)
-
-
-# pdfio1.def (Windows DLL exports file...)
-#
-# I'd love to use __declspec(dllexport) but MS puts it before the function
-# declaration instead of after like everyone else, and it breaks Codedoc and
-# other tools I rely on...
-pdfio1.def: $(LIBOBJS) Makefile
-	echo Generating $@...
-	echo "LIBRARY pdfio1" >$@
-	echo "VERSION 1.0" >>$@
-	echo "EXPORTS" >>$@
-	(nm $(LIBOBJS) 2>/dev/null | grep "T _" | awk '{print $$3}' | \
-		grep -v '^_ttf' | grep -v '^__' | sed -e '1,$$s/^_//'; \
-		echo pdfioAdobeRGBGamma; echo pdfioAdobeRGBMatrix; \
-		echo pdfioAdobeRGBWhitePoint; \
-		echo pdfioDisplayP3Gamma; echo pdfioDisplayP3Matrix; \
-		echo pdfioDisplayP3WhitePoint; \
-		echo pdfioSRGBGamma; echo pdfioSRGBMatrix; \
-		echo pdfioSRGBWhitePoint; \
-		echo _pdfioTokenInit; \
-		echo _pdfioValueDebug; echo _pdfioValueRead) | sort >>$@
-
-
-# pdfio test program
-testpdfio:		testpdfio.o libpdfio.a
-	$(CC) $(LDFLAGS) $(COMMONFLAGS) -o $@ testpdfio.o libpdfio.a $(LIBS)
-
-
-# Dependencies
-$(OBJS):		pdfio.h Makefile
-$(LIBOBJS):		pdfio-private.h
-pdfio-content.o:	pdfio-content.h ttf.h
-ttf.o:			ttf.h
-
-# Make documentation using Codedoc <https://www.msweet.org/codedoc>
-DOCFLAGS	=	\
-			--author "Michael R Sweet" \
-			--copyright "Copyright (c) 2021 by Michael R Sweet" \
-			--docversion $(VERSION)
-
-.PHONY: doc
-doc:
-	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(VERSION)" $(PUBHEADERS) $(PUBOBJS:.o=.c) --body doc/pdfio.md --coverimage doc/pdfio-512.png pdfio.xml >doc/pdfio.html
-	codedoc $(DOCFLAGS) --title "pdf read/write library" --man pdfio --section 3 --body doc/pdfio.md pdfio.xml >doc/pdfio.3
-	rm -f pdfio.xml
-
-
-# Analyze code with the Clang static analyzer <https://clang-analyzer.llvm.org>
-clang:
-	clang $(CPPFLAGS) --analyze $(OBJS:.o=.c) 2>clang.log
-	rm -rf $(OBJS:.o=.plist)
-	test -s clang.log && (echo "$(GHA_ERROR)Clang detected issues."; echo ""; cat clang.log; exit 1) || exit 0
-
-
-# Analyze code using Cppcheck <http://cppcheck.sourceforge.net>
-cppcheck:
-	cppcheck $(CPPFLAGS) --template=gcc --addon=cert.py --suppressions-list=.cppcheck $(OBJS:.o=.c) 2>cppcheck.log
-	test -s cppcheck.log && (echo "$(GHA_ERROR)Cppcheck detected issues."; echo ""; cat cppcheck.log; exit 1) || exit 0

Makefile.in

@@ -0,0 +1,262 @@
+#
+# Makefile for PDFio.
+#
+# Copyright © 2021-2024 by Michael R Sweet.
+#
+# Licensed under Apache License v2.0.  See the file "LICENSE" for more
+# information.
+#
+
+# POSIX makefile
+.POSIX:
+
+
+# Build silently
+.SILENT:
+
+
+# Version number...
+PDFIO_VERSION		=	@PDFIO_VERSION@
+PDFIO_VERSION_MAJOR	=	@PDFIO_VERSION_MAJOR@
+PDFIO_VERSION_MINOR	=	@PDFIO_VERSION_MINOR@
+
+
+# Programs and options...
+AR		=	@AR@
+ARFLAGS		=	@ARFLAGS@
+CC		=	@CC@
+CFLAGS		=	@CFLAGS@ $(CPPFLAGS) $(OPTIM) $(WARNINGS)
+CODE_SIGN	=	@CODE_SIGN@
+CODESIGN_IDENTITY =	-
+CPPFLAGS	=	@CPPFLAGS@
+CSFLAGS		=	-s "$(CODESIGN_IDENTITY)" @CSFLAGS@ --timestamp
+DSOFLAGS	=	@DSOFLAGS@ $(CFLAGS)
+INSTALL		=	@INSTALL@
+LDFLAGS		=	@LDFLAGS@ $(OPTIM)
+LIBS		=	@LIBS@ -lm
+LN		=	@LN@
+OPTIM		=	@OPTIM@
+RANLIB		=	@RANLIB@
+RM		=	@RM@ -f
+RMDIR		=	@RMDIR@
+SHELL		=	/bin/sh
+WARNINGS	=	@WARNINGS@
+
+
+# Targets
+LIBPDFIO	=	@LIBPDFIO@
+LIBPDFIO_STATIC	=	@LIBPDFIO_STATIC@
+
+
+# Directories...
+bindir		=	@bindir@
+datadir		=	@datadir@
+datarootdir	=	@datarootdir@
+exec_prefix	=	@exec_prefix@
+includedir	=	@includedir@
+infodir		=	@infodir@
+libdir		=	@libdir@
+libexecdir	=	@libexecdir@
+localstatedir	=	@localstatedir@
+mandir		=	@mandir@
+oldincludedir	=	@oldincludedir@
+prefix		=	@prefix@
+sbindir		=	@sbindir@
+sharedstatedir	=	@sharedstatedir@
+srcdir		=	@srcdir@
+sysconfdir	=	@sysconfdir@
+top_srcdir	=	@top_srcdir@
+
+BUILDROOT	=	$(DSTROOT)$(RPM_BUILD_ROOT)$(DESTDIR)
+
+
+# Build commands...
+.SUFFIXES:	.c .h .o
+.c.o:
+	echo Compiling $<...
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+
+# Files
+PUBHEADERS	=	\
+			pdfio.h \
+			pdfio-content.h
+PUBOBJS		=	\
+			pdfio-aes.o \
+			pdfio-array.o \
+			pdfio-common.o \
+			pdfio-content.o \
+			pdfio-crypto.o \
+			pdfio-dict.o \
+			pdfio-file.o \
+			pdfio-md5.o \
+			pdfio-object.o \
+			pdfio-page.o \
+			pdfio-rc4.o \
+			pdfio-sha256.o \
+			pdfio-stream.o \
+			pdfio-string.o \
+			pdfio-token.o \
+			pdfio-value.o
+LIBOBJS		=	\
+			$(PUBOBJS) \
+			ttf.o
+OBJS		=	\
+			$(LIBOBJS) \
+			pdfiototext.o \
+			testpdfio.o \
+			testttf.o
+TARGETS		=	\
+			$(LIBPDFIO) \
+			$(LIBPDFIO_STATIC) \
+			pdfiototext \
+			testpdfio \
+			testttf
+
+
+# Make everything
+all:		$(TARGETS)
+
+
+# Clean everything
+clean:
+	rm -f $(TARGETS) $(OBJS)
+
+
+# Install everything
+install:	$(TARGETS)
+	echo Installing header files to $(BUILDROOT)$(includedir)...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(includedir)
+	for file in $(PUBHEADERS); do \
+		$(INSTALL) -c -m 644 $$file $(BUILDROOT)$(includedir); \
+	done
+	echo Installing library files to $(BUILDROOT)$(libdir)...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(libdir)
+	if test "x$(LIBPDFIO_STATIC)" != x; then \
+		$(INSTALL) -c -m 644 $(LIBPDFIO_STATIC) $(BUILDROOT)$(libdir); \
+		$(RANLIB) $(BUILDROOT)$(libdir)/$(LIBPDFIO_STATIC); \
+	fi
+	if test "x$(LIBPDFIO)" = xlibpdfio.so.1; then \
+		$(INSTALL) -c -m 755 libpdfio.so.1 $(BUILDROOT)$(libdir); \
+		ln -sf libpdfio.so.1 $(BUILDROOT)$(libdir)/libpdfio.so; \
+	elif test "x$(LIBPDFIO)" = xlibpdfio.1.dylib; then \
+		$(INSTALL) -c -m 755 libpdfio.1.dylib $(BUILDROOT)$(libdir); \
+		codesign -s "$(CODESIGN_IDENTITY)" -o runtime --timestamp $(BUILDROOT)$(libdir)/libpdfio.1.dylib; \
+		ln -sf libpdfio.1.dylib $(BUILDROOT)$(libdir)/libpdfio.dylib; \
+	else \
+		$(INSTALL) -c -m 644 $(LIBPDFIO) $(BUILDROOT)$(libdir); \
+		$(RANLIB) $(BUILDROOT)$(libdir)/$(LIBPDFIO); \
+	fi
+	echo Installing pkg-config files to $(BUILDROOT)$(libdir)/pkgconfig...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(libdir)/pkgconfig
+	$(INSTALL) -c -m 644 pdfio.pc $(BUILDROOT)$(libdir)/pkgconfig
+	echo Installing documentation to $(BUILDROOT)$(datadir)/doc/pdfio...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(datadir)/doc/pdfio
+	for file in doc/pdfio.html doc/pdfio-512.png LICENSE NOTICE; do \
+		$(INSTALL) -c -m 644  $$file $(BUILDROOT)$(datadir)/doc/pdfio; \
+	done
+	echo Installing man page to $(BUILDROOT)$(mandir)/man3...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(mandir)/man3
+	$(INSTALL) -c -m 644 doc/pdfio.3 $(BUILDROOT)$(mandir)/man3
+
+
+# Test everything
+test:	testpdfio testttf
+	./testttf 2>test.log
+	./testpdfio 2>>test.log
+	LANG=fr_FR.UTF-8 ./testpdfio 2>>test.log
+
+
+valgrind:	testpdfio
+	valgrind --leak-check=full ./testpdfio
+
+
+# pdfio library
+libpdfio.a:		$(LIBOBJS)
+	echo Archiving $@...
+	$(RM) $@
+	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
+	$(RANLIB) $@
+
+libpdfio.so.1:		$(LIBOBJS)
+	echo Linking $@...
+	$(CC) $(DSOFLAGS) -shared -o $@ -Wl,-soname,$@ $(LIBOBJS) $(LIBS)
+
+libpdfio.1.dylib:	$(LIBOBJS)
+	echo Linking $@...
+	$(CC) $(DSOFLAGS) -dynamiclib -o $@ -install_name $(libdir)/$@ -current_version $(PDFIO_VERSION_MAJOR).$(PDFIO_VERSION_MINOR) -compatibility_version 1.0 $(LIBOBJS) $(LIBS)
+
+
+# pdfio1.def (Windows DLL exports file...)
+#
+# I'd love to use __declspec(dllexport) but MS puts it before the function
+# declaration instead of after like everyone else, and it breaks Codedoc and
+# other tools I rely on...
+pdfio1.def: $(LIBOBJS) Makefile
+	echo Generating $@...
+	echo "LIBRARY pdfio1" >$@
+	echo "VERSION $(PDFIO_VERSION_MAJOR).$(PDFIO_VERSION_MINOR)" >>$@
+	echo "EXPORTS" >>$@
+	nm $(LIBOBJS) 2>/dev/null | grep "T _" | awk '{print $$3}' | \
+		grep -v '^_ttf' | sed -e '1,$$s/^_//' | sort >>$@
+
+
+# pdfio text extraction (demo, doesn't handle a lot of things yet)
+pdfiototext:		pdfiototext.o libpdfio.a
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ pdfiototext.o libpdfio.a $(LIBS)
+
+
+# pdfio test program
+testpdfio:		testpdfio.o libpdfio.a
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ testpdfio.o libpdfio.a $(LIBS)
+
+
+# TTF test program
+testttf:	ttf.o testttf.o
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o testttf ttf.o testttf.o $(LIBS)
+
+
+# Dependencies
+$(OBJS):		pdfio.h pdfio-private.h Makefile
+pdfio-content.o:	pdfio-content.h ttf.h
+testttf.o:		ttf.h
+ttf.o:			ttf.h
+
+
+# Make documentation using Codedoc <https://www.msweet.org/codedoc>
+DOCFLAGS	=	\
+			--author "Michael R Sweet" \
+			--copyright "Copyright (c) 2021-2024 by Michael R Sweet" \
+			--docversion $(PDFIO_VERSION)
+
+.PHONY: doc
+doc:
+	echo Generating documentation...
+	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(PDFIO_VERSION)" $(PUBHEADERS) $(PUBOBJS:.o=.c) --body doc/pdfio.md --coverimage doc/pdfio-512.png pdfio.xml >doc/pdfio.html
+	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(PDFIO_VERSION)" --body doc/pdfio.md --coverimage doc/pdfio-epub.png pdfio.xml --epub doc/pdfio.epub
+	codedoc $(DOCFLAGS) --title "pdf read/write library" --man pdfio --section 3 --body doc/pdfio.md pdfio.xml >doc/pdfio.3
+	rm -f pdfio.xml
+
+
+# Fuzz-test the library <https://lcamtuf.coredump.cx/afl/>
+.PHONY: afl
+afl:
+	$(MAKE) -$(MAKEFLAGS) CC="afl-clang-fast" COMMONFLAGS="-g" clean all
+	test afl-output || rm -rf afl-output
+	afl-fuzz -x afl-pdf.dict -i afl-input -o afl-output -V 600 -e pdf -t 5000 ./testpdfio @@
+
+
+# Analyze code with the Clang static analyzer <https://clang-analyzer.llvm.org>
+clang:
+	clang $(CPPFLAGS) --analyze $(OBJS:.o=.c) 2>clang.log
+	rm -rf $(OBJS:.o=.plist)
+	test -s clang.log && (echo "$(GHA_ERROR)Clang detected issues."; echo ""; cat clang.log; exit 1) || exit 0
+
+
+# Analyze code using Cppcheck <http://cppcheck.sourceforge.net>
+cppcheck:
+	cppcheck $(CPPFLAGS) --template=gcc --addon=cert.py --suppressions-list=.cppcheck $(OBJS:.o=.c) 2>cppcheck.log
+	test -s cppcheck.log && (echo "$(GHA_ERROR)Cppcheck detected issues."; echo ""; cat cppcheck.log; exit 1) || exit 0

NOTICE

@@ -1,6 +1,6 @@
 PDFio - PDF Read/Write Library
 
-Copyright © 2021 by Michael R Sweet.
+Copyright © 2021-2024 by Michael R Sweet.
 
 (Optional) Exceptions to the Apache 2.0 License:
 ================================================

README.md

@@ -3,18 +3,15 @@ pdfio - PDF Read/Write Library
 
 ![Version](https://img.shields.io/github/v/release/michaelrsweet/pdfio?include_prereleases)
 ![Apache 2.0](https://img.shields.io/github/license/michaelrsweet/pdfio)
-![Build](https://github.com/michaelrsweet/pdfio/workflows/Build/badge.svg)
+[![Build Status](https://img.shields.io/github/workflow/status/michaelrsweet/pdfio/Build)](https://github.com/michaelrsweet/pdfio/actions/workflows/build.yml)
 [![Coverity Scan Status](https://img.shields.io/coverity/scan/22385.svg)](https://scan.coverity.com/projects/michaelrsweet-pdfio)
-[![LGTM Grade](https://img.shields.io/lgtm/grade/cpp/github/michaelrsweet/pdfio)](https://lgtm.com/projects/g/michaelrsweet/pdfio/context:cpp)
-[![LGTM Alerts](https://img.shields.io/lgtm/alerts/github/michaelrsweet/pdfio)](https://lgtm.com/projects/g/michaelrsweet/pdfio/)
 
 PDFio is a simple C library for reading and writing PDF files.  The primary
 goals of PDFio are:
 
 - Read and write any version of PDF file
 - Provide access to pages, objects, and streams within a PDF file
-- Support reading encrypted PDF files
-- Support writing PDF files with digital signatures
+- Support reading and writing of encrypted PDF files
 - Extract or embed useful metadata (author, creator, page information, etc.)
 - "Filter" PDF files, for example to extract a range of pages or to embed fonts
   that are missing from a PDF
@@ -31,7 +28,7 @@ PDFio requires the following to build the software:
 
 - A C99 compiler such as Clang, GCC, or MS Visual C
 - A POSIX-compliant `make` program
-- ZLIB (<https://www.zlib.net>) 1.0 or higher
+- ZLIB (<https://www.zlib.net>) 1.1 or higher
 
 IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 
@@ -39,15 +36,27 @@ IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 Documentation
 -------------
 
-See the man page (`pdfio.3`), frequently ask questions (`FAQ.md`), and full HTML
-documentation (`pdfio.html`) for information on using PDFio.
+See the man page (`pdfio.3`) and full HTML documentation (`pdfio.html`) for
+information on using PDFio.
 
 
-Installing pdfio
+Installing PDFio
 ----------------
 
-PDFio comes with a portable makefile that will work on any POSIX-compliant
-system with ZLIB installed.  To make it, run:
+PDFio uses a configure script on Unix systems to generate a makefile:
+
+    ./configure
+
+If you want a shared library, run:
+
+    ./configure --enable-shared
+
+The default installation location is "/usr/local".  Pass the `--prefix` option
+to make to install it to another location:
+
+    ./configure --prefix=/some/other/directory
+
+Once configured, run the following to make the library:
 
     make all
 
@@ -57,53 +66,15 @@ To test it, run:
 
 To install it, run:
 
-    make install
-
-If you want a shared library, run:
-
-    make all-shared
-    make install-shared
-
-The default installation location is "/usr/local".  Pass the `prefix` variable
-to make to install it to another location:
-
-    make install prefix=/some/other/directory
-
-The makefile installs the pdfio header to "${prefix}/include", the library to
-"${prefix}/lib", the `pkg-config` file to "${prefix}/lib/pkgconfig", the man
-page to "${prefix}/share/man/man3", and the documentation to
-"${prefix}/share/doc/pdfio".
-
-The makefile supports the following variables that can be specified in the make
-command or as environment variables:
-
-- `AR`: the library archiver (default "ar")
-- `ARFLAGS`: options for the library archiver (default "cr")
-- `CC`: the C compiler (default "cc")
-- `CFLAGS`: options for the C compiler (default "")
-- `CODESIGN_IDENTITY`: the identity to use when code signing the shared library
-  on macOS (default "Developer ID")
-- `COMMONFLAGS`: options for the C compiler and linker (typically architecture
-  and optimization options, default is "-Os -g")
-- `CPPFLAGS`: options for the C preprocessor (default "")
-- `DESTDIR` and `DSTROOT`: specifies a root directory when installing
-  (default is "", specify only one)
-- `DSOFLAGS`: options for the C compiler when linking the shared library
-  (default "")
-- `LDFLAGS`: options for the C compiler when linking the test programs
-  (default "")
-- `LIBS`: library options when linking the test programs (default "-lz")
-- `RANLIB`: program that generates a table-of-contents in a library
-  (default "ranlib")
-- `prefix`: specifies the installation directory (default "/usr/local")
+    sudo make install
 
 
 Visual Studio Project
 ---------------------
 
 The Visual Studio solution ("pdfio.sln") is provided for Windows developers and
-generates both a static library and DLL.  You can also use NuGet to install the
-`pdfio_native` package.
+generates the PDFIO1 DLL.  You can also use NuGet to install the `pdfio_native`
+package.
 
 
 Xcode Project
@@ -114,15 +85,11 @@ generates a static library that will be installed under "/usr/local" with:
 
     sudo xcodebuild install
 
-You can reproduce this with the makefile using:
-
-    sudo make 'COMMONFLAGS="-Os -mmacosx-version-min=10.14 -arch x86_64 -arch arm64"' install
-
 
 Legal Stuff
 -----------
 
-PDFio is Copyright © 2021 by Michael R Sweet.
+PDFio is Copyright © 2021-2024 by Michael R Sweet.
 
 This software is licensed under the Apache License Version 2.0 with an
 (optional) exception to allow linking against GPL2/LGPL2 software.  See the

SECURITY.md

@@ -0,0 +1,132 @@
+Security Policy
+===============
+
+This file describes how security issues are reported and handled, and what the
+expectations are for security issues reported to this project.
+
+
+Reporting a Security Bug
+------------------------
+
+For the purposes of this project, a security bug is a software defect that
+allows a *local or remote user* to gain unauthorized access or privileges on the
+host computer or to cause the software to crash.  Such defects should be
+reported to the project security advisory page at
+<https://github.com/michaelrsweet/pdfio/security/advisories>.
+
+Alternately, security bugs can be reported to "security AT msweet.org" using the
+PGP public key below.  Expect a response within 5 business days.  Any proposed
+embargo date should be at least 30 days and no more than 90 days in the future.
+
+> *Note:* If you've found a software defect that allows a *program* to gain
+> unauthorized access or privileges on the host computer or causes the program
+> to crash, that defect should be reported as an ordinary project issue at
+> <https://github.com/michaelrsweet/pdfio/issues>.
+
+
+Responsible Disclosure
+----------------------
+
+With *responsible disclosure*, a security issue (and its fix) is disclosed only
+after a mutually-agreed period of time (the "embargo date").  The issue and fix
+are shared amongst and reviewed by the key stakeholders (Linux distributions,
+OS vendors, etc.) and the CERT/CC.  Fixes are released to the public on the
+agreed-upon date.
+
+> Responsible disclosure applies only to production releases.  A security
+> vulnerability that only affects unreleased code can be fixed immediately
+> without coordination.  Vendors *should not* package and release unstable
+> snapshots, beta releases, or release candidates of this software.
+
+
+Supported Versions
+------------------
+
+All production releases of this software are subject to this security policy.  A
+production release is tagged and given a semantic version number of the form:
+
+    MAJOR.MINOR.PATCH
+
+where "MAJOR" is an integer starting at 1 and "MINOR" and "PATCH" are integers
+starting at 0.  A feature release has a "PATCH" value of 0, for example:
+
+    1.0.0
+    1.1.0
+    2.0.0
+
+Beta releases and release candidates are *not* production releases and use
+semantic version numbers of the form:
+
+    MAJOR.MINORbNUMBER
+    MAJOR.MINORrcNUMBER
+
+where "MAJOR" and "MINOR" identify the new feature release version number and
+"NUMBER" identifies a beta or release candidate number starting at 1, for
+example:
+
+    1.0b1
+    1.0b2
+    1.0rc1
+
+
+PGP Public Key
+--------------
+
+The following PGP public key can be used for signing security messages.
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Comment: GPGTools - https://gpgtools.org
+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+=0GzT
+-----END PGP PUBLIC KEY BLOCK-----
+```

afl-input/PDFBOX-1037-0.pdf

@@ -0,0 +1,55 @@
+%PDF-1.3
+1 0 obj<</Type/Catalog/Pages 5 0 R>>
+endobj
+3 0 obj<</ModDate(D:20110505091515-05'00')/CreationDate(2011/05/05 09:15)/Creator(PaperPort 11.0)/Producer(PaperPort 11.0)/Subject()/Author()/Keywords()/Title()>>
+endobj
+4 0 obj<</Type/Page/MediaBox[0 0 622.0799 756]/Parent 5 0 R/CropBox[0 0 622.0799 756]/Contents 7 0 R/Resources<</ProcSet[/PDF/Text/ImageB/ImageC/ImageI]/XObject<</Z_Im0 6 0 R>>>>>>
+endobj
+5 0 obj<</Count 1/Type/Pages/Kids[ 4 0 R]>>
+endobj
+6 0 obj<</Type/XObject/Subtype/Image/Name/XImg/Width 1728/Height 2100/BitsPerComponent 1/ColorSpace/DeviceGray/Intent//Filter[/CCITTFaxDecode]/DecodeParms[<</Colors 1/Columns 1728/Rows 2100/K -1>>]/Length 81592>>stream
+endstream
+endobj
+7 0 obj<</Length 72>>stream
+q
+622.07996 0 0 756 0 0 cm 
+0 g
+[]0 d 1 w 10 M 0 i 0 J 0 j 
+/Z_Im0 Do
+Q
+
+endstream
+endobj
+xref
+0 8
+0000000002 65535 f 
+0000000010 00000 n 
+0000000000 00000 f 
+0000000054 00000 n 
+0000000224 00000 n 
+0000000412 00000 n 
+0000000463 00000 n 
+0000082294 00000 n 
+trailer
+<</Size 8/Info 3 0 R/Root 1 0 R/ID[<c48c2a5922382dc456a05f8e3ccbb9f8><94a076a2f82a754598b70200e827ac8b>]>>
+startxref
+82414
+%%EOF
+%PaperPortPDFversion3 0 obj<</ModDate(D:20110505091515-05'00')/CreationDate(2011/05/05 09:15)/Creator(PaperPort 11.0)/Producer(PaperPort 11.0)/Subject()/Author()/Keywords()/Title()>>
+endobj
+5 0 obj<</Count 2/Type/Pages/Kids[ 4 0 R 8 0 R]>>
+endobj
+8 0 obj<</Type/Page/MediaBox[0 0 622.0799 757.4399]/Parent 5 0 R/CropBox[0 0 622.0799 757.4399]/Contents 10 0 R/Resources<</ProcSet[/PDF/Text/ImageB/ImageC/ImageI]/XObject<</Z_Im0 9 0 R>>>>>>
+endobj
+9 0 obj<</Type/XObject/Subtype/Image/Name/XImg/Width 1728/Height 2104/BitsPerComponent 1/ColorSpace/DeviceGray/Intent//Filter[/CCITTFaxDecode]/DecodeParms[<</Colors 1/Columns 1728/Rows 2104/K -1>>]/Length 78404>>stream
+endstream
+endobj
+10 0 obj<</Length 78>>stream
+q
+622.07996 0 0 757.44001 0 0 cm 
+0 g
+[]0 d 1 w 10 M 0 i 0 J 0 j 
+/Z_Im0 Do
+Q
+
+endstream

configure.ac

@@ -0,0 +1,273 @@
+dnl
+dnl Configuration script for PDFio
+dnl
+dnl Copyright © 2023-2024 by Michael R Sweet
+dnl
+dnl Licensed under Apache License v2.0.  See the file "LICENSE" for more
+dnl information.
+dnl
+
+dnl ***********************************************************************
+dnl
+dnl Note: Using autoheader or automake on this project will break the PDFio
+dnl build system.  Use "autoconf -f" to regenerate the configure script if
+dnl you make changes to this file.
+dnl
+dnl ***********************************************************************
+
+
+dnl We need at least autoconf 2.70 for --runstatedir...
+AC_PREREQ([2.70])
+
+
+dnl Package name and version...
+AC_INIT([pdfio], [1.3.2], [https://github.com/michaelrsweet/pdfio/issues], [pdfio], [https://www.msweet.org/pdfio])
+
+PDFIO_VERSION="AC_PACKAGE_VERSION"
+PDFIO_VERSION_MAJOR="`echo AC_PACKAGE_VERSION | awk -F. '{print $1}'`"
+PDFIO_VERSION_MINOR="`echo AC_PACKAGE_VERSION | awk -F. '{printf("%d\n",$2);}'`"
+AC_SUBST([PDFIO_VERSION])
+AC_SUBST([PDFIO_VERSION_MAJOR])
+AC_SUBST([PDFIO_VERSION_MINOR])
+
+
+dnl This line is provided to ensure that you don't run the autoheader program
+dnl against this project.  Doing so is completely unsupported and WILL cause
+dnl problems!
+AH_TOP([#error "Somebody ran autoheader on this project which is unsupported and WILL cause problems."])
+
+
+dnl Get the build and host platforms and split the host_os value
+AC_CANONICAL_BUILD
+AC_CANONICAL_HOST
+
+[host_os_name="$(echo $host_os | sed -e '1,$s/[0-9.]*$//g')"]
+[host_os_version="$(echo $host_os | sed -e '1,$s/^[^0-9.]*//g' | awk -F. '{print $1 $2}')"]
+# Linux often does not yield an OS version we can use...
+AS_IF([test "x$host_os_version" = x], [
+    host_os_version="0"
+])
+
+
+dnl Compiler options...
+CFLAGS="${CFLAGS:=}"
+CPPFLAGS="${CPPFLAGS:=}"
+DSOFLAGS="${DSOFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+LIBS="${LIBS:=}"
+OPTIM="${OPTIM:=}"
+
+AC_SUBST([DSOFLAGS])
+AC_SUBST([OPTIM])
+
+
+dnl Standard programs...
+AC_PROG_CC
+AC_PROG_RANLIB
+AC_PATH_PROG([AR], [ar])
+AC_PATH_PROGS([CODE_SIGN], [codesign true])
+AC_PATH_PROG([MKDIR], [mkdir])
+AC_PATH_PROG([RM], [rm])
+AC_PATH_PROG([RMDIR], [rmdir])
+AC_PATH_PROG([LN], [ln])
+
+
+dnl Figure out the correct "ar" command flags...
+AS_IF([test "$ac_cv_prog_ranlib" = ":"], [
+    ARFLAGS="crs"
+], [
+    ARFLAGS="cr"
+])
+AC_SUBST([ARFLAGS])
+
+
+dnl install-sh
+AC_MSG_CHECKING([for install-sh script])
+INSTALL="$(pwd)/install-sh"
+AC_SUBST([INSTALL])
+AC_MSG_RESULT([using $INSTALL])
+
+
+dnl Check for pkg-config, which is used for some other tests later on...
+AC_PATH_TOOL([PKGCONFIG], [pkg-config])
+
+PKGCONFIG_CFLAGS="-I\${includedir}"
+PKGCONFIG_LIBS="-L\${libdir} -lpdfio"
+PKGCONFIG_LIBS_PRIVATE="-lm"
+PKGCONFIG_REQUIRES="zlib"
+AC_SUBST([PKGCONFIG_CFLAGS])
+AC_SUBST([PKGCONFIG_LIBS])
+AC_SUBST([PKGCONFIG_LIBS_PRIVATE])
+AC_SUBST([PKGCONFIG_REQUIRES])
+
+
+dnl ZLIB
+AC_MSG_CHECKING([for zlib via pkg-config])
+AS_IF([$PKGCONFIG --exists zlib], [
+    AC_MSG_RESULT([yes])
+    CPPFLAGS="$($PKGCONFIG --cflags zlib) $CPPFLAGS"
+    LIBS="$($PKGCONFIG --libs zlib) $LIBS"
+],[
+    AC_MSG_RESULT([no])
+    AC_CHECK_HEADER([zlib.h])
+    AC_CHECK_LIB([z], [inflateCopy])
+
+    AS_IF([test x$ac_cv_header_zlib_h != xyes -o x$ac_cv_lib_z_inflateCopy != xyes], [
+	AC_MSG_ERROR([Sorry, this software requires zlib 1.1 or higher.])
+    ])
+
+    PKGCONFIG_REQUIRES=""
+    PKGCONFIG_LIBS_PRIVATE="-lz $PKGCONFIG_LIBS_PRIVATE"
+])
+
+
+dnl Library target...
+AC_ARG_ENABLE([static], AS_HELP_STRING([--disable-static], [do not install static library]))
+AC_ARG_ENABLE([shared], AS_HELP_STRING([--enable-shared], [install shared library]))
+
+AS_IF([test x$enable_shared = xyes], [
+    AS_IF([test "$host_os_name" = darwin], [
+	LIBPDFIO="libpdfio.1.dylib"
+    ], [
+	LIBPDFIO="libpdfio.so.1"
+    ])
+
+    AS_IF([test x$enable_static != xno], [
+        LIBPDFIO_STATIC="libpdfio.a"
+    ], [
+	LIBPDFIO_STATIC=""
+    ])
+], [
+    LIBPDFIO="libpdfio.a"
+    LIBPDFIO_STATIC=""
+    PKGCONFIG_LIBS="$PKGCONFIG_LIBS $PKGCONFIG_LIBS_PRIVATE"
+    PKGCONFIG_LIBS_PRIVATE=""
+])
+
+AC_SUBST([LIBPDFIO])
+AC_SUBST([LIBPDFIO_STATIC])
+
+
+dnl Extra compiler options...
+AC_ARG_ENABLE([debug], AS_HELP_STRING([--enable-debug], [turn on debugging, default=no]))
+AC_ARG_ENABLE([maintainer], AS_HELP_STRING([--enable-maintainer], [turn on maintainer mode, default=no]))
+AC_ARG_ENABLE([sanitizer], AS_HELP_STRING([--enable-sanitizer], [build with AddressSanitizer, default=no]))
+
+AS_IF([test x$enable_debug = xyes], [
+    OPTIM="$OPTIM -g"
+    CSFLAGS=""
+], [
+    OPTIM="$OPTIM -g -Os"
+    CSFLAGS="-o runtime"
+])
+
+AC_SUBST([CSFLAGS])
+
+WARNINGS=""
+AC_SUBST([WARNINGS])
+
+AS_IF([test -n "$GCC"], [
+    AS_IF([test x$enable_sanitizer = xyes], [
+	# Use -fsanitize=address with debugging...
+	OPTIM="$OPTIM -fsanitize=address"
+    ], [
+	# Otherwise use the Fortify enhancements to catch any unbounded
+	# string operations...
+	CPPFLAGS="$CPPFLAGS -D_FORTIFY_SOURCE=2"
+    ])
+
+    dnl Show all standard warnings + unused variables when compiling...
+    WARNINGS="-Wall -Wunused"
+
+    dnl Drop some not-useful/unreliable warnings...
+    for warning in char-subscripts format-truncation format-y2k switch unused-result; do
+	AC_MSG_CHECKING([whether compiler supports -Wno-$warning])
+
+	OLDCFLAGS="$CFLAGS"
+	CFLAGS="$CFLAGS -Wno-$warning -Werror"
+
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [
+	    AC_MSG_RESULT(yes)
+	    WARNINGS="$WARNINGS -Wno-$warning"
+        ], [
+	    AC_MSG_RESULT(no)
+	])
+
+	CFLAGS="$OLDCFLAGS"
+    done
+
+    dnl Maintainer mode enables -Werror...
+    AS_IF([test x$enable_maintainer = xyes], [
+	WARNINGS="$WARNINGS -Werror -Wno-error=deprecated"
+    ])
+
+    dnl See if PIE options are supported...
+    AC_MSG_CHECKING(whether compiler supports -fPIE)
+    OLDCFLAGS="$CFLAGS"
+    AS_CASE(["$host_os_name"],
+    [darwin*], [
+	CFLAGS="$CFLAGS -fPIC -fPIE -Wl,-pie"
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[
+	    OLDCFLAGS="-fPIC $OLDCFLAGS"
+	    LDFLAGS="-fPIE -Wl,-pie $LDFLAGS"
+	    AC_MSG_RESULT(yes)
+	],[
+	    AC_MSG_RESULT(no)
+	])
+    ], [*], [
+	CFLAGS="$CFLAGS -fPIC -fPIE -pie"
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[
+	    OLDCFLAGS="-fPIC $OLDCFLAGS"
+	    LDFLAGS="-fPIE -pie $LDFLAGS"
+	    AC_MSG_RESULT(yes)
+	],[
+	    AC_MSG_RESULT(no)
+	])
+    ])
+    CFLAGS="$OLDCFLAGS"
+
+    dnl OS-specific compiler options...
+    AC_MSG_CHECKING([for OS-specific compiler options])
+    AS_CASE(["$host_os_name"], [linux*], [
+    	# Make sure we get the full set of 64-bit Linux APIs from the headers...
+	CPPFLAGS="$CPPFLAGS -D__USE_MISC -D_GNU_SOURCE -D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64"
+
+	# Mark read-only sections as relocatable to random addresses...
+	LDFLAGS="$LDFLAGS -Wl,-z,relro,-z,now"
+
+        AC_MSG_RESULT([-D__USE_MISC -D_GNU_SOURCE -D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64 -Wl,-z,relro,-z,now])
+    ], [darwin*], [
+        # When not building for debug, target macOS 11 or later, "universal"
+        # binaries when possible...
+        AS_IF([echo "$CPPFLAGS $CFLAGS $LDFLAGS $OPTIM" | grep -q "\\-arch "], [
+            # Don't add architecture/min-version flags if they are already present
+            AC_MSG_RESULT([none])
+        ], [echo "$CPPFLAGS $CFLAGS $LDFLAGS $OPTIM" | grep -q "\\-mmacosx-version-"], [
+            # Don't add architecture/min-version flags if they are already present
+            AC_MSG_RESULT([none])
+        ], [test "$host_os_version" -ge 200 -a x$enable_debug != xyes], [
+	    # macOS 11.0 and higher support the Apple Silicon (arm64) CPUs
+	    OPTIM="$OPTIM -mmacosx-version-min=11.0 -arch x86_64 -arch arm64"
+            AC_MSG_RESULT([-mmacosx-version-min=11.0 -arch x86_64 -arch arm64])
+	], [
+	    # Don't add architecture/min-version flags if debug enabled
+            AC_MSG_RESULT([none])
+	])
+    ], [*], [
+        AC_MSG_RESULT([none])
+    ])
+])
+
+
+dnl Extra linker options...
+AC_ARG_WITH([dsoflags], AS_HELP_STRING([--with-dsoflags=...], [Specify additional DSOFLAGS]), [
+    DSOFLAGS="$withval $DSOFLAGS"
+])
+AC_ARG_WITH([ldflags], AS_HELP_STRING([--with-ldflags=...], [Specify additional LDFLAGS]), [
+    LDFLAGS="$withval $LDFLAGS"
+])
+
+
+dnl Generate the Makefile and pkg-config file...
+AC_CONFIG_FILES([Makefile pdfio.pc])
+AC_OUTPUT

doc/pdfio.md

@@ -4,8 +4,9 @@ Introduction
 PDFio is a simple C library for reading and writing PDF files.  The primary
 goals of pdfio are:
 
-- Read any PDF file with or without encryption or linearization
-- Write PDF files without encryption or linearization
+- Read and write any version of PDF file
+- Provide access to pages, objects, and streams within a PDF file
+- Support reading and writing of encrypted PDF files
 - Extract or embed useful metadata (author, creator, page information, etc.)
 - "Filter" PDF files, for example to extract a range of pages or to embed fonts
   that are missing from a PDF
@@ -14,8 +15,8 @@ goals of pdfio are:
 PDFio is *not* concerned with rendering or viewing a PDF file, although a PDF
 RIP or viewer could be written using it.
 
-PDFio is Copyright © 2021 by Michael R Sweet and is licensed under the Apache
-License Version 2.0 with an (optional) exception to allow linking against
+PDFio is Copyright © 2021-2024 by Michael R Sweet and is licensed under the
+Apache License Version 2.0 with an (optional) exception to allow linking against
 GPL2/LGPL2 software.  See the files "LICENSE" and "NOTICE" for more information.
 
 
@@ -26,6 +27,7 @@ PDFio requires the following to build the software:
 
 - A C99 compiler such as Clang, GCC, or MS Visual C
 - A POSIX-compliant `make` program
+- A POSIX-compliant `sh` program
 - ZLIB (<https://www.zlib.net>) 1.0 or higher
 
 IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
@@ -34,10 +36,11 @@ IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 Installing pdfio
 ----------------
 
-PDFio comes with a portable makefile that will work on any POSIX-compliant
-system with ZLIB installed.  To make it, run:
+PDFio comes with a configure script that creates a portable makefile that will
+work on any POSIX-compliant system with ZLIB installed.  To make it, run:
 
-    make all
+    ./configure
+    make
 
 To test it, run:
 
@@ -45,45 +48,22 @@ To test it, run:
 
 To install it, run:
 
-    make install
+    sudo make install
 
 If you want a shared library, run:
 
-    make all-shared
-    make install-shared
+    ./configure --enable-shared
+    make
+    sudo make install
 
-The default installation location is "/usr/local".  Pass the `prefix` variable
+The default installation location is "/usr/local".  Pass the `--prefix` option
 to make to install it to another location:
 
-    make install prefix=/some/other/directory
+    ./configure --prefix=/some/other/directory
 
-The makefile installs the pdfio header to "${prefix}/include", the library to
-"${prefix}/lib", the `pkg-config` file to "${prefix}/lib/pkgconfig", the man
-page to "${prefix}/share/man/man3", and the documentation to
-"${prefix}/share/doc/pdfio".
+Other configure options can be found using the `--help` option:
 
-The makefile supports the following variables that can be specified in the make
-command or as environment variables:
-
-- `AR`: the library archiver (default "ar")
-- `ARFLAGS`: options for the library archiver (default "cr")
-- `CC`: the C compiler (default "cc")
-- `CFLAGS`: options for the C compiler (default "")
-- `CODESIGN_IDENTITY`: the identity to use when code signing the shared library
-  on macOS (default "Developer ID")
-- `COMMONFLAGS`: options for the C compiler and linker (typically architecture
-  and optimization options, default is "-Os -g")
-- `CPPFLAGS`: options for the C preprocessor (default "")
-- `DESTDIR` and `DSTROOT`: specifies a root directory when installing
-  (default is "", specify only one)
-- `DSOFLAGS`: options for the C compiler when linking the shared library
-  (default "")
-- `LDFLAGS`: options for the C compiler when linking the test programs
-  (default "")
-- `LIBS`: library options when linking the test programs (default "-lz")
-- `RANLIB`: program that generates a table-of-contents in a library
-  (default "ranlib")
-- `prefix`: specifies the installation directory (default "/usr/local")
+    ./configure --help
 
 
 Visual Studio Project
@@ -101,10 +81,6 @@ generates a static library that will be installed under "/usr/local" with:
 
     sudo xcodebuild install
 
-You can reproduce this with the makefile using:
-
-    sudo make 'COMMONFLAGS="-Os -mmacosx-version-min=10.14 -arch x86_64 -arch arm64"' install
-
 
 Detecting PDFio
 ---------------
@@ -112,7 +88,7 @@ Detecting PDFio
 PDFio can be detected using the `pkg-config` command, for example:
 
     if pkg-config --exists pdfio; then
-        ... 
+        ...
     fi
 
 In a makefile you can add the necessary compiler and linker options with:
@@ -122,8 +98,9 @@ CFLAGS  +=      `pkg-config --cflags pdfio`
 LIBS    +=      `pkg-config --libs pdfio`
 ```
 
-On Windows, you need to link to the `PDFIO.LIB` (static) or `PDFIO1.LIB` (DLL)
-libraries and include the "zlib" NuGet package dependency.
+On Windows, you need to link to the `PDFIO1.LIB` (DLL) library and include the
+`zlib_native` NuGet package dependency.  You can also use the published
+`pdfio_native` NuGet package.
 
 
 Header Files
@@ -161,15 +138,32 @@ Reading PDF Files
 You open an existing PDF file using the [`pdfioFileOpen`](@@) function:
 
 ```c
-pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", error_cb, error_data);
+pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", password_cb, password_data,
+                                  error_cb, error_data);
 
 ```
 
-where the three arguments to the function are the filename ("myinputfile.pdf"),
-an optional error callback function (`error_cb`), and an optional pointer value
-for the error callback function (`error_data`).  The error callback is called
-for both errors and warnings and accepts the `pdfio_file_t` pointer, a message
-string, and the callback pointer value, for example:
+where the five arguments to the function are the filename ("myinputfile.pdf"),
+an optional password callback function (`password_cb`) and data pointer value
+(`password_data`), and an optional error callback function (`error_cb`) and data
+pointer value (`error_data`).  The password callback is called for encrypted PDF
+files that are not using the default password, for example:
+
+```c
+const char *
+password_cb(void *data, const char *filename)
+{
+  (void)data;     // This callback doesn't use the data pointer
+  (void)filename; // This callback doesn't use the filename
+
+  // Return a password string for the file...
+  return ("Password42");
+}
+```
+
+The error callback is called for both errors and warnings and accepts the
+`pdfio_file_t` pointer, a message string, and the callback pointer value, for
+example:
 
 ```c
 bool
@@ -207,7 +201,75 @@ for (i = 0, count = pdfioFileGetNumPages(pdf); i < count; i ++)
 Each page is represented by a "page tree" object (what [`pdfioFileGetPage`](@@)
 returns) that specifies information about the page and one or more "content"
 objects that contain the images, fonts, text, and graphics that appear on the
-page.
+page.  Use the [`pdfioPageGetNumStreams`](@@) and [`pdfioPageOpenStream`](@@)
+functions to access the content streams for each page, and
+[`pdfioObjGetDict`](@@) to get the associated page object dictionary.  For
+example, if you want to display the media and crop boxes for a given page:
+
+```c
+pdfio_file_t  *pdf;             // PDF file
+size_t        i;                // Looping var
+size_t        count;            // Number of pages
+pdfio_obj_t   *page;            // Current page
+pdfio_dict_t  *dict;            // Current page dictionary
+pdfio_array_t *media_box;       // MediaBox array
+double        media_values[4];  // MediaBox values
+pdfio_array_t *crop_box;        // CropBox array
+double        crop_values[4];   // CropBox values
+
+// Iterate the pages in the PDF file
+for (i = 0, count = pdfioFileGetNumPages(pdf); i < count; i ++)
+{
+  page = pdfioFileGetPage(pdf, i);
+  dict = pdfioObjGetDict(page);
+
+  media_box       = pdfioDictGetArray(dict, "MediaBox");
+  media_values[0] = pdfioArrayGetNumber(media_box, 0);
+  media_values[1] = pdfioArrayGetNumber(media_box, 1);
+  media_values[2] = pdfioArrayGetNumber(media_box, 2);
+  media_values[3] = pdfioArrayGetNumber(media_box, 3);
+
+  crop_box       = pdfioDictGetArray(dict, "CropBox");
+  crop_values[0] = pdfioArrayGetNumber(crop_box, 0);
+  crop_values[1] = pdfioArrayGetNumber(crop_box, 1);
+  crop_values[2] = pdfioArrayGetNumber(crop_box, 2);
+  crop_values[3] = pdfioArrayGetNumber(crop_box, 3);
+
+  printf("Page %u: MediaBox=[%g %g %g %g], CropBox=[%g %g %g %g]\n",
+         (unsigned)(i + 1),
+         media_values[0], media_values[1], media_values[2], media_values[3],
+         crop_values[0], crop_values[1], crop_values[2], crop_values[3]);
+}
+```
+
+Page object dictionaries have several (mostly optional) key/value pairs,
+including:
+
+- "Annots": An array of annotation dictionaries for the page; use
+  [`pdfioDictGetArray`](@@) to get the array
+- "CropBox": The crop box as an array of four numbers for the left, bottom,
+  right, and top coordinates of the target media; use [`pdfioDictGetArray`](@@)
+  to get a pointer to the array of numbers
+- "Dur": The number of seconds the page should be displayed; use
+  [`pdfioDictGetNumber`](@@) to get the page duration value
+- "Group": The dictionary of transparency group values for the page; use
+  [`pdfioDictGetDict`](@@) to get a pointer to the resources dictionary
+- "LastModified": The date and time when this page was last modified; use
+  [`pdfioDictGetDate`](@@) to get the Unix `time_t` value
+- "Parent": The parent page tree node object for this page; use
+  [`pdfioDictGetObj`](@@) to get a pointer to the object
+- "MediaBox": The media box as an array of four numbers for the left, bottom,
+  right, and top coordinates of the target media; use [`pdfioDictGetArray`](@@)
+  to get a pointer to the array of numbers
+- "Resources": The dictionary of resources for the page; use
+  [`pdfioDictGetDict`](@@) to get a pointer to the resources dictionary
+- "Rotate": A number indicating the number of degrees of counter-clockwise
+  rotation to apply to the page when viewing; use [`pdfioDictGetNumber`](@@)
+  to get the rotation angle
+- "Thumb": A thumbnail image object for the page; use [`pdfioDictGetObj`](@@)
+  to get a pointer to the thumbnail image object
+- "Trans": The page transition dictionary; use [`pdfioDictGetDict`](@@) to get
+  a pointer to the dictionary
 
 The [`pdfioFileClose`](@@) function closes a PDF file and frees all memory that
 was used for it:
@@ -235,6 +297,16 @@ error callback function (`error_cb`), and an optional pointer value for the
 error callback function (`error_data`).  The units for the media and crop boxes
 are points (1/72nd of an inch).
 
+Alternately you can stream a PDF file using the [`pdfioFileCreateOutput`](@@)
+function:
+
+```c
+pdfio_rect_t media_box = { 0.0, 0.0, 612.0, 792.0 };  // US Letter
+pdfio_rect_t crop_box = { 36.0, 36.0, 576.0, 756.0 }; // w/0.5" margins
+
+pdfio_file_t *pdf = pdfioFileCreateOutput(output_cb, output_ctx, "2.0", &media_box, &crop_box, error_cb, error_data);
+```
+
 Once the file is created, use the [`pdfioFileCreateObj`](@@),
 [`pdfioFileCreatePage`](@@), and [`pdfioPageCopy`](@@) functions to create
 objects and pages in the file.
@@ -282,6 +354,15 @@ The first argument is the object pointer.  The second argument is a boolean
 value that specifies whether you want to decode (typically decompress) the
 stream data or return it as-is.
 
+When reading a page stream you'll use the [`pdfioPageOpenStream`](@@) function
+instead:
+
+```c
+pdfio_file_t *pdf = pdfioFileOpen(...);
+pdfio_obj_t *obj = pdfioFileGetPage(pdf, number);
+pdfio_stream_t *st = pdfioPageOpenStream(obj, 0, true);
+```
+
 Once you have the stream open, you can use one of several functions to read
 from it:
 
@@ -303,14 +384,23 @@ function:
 
 ```c
 pdfio_file_t *pdf = pdfioFileCreate(...);
-pdfio_obj_t *pdfioFileCreateObj(pdf, ...);
-pdfio_stream_t *pdfioObjCreateStream(obj, PDFIO_FILTER_FLATE);
+pdfio_obj_t *obj = pdfioFileCreateObj(pdf, ...);
+pdfio_stream_t *st = pdfioObjCreateStream(obj, PDFIO_FILTER_FLATE);
 ```
 
 The first argument is the newly created object.  The second argument is either
 `PDFIO_FILTER_NONE` to specify that any encoding is done by your program or
 `PDFIO_FILTER_FLATE` to specify that PDFio should Flate compress the stream.
 
+To create a page content stream call the [`pdfioFileCreatePage`](@@) function:
+
+```c
+pdfio_file_t *pdf = pdfioFileCreate(...);
+pdfio_dict_t *dict = pdfioDictCreate(pdf);
+... set page dictionary keys and values ...
+pdfio_stream_t *st = pdfioFileCreatePage(pdf, dict);
+```
+
 Once you have created the stream, use any of the following functions to write
 to the stream:
 
@@ -322,7 +412,7 @@ to the stream:
 The [PDF content helper functions](@) provide additional functions for writing
 specific PDF page stream commands.
 
-When you are done writing the stream, call [`pdfioStreamCLose`](@@) to close
+When you are done writing the stream, call [`pdfioStreamClose`](@@) to close
 both the stream and the object.
 
 
@@ -330,7 +420,7 @@ PDF Content Helper Functions
 ----------------------------
 
 PDFio includes many helper functions for embedding or writing specific kinds of
-content to a PDF file.  These functions can be roughly grouped into ???
+content to a PDF file.  These functions can be roughly grouped into five
 categories:
 
 - [Color Space Functions](@)
@@ -424,7 +514,7 @@ pdfio_obj_t *arial = pdfioFileCreateFontObjFromFile(pdf, "NotoSansJP-Regular.otf
 
 will embed the NotoSansJP Regular OpenType font with full support for Unicode.
 
-Note: Not all fonts support Unicode.
+> Note: Not all fonts support Unicode.
 
 
 ### Image Object Functions
@@ -553,9 +643,143 @@ escaping, as needed:
 - [`pdfioContentTextMoveLine`](@@) moves to the next line with an offset in a
   text block
 - [`pdfioContentTextMoveTo`](@@) moves within the current line in a text block
-- [`pdfioContentTextNextLine`](@@) moves to the beginning of the next line in a
+- [`pdfioContentTextNewLine`](@@) moves to the beginning of the next line in a
   text block
+- [`pdfioContentTextNewLineShow`](@@) moves to the beginning of the next line in a
+  text block and shows literal text with optional word and character spacing
+- [`pdfioContentTextNewLineShowf`](@@) moves to the beginning of the next line in a
+  text block and shows formatted text with optional word and character spacing
 - [`pdfioContentTextShow`](@@) draws a literal string in a text block
 - [`pdfioContentTextShowf`](@@) draws a formatted string in a text block
 - [`pdfioContentTextShowJustified`](@@) draws an array of literal strings with
   offsets between them
+
+
+Examples
+========
+
+Read PDF Metadata
+-----------------
+
+The following example function will open a PDF file and print the title, author,
+creation date, and number of pages:
+
+```c
+#include <pdfio.h>
+#include <time.h>
+
+
+void
+show_pdf_info(const char *filename)
+{
+  pdfio_file_t *pdf;
+  time_t       creation_date;
+  struct tm    *creation_tm;
+  char         creation_text[256];
+
+
+  // Open the PDF file with the default callbacks...
+  pdf = pdfioFileOpen(filename, /*password_cb*/NULL, /*password_cbdata*/NULL, /*error_cb*/NULL, /*error_cbdata*/NULL);
+  if (pdf == NULL)
+    return;
+
+  // Get the creation date and convert to a string...
+  creation_date = pdfioFileGetCreationDate(pdf);
+  creation_tm   = localtime(&creation_date);
+  strftime(creation_text, sizeof(creation_text), "%c", &creation_tm);
+
+  // Print file information to stdout...
+  printf("%s:\n", filename);
+  printf("         Title: %s\n", pdfioFileGetTitle(pdf));
+  printf("        Author: %s\n", pdfioFileGetAuthor(pdf));
+  printf("    Created On: %s\n", creation_text);
+  printf("  Number Pages: %u\n", (unsigned)pdfioFileGetNumPages(pdf));
+
+  // Close the PDF file...
+  pdfioFileClose(pdf);
+}
+```
+
+
+Create PDF File With Text and Image
+-----------------------------------
+
+The following example function will create a PDF file, embed a base font and the
+named JPEG or PNG image file, and then creates a page with the image centered on
+the page with the text centered below:
+
+```c
+#include <pdfio.h>
+#include <pdfio-content.h>
+#include <string.h>
+
+
+void
+create_pdf_image_file(const char *pdfname, const char *imagename, const char *caption)
+{
+  pdfio_file_t   *pdf;
+  pdfio_obj_t    *font;
+  pdfio_obj_t    *image;
+  pdfio_dict_t   *dict;
+  pdfio_stream_t *page;
+  double         width, height;
+  double         swidth, sheight;
+  double         tx, ty;
+
+
+  // Create the PDF file...
+  pdf = pdfioFileCreate(pdfname, /*version*/NULL, /*media_box*/NULL, /*crop_box*/NULL, /*error_cb*/NULL, /*error_cbdata*/NULL);
+
+  // Create a Courier base font for the caption
+  font = pdfioFileCreateFontObjFromBase(pdf, "Courier");
+
+  // Create an image object from the JPEG/PNG image file...
+  image = pdfioFileCreateImageObjFromFile(pdf, imagename, true);
+
+  // Create a page dictionary with the font and image...
+  dict = pdfioDictCreate(pdf);
+  pdfioPageDictAddFont(dict, "F1", font);
+  pdfioPageDictAddImage(dict, "IM1", image);
+
+  // Create the page and its content stream...
+  page = pdfioFileCreatePage(pdf, dict);
+
+  // Position and scale the image on the page...
+  width  = pdfioImageGetWidth(image);
+  height = pdfioImageGetHeight(image);
+
+  // Default media_box is "universal" 595.28x792 points (8.27x11in or 210x279mm)
+  // Use margins of 36 points (0.5in or 12.7mm) with another 36 points for the
+  // caption underneath...
+  swidth  = 595.28 - 72.0;
+  sheight = swidth * height / width;
+  if (sheight > (792.0 - 36.0 - 72.0))
+  {
+    sheight = 792.0 - 36.0 - 72.0;
+    swidth  = sheight * width / height;
+  }
+
+  tx = 0.5 * (595.28 - swidth);
+  ty = 0.5 * (792 - 36 - sheight);
+
+  pdfioContentDrawImage(page, "IM1", tx, ty + 36.0, swidth, sheight);
+
+  // Draw the caption in black...
+  pdfioContentSetFillColorDeviceGray(page, 0.0);
+
+  // Compute the starting point for the text - Courier is monospaced with a
+  // nominal width of 0.6 times the text height...
+  tx = 0.5 * (595.28 - 18.0 * 0.6 * strlen(caption));
+
+  // Position and draw the caption underneath...
+  pdfioContentTextBegin(page);
+  pdfioContentSetTextFont(page, "F1", 18.0);
+  pdfioContentTextMoveTo(page, tx, ty);
+  pdfioContentTextShow(page, /*unicode*/false, caption);
+  pdfioContentTextEnd(page);
+
+  // Close the page stream and the PDF file...
+  pdfioStreamClose(page);
+  pdfioFileClose(pdf);
+}
+```

install-sh

@@ -0,0 +1,232 @@
+#!/bin/sh
+#
+# Install a program, script, or datafile.
+#
+# Copyright 2008-2012 by Apple Inc.
+#
+# This script is not compatible with BSD (or any other) install program, as it
+# allows owner and group changes to fail with a warning and makes sure that the
+# destination directory permissions are as specified - BSD install and the
+# original X11 install script did not change permissions of existing
+# directories.  It also does not support the transform options since CUPS does
+# not use them...
+#
+# Original script from X11R5 (mit/util/scripts/install.sh)
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+
+# set DOITPROG to echo to test this script
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+# Force umask to 022...
+umask 022
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+gzipprog="${GZIPPROG-gzip}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+gzipcp() {
+	# gzipcp from to
+	$gzipprog -9 <"$1" >"$2"
+}
+
+while [ x"$1" != x ]; do
+	case $1 in
+		-c)
+		instcmd="$cpprog"
+		shift
+		continue
+		;;
+
+		-d)
+		dir_arg=true
+		shift
+		continue
+		;;
+
+		-m)
+		chmodcmd="$chmodprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-o)
+		chowncmd="$chownprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-g)
+		chgrpcmd="$chgrpprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-s)
+		stripcmd="$stripprog"
+		shift
+		continue
+		;;
+
+		-z)
+		instcmd="gzipcp"
+		shift
+		continue
+		;;
+
+		*)
+		if [ x"$src" = x ]; then
+			src="$1"
+		else
+			dst="$1"
+		fi
+		shift
+		continue
+		;;
+	esac
+done
+
+if [ x"$src" = x ]; then
+	echo "install-sh: No input file specified"
+	exit 1
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst="$src"
+	src=""
+
+	if [ -d "$dst" ]; then
+		instcmd=:
+	else
+		instcmd=$mkdirprog
+	fi
+else
+	# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+	# might cause directories to be created, which would be especially bad
+	# if $src (and thus $dsttmp) contains '*'.
+	if [ ! -f "$src" -a ! -d "$src" ]; then
+		echo "install: $src does not exist"
+		exit 1
+	fi
+
+	if [ x"$dst" = x ]; then
+		echo "install: No destination specified"
+		exit 1
+	fi
+
+	# If destination is a directory, append the input filename.
+	if [ -d "$dst" ]; then
+		dst="$dst/`basename $src`"
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir="`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`"
+
+# Make sure that the destination directory exists.
+# This part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+	defaultIFS='
+	'
+	IFS="${IFS-${defaultIFS}}"
+
+	oIFS="${IFS}"
+	# Some sh's can't handle IFS=/ for some reason.
+	IFS='%'
+	set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+	IFS="${oIFS}"
+
+	pathcomp=''
+
+	while [ $# -ne 0 ] ; do
+		pathcomp="${pathcomp}${1}"
+		shift
+
+		if [ ! -d "${pathcomp}" ]; then $doit $mkdirprog "${pathcomp}"; fi
+
+		pathcomp="${pathcomp}/"
+	done
+fi
+
+if [ x"$dir_arg" != x ]; then
+	# Make a directory...
+	$doit $instcmd $dst || exit 1
+
+	# Allow chown/chgrp to fail, but log a warning
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst || echo "warning: Unable to change owner of $dst!"; fi
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst || echo "warning: Unable to change group of $dst!"; fi
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst || exit 1; fi
+else
+	# Install a file...
+	dstfile="`basename $dst`"
+
+	# Check the destination file - for libraries just use the "-x" option
+	# to strip...
+	case "$dstfile" in
+		*.a | *.dylib | *.sl | *.sl.* | *.so | *.so.*)
+			stripopt="-x"
+			;;
+		*)
+			stripopt=""
+			;;
+	esac
+
+	# Make a temp file name in the proper directory.
+	dsttmp="$dstdir/#inst.$$#"
+
+	# Move or copy the file name to the temp name
+	$doit $instcmd $src $dsttmp || exit 1
+
+	# Update permissions and strip as needed, then move to the final name.
+	# If the chmod, strip, rm, or mv commands fail, remove the installed
+	# file...
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $stripopt "$dsttmp" || echo "warning: Unable to strip $dst!"; fi
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dsttmp" || echo "warning: Unable to change owner of $dst!"; fi
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dsttmp" || echo "warning: Unable to change group of $dst!"; fi
+
+	trap "rm -f ${dsttmp}" 0 &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dsttmp"; fi &&
+	$doit $rmcmd -f "$dstdir/$dstfile" &&
+	$doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
+fi
+
+exit 0

makesrcdist

@@ -2,18 +2,61 @@
 #
 # makesrcdist - make a source distribution of pdfio.
 #
+# Usage:
+#
+#   ./makesrcdist [--snapshot] VERSION
+#
 
+# Support "--snapshot" option...
+if test "$1" == "--snapshot"; then
+    shift
+    snapshot=1
+else
+    snapshot=0
+fi
+
+# Get version...
 if test $# != 1; then
-	echo "Usage: ./makesrcdist version"
-	exit 1
+    echo "Usage: ./makesrcdist [--snapshot] VERSION"
+    exit 1
 fi
 
 version=$1
 
-echo Creating tag for release...
-git tag -m "Tag $version" v$version
-git push origin v$version
+# Check that version number has been updated everywhere...
+if test $(grep AC_INIT configure.ac | awk '{print $2}') != "[$version],"; then
+    echo "Still need to update AC_INIT version in 'configure.ac'."
+    exit 1
+fi
 
+if test $(grep PDFIO_VERSION= configure | awk -F \" '{print $2}') != "$version"; then
+    echo "Still need to run 'autoconf -f'."
+    exit 1
+fi
+
+if test $(grep '<version>' pdfio_native.nuspec | sed -E -e '1,$s/^.*<version>([0-9.]+).*$/\1/') != "$version"; then
+    echo "Still need to update version in 'pdfio_native.nuspec'."
+    exit 1
+fi
+
+if test $(grep '<version>' pdfio_native.redist.nuspec | sed -E -e '1,$s/^.*<version>([0-9.]+).*$/\1/') != "$version"; then
+    echo "Still need to update version in 'pdfio_native.redist.nuspec'."
+    exit 1
+fi
+
+if test $(grep PDFIO_VERSION pdfio.h | awk -F \" '{print $2}') != "$version"; then
+    echo "Still need to update PDFIO_VERSION in 'pdfio.h'."
+    exit 1
+fi
+
+# Tag release...
+if test $snapshot = 0; then
+    echo Creating tag for release...
+    git tag -m "Tag $version" v$version
+    git push origin v$version
+fi
+
+# Make source archives...
 echo Creating pdfio-$version.tar.gz...
 git archive --format tar --prefix=pdfio-$version/ HEAD | gzip -v9 >pdfio-$version.tar.gz
 gpg --detach-sign pdfio-$version.tar.gz

pdfio-aes.c

@@ -0,0 +1,519 @@
+//
+// AES functions for PDFio.
+//
+// Copyright © 2021 by Michael R Sweet.
+//
+// Licensed under Apache License v2.0.  See the file "LICENSE" for more
+// information.
+//
+// AES code is adapted from the "tiny-AES-c" project
+// (<https://github.com/kokke/tiny-AES-c>)
+//
+
+#include "pdfio-private.h"
+
+
+//
+// Local types...
+//
+
+typedef uint8_t state_t[4][4];		// 4x4 AES state table @private@
+
+
+//
+// Local globals...
+//
+
+static const uint8_t sbox[256] =	// S-box lookup table
+{
+  //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F
+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
+};
+static const uint8_t rsbox[256] =	// Reverse S-box lookup table
+{
+  0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
+};
+
+// The round constant word array, Rcon[i], contains the values given by
+// x to the power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
+static const uint8_t Rcon[11] =		// Round constants
+{
+  0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36
+};
+
+
+//
+// Local functions...
+//
+
+static void	AddRoundKey(size_t round, state_t *state, const uint8_t *RoundKey);
+static void	SubBytes(state_t *state);
+static void	ShiftRows(state_t *state);
+static uint8_t	xtime(uint8_t x);
+static void	MixColumns(state_t *state);
+static uint8_t	Multiply(uint8_t x, uint8_t y);
+static void	InvMixColumns(state_t *state);
+static void	InvSubBytes(state_t *state);
+static void	InvShiftRows(state_t *state);
+static void	Cipher(state_t *state, const _pdfio_aes_t *ctx);
+static void	InvCipher(state_t *state, const _pdfio_aes_t *ctx);
+static void	XorWithIv(uint8_t *buf, const uint8_t *Iv);
+
+
+//
+// '_pdfioCryptoAESInit()' - Initialize an AES context.
+//
+
+void
+_pdfioCryptoAESInit(
+    _pdfio_aes_t  *ctx,			// I - AES context
+    const uint8_t *key,			// I - Key
+    size_t        keylen,		// I - Length of key (must be 16 or 32)
+    const uint8_t *iv)			// I - 16-byte initialization vector
+{
+  size_t	i;			// Looping var
+  uint8_t	*rkptr0,		// Previous round_key values
+		*rkptr,			// Current round_key values
+		*rkend,			// End of round_key values
+		tempa[4];		// Used for the column/row operations
+//  size_t	roundlen = keylen + 24;	// Length of round_key
+  size_t	nwords = keylen / 4;	// Number of 32-bit words in key
+
+
+  // Clear context
+  memset(ctx, 0, sizeof(_pdfio_aes_t));
+  ctx->round_size = keylen / 4 + 6;
+
+  // The first round key is the key itself.
+  memcpy(ctx->round_key, key, keylen);
+
+  // All other round keys are found from the previous round keys.
+  for (rkptr0 = ctx->round_key, rkptr = rkptr0 + keylen, rkend = rkptr + 16 * ctx->round_size, i = nwords; rkptr < rkend; i ++)
+  {
+    if ((i % nwords) == 0)
+    {
+      // Shifts word left once - [a0,a1,a2,a3] becomes [a1,a2,a3,a0], then
+      // apply the S-box to each of the four bytes to produce an output word.
+      tempa[0] = sbox[rkptr[-3]] ^ Rcon[i / nwords];
+      tempa[1] = sbox[rkptr[-2]];
+      tempa[2] = sbox[rkptr[-1]];
+      tempa[3] = sbox[rkptr[-4]];
+    }
+    else if (keylen == 32 && (i % nwords) == 4)
+    {
+      // Apply the S-box to each of the four bytes to produce an output word.
+      tempa[0] = sbox[rkptr[-4]];
+      tempa[1] = sbox[rkptr[-3]];
+      tempa[2] = sbox[rkptr[-2]];
+      tempa[3] = sbox[rkptr[-1]];
+    }
+    else
+    {
+      // Use unshifted values without S-box...
+      tempa[0] = rkptr[-4];
+      tempa[1] = rkptr[-3];
+      tempa[2] = rkptr[-2];
+      tempa[3] = rkptr[-1];
+    }
+
+    // TODO: Optimize to incorporate this into previous steps
+    *rkptr++ = *rkptr0++ ^ tempa[0];
+    *rkptr++ = *rkptr0++ ^ tempa[1];
+    *rkptr++ = *rkptr0++ ^ tempa[2];
+    *rkptr++ = *rkptr0++ ^ tempa[3];
+  }
+
+  // Copy the initialization vector...
+  if (iv)
+    memcpy(ctx->iv, iv, sizeof(ctx->iv));
+}
+
+
+//
+// '_pdfioCryptoAESDecrypt()' - Decrypt a block of bytes with AES.
+//
+// "inbuffer" and "outbuffer" can point to the same memory.  Length must be a
+// multiple of 16 bytes (excess is not decrypted).
+//
+
+size_t					// O - Number of bytes in output buffer
+_pdfioCryptoAESDecrypt(
+    _pdfio_aes_t  *ctx,			// I - AES context
+    uint8_t       *outbuffer,		// I - Output buffer
+    const uint8_t *inbuffer,		// I - Input buffer
+    size_t        len)			// I - Number of bytes to decrypt
+{
+  uint8_t	next_iv[16];		// Next IV value
+  size_t	outbytes = 0;		// Output bytes
+
+
+  if (inbuffer != outbuffer)
+  {
+    // Not the most efficient, but we can optimize later - the sample AES code
+    // manipulates the data directly in memory and doesn't support separate
+    // input and output buffers...
+    memcpy(outbuffer, inbuffer, len);
+  }
+
+  while (len > 15)
+  {
+    memcpy(next_iv, outbuffer, 16);
+    InvCipher((state_t *)outbuffer, ctx);
+    XorWithIv(outbuffer, ctx->iv);
+    memcpy(ctx->iv, next_iv, 16);
+    outbuffer += 16;
+    len -= 16;
+    outbytes += 16;
+  }
+
+  return (outbytes);
+}
+
+
+//
+// '_pdfioCryptoAESEncrypt()' - Encrypt a block of bytes with AES.
+//
+// "inbuffer" and "outbuffer" can point to the same memory.  "outbuffer" must
+// be a multiple of 16 bytes.
+//
+
+size_t					// O - Number of bytes in output buffer
+_pdfioCryptoAESEncrypt(
+    _pdfio_aes_t  *ctx,			// I - AES context
+    uint8_t       *outbuffer,		// I - Output buffer
+    const uint8_t *inbuffer,		// I - Input buffer
+    size_t        len)			// I - Number of bytes to decrypt
+{
+  uint8_t	*iv = ctx->iv;		// Current IV for CBC
+  size_t	outbytes = 0;		// Output bytes
+
+
+  if (len == 0)
+    return (0);
+
+  if (inbuffer != outbuffer)
+  {
+    // Not the most efficient, but we can optimize later - the sample AES code
+    // manipulates the data directly in memory and doesn't support separate
+    // input and output buffers...
+    memcpy(outbuffer, inbuffer, len);
+  }
+
+  while (len > 15)
+  {
+    XorWithIv(outbuffer, iv);
+    Cipher((state_t*)outbuffer, ctx);
+    iv = outbuffer;
+    outbuffer += 16;
+    len -= 16;
+    outbytes += 16;
+  }
+
+  if (len > 0)
+  {
+    // Pad the final buffer with (16 - len)...
+    memset(outbuffer + len, 16 - len, 16 - len);
+
+    XorWithIv(outbuffer, iv);
+    Cipher((state_t*)outbuffer, ctx);
+    iv = outbuffer;
+    outbytes += 16;
+  }
+
+  /* store Iv in ctx for next call */
+  memcpy(ctx->iv, iv, 16);
+
+  return (outbytes);
+}
+
+
+// This function adds the round key to state.
+// The round key is added to the state by an XOR function.
+static void
+AddRoundKey(size_t round, state_t *state, const uint8_t *RoundKey)
+{
+  unsigned	i;			// Looping var
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+
+
+  for (RoundKey += round * 16, i = 16; i > 0; i --, sptr ++, RoundKey ++)
+    *sptr ^= *RoundKey;
+}
+
+
+// The SubBytes Function Substitutes the values in the
+// state matrix with values in an S-box.
+static void
+SubBytes(state_t *state)
+{
+  unsigned	i;			// Looping var
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+
+
+  for (i = 16; i > 0; i --, sptr ++)
+    *sptr = sbox[*sptr];
+}
+
+// The ShiftRows() function shifts the rows in the state to the left.
+// Each row is shifted with different offset.
+// Offset = Row number. So the first row is not shifted.
+static void
+ShiftRows(state_t *state)
+{
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+  uint8_t	temp;			// Temporary value
+
+
+  // Rotate first row 1 columns to left
+  temp     = sptr[1];
+  sptr[1]  = sptr[5];
+  sptr[5]  = sptr[9];
+  sptr[9]  = sptr[13];
+  sptr[13] = temp;
+
+  // Rotate second row 2 columns to left
+  temp     = sptr[2];
+  sptr[2]  = sptr[10];
+  sptr[10] = temp;
+
+  temp     = sptr[6];
+  sptr[6]  = sptr[14];
+  sptr[14] = temp;
+
+  // Rotate third row 3 columns to left
+  temp     = sptr[3];
+  sptr[3]  = sptr[15];
+  sptr[15] = sptr[11];
+  sptr[11] = sptr[7];
+  sptr[7]  = temp;
+}
+
+
+static uint8_t
+xtime(uint8_t x)
+{
+  return ((uint8_t)((x << 1) ^ ((x >> 7) * 0x1b)));
+}
+
+
+// MixColumns function mixes the columns of the state matrix
+static void
+MixColumns(state_t *state)
+{
+  unsigned	i;			// Looping var
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+  uint8_t	Tmp, Tm, t;		// Temporary values
+
+  for (i = 4; i > 0; i --, sptr += 4)
+  {
+    t       = sptr[0];
+    Tmp     = sptr[0] ^ sptr[1] ^ sptr[2] ^ sptr[3];
+    Tm      = sptr[0] ^ sptr[1];
+    Tm      = xtime(Tm);
+    sptr[0] ^= Tm ^ Tmp;
+
+    Tm      = sptr[1] ^ sptr[2];
+    Tm      = xtime(Tm);
+    sptr[1] ^= Tm ^ Tmp;
+
+    Tm      = sptr[2] ^ sptr[3];
+    Tm      = xtime(Tm);
+    sptr[2] ^= Tm ^ Tmp;
+
+    Tm      = sptr[3] ^ t;
+    Tm      = xtime(Tm);
+    sptr[3] ^= Tm ^ Tmp;
+  }
+}
+
+
+// Multiply is used to multiply numbers in the field GF(2^8)
+// Note: The last call to xtime() is unneeded, but often ends up generating a smaller binary
+//       The compiler seems to be able to vectorize the operation better this way.
+//       See https://github.com/kokke/tiny-AES-c/pull/34
+static uint8_t Multiply(uint8_t x, uint8_t y)
+{
+  return (((y & 1) * x) ^
+	  ((y>>1 & 1) * xtime(x)) ^
+	  ((y>>2 & 1) * xtime(xtime(x))) ^
+	  ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^
+	  ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))); /* this last call to xtime() can be omitted */
+}
+
+
+// MixColumns function mixes the columns of the state matrix.
+// The method used to multiply may be difficult to understand for the inexperienced.
+// Please use the references to gain more information.
+static void
+InvMixColumns(state_t *state)
+{
+  unsigned	i;			// Looping var
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+  uint8_t	a, b, c, d;		// Temporary values
+
+
+  for (i = 4; i > 0; i --)
+  {
+    a = sptr[0];
+    b = sptr[1];
+    c = sptr[2];
+    d = sptr[3];
+
+    *sptr++ = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09);
+    *sptr++ = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);
+    *sptr++ = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);
+    *sptr++ = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e);
+  }
+}
+
+
+// The SubBytes Function Substitutes the values in the
+// state matrix with values in an S-box.
+static void
+InvSubBytes(state_t *state)
+{
+  unsigned	i;			// Looping var
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+
+
+  for (i = 16; i > 0; i --, sptr ++)
+    *sptr = rsbox[*sptr];
+}
+
+
+static void
+InvShiftRows(state_t *state)
+{
+  uint8_t	*sptr = (*state)[0];	// Pointer into state
+  uint8_t	temp;			// Temporary value
+
+
+  // Rotate first row 1 columns to right
+  temp     = sptr[13];
+  sptr[13] = sptr[9];
+  sptr[9]  = sptr[5];
+  sptr[5]  = sptr[1];
+  sptr[1]  = temp;
+
+  // Rotate second row 2 columns to right
+  temp     = sptr[2];
+  sptr[2]  = sptr[10];
+  sptr[10] = temp;
+
+  temp     = sptr[6];
+  sptr[6]  = sptr[14];
+  sptr[14] = temp;
+
+  // Rotate third row 3 columns to right
+  temp     = sptr[3];
+  sptr[3]  = sptr[7];
+  sptr[7]  = sptr[11];
+  sptr[11] = sptr[15];
+  sptr[15] = temp;
+}
+
+
+// Cipher is the main function that encrypts the PlainText.
+static void
+Cipher(state_t *state, const _pdfio_aes_t *ctx)
+{
+  size_t round = 0;
+
+  // Add the First round key to the state before starting the rounds.
+  AddRoundKey(0, state, ctx->round_key);
+
+  // There will be Nr rounds.
+  // The first Nr-1 rounds are identical.
+  // These Nr rounds are executed in the loop below.
+  // Last one without MixColumns()
+  for (round = 1; round < ctx->round_size; round ++)
+  {
+    SubBytes(state);
+    ShiftRows(state);
+    MixColumns(state);
+    AddRoundKey(round, state, ctx->round_key);
+  }
+  // Add round key to last round
+  SubBytes(state);
+  ShiftRows(state);
+  AddRoundKey(ctx->round_size, state, ctx->round_key);
+}
+
+
+static void
+InvCipher(state_t *state, const _pdfio_aes_t *ctx)
+{
+  size_t round;
+
+  // Add the First round key to the state before starting the rounds.
+  AddRoundKey(ctx->round_size, state, ctx->round_key);
+
+  // There will be Nr rounds.
+  // The first Nr-1 rounds are identical.
+  // These Nr rounds are executed in the loop below.
+  // Last one without InvMixColumn()
+  for (round = ctx->round_size - 1; ; round --)
+  {
+    InvShiftRows(state);
+    InvSubBytes(state);
+    AddRoundKey(round, state, ctx->round_key);
+
+    if (round == 0)
+      break;
+
+    InvMixColumns(state);
+  }
+}
+
+
+static void
+XorWithIv(uint8_t *buf, const uint8_t *Iv)
+{
+  // 16-byte block...
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+  *buf++ ^= *Iv++;
+}

pdfio-array.c

@@ -7,10 +7,6 @@
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -331,6 +327,30 @@ pdfioArrayCreate(pdfio_file_t *pdf)	// I - PDF file
 }
 
 
+//
+// '_pdfioArrayDecrypt()' - Decrypt values in an array.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioArrayDecrypt(pdfio_file_t  *pdf,	// I - PDF file
+                   pdfio_obj_t   *obj,	// I - Object
+                   pdfio_array_t *a,	// I - Array
+                   size_t        depth)	// I - Depth
+{
+  size_t		i;		// Looping var
+  _pdfio_value_t	*v;		// Current value
+
+
+  for (i = a->num_values, v = a->values; i > 0; i --, v ++)
+  {
+    if (!_pdfioValueDecrypt(pdf, obj, v, depth))
+      return (false);
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioArrayDebug()' - Print the contents of an array.
 //
@@ -343,6 +363,9 @@ _pdfioArrayDebug(pdfio_array_t *a,	// I - Array
   _pdfio_value_t	*v;		// Current value
 
 
+  if (!a)
+    return;
+
   putc('[', fp);
   for (i = a->num_values, v = a->values; i > 0; i --, v ++)
     _pdfioValueDebug(v, fp);
@@ -357,9 +380,16 @@ _pdfioArrayDebug(pdfio_array_t *a,	// I - Array
 void
 _pdfioArrayDelete(pdfio_array_t *a)	// I - Array
 {
-  if (a)
-    free(a->values);
+  size_t	i;			// Looping var
 
+
+  for (i = 0; i < a->num_values; i ++)
+  {
+    if (a->values[i].type == PDFIO_VALTYPE_BINARY)
+      free(a->values[i].value.binary.data);
+  }
+
+  free(a->values);
   free(a);
 }
 
@@ -389,17 +419,26 @@ pdfioArrayGetBinary(
     size_t        n,			// I - Index
     size_t        *length)		// O - Length of string
 {
-  if (!a || n >= a->num_values || a->values[n].type != PDFIO_VALTYPE_BINARY || !length)
+  if (!a || n >= a->num_values || (a->values[n].type != PDFIO_VALTYPE_BINARY && a->values[n].type != PDFIO_VALTYPE_STRING))
   {
     if (length)
       *length = 0;
 
     return (NULL);
   }
+  else if (a->values[n].type == PDFIO_VALTYPE_BINARY)
+  {
+    if (length)
+      *length = a->values[n].value.binary.datalen;
+
+    return (a->values[n].value.binary.data);
+  }
   else
   {
-    *length = a->values[n].value.binary.datalen;
-    return (a->values[n].value.binary.data);
+    if (length)
+      *length = strlen(a->values[n].value.string);
+
+    return ((unsigned char *)a->values[n].value.string);
   }
 }
 
@@ -558,7 +597,9 @@ _pdfioArrayGetValue(pdfio_array_t *a,	// I - Array
 
 pdfio_array_t *				// O - New array
 _pdfioArrayRead(pdfio_file_t   *pdf,	// I - PDF file
-                _pdfio_token_t *tb)	// I - Token buffer/stack
+		pdfio_obj_t    *obj,	// I - Object, if any
+                _pdfio_token_t *tb,	// I - Token buffer/stack
+                size_t         depth)	// I - Depth of array
 {
   pdfio_array_t		*array;		// New array
   char			token[8192];	// Token from file
@@ -568,7 +609,8 @@ _pdfioArrayRead(pdfio_file_t   *pdf,	// I - PDF file
   PDFIO_DEBUG("_pdfioArrayRead(pdf=%p, tb=%p)\n", pdf, tb);
 
   // Create an array...
-  array = pdfioArrayCreate(pdf);
+  if ((array = pdfioArrayCreate(pdf)) == NULL)
+    return (NULL);
 
   // Read until we get "]" to end the array...
   while (_pdfioTokenGet(tb, token, sizeof(token)))
@@ -581,7 +623,7 @@ _pdfioArrayRead(pdfio_file_t   *pdf,	// I - PDF file
 
     // Push the token and decode the value...
     _pdfioTokenPush(tb, token);
-    if (!_pdfioValueRead(pdf, tb, &value))
+    if (!_pdfioValueRead(pdf, obj, tb, &value, depth))
       break;
 
 //    PDFIO_DEBUG("_pdfioArrayRead(%p): Appending ", (void *)array);
@@ -600,7 +642,8 @@ _pdfioArrayRead(pdfio_file_t   *pdf,	// I - PDF file
 //
 
 bool					// O - `true` on success, `false` otherwise
-_pdfioArrayWrite(pdfio_array_t *a)	// I - Array
+_pdfioArrayWrite(pdfio_array_t *a,	// I - Array
+		 pdfio_obj_t   *obj)	// I - Object, if any
 {
   pdfio_file_t	*pdf = a->pdf;		// PDF file
   size_t	i;			// Looping var
@@ -614,7 +657,7 @@ _pdfioArrayWrite(pdfio_array_t *a)	// I - Array
   // Write each value...
   for (i = a->num_values, v = a->values; i > 0; i --, v ++)
   {
-    if (!_pdfioValueWrite(pdf, v, NULL))
+    if (!_pdfioValueWrite(pdf, obj, v, NULL))
       return (false);
   }
 

pdfio-common.c

@@ -1,16 +1,12 @@
 //
 // Common support functions for pdfio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -38,6 +34,8 @@ _pdfioFileConsume(pdfio_file_t *pdf,	// I - PDF file
   else if (_pdfioFileSeek(pdf, (off_t)bytes, SEEK_CUR) < 0)
     return (false);
 
+  PDFIO_DEBUG("_pdfioFileConsume: pos=%ld\n", (long)(pdf->bufpos + pdf->bufptr - pdf->buffer));
+
   return (true);
 }
 
@@ -143,7 +141,7 @@ _pdfioFileGets(pdfio_file_t *pdf,	// I - PDF file
 	*bufend = buffer + bufsize - 1;	// Pointer to end of buffer
 
 
-  PDFIO_DEBUG("_pdfioFileGets(pdf=%p, buffer=%p, bufsize=%lu) bufpos=%ld, buffer=%p, bufptr=%p, bufend=%p\n", pdf, buffer, (unsigned long)bufsize, (long)pdf->bufpos, pdf->buffer, pdf->bufptr, pdf->bufend);
+  PDFIO_DEBUG("_pdfioFileGets(pdf=%p, buffer=%p, bufsize=%lu) bufpos=%ld, buffer=%p, bufptr=%p, bufend=%p, offset=%lu\n", pdf, buffer, (unsigned long)bufsize, (long)pdf->bufpos, pdf->buffer, pdf->bufptr, pdf->bufend, (unsigned long)(pdf->bufpos + (pdf->bufptr - pdf->buffer)));
 
   while (!eol)
   {
@@ -263,7 +261,7 @@ _pdfioFilePrintf(pdfio_file_t *pdf,	// I - PDF file
 
   // Format the string...
   va_start(ap, format);
-  vsnprintf(buffer, sizeof(buffer), format, ap);
+  _pdfio_vsnprintf(pdf, buffer, sizeof(buffer), format, ap);
   va_end(ap);
 
   // Write it...
@@ -329,6 +327,11 @@ _pdfioFileRead(pdfio_file_t *pdf,	// I - PDF file
 	pdf->bufpos += rbytes;
 	continue;
       }
+      else if (rbytes < 0 && (errno == EINTR || errno == EAGAIN))
+      {
+        rbytes = 0;
+        continue;
+      }
       else
         break;
     }
@@ -353,12 +356,12 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
                off_t        offset,	// I - Offset
                int          whence)	// I - Offset base
 {
-  PDFIO_DEBUG("_pdfioFileSeek(pdf=%p, offset=%ld, whence=%d)\n", pdf, (long)offset, whence);
+  PDFIO_DEBUG("_pdfioFileSeek(pdf=%p, offset=%ld, whence=%d) pdf->bufpos=%lu\n", pdf, (long)offset, whence, (unsigned long)(pdf ? pdf->bufpos : 0));
 
   // Adjust offset for relative seeks...
   if (whence == SEEK_CUR)
   {
-    offset += pdf->bufpos;
+    offset += pdf->bufpos + (pdf->bufptr - pdf->buffer);
     whence = SEEK_SET;
   }
 
@@ -368,15 +371,20 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
     if (whence != SEEK_END && offset >= pdf->bufpos && offset < (pdf->bufpos + pdf->bufend - pdf->buffer))
     {
       // Yes, seek within existing buffer...
-      pdf->bufptr = pdf->buffer + offset - pdf->bufpos;
+      pdf->bufptr = pdf->buffer + (offset - pdf->bufpos);
       PDFIO_DEBUG("_pdfioFileSeek: Seek within buffer, bufpos=%ld.\n", (long)pdf->bufpos);
-      PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p, bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufend);
+      PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p(<%02X%02X...>), bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufptr[0] & 255, pdf->bufptr[1] & 255, pdf->bufend);
       return (offset);
     }
 
     // No, reset the read buffer
     pdf->bufptr = pdf->bufend = NULL;
   }
+  else if (pdf->output_cb)
+  {
+    _pdfioFileError(pdf, "Unable to seek within output stream.");
+    return (-1);
+  }
   else
   {
     // Writing, make sure we write any buffered data...
@@ -396,7 +404,7 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
     return (-1);
   }
 
-  PDFIO_DEBUG("_pdfioFileSeek: Reset bufpos=%ld.\n", (long)pdf->bufpos);
+  PDFIO_DEBUG("_pdfioFileSeek: Reset bufpos=%ld, offset=%lu.\n", (long)pdf->bufpos, (unsigned long)offset);
   PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p, bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufend);
 
   pdf->bufpos = offset;
@@ -515,7 +523,7 @@ read_buffer(pdfio_file_t *pdf,		// I - PDF file
   return (rbytes);
 }
 
-  
+
 //
 // 'write_buffer()' - Write a buffer to a PDF file.
 //
@@ -530,25 +538,37 @@ write_buffer(pdfio_file_t *pdf,		// I - PDF file
   ssize_t	wbytes;			// Bytes written...
 
 
-  // Write to the file...
-  while (bytes > 0)
+  if (pdf->output_cb)
   {
-    while ((wbytes = write(pdf->fd, bufptr, bytes)) < 0)
+    // Write to a stream...
+    if ((pdf->output_cb)(pdf->output_ctx, buffer, bytes) < 0)
     {
-      // Stop if we have an error that shouldn't be retried...
-      if (errno != EINTR && errno != EAGAIN)
-	break;
-    }
-
-    if (wbytes < 0)
-    {
-      // Hard error...
-      _pdfioFileError(pdf, "Unable to write to file - %s", strerror(errno));
+      _pdfioFileError(pdf, "Unable to write to output callback.");
       return (false);
     }
+  }
+  else
+  {
+    // Write to the file...
+    while (bytes > 0)
+    {
+      while ((wbytes = write(pdf->fd, bufptr, bytes)) < 0)
+      {
+	// Stop if we have an error that shouldn't be retried...
+	if (errno != EINTR && errno != EAGAIN)
+	  break;
+      }
 
-    bufptr += wbytes;
-    bytes  -= (size_t)wbytes;
+      if (wbytes < 0)
+      {
+	// Hard error...
+	_pdfioFileError(pdf, "Unable to write to file - %s", strerror(errno));
+	return (false);
+      }
+
+      bufptr += wbytes;
+      bytes  -= (size_t)wbytes;
+    }
   }
 
   return (true);

pdfio-content.c

@@ -1,16 +1,12 @@
 //
 // Content helper functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 #include "pdfio-content.h"
 #include "ttf.h"
@@ -489,8 +485,11 @@ pdfioContentMatrixRotate(
     pdfio_stream_t *st,			// I - Stream
     double         degrees)		// I - Rotation angle in degrees counter-clockwise
 {
-  double dcos = cos(degrees / M_PI);	// Cosine
-  double dsin = sin(degrees / M_PI);	// Sine
+  double dcos = cos(M_PI * degrees / 180.0);
+					// Cosine
+  double dsin = sin(M_PI * degrees / 180.0);
+					// Sine
+
 
   return (pdfioStreamPrintf(st, "%g %g %g %g 0 0 cm\n", dcos, -dsin, dsin, dcos));
 }
@@ -586,6 +585,17 @@ pdfioContentPathCurve23(
 }
 
 
+//
+// 'pdfioContentPathEnd()' - Clear the current path.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentPathEnd(pdfio_stream_t *st)	// I - Stream
+{
+  return (pdfioStreamPuts(st, "n\n"));
+}
+
+
 //
 // 'pdfioContentPathLineTo()' - Add a straight line to the current path.
 //
@@ -656,15 +666,23 @@ pdfioContentSave(pdfio_stream_t *st)	// I - Stream
 //
 // 'pdfioContentSetDashPattern()' - Set the stroke pattern.
 //
+// This function sets the stroke pattern when drawing lines.  If "on" and "off"
+// are 0, a solid line is drawn.
+//
 
 bool					// O - `true` on success, `false` on failure
 pdfioContentSetDashPattern(
     pdfio_stream_t *st,			// I - Stream
-    int            phase,		// I - Phase (offset within pattern)
-    int            on,			// I - On length
-    int            off)			// I - Off length
+    double         phase,		// I - Phase (offset within pattern)
+    double         on,			// I - On length
+    double         off)			// I - Off length
 {
-  return (pdfioStreamPrintf(st, "[%d %d] %d d\n", on, off, phase));
+  if (on <= 0.0 && off <= 0.0)
+    return (pdfioStreamPrintf(st, "[] %g d\n", phase));
+  else if (fabs(on - off) < 0.001)
+    return (pdfioStreamPrintf(st, "[%g] %g d\n", on, phase));
+  else
+    return (pdfioStreamPrintf(st, "[%g %g] %g d\n", on, off, phase));
 }
 
 
@@ -1042,6 +1060,104 @@ pdfioContentTextEnd(pdfio_stream_t *st)	// I - Stream
 }
 
 
+//
+// 'pdfioContentTextMeasure()' - Measure a text string and return its width.
+//
+// This function measures the given text string "s" and returns its width based
+// on "size". The text string must always use the UTF-8 (Unicode) encoding but
+// any control characters (such as newlines) are ignored.
+//
+
+double					// O - Width
+pdfioContentTextMeasure(
+    pdfio_obj_t *font,			// I - Font object created by @link pdfioFileCreateFontObjFromFile@
+    const char  *s,			// I - UTF-8 string
+    double      size)			// I - Font size/height
+{
+  const char	*subtype;		// Font sub-type
+  ttf_t		*ttf = (ttf_t *)_pdfioObjGetExtension(font);
+					// TrueType font data
+  ttf_rect_t	extents;		// Text extents
+  int		ch;			// Unicode character
+  char		temp[1024],		// Temporary string
+		*tempptr;		// Pointer into temporary string
+
+
+  if ((subtype = pdfioObjGetSubtype(font)) == NULL || strcmp(subtype, "Type0"))
+  {
+    // Map non-CP1282 characters to '?', everything else as-is...
+    tempptr = temp;
+
+    while (*s && tempptr < (temp + sizeof(temp) - 3))
+    {
+      if ((*s & 0xe0) == 0xc0)
+      {
+	// Two-byte UTF-8
+        ch = ((s[0] & 0x1f) << 6) | (s[1] & 0x3f);
+	s += 2;
+      }
+      else if ((*s & 0xf0) == 0xe0)
+      {
+	// Three-byte UTF-8
+        ch = ((s[0] & 0x0f) << 12) | ((s[1] & 0x3f) << 6) | (s[2] & 0x3f);
+	s += 3;
+      }
+      else if ((*s & 0xf8) == 0xf0)
+      {
+	// Four-byte UTF-8
+        ch = ((s[0] & 0x07) << 18) | ((s[1] & 0x3f) << 12) | ((s[2] & 0x3f) << 6) | (s[3] & 0x3f);
+	s += 4;
+      }
+      else
+      {
+	ch = *s++;
+      }
+
+      if (ch > 255)
+      {
+	// Try mapping from Unicode to CP1252...
+	size_t i;			// Looping var
+
+	for (i = 0; i < (sizeof(_pdfio_cp1252) / sizeof(_pdfio_cp1252[0])); i ++)
+	{
+	  if (ch == _pdfio_cp1252[i])
+	    break;
+	}
+
+	if (i >= (sizeof(_pdfio_cp1252) / sizeof(_pdfio_cp1252[0])))
+	  ch = '?';			// Unsupported chars map to ?
+      }
+
+      if (ch < 128)
+      {
+        // ASCII
+	*tempptr++ = (char)ch;
+      }
+      else if (ch < 2048)
+      {
+        // 2-byte UTF-8
+        *tempptr++ = (char)(0xc0 | ((ch >> 6) & 0x1f));
+        *tempptr++ = (char)(0x80 | (ch & 0x3f));
+      }
+      else
+      {
+        // 3-byte UTF-8
+        *tempptr++ = (char)(0xe0 | ((ch >> 12) & 0x0f));
+        *tempptr++ = (char)(0x80 | ((ch >> 6) & 0x3f));
+        *tempptr++ = (char)(0x80 | (ch & 0x3f));
+      }
+    }
+
+    *tempptr = '\0';
+    s        = temp;
+  }
+
+  ttfGetExtents(ttf, (float)size, s, &extents);
+
+  return (extents.right - extents.left);
+}
+
+
 //
 // 'pdfioContentTextMoveLine()' - Move to the next line and offset.
 //
@@ -1071,7 +1187,21 @@ pdfioContentTextMoveTo(
 
 
 //
-// 'pdfioContentTextNextLine()' - Move to the next line.
+// 'pdfioContentTextNewLine()' - Move to the next line.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLine(
+    pdfio_stream_t *st)			// I - Stream
+{
+  return (pdfioStreamPuts(st, "T*\n"));
+}
+
+
+//
+// 'pdfioContentTextNextLine()' - Legacy function name preserved for binary compatibility.
+//
+// @private@
 //
 
 bool					// O - `true` on success, `false` on failure
@@ -1082,6 +1212,86 @@ pdfioContentTextNextLine(
 }
 
 
+//
+// 'pdfioContentTextNewLineShow()' - Move to the next line and show text.
+//
+// This function moves to the next line and then shows some text with optional
+// word and character spacing in a PDF content stream. The "unicode" argument
+// specifies that the current font maps to full Unicode.  The "s" argument
+// specifies a UTF-8 encoded string.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLineShow(
+    pdfio_stream_t *st,			// I - Stream
+    double         ws,			// I - Word spacing or `0.0` for none
+    double         cs,			// I - Character spacing or `0.0` for none
+    bool           unicode,		// I - Unicode text?
+    const char     *s)			// I - String to show
+{
+  bool	newline = false;		// New line?
+  char	op;				// Text operator
+
+
+  // Write word and/or character spacing as needed...
+  if (ws > 0.0 || cs > 0.0)
+  {
+    // Use " operator to show text with word and character spacing...
+    if (!pdfioStreamPrintf(st, "%g %g", ws, cs))
+      return (false);
+
+    op = '\"';
+  }
+  else
+  {
+    // Use ' operator to show text with the defaults...
+    op = '\'';
+  }
+
+  // Write the string...
+  if (!write_string(st, unicode, s, &newline))
+    return (false);
+
+  // Draw it...
+  if (newline)
+    return (pdfioStreamPrintf(st, "%c T*\n", op));
+  else
+    return (pdfioStreamPrintf(st, "%c\n", op));
+}
+
+
+//
+// 'pdfioContentTextNewLineShowf()' - Show formatted text.
+//
+// This function moves to the next line and shows some formatted text with
+// optional word and character spacing in a PDF content stream. The "unicode"
+// argument specifies that the current font maps to full Unicode.  The "format"
+// argument specifies a UTF-8 encoded `printf`-style format string.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLineShowf(
+    pdfio_stream_t *st,			// I - Stream
+    double         ws,			// I - Word spacing or `0.0` for none
+    double         cs,			// I - Character spacing or `0.0` for none
+    bool           unicode,		// I - Unicode text?
+    const char     *format,		// I - `printf`-style format string
+    ...)				// I - Additional arguments as needed
+{
+  char		buffer[8192];		// Text buffer
+  va_list	ap;			// Argument pointer
+
+
+  // Format the string...
+  va_start(ap, format);
+  vsnprintf(buffer, sizeof(buffer), format, ap);
+  va_end(ap);
+
+  // Show it...
+  return (pdfioContentTextNewLineShow(st, ws, cs, unicode, buffer));
+}
+
+
 //
 // 'pdfioContentTextShow()' - Show text.
 //
@@ -1114,9 +1324,9 @@ pdfioContentTextShow(
 //
 // 'pdfioContentTextShowf()' - Show formatted text.
 //
-// This function shows some text in a PDF content stream. The "unicode" argument
-// specifies that the current font maps to full Unicode.  The "format" argument
-// specifies a UTF-8 encoded `printf`-style format string.
+// This function shows some formatted text in a PDF content stream. The
+// "unicode" argument specifies that the current font maps to full Unicode.
+// The "format" argument specifies a UTF-8 encoded `printf`-style format string.
 //
 
 bool
@@ -1267,13 +1477,13 @@ pdfioFileCreateFontObjFromFile(
   pdfio_dict_t	*dict,			// Font dictionary
 		*desc,			// Font descriptor
 		*file;			// Font file dictionary
-  pdfio_obj_t	*obj,			// Font object
+  pdfio_obj_t	*obj = NULL,		// Font object
 		*desc_obj,		// Font descriptor object
 		*file_obj;		// Font file object
   const char	*basefont;		// Base font name
   pdfio_array_t	*bbox;			// Font bounding box array
   pdfio_stream_t *st;			// Font stream
-  int		fd;			// File
+  int		fd = -1;		// File
   unsigned char	buffer[16384];		// Read buffer
   ssize_t	bytes;			// Bytes read
 
@@ -1302,48 +1512,32 @@ pdfioFileCreateFontObjFromFile(
 
   // Create the font file dictionary and object...
   if ((file = pdfioDictCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   pdfioDictSetName(file, "Filter", "FlateDecode");
 
   if ((file_obj = pdfioFileCreateObj(pdf, file)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   if ((st = pdfioObjCreateStream(file_obj, PDFIO_FILTER_FLATE)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   while ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
   {
     if (!pdfioStreamWrite(st, buffer, (size_t)bytes))
     {
-      ttfDelete(font);
-      close(fd);
       pdfioStreamClose(st);
-      return (NULL);
+      goto done;
     }
   }
 
   close(fd);
+  fd = -1;
   pdfioStreamClose(st);
 
   // Create the font descriptor dictionary and object...
   if ((bbox = pdfioArrayCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   ttfGetBounds(font, &bounds);
 
@@ -1353,10 +1547,7 @@ pdfioFileCreateFontObjFromFile(
   pdfioArrayAppendNumber(bbox, bounds.top);
 
   if ((desc = pdfioDictCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   basefont = pdfioStringCreate(pdf, ttfGetPostScriptName(font));
 
@@ -1375,59 +1566,70 @@ pdfioFileCreateFontObjFromFile(
   pdfioDictSetNumber(desc, "StemV", ttfGetWeight(font) / 4 + 25);
 
   if ((desc_obj = pdfioFileCreateObj(pdf, desc)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   pdfioObjClose(desc_obj);
 
   if (unicode)
   {
     // Unicode (CID) font...
-    pdfio_dict_t	*cid2gid;	// CIDToGIDMap dictionary
-    pdfio_obj_t		*cid2gid_obj;	// CIDToGIDMap object
+    pdfio_dict_t	*cid2gid,	// CIDToGIDMap dictionary
+			*to_unicode;	// ToUnicode dictionary
+    pdfio_obj_t		*cid2gid_obj,	// CIDToGIDMap object
+			*to_unicode_obj;// ToUnicode object
     size_t		i,		// Looping var
+			start,		// Start character
 			num_cmap;	// Number of CMap entries
     const int		*cmap;		// CMap entries
+    int			min_glyph,	// First glyph
+			max_glyph;	// Last glyph
+    unsigned short	glyphs[65536];	// Glyph to Unicode mapping
     unsigned char	*bufptr,	// Pointer into buffer
 			*bufend;	// End of buffer
     pdfio_dict_t	*type2;		// CIDFontType2 font dictionary
     pdfio_obj_t		*type2_obj;	// CIDFontType2 font object
     pdfio_array_t	*descendants;	// Decendant font list
     pdfio_dict_t	*sidict;	// CIDSystemInfo dictionary
+    pdfio_array_t	*w_array,	// Width array
+			*temp_array;	// Temporary width sub-array
+    int			w0, w1;		// Widths
+
+    // Create a CIDSystemInfo mapping to Adobe UCS2 v0 (Unicode)
+    if ((sidict = pdfioDictCreate(pdf)) == NULL)
+      goto done;
+
+    pdfioDictSetString(sidict, "Registry", "Adobe");
+    pdfioDictSetString(sidict, "Ordering", "Identity");
+    pdfioDictSetNumber(sidict, "Supplement", 0);
 
     // Create a CIDToGIDMap object for the Unicode font...
     if ((cid2gid = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
 #ifndef DEBUG
     pdfioDictSetName(cid2gid, "Filter", "FlateDecode");
 #endif // !DEBUG
 
     if ((cid2gid_obj = pdfioFileCreateObj(pdf, cid2gid)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
 #ifdef DEBUG
     if ((st = pdfioObjCreateStream(cid2gid_obj, PDFIO_FILTER_NONE)) == NULL)
 #else
     if ((st = pdfioObjCreateStream(cid2gid_obj, PDFIO_FILTER_FLATE)) == NULL)
 #endif // DEBUG
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
-    cmap = ttfGetCMap(font, &num_cmap);
+    cmap      = ttfGetCMap(font, &num_cmap);
+    min_glyph = 65536;
+    max_glyph = 0;
+    memset(glyphs, 0, sizeof(glyphs));
+
+    PDFIO_DEBUG("pdfioFileCreateFontObjFromFile: num_cmap=%u\n", (unsigned)num_cmap);
 
     for (i = 0, bufptr = buffer, bufend = buffer + sizeof(buffer); i < num_cmap; i ++)
     {
+      PDFIO_DEBUG("pdfioFileCreateFontObjFromFile: cmap[%u]=%d\n", (unsigned)i, cmap[i]);
       if (cmap[i] < 0)
       {
         // Map undefined glyph to .notdef...
@@ -1439,6 +1641,12 @@ pdfioFileCreateFontObjFromFile(
         // Map to specified glyph...
         *bufptr++ = (unsigned char)(cmap[i] >> 8);
         *bufptr++ = (unsigned char)(cmap[i] & 255);
+
+        glyphs[cmap[i]] = (unsigned short)i;
+        if (cmap[i] < min_glyph)
+          min_glyph = cmap[i];
+        if (cmap[i] > max_glyph)
+          max_glyph = cmap[i];
       }
 
       if (bufptr >= bufend)
@@ -1447,8 +1655,7 @@ pdfioFileCreateFontObjFromFile(
         if (!pdfioStreamWrite(st, buffer, (size_t)(bufptr - buffer)))
         {
 	  pdfioStreamClose(st);
-          ttfDelete(font);
-          return (NULL);
+	  goto done;
         }
 
         bufptr = buffer;
@@ -1461,30 +1668,102 @@ pdfioFileCreateFontObjFromFile(
       if (!pdfioStreamWrite(st, buffer, (size_t)(bufptr - buffer)))
       {
 	pdfioStreamClose(st);
-	ttfDelete(font);
-	return (NULL);
+	goto done;
       }
     }
 
     pdfioStreamClose(st);
 
+    // ToUnicode mapping object
+    to_unicode = pdfioDictCreate(pdf);
+    pdfioDictSetName(to_unicode, "Type", "CMap");
+    pdfioDictSetName(to_unicode, "CMapName", "Adobe-Identity-UCS2");
+    pdfioDictSetDict(to_unicode, "CIDSystemInfo", sidict);
+
+#ifndef DEBUG
+    pdfioDictSetName(to_unicode, "Filter", "FlateDecode");
+#endif // !DEBUG
+
+    if ((to_unicode_obj = pdfioFileCreateObj(pdf, to_unicode)) == NULL)
+      goto done;
+
+#ifdef DEBUG
+    if ((st = pdfioObjCreateStream(to_unicode_obj, PDFIO_FILTER_NONE)) == NULL)
+#else
+    if ((st = pdfioObjCreateStream(to_unicode_obj, PDFIO_FILTER_FLATE)) == NULL)
+#endif // DEBUG
+      goto done;
+
+    pdfioStreamPuts(st,
+		    "stream\n"
+		    "/CIDInit /ProcSet findresource begin\n"
+		    "12 dict begin\n"
+		    "begincmap\n"
+		    "/CIDSystemInfo<<\n"
+		    "/Registry (Adobe)\n"
+		    "/Ordering (UCS2)\n"
+		    "/Supplement 0\n"
+		    ">> def\n"
+		    "/CMapName /Adobe-Identity-UCS2 def\n"
+		    "/CMapType 2 def\n"
+		    "1 begincodespacerange\n"
+		    "<0000> <FFFF>\n"
+		    "endcodespacerange\n"
+		    "1 beginbfrange\n"
+		    "<0000> <FFFF> <0000>\n"
+                    "endbfrange\n"
+                    "endcmap\n"
+                    "CMapName currentdict /CMap defineresource pop\n"
+                    "end\n"
+                    "end\n");
+
+    pdfioStreamClose(st);
+
     // Create a CIDFontType2 dictionary for the Unicode font...
     if ((type2 = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
-    if ((sidict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+    // Width array
+    if ((w_array = pdfioArrayCreate(pdf)) == NULL)
+      goto done;
 
-    // CIDSystemInfo mapping to Adobe UCS2 v0 (Unicode)
-    pdfioDictSetString(sidict, "Registry", "Adobe");
-    pdfioDictSetString(sidict, "Ordering", "Identity");
-    pdfioDictSetNumber(sidict, "Supplement", 0);
+    for (start = 0, w0 = ttfGetWidth(font, 0), w1 = 0, i = 1; i < 65536; start = i, w0 = w1, i ++)
+    {
+      while (i < 65536 && (w1 = ttfGetWidth(font, (int)i)) == w0)
+        i ++;
+
+      if ((i - start) > 1)
+      {
+        // Encode a repeating sequence...
+        pdfioArrayAppendNumber(w_array, start);
+        pdfioArrayAppendNumber(w_array, i - 1);
+        pdfioArrayAppendNumber(w_array, w0);
+      }
+      else
+      {
+        // Encode a non-repeating sequence...
+        pdfioArrayAppendNumber(w_array, start);
+
+        if ((temp_array = pdfioArrayCreate(pdf)) == NULL)
+	  goto done;
+
+        pdfioArrayAppendNumber(temp_array, w0);
+        for (w0 = w1, i ++; i < 65536; w0 = w1, i ++)
+        {
+          if ((w1 = ttfGetWidth(font, (int)i)) == w0 && i < 65535)
+            break;
+
+	  pdfioArrayAppendNumber(temp_array, w0);
+        }
+
+        if (i == 65536)
+	  pdfioArrayAppendNumber(temp_array, w0);
+	else
+	  i --;
+
+        pdfioArrayAppendArray(w_array, temp_array);
+      }
+    }
 
     // Then the dictionary for the CID base font...
     pdfioDictSetName(type2, "Type", "Font");
@@ -1493,56 +1772,41 @@ pdfioFileCreateFontObjFromFile(
     pdfioDictSetDict(type2, "CIDSystemInfo", sidict);
     pdfioDictSetObj(type2, "CIDToGIDMap", cid2gid_obj);
     pdfioDictSetObj(type2, "FontDescriptor", desc_obj);
+    pdfioDictSetArray(type2, "W", w_array);
 
     if ((type2_obj = pdfioFileCreateObj(pdf, type2)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioObjClose(type2_obj);
 
     // Create a Type 0 font object...
     if ((descendants = pdfioArrayCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioArrayAppendObj(descendants, type2_obj);
 
     if ((dict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioDictSetName(dict, "Type", "Font");
     pdfioDictSetName(dict, "Subtype", "Type0");
     pdfioDictSetName(dict, "BaseFont", basefont);
     pdfioDictSetArray(dict, "DescendantFonts", descendants);
     pdfioDictSetName(dict, "Encoding", "Identity-H");
+    pdfioDictSetObj(dict, "ToUnicode", to_unicode_obj);
 
-    if ((obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-      return (NULL);
-
-    pdfioObjClose(obj);
+    if ((obj = pdfioFileCreateObj(pdf, dict)) != NULL)
+      pdfioObjClose(obj);
   }
   else
   {
     // Simple (CP1282 or custom encoding) 8-bit font...
     if (ttfGetMaxChar(font) >= 255 && !pdf->cp1252_obj && !create_cp1252(pdf))
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     // Create a TrueType font object...
     if ((dict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioDictSetName(dict, "Type", "Font");
     pdfioDictSetName(dict, "Subtype", "TrueType");
@@ -1552,16 +1816,16 @@ pdfioFileCreateFontObjFromFile(
 
     pdfioDictSetObj(dict, "FontDescriptor", desc_obj);
 
-    if ((obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
-
-    pdfioObjClose(obj);
+    if ((obj = pdfioFileCreateObj(pdf, dict)) != NULL)
+      pdfioObjClose(obj);
   }
 
-  ttfDelete(font);
+  done:
+
+  if (fd >= 0)
+    close(fd);
+
+  _pdfioObjSetExtension(obj, font, (_pdfio_extfree_t)ttfDelete);
 
   return (obj);
 }
@@ -2085,7 +2349,7 @@ pdfioPageDictAddColorSpace(
 bool					// O - `true` on success, `false` on failure
 pdfioPageDictAddFont(
     pdfio_dict_t *dict,			// I - Page dictionary
-    const char   *name,			// I - Font name
+    const char   *name,			// I - Font name; must not contain spaces
     pdfio_obj_t  *obj)			// I - Font object
 {
   pdfio_dict_t	*resources;		// Resource dictionary
@@ -2358,7 +2622,7 @@ copy_png(pdfio_dict_t *dict,		// I - Dictionary
               PDFIO_DEBUG("copy_png: Adding %s ColorSpace value.\n", color_type == _PDFIO_PNG_TYPE_GRAY ? "CalGray" : "CalRGB");
 
 	      if (wx != 0.0)
-		pdfioDictSetArray(dict, "ColorSpace", pdfioArrayCreateColorFromPrimaries(dict->pdf, color_type == _PDFIO_PNG_TYPE_GRAY ? 1 : 3, gamma, wx, wy, rx, ry, bx, by, gx, gy));
+		pdfioDictSetArray(dict, "ColorSpace", pdfioArrayCreateColorFromPrimaries(dict->pdf, color_type == _PDFIO_PNG_TYPE_GRAY ? 1 : 3, gamma, wx, wy, rx, ry, gx, gy, bx, by));
               else
 		pdfioDictSetArray(dict, "ColorSpace", pdfioArrayCreateColorFromStandard(dict->pdf, color_type == _PDFIO_PNG_TYPE_GRAY ? 1 : 3, PDFIO_CS_SRGB));
             }

pdfio-content.h

@@ -1,7 +1,7 @@
 //
 // Public content header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,18 +9,7 @@
 
 #ifndef PDFIO_CONTENT_H
 #  define PDFIO_CONTENT_H
-
-//
-// Include necessary headers...
-//
-
 #  include "pdfio.h"
-
-
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 extern "C" {
 #  endif // __cplusplus
@@ -91,12 +80,13 @@ extern bool		pdfioContentPathClose(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve(pdfio_stream_t *st, double x1, double y1, double x2, double y2, double x3, double y3) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve13(pdfio_stream_t *st, double x1, double y1, double x3, double y3) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve23(pdfio_stream_t *st, double x2, double y2, double x3, double y3) _PDFIO_PUBLIC;
+extern bool		pdfioContentPathEnd(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathLineTo(pdfio_stream_t *st, double x, double y) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathMoveTo(pdfio_stream_t *st, double x, double y) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathRect(pdfio_stream_t *st, double x, double y, double width, double height) _PDFIO_PUBLIC;
 extern bool		pdfioContentRestore(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentSave(pdfio_stream_t *st) _PDFIO_PUBLIC;
-extern bool		pdfioContentSetDashPattern(pdfio_stream_t *st, int phase, int on, int off) _PDFIO_PUBLIC;
+extern bool		pdfioContentSetDashPattern(pdfio_stream_t *st, double phase, double on, double off) _PDFIO_PUBLIC;
 extern bool		pdfioContentSetFillColorDeviceCMYK(pdfio_stream_t *st, double c, double m, double y, double k) _PDFIO_PUBLIC;
 extern bool		pdfioContentSetFillColorDeviceGray(pdfio_stream_t *st, double g) _PDFIO_PUBLIC;
 extern bool		pdfioContentSetFillColorDeviceRGB(pdfio_stream_t *st, double r, double g, double b) _PDFIO_PUBLIC;
@@ -125,8 +115,12 @@ extern bool		pdfioContentSetTextXScaling(pdfio_stream_t *st, double percent) _PD
 extern bool		pdfioContentStroke(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextBegin(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextEnd(pdfio_stream_t *st) _PDFIO_PUBLIC;
+extern double		pdfioContentTextMeasure(pdfio_obj_t *font, const char *s, double size) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextMoveLine(pdfio_stream_t *st, double tx, double ty) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextMoveTo(pdfio_stream_t *st, double tx, double ty) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLine(pdfio_stream_t *st) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLineShow(pdfio_stream_t *st, double ws, double cs, bool unicode, const char *s) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLineShowf(pdfio_stream_t *st, double ws, double cs, bool unicode, const char *format, ...) _PDFIO_PUBLIC _PDFIO_FORMAT(5,6);
 extern bool		pdfioContentTextNextLine(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextShow(pdfio_stream_t *st, bool unicode, const char *s) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextShowf(pdfio_stream_t *st, bool unicode, const char *format, ...) _PDFIO_PUBLIC _PDFIO_FORMAT(3,4);
@@ -150,10 +144,6 @@ extern bool		pdfioPageDictAddFont(pdfio_dict_t *dict, const char *name, pdfio_ob
 extern bool		pdfioPageDictAddImage(pdfio_dict_t *dict, const char *name, pdfio_obj_t *obj) _PDFIO_PUBLIC;
 
 
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus

pdfio-dict.c

@@ -1,16 +1,12 @@
 //
 // PDF dictionary functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -21,6 +17,42 @@
 static int	compare_pairs(_pdfio_pair_t *a, _pdfio_pair_t *b);
 
 
+//
+// '_pdfioDictClear()' - Remove a key/value pair from a dictionary.
+//
+
+void
+_pdfioDictClear(pdfio_dict_t *dict,	// I - Dictionary
+                const char   *key)	// I - Key
+{
+  size_t	idx;			// Index into pairs
+  _pdfio_pair_t	*pair,			// Current pair
+		pkey;			// Search key
+
+
+  PDFIO_DEBUG("_pdfioDictClear(dict=%p, key=\"%s\")\n", dict, key);
+
+  // See if the key is already set...
+  if (dict->num_pairs > 0)
+  {
+    pkey.key = key;
+
+    if ((pair = (_pdfio_pair_t *)bsearch(&pkey, dict->pairs, dict->num_pairs, sizeof(_pdfio_pair_t), (int (*)(const void *, const void *))compare_pairs)) != NULL)
+    {
+      // Yes, remove it...
+      if (pair->value.type == PDFIO_VALTYPE_BINARY)
+        free(pair->value.value.binary.data);
+
+      idx = (size_t)(pair - dict->pairs);
+      dict->num_pairs --;
+
+      if (idx < dict->num_pairs)
+        memmove(pair, pair + 1, (dict->num_pairs - idx) * sizeof(_pdfio_pair_t));
+    }
+  }
+}
+
+
 //
 // 'pdfioDictCopy()' - Copy a dictionary to a PDF file.
 //
@@ -126,6 +158,30 @@ pdfioDictCreate(pdfio_file_t *pdf)	// I - PDF file
 }
 
 
+//
+// '_pdfioDictDecrypt()' - Decrypt the values in a dictionary.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioDictDecrypt(pdfio_file_t *pdf,	// I - PDF file
+                  pdfio_obj_t  *obj,	// I - Object
+                  pdfio_dict_t *dict,	// I - Dictionary
+                  size_t       depth)	// I - Depth
+{
+  size_t	i;			// Looping var
+  _pdfio_pair_t	*pair;			// Current pair
+
+
+  for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
+  {
+    if (strcmp(pair->key, "ID") && !_pdfioValueDecrypt(pdf, obj, &pair->value, depth + 1))
+      return (false);
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioDictDebug()' - Dump a dictionary to stderr.
 //
@@ -138,6 +194,9 @@ _pdfioDictDebug(pdfio_dict_t *dict,	// I - Dictionary
   _pdfio_pair_t	*pair;			// Current pair
 
 
+  if (!dict)
+    return;
+
   for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
   {
     fprintf(fp, "/%s", pair->key);
@@ -154,7 +213,18 @@ void
 _pdfioDictDelete(pdfio_dict_t *dict)	// I - Dictionary
 {
   if (dict)
+  {
+    size_t	i;			// Looping var
+    _pdfio_pair_t *pair;		// Current pair
+
+    for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
+    {
+      if (pair->value.type == PDFIO_VALTYPE_BINARY)
+        free(pair->value.value.binary.data);
+    }
+
     free(dict->pairs);
+  }
 
   free(dict);
 }
@@ -198,6 +268,11 @@ pdfioDictGetBinary(pdfio_dict_t *dict,	// I - Dictionary
     *length = value->value.binary.datalen;
     return (value->value.binary.data);
   }
+  else if (value && value->type == PDFIO_VALTYPE_STRING)
+  {
+    *length = strlen(value->value.string);
+    return ((unsigned char *)value->value.string);
+  }
   else
   {
     *length = 0;
@@ -354,9 +429,27 @@ pdfioDictGetString(pdfio_dict_t *dict,	// I - Dictionary
 
 
   if (value && value->type == PDFIO_VALTYPE_STRING)
+  {
     return (value->value.string);
+  }
+  else if (value && value->type == PDFIO_VALTYPE_BINARY && value->value.binary.datalen < 4096)
+  {
+    // Convert binary string to regular string...
+    char	temp[4096];		// Temporary string
+
+    memcpy(temp, value->value.binary.data, value->value.binary.datalen);
+    temp[value->value.binary.datalen] = '\0';
+
+    free(value->value.binary.data);
+    value->type         = PDFIO_VALTYPE_STRING;
+    value->value.string = pdfioStringCreate(dict->pdf, temp);
+
+    return (value->value.string);
+  }
   else
+  {
     return (NULL);
+  }
 }
 
 
@@ -412,6 +505,47 @@ _pdfioDictGetValue(pdfio_dict_t *dict,	// I - Dictionary
 }
 
 
+//
+// 'pdfioDictIterateKeys()' - Iterate the keys in a dictionary.
+//
+// This function iterates the keys in a dictionary, calling the supplied
+// function "cb":
+//
+// ```
+// bool
+// my_dict_cb(pdfio_dict_t *dict, const char *key, void *cb_data)
+// {
+// ... "key" contains the dictionary key ...
+// ... return true to continue or false to stop ...
+// }
+// ```
+//
+// The iteration continues as long as the callback returns `true` or all keys
+// have been iterated.
+//
+
+void
+pdfioDictIterateKeys(
+    pdfio_dict_t    *dict,		// I - Dictionary
+    pdfio_dict_cb_t cb,			// I - Callback function
+    void            *cb_data)		// I - Callback data
+{
+  size_t	i;			// Looping var
+  _pdfio_pair_t	*pair;			// Current pair
+
+
+  // Range check input...
+  if (!dict || !cb)
+    return;
+
+  for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
+  {
+    if (!(cb)(dict, pair->key, cb_data))
+      break;
+  }
+}
+
+
 //
 // '_pdfioDictRead()' - Read a dictionary from a PDF file.
 //
@@ -420,14 +554,16 @@ _pdfioDictGetValue(pdfio_dict_t *dict,	// I - Dictionary
 
 pdfio_dict_t *				// O - New dictionary
 _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
-               _pdfio_token_t *tb)	// I - Token buffer/stack
+               pdfio_obj_t    *obj,	// I - Object, if any
+               _pdfio_token_t *tb,	// I - Token buffer/stack
+               size_t         depth)	// I - Depth of dictionary
 {
   pdfio_dict_t		*dict;		// New dictionary
   char			key[256];	// Dictionary key
   _pdfio_value_t	value;		// Dictionary value
 
 
-  PDFIO_DEBUG("_pdfioDictRead(pdf=%p)\n", pdf);
+  PDFIO_DEBUG("_pdfioDictRead(pdf=%p, obj=%p, tb=%p, depth=%lu)\n", pdf, obj, tb, (unsigned long)depth);
 
   // Create a dictionary and start reading...
   if ((dict = pdfioDictCreate(pdf)) == NULL)
@@ -439,6 +575,7 @@ _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
     if (!strcmp(key, ">>"))
     {
       // End of dictionary...
+      PDFIO_DEBUG("_pdfioDictRead: Returning dictionary value...\n");
       return (dict);
     }
     else if (key[0] != '/')
@@ -446,18 +583,25 @@ _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
       _pdfioFileError(pdf, "Invalid dictionary contents.");
       break;
     }
+    else if (_pdfioDictGetValue(dict, key + 1))
+    {
+      _pdfioFileError(pdf, "Duplicate dictionary key '%s'.", key + 1);
+      return (NULL);
+    }
 
     // Then get the next value...
-    if (!_pdfioValueRead(pdf, tb, &value))
+    PDFIO_DEBUG("_pdfioDictRead: Reading value for '%s'.\n", key + 1);
+
+    if (!_pdfioValueRead(pdf, obj, tb, &value, depth))
     {
-      _pdfioFileError(pdf, "Missing value for dictionary key.");
+      _pdfioFileError(pdf, "Missing value for dictionary key '%s'.", key + 1);
       break;
     }
 
     if (!_pdfioDictSetValue(dict, pdfioStringCreate(pdf, key + 1), &value))
       break;
 
-//    PDFIO_DEBUG("_pdfioDictRead: Set %s.\n", key);
+    PDFIO_DEBUG("_pdfioDictRead: Set %s.\n", key);
   }
 
   // Dictionary is invalid - pdfioFileClose will free the memory, return NULL
@@ -653,7 +797,7 @@ pdfioDictSetNull(pdfio_dict_t *dict,	// I - Dictionary
 bool					// O - `true` on success, `false` on failure
 pdfioDictSetNumber(pdfio_dict_t  *dict,	// I - Dictionary
                    const char    *key,	// I - Key
-                   double         value)	// I - Value
+                   double        value)	// I - Value
 {
   _pdfio_value_t temp;			// New value
 
@@ -802,6 +946,8 @@ _pdfioDictSetValue(
     {
       // Yes, replace the value...
       PDFIO_DEBUG("_pdfioDictSetValue: Replacing existing value.\n");
+      if (pair->value.type == PDFIO_VALTYPE_BINARY)
+        free(pair->value.value.binary.data);
       pair->value = *value;
       return (true);
     }
@@ -835,9 +981,9 @@ _pdfioDictSetValue(
 
 #ifdef DEBUG
   PDFIO_DEBUG("_pdfioDictSetValue(%p): %lu pairs\n", (void *)dict, (unsigned long)dict->num_pairs);
-  PDFIO_DEBUG("_pdfioDictSetValue(%p): ", (void *)dict);
-  PDFIO_DEBUG_DICT(dict);
-  PDFIO_DEBUG("\n");
+//  PDFIO_DEBUG("_pdfioDictSetValue(%p): ", (void *)dict);
+//  PDFIO_DEBUG_DICT(dict);
+//  PDFIO_DEBUG("\n");
 #endif // DEBUG
 
   return (true);
@@ -850,6 +996,7 @@ _pdfioDictSetValue(
 
 bool					// O - `true` on success, `false` on failure
 _pdfioDictWrite(pdfio_dict_t *dict,	// I - Dictionary
+		pdfio_obj_t  *obj,	// I - Object, if any
                 off_t        *length)	// I - Offset to length value
 {
   pdfio_file_t	*pdf = dict->pdf;	// PDF file
@@ -877,7 +1024,7 @@ _pdfioDictWrite(pdfio_dict_t *dict,	// I - Dictionary
       if (!_pdfioFilePuts(pdf, " 9999999999"))
         return (false);
     }
-    else if (!_pdfioValueWrite(pdf, &pair->value, NULL))
+    else if (!_pdfioValueWrite(pdf, obj, &pair->value, NULL))
       return (false);
   }
 

pdfio-md5.c

@@ -0,0 +1,338 @@
+//
+// MD5 functions for PDFio.
+//
+// Copyright © 2021 by Michael R Sweet.
+// Copyright © 1999 Aladdin Enterprises.  All rights reserved.
+//
+// This software is provided 'as-is', without any express or implied
+// warranty.  In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would be
+//    appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+//
+// L. Peter Deutsch
+// ghost@aladdin.com
+//
+
+#include "pdfio-private.h"
+
+
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321.
+  It is derived directly from the text of the RFC and not from the
+  reference implementation.
+
+  The original and principal author of md5.c is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+  1999-05-03 lpd Original version.
+ */
+
+#define T1 0xd76aa478
+#define T2 0xe8c7b756
+#define T3 0x242070db
+#define T4 0xc1bdceee
+#define T5 0xf57c0faf
+#define T6 0x4787c62a
+#define T7 0xa8304613
+#define T8 0xfd469501
+#define T9 0x698098d8
+#define T10 0x8b44f7af
+#define T11 0xffff5bb1
+#define T12 0x895cd7be
+#define T13 0x6b901122
+#define T14 0xfd987193
+#define T15 0xa679438e
+#define T16 0x49b40821
+#define T17 0xf61e2562
+#define T18 0xc040b340
+#define T19 0x265e5a51
+#define T20 0xe9b6c7aa
+#define T21 0xd62f105d
+#define T22 0x02441453
+#define T23 0xd8a1e681
+#define T24 0xe7d3fbc8
+#define T25 0x21e1cde6
+#define T26 0xc33707d6
+#define T27 0xf4d50d87
+#define T28 0x455a14ed
+#define T29 0xa9e3e905
+#define T30 0xfcefa3f8
+#define T31 0x676f02d9
+#define T32 0x8d2a4c8a
+#define T33 0xfffa3942
+#define T34 0x8771f681
+#define T35 0x6d9d6122
+#define T36 0xfde5380c
+#define T37 0xa4beea44
+#define T38 0x4bdecfa9
+#define T39 0xf6bb4b60
+#define T40 0xbebfbc70
+#define T41 0x289b7ec6
+#define T42 0xeaa127fa
+#define T43 0xd4ef3085
+#define T44 0x04881d05
+#define T45 0xd9d4d039
+#define T46 0xe6db99e5
+#define T47 0x1fa27cf8
+#define T48 0xc4ac5665
+#define T49 0xf4292244
+#define T50 0x432aff97
+#define T51 0xab9423a7
+#define T52 0xfc93a039
+#define T53 0x655b59c3
+#define T54 0x8f0ccc92
+#define T55 0xffeff47d
+#define T56 0x85845dd1
+#define T57 0x6fa87e4f
+#define T58 0xfe2ce6e0
+#define T59 0xa3014314
+#define T60 0x4e0811a1
+#define T61 0xf7537e82
+#define T62 0xbd3af235
+#define T63 0x2ad7d2bb
+#define T64 0xeb86d391
+
+static void
+md5_process(_pdfio_md5_t *pms, const uint8_t *data /*[64]*/)
+{
+    uint32_t
+	a = pms->abcd[0], b = pms->abcd[1],
+	c = pms->abcd[2], d = pms->abcd[3];
+    uint32_t t;
+
+#ifndef ARCH_IS_BIG_ENDIAN
+# define ARCH_IS_BIG_ENDIAN 1	/* slower, default implementation */
+#endif
+#if ARCH_IS_BIG_ENDIAN
+
+    /*
+     * On big-endian machines, we must arrange the bytes in the right
+     * order.  (This also works on machines of unknown byte order.)
+     */
+    uint32_t X[16];
+    const uint8_t *xp = data;
+    int i;
+
+    for (i = 0; i < 16; ++i, xp += 4)
+	X[i] = xp[0] + (unsigned)(xp[1] << 8) + (unsigned)(xp[2] << 16) + (unsigned)(xp[3] << 24);
+
+#else  /* !ARCH_IS_BIG_ENDIAN */
+
+    /*
+     * On little-endian machines, we can process properly aligned data
+     * without copying it.
+     */
+    uint32_t xbuf[16];
+    const uint32_t *X;
+
+    if (!((data - (const uint8_t *)0) & 3)) {
+	/* data are properly aligned */
+	X = (const uint32_t *)data;
+    } else {
+	/* not aligned */
+	memcpy(xbuf, data, 64);
+	X = xbuf;
+    }
+#endif
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+    /* Round 1. */
+    /* Let [abcd k s i] denote the operation
+       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + F(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  7,  T1);
+    SET(d, a, b, c,  1, 12,  T2);
+    SET(c, d, a, b,  2, 17,  T3);
+    SET(b, c, d, a,  3, 22,  T4);
+    SET(a, b, c, d,  4,  7,  T5);
+    SET(d, a, b, c,  5, 12,  T6);
+    SET(c, d, a, b,  6, 17,  T7);
+    SET(b, c, d, a,  7, 22,  T8);
+    SET(a, b, c, d,  8,  7,  T9);
+    SET(d, a, b, c,  9, 12, T10);
+    SET(c, d, a, b, 10, 17, T11);
+    SET(b, c, d, a, 11, 22, T12);
+    SET(a, b, c, d, 12,  7, T13);
+    SET(d, a, b, c, 13, 12, T14);
+    SET(c, d, a, b, 14, 17, T15);
+    SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+     /* Round 2. */
+     /* Let [abcd k s i] denote the operation
+          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + G(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  1,  5, T17);
+    SET(d, a, b, c,  6,  9, T18);
+    SET(c, d, a, b, 11, 14, T19);
+    SET(b, c, d, a,  0, 20, T20);
+    SET(a, b, c, d,  5,  5, T21);
+    SET(d, a, b, c, 10,  9, T22);
+    SET(c, d, a, b, 15, 14, T23);
+    SET(b, c, d, a,  4, 20, T24);
+    SET(a, b, c, d,  9,  5, T25);
+    SET(d, a, b, c, 14,  9, T26);
+    SET(c, d, a, b,  3, 14, T27);
+    SET(b, c, d, a,  8, 20, T28);
+    SET(a, b, c, d, 13,  5, T29);
+    SET(d, a, b, c,  2,  9, T30);
+    SET(c, d, a, b,  7, 14, T31);
+    SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+     /* Round 3. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + H(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  5,  4, T33);
+    SET(d, a, b, c,  8, 11, T34);
+    SET(c, d, a, b, 11, 16, T35);
+    SET(b, c, d, a, 14, 23, T36);
+    SET(a, b, c, d,  1,  4, T37);
+    SET(d, a, b, c,  4, 11, T38);
+    SET(c, d, a, b,  7, 16, T39);
+    SET(b, c, d, a, 10, 23, T40);
+    SET(a, b, c, d, 13,  4, T41);
+    SET(d, a, b, c,  0, 11, T42);
+    SET(c, d, a, b,  3, 16, T43);
+    SET(b, c, d, a,  6, 23, T44);
+    SET(a, b, c, d,  9,  4, T45);
+    SET(d, a, b, c, 12, 11, T46);
+    SET(c, d, a, b, 15, 16, T47);
+    SET(b, c, d, a,  2, 23, T48);
+#undef SET
+
+     /* Round 4. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + I(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  6, T49);
+    SET(d, a, b, c,  7, 10, T50);
+    SET(c, d, a, b, 14, 15, T51);
+    SET(b, c, d, a,  5, 21, T52);
+    SET(a, b, c, d, 12,  6, T53);
+    SET(d, a, b, c,  3, 10, T54);
+    SET(c, d, a, b, 10, 15, T55);
+    SET(b, c, d, a,  1, 21, T56);
+    SET(a, b, c, d,  8,  6, T57);
+    SET(d, a, b, c, 15, 10, T58);
+    SET(c, d, a, b,  6, 15, T59);
+    SET(b, c, d, a, 13, 21, T60);
+    SET(a, b, c, d,  4,  6, T61);
+    SET(d, a, b, c, 11, 10, T62);
+    SET(c, d, a, b,  2, 15, T63);
+    SET(b, c, d, a,  9, 21, T64);
+#undef SET
+
+     /* Then perform the following additions. (That is increment each
+        of the four registers by the value it had before this block
+        was started.) */
+    pms->abcd[0] += a;
+    pms->abcd[1] += b;
+    pms->abcd[2] += c;
+    pms->abcd[3] += d;
+}
+
+void
+_pdfioCryptoMD5Init(_pdfio_md5_t *pms)
+{
+    pms->count[0] = pms->count[1] = 0;
+    pms->abcd[0] = 0x67452301;
+    pms->abcd[1] = 0xefcdab89;
+    pms->abcd[2] = 0x98badcfe;
+    pms->abcd[3] = 0x10325476;
+}
+
+void
+_pdfioCryptoMD5Append(_pdfio_md5_t *pms, const uint8_t *data, size_t nbytes)
+{
+    const uint8_t *p = data;
+    size_t left = nbytes;
+    size_t offset = (pms->count[0] >> 3) & 63;
+    uint32_t nbits = (uint32_t)(nbytes << 3);
+
+    if (nbytes == 0)
+	return;
+
+    /* Update the message length. */
+    pms->count[1] += (unsigned)(nbytes >> 29);
+    pms->count[0] += nbits;
+    if (pms->count[0] < nbits)
+	pms->count[1]++;
+
+    /* Process an initial partial block. */
+    if (offset) {
+	size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+	memcpy(pms->buf + offset, p, copy);
+	if (offset + copy < 64)
+	    return;
+	p += copy;
+	left -= copy;
+	md5_process(pms, pms->buf);
+    }
+
+    /* Process full blocks. */
+    for (; left >= 64; p += 64, left -= 64)
+	md5_process(pms, p);
+
+    /* Process a final partial block. */
+    if (left)
+	memcpy(pms->buf, p, left);
+}
+
+void
+_pdfioCryptoMD5Finish(_pdfio_md5_t *pms, uint8_t digest[16])
+{
+    static const uint8_t pad[64] = {
+	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    uint8_t data[8];
+    int i;
+
+    /* Save the length before padding. */
+    for (i = 0; i < 8; ++i)
+	data[i] = (uint8_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+    /* Pad to 56 bytes mod 64. */
+    _pdfioCryptoMD5Append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+    /* Append the length. */
+    _pdfioCryptoMD5Append(pms, data, 8);
+    for (i = 0; i < 16; ++i)
+	digest[i] = (uint8_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}

pdfio-object.c

@@ -1,16 +1,12 @@
 //
 // PDF object functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -33,8 +29,14 @@ pdfioObjClose(pdfio_obj_t *obj)		// I - Object
   if (!obj)
     return (false);
 
+  // Clear the current object pointer...
+  obj->pdf->current_obj = NULL;
+
   if (obj->pdf->mode != _PDFIO_MODE_WRITE)
-    return (true);			// Nothing to do when reading
+  {
+    // Nothing to do when reading
+    return (true);
+  }
 
   // Write what remains for the object...
   if (!obj->offset)
@@ -96,6 +98,9 @@ pdfioObjCopy(pdfio_file_t *pdf,		// I - PDF file
   if (!_pdfioValueCopy(pdf, &dstobj->value, srcobj->pdf, &srcobj->value))
     return (NULL);
 
+  if (dstobj->value.type == PDFIO_VALTYPE_DICT)
+    _pdfioDictClear(dstobj->value.value.dict, "Length");
+
   if (srcobj->stream_offset)
   {
     // Copy stream data...
@@ -143,6 +148,9 @@ pdfioObjCreateStream(
     pdfio_obj_t    *obj,		// I - Object
     pdfio_filter_t filter)		// I - Type of compression to apply
 {
+  pdfio_obj_t	*length_obj = NULL;	// Length object, if any
+
+
   // Range check input
   if (!obj || obj->pdf->mode != _PDFIO_MODE_WRITE || obj->value.type != PDFIO_VALTYPE_DICT)
     return (NULL);
@@ -159,12 +167,32 @@ pdfioObjCreateStream(
     return (NULL);
   }
 
+  if (obj->pdf->current_obj)
+  {
+    _pdfioFileError(obj->pdf, "Another object (%u) is already open.", (unsigned)obj->pdf->current_obj->number);
+    return (NULL);
+  }
+
   // Write the header...
   if (!_pdfioDictGetValue(obj->value.value.dict, "Length"))
   {
-    // Need a Length key for the stream, add a placeholder that we can fill in
-    // later...
-    pdfioDictSetNumber(obj->value.value.dict, "Length", 0.0);
+    if (obj->pdf->output_cb)
+    {
+      // Streaming via an output callback, so add a placeholder length object
+      _pdfio_value_t	length_value;	// Length value
+
+      length_value.type         = PDFIO_VALTYPE_NUMBER;
+      length_value.value.number = 0.0f;
+
+      length_obj = _pdfioFileCreateObj(obj->pdf, obj->pdf, &length_value);
+      pdfioDictSetObj(obj->value.value.dict, "Length", length_obj);
+    }
+    else
+    {
+      // Need a Length key for the stream, add a placeholder that we can fill in
+      // later...
+      pdfioDictSetNumber(obj->value.value.dict, "Length", 0.0);
+    }
   }
 
   if (!write_obj_header(obj))
@@ -173,10 +201,11 @@ pdfioObjCreateStream(
   if (!_pdfioFilePuts(obj->pdf, "stream\n"))
     return (NULL);
 
-  obj->stream_offset = _pdfioFileTell(obj->pdf);
+  obj->stream_offset    = _pdfioFileTell(obj->pdf);
+  obj->pdf->current_obj = obj;
 
   // Return the new stream...
-  return (_pdfioStreamCreate(obj, filter));
+  return (_pdfioStreamCreate(obj, length_obj, filter));
 }
 
 
@@ -188,8 +217,13 @@ void
 _pdfioObjDelete(pdfio_obj_t *obj)	// I - Object
 {
   if (obj)
+  {
     pdfioStreamClose(obj->stream);
 
+    if (obj->datafree)
+      (obj->datafree)(obj->data);
+  }
+
   free(obj);
 }
 
@@ -234,6 +268,17 @@ pdfioObjGetDict(pdfio_obj_t *obj)	// I - Object
 }
 
 
+//
+// '_pdfioObjGetExtension()' - Get the extension pointer for an object.
+//
+
+void *					// O - Extension data
+_pdfioObjGetExtension(pdfio_obj_t *obj)	// I - Object
+{
+  return (obj->data);
+}
+
+
 //
 // 'pdfioObjGetGeneration()' - Get the object's generation number.
 //
@@ -288,6 +333,26 @@ pdfioObjGetLength(pdfio_obj_t *obj)	// I - Object
 }
 
 
+//
+// 'pdfioObjGetName()' - Get the name value associated with an object.
+//
+
+const char *				// O - Dictionary or `NULL` on error
+pdfioObjGetName(pdfio_obj_t *obj)	// I - Object
+{
+  if (!obj)
+    return (NULL);
+
+  if (obj->value.type == PDFIO_VALTYPE_NONE)
+    _pdfioObjLoad(obj);
+
+  if (obj->value.type == PDFIO_VALTYPE_NAME)
+    return (obj->value.value.name);
+  else
+    return (NULL);
+}
+
+
 //
 // 'pdfioObjGetNumber()' - Get the object's number.
 //
@@ -302,8 +367,21 @@ pdfioObjGetNumber(pdfio_obj_t *obj)	// I - Object
 //
 // 'pdfioObjGetSubtype()' - Get an object's subtype.
 //
+// This function returns an object's PDF subtype name, if any.  Common subtype
+// names include:
+//
+// - "CIDFontType0": A CID Type0 font
+// - "CIDFontType2": A CID TrueType font
+// - "Image": An image or image mask
+// - "Form": A fillable form
+// - "OpenType": An OpenType font
+// - "Type0": A composite font
+// - "Type1": A PostScript Type1 font
+// - "Type3": A PDF Type3 font
+// - "TrueType": A TrueType font
+//
 
-const char *				// O - Object subtype
+const char *				// O - Object subtype name or `NULL` for none
 pdfioObjGetSubtype(pdfio_obj_t *obj)	// I - Object
 {
   pdfio_dict_t	*dict;			// Object dictionary
@@ -319,8 +397,21 @@ pdfioObjGetSubtype(pdfio_obj_t *obj)	// I - Object
 //
 // 'pdfioObjGetType()' - Get an object's type.
 //
+// This function returns an object's PDF type name, if any. Common type names
+// include:
+//
+// - "CMap": A character map for composite fonts
+// - "Font": An embedded font (@link pdfioObjGetSubtype@ will tell you the
+//   font format)
+// - "FontDescriptor": A font descriptor
+// - "Page": A (visible) page
+// - "Pages": A page tree node
+// - "Template": An invisible template page
+// - "XObject": An image, image mask, or form (@link pdfioObjGetSubtype@ will
+//   tell you which)
+//
 
-const char *				// O - Object type
+const char *				// O - Object type name or `NULL` for none
 pdfioObjGetType(pdfio_obj_t *obj)	// I - Object
 {
   pdfio_dict_t	*dict;			// Object dictionary
@@ -387,12 +478,15 @@ _pdfioObjLoad(pdfio_obj_t *obj)		// I - Object
   }
 
   ptr += 3;
+  while (*ptr && isspace(*ptr & 255))
+    ptr ++;
+
   _pdfioFileConsume(obj->pdf, (size_t)(ptr - line));
 
   // Then grab the object value...
   _pdfioTokenInit(&tb, obj->pdf, (_pdfio_tconsume_cb_t)_pdfioFileConsume, (_pdfio_tpeek_cb_t)_pdfioFilePeek, obj->pdf);
 
-  if (!_pdfioValueRead(obj->pdf, &tb, &obj->value))
+  if (!_pdfioValueRead(obj->pdf, obj, &tb, &obj->value, 0))
   {
     _pdfioFileError(obj->pdf, "Unable to read value for object %lu.", (unsigned long)obj->number);
     return (false);
@@ -405,15 +499,29 @@ _pdfioObjLoad(pdfio_obj_t *obj)		// I - Object
     return (false);
   }
 
+  PDFIO_DEBUG("_pdfioObjLoad: tb.bufptr=%p, tb.bufend=%p, tb.bufptr[0]=0x%02x, tb.bufptr[1]=0x%02x\n", tb.bufptr, tb.bufend, tb.bufptr[0], tb.bufptr[1]);
+
   _pdfioTokenFlush(&tb);
 
   if (!strcmp(line, "stream"))
   {
-    // Yes, save its location...
+    // Yes, this is an embedded stream so save its location...
     obj->stream_offset = _pdfioFileTell(obj->pdf);
     PDFIO_DEBUG("_pdfioObjLoad: stream_offset=%lu.\n", (unsigned long)obj->stream_offset);
   }
 
+  // Decrypt as needed...
+  if (obj->pdf->encryption)
+  {
+    PDFIO_DEBUG("_pdfioObjLoad: Decrypting value...\n");
+
+    if (!_pdfioValueDecrypt(obj->pdf, obj, &obj->value, 0))
+    {
+      PDFIO_DEBUG("_pdfioObjLoad: Failed to decrypt.\n");
+      return (false);
+    }
+  }
+
   PDFIO_DEBUG("_pdfioObjLoad: ");
   PDFIO_DEBUG_VALUE(&obj->value);
   PDFIO_DEBUG("\n");
@@ -434,6 +542,12 @@ pdfioObjOpenStream(pdfio_obj_t *obj,	// I - Object
   if (!obj)
     return (NULL);
 
+  if (obj->pdf->current_obj)
+  {
+    _pdfioFileError(obj->pdf, "Another object (%u) is already open.", (unsigned)obj->pdf->current_obj->number);
+    return (NULL);
+  }
+
   // Make sure we've loaded the object dictionary...
   if (!obj->value.type)
   {
@@ -446,10 +560,27 @@ pdfioObjOpenStream(pdfio_obj_t *obj,	// I - Object
     return (NULL);
 
   // Open the stream...
+  obj->pdf->current_obj = obj;
+
   return (_pdfioStreamOpen(obj, decode));
 }
 
 
+//
+// '_pdfioObjSetExtension()' - Set extension data for an object.
+//
+
+void
+_pdfioObjSetExtension(
+    pdfio_obj_t      *obj,		// I - Object
+    void             *data,		// I - Data
+    _pdfio_extfree_t datafree)		// I - Free function
+{
+  obj->data     = data;
+  obj->datafree = datafree;
+}
+
+
 //
 // 'write_obj_header()' - Write the object header...
 //
@@ -462,7 +593,7 @@ write_obj_header(pdfio_obj_t *obj)	// I - Object
   if (!_pdfioFilePrintf(obj->pdf, "%lu %u obj\n", (unsigned long)obj->number, obj->generation))
     return (false);
 
-  if (!_pdfioValueWrite(obj->pdf, &obj->value, &obj->length_offset))
+  if (!_pdfioValueWrite(obj->pdf, obj, &obj->value, &obj->length_offset))
     return (false);
 
   return (_pdfioFilePuts(obj->pdf, "\n"));

pdfio-page.c

@@ -1,17 +1,20 @@
 //
 // PDF page functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2022 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
+#include "pdfio-private.h"
+
+
 //
-// Include necessary headers...
+// Local functions...
 //
 
-#include "pdfio-private.h"
+static _pdfio_value_t	*get_contents(pdfio_obj_t *page);
 
 
 //
@@ -47,3 +50,74 @@ pdfioPageCopy(pdfio_file_t *pdf,	// I - PDF file
   else
     return (_pdfioFileAddPage(pdf, dstpage));
 }
+
+
+//
+// 'pdfioPageGetNumStreams()' - Get the number of content streams for a page object.
+//
+
+size_t					// O - Number of streams
+pdfioPageGetNumStreams(
+    pdfio_obj_t *page)			// I - Page object
+{
+  _pdfio_value_t *contents = get_contents(page);
+					// Contents value
+
+
+  if (!contents)
+    return (0);
+  else if (contents->type == PDFIO_VALTYPE_ARRAY)
+    return (pdfioArrayGetSize(contents->value.array));
+  else
+    return (1);
+}
+
+
+//
+// 'pdfioPageOpenStream()' - Open a content stream for a page.
+//
+
+pdfio_stream_t *			// O - Stream
+pdfioPageOpenStream(
+    pdfio_obj_t *page,			// I - Page object
+    size_t      n,			// I - Stream index (0-based)
+    bool        decode)			// I - `true` to decode/decompress stream
+{
+  _pdfio_value_t *contents = get_contents(page);
+					// Contents value
+
+
+  if (!contents)
+    return (NULL);
+  else if (contents->type == PDFIO_VALTYPE_ARRAY && n < pdfioArrayGetSize(contents->value.array))
+    return (pdfioObjOpenStream(pdfioArrayGetObj(contents->value.array, n), decode));
+  else if (n)
+    return (NULL);
+  else
+    return (pdfioObjOpenStream(pdfioFileFindObj(page->pdf, contents->value.indirect.number), decode));
+}
+
+
+//
+// 'get_contents()' - Get a page's Contents value.
+//
+
+static _pdfio_value_t *			// O - Value or NULL on error
+get_contents(pdfio_obj_t *page)		// I - Page object
+{
+  // Range check input...
+  if (!page)
+    return (NULL);
+
+  // Load the page object as needed...
+  if (page->value.type == PDFIO_VALTYPE_NONE)
+  {
+    if (!_pdfioObjLoad(page))
+      return (NULL);
+  }
+
+  if (page->value.type != PDFIO_VALTYPE_DICT)
+    return (NULL);
+
+  return (_pdfioDictGetValue(page->value.value.dict, "Contents"));
+}

pdfio-private.h

@@ -1,7 +1,7 @@
 //
 // Private header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,40 +9,23 @@
 
 #ifndef PDFIO_PRIVATE_H
 #  define PDFIO_PRIVATE_H
-
-//
-// Include necessary headers...
-//
-
 #  ifdef _WIN32
-/*
- * Disable bogus VS warnings/errors...
- */
-
-#    define _CRT_SECURE_NO_WARNINGS
+#    define _CRT_SECURE_NO_WARNINGS	// Disable bogus VS warnings/errors...
 #  endif // _WIN32
-
 #  include "pdfio.h"
 #  include <stdarg.h>
+#  include <stdint.h>
 #  include <string.h>
+#  include <ctype.h>
 #  include <errno.h>
 #  include <inttypes.h>
 #  include <fcntl.h>
+#  include <locale.h>
 #  ifdef _WIN32
 #    include <io.h>
 #    include <direct.h>
-
-/*
- * Microsoft renames the POSIX functions to _name, and introduces
- * a broken compatibility layer using the original names.  As a result,
- * random crashes can occur when, for example, strdup() allocates memory
- * from a different heap than used by malloc() and free().
- *
- * To avoid moronic problems like this, we #define the POSIX function
- * names to the corresponding non-standard Microsoft names.
- */
-
-#    define access	_access
+#    include <windows.h> // GetTempPathA
+#    define access	_access		// Map standard POSIX/C99 names
 #    define close	_close
 #    define fileno	_fileno
 #    define lseek	_lseek
@@ -55,25 +38,20 @@
 #    define unlink	_unlink
 #    define vsnprintf	_vsnprintf
 #    define write	_write
-
-/*
- * Map various parameters for POSIX...
- */
-
-#    define F_OK	00
-#    define W_OK	02
-#    define R_OK	04
-#    define O_RDONLY	_O_RDONLY
+#    ifndef F_OK
+#      define F_OK	00		// POSIX parameters/flags
+#      define W_OK	02
+#      define R_OK	04
+#    endif // !F_OK
+#    define O_RDONLY	_O_RDONLY	// Map standard POSIX open flags
 #    define O_WRONLY	_O_WRONLY
 #    define O_CREAT	_O_CREAT
 #    define O_TRUNC	_O_TRUNC
 #    define O_BINARY	_O_BINARY
 #  else // !_WIN32
 #    include <unistd.h>
-#    define O_BINARY	0
+#    define O_BINARY	0		// Map Windows-specific open flag
 #  endif // _WIN32
-#  include <string.h>
-#  include <ctype.h>
 #  include <zlib.h>
 
 
@@ -115,6 +93,11 @@
 // Types and constants...
 //
 
+#  define PDFIO_MAX_DEPTH	32	// Maximum nesting depth for values
+
+typedef void (*_pdfio_extfree_t)(void *);
+					// Extension data free function
+
 typedef enum _pdfio_mode_e		// Read/write mode
 {
   _PDFIO_MODE_READ,			// Read a PDF file
@@ -174,6 +157,44 @@ typedef struct _pdfio_value_s		// Value structure
   }		value;			// Value union
 } _pdfio_value_t;
 
+typedef struct _pdfio_aes_s		// AES encryption state
+{
+  size_t	round_size;		// Size of round key
+  uint8_t	round_key[240],		// Round key
+		iv[16];			// Initialization vector
+} _pdfio_aes_t;
+
+typedef struct _pdfio_md5_s		// MD5 hash state
+{
+  uint32_t	count[2];		// Message length in bits, lsw first
+  uint32_t	abcd[4];		// Digest buffer
+  uint8_t	buf[64];		// Accumulate block
+} _pdfio_md5_t;
+
+typedef struct _pdfio_rc4_s		// RC4 encryption state
+{
+  uint8_t	sbox[256];		// S boxes for encryption
+  uint8_t	i, j;			// Current indices into S boxes
+} _pdfio_rc4_t;
+
+typedef struct _pdfio_sha265_s		// SHA-256 hash state
+{
+  uint32_t	Intermediate_Hash[8];	// Message Digest
+  uint32_t	Length_High;		// Message length in bits
+  uint32_t	Length_Low;		// Message length in bits
+  int		Message_Block_Index;	// Message_Block array index
+  uint8_t	Message_Block[64];	// 512-bit message blocks
+  int		Computed;		// Is the hash computed?
+  int		Corrupted;		// Cumulative corruption code
+} _pdfio_sha256_t;
+
+typedef union _pdfio_crypto_ctx_u	// Cryptographic contexts
+{
+  _pdfio_aes_t	aes;			// AES-128/256 context
+  _pdfio_rc4_t	rc4;			// RC4-40/128 context
+} _pdfio_crypto_ctx_t;
+typedef size_t (*_pdfio_crypto_cb_t)(_pdfio_crypto_ctx_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len);
+
 struct _pdfio_array_s
 {
   pdfio_file_t	*pdf;			// PDF file
@@ -206,24 +227,37 @@ typedef struct _pdfio_objmap_s		// PDF object map
 struct _pdfio_file_s			// PDF file structure
 {
   char		*filename;		// Filename
+  struct lconv	*loc;			// Locale data
   char		*version;		// Version number
   pdfio_rect_t	media_box,		// Default MediaBox value
 		crop_box;		// Default CropBox value
   _pdfio_mode_t	mode;			// Read/write mode
+  pdfio_output_cb_t output_cb;		// Output callback
+  void		*output_ctx;		// Context for output callback
   pdfio_error_cb_t error_cb;		// Error callback
   void		*error_data;		// Data for error callback
 
+  pdfio_encryption_t encryption;	// Encryption mode
+  pdfio_permission_t permissions;	// Access permissions (encrypted PDF files)
+  uint8_t	file_key[16],		// File encryption key
+		owner_key[32],		// Owner encryption key
+		user_key[32],		// User encryption key
+		password[32];		// Padded password
+  size_t	file_keylen,		// Length of file encryption key
+		owner_keylen,		// Length of owner encryption key
+		user_keylen;		// Length of user encryption key
+
   // Active file data
   int		fd;			// File descriptor
   char		buffer[8192],		// Read/write buffer
 		*bufptr,		// Pointer into buffer
 		*bufend;		// End of buffer
   off_t		bufpos;			// Position in file for start of buffer
-  pdfio_dict_t	*trailer;		// Trailer dictionary
-  pdfio_obj_t	*root;			// Root object/dictionary
-  pdfio_obj_t	*info;			// Information object
-  pdfio_obj_t	*pages_root;		// Root pages object
-  pdfio_obj_t	*encrypt;		// Encryption object/dictionary
+  pdfio_dict_t	*trailer_dict;		// Trailer dictionary
+  pdfio_obj_t	*root_obj;		// Root object/dictionary
+  pdfio_obj_t	*info_obj;		// Information object
+  pdfio_obj_t	*pages_obj;		// Root pages object
+  pdfio_obj_t	*encrypt_obj;		// De/Encryption object/dictionary
   pdfio_obj_t	*cp1252_obj,		// CP1252 font encoding object
 		*unicode_obj;		// Unicode font encoding object
   pdfio_array_t	*id_array;		// ID array
@@ -236,8 +270,10 @@ struct _pdfio_file_s			// PDF file structure
 		alloc_dicts;		// Allocated dictionaries
   pdfio_dict_t	**dicts;		// Dictionaries
   size_t	num_objs,		// Number of objects
-		alloc_objs;		// Allocated objects
-  pdfio_obj_t	**objs;			// Objects
+		alloc_objs,		// Allocated objects
+		last_obj;		// Last object added
+  pdfio_obj_t	**objs,			// Objects
+		*current_obj;		// Current object being written/read
   size_t	num_objmaps,		// Number of object maps
 		alloc_objmaps;		// Allocated object maps
   _pdfio_objmap_t *objmaps;		// Object maps
@@ -260,12 +296,15 @@ struct _pdfio_obj_s			// Object
   size_t	stream_length;		// Length of stream, if any
   _pdfio_value_t value;			// Dictionary/number/etc. value
   pdfio_stream_t *stream;		// Open stream, if any
+  void		*data;			// Extension data, if any
+  _pdfio_extfree_t datafree;		// Free callback for extension data
 };
 
 struct _pdfio_stream_s			// Stream
 {
   pdfio_file_t	*pdf;			// PDF file
   pdfio_obj_t	*obj;			// Object
+  pdfio_obj_t	*length_obj;		// Length object, if any
   pdfio_filter_t filter;		// Compression/decompression filter
   size_t	remaining;		// Remaining bytes in stream
   char		buffer[8192],		// Read/write buffer
@@ -278,6 +317,8 @@ struct _pdfio_stream_s			// Stream
   unsigned char	cbuffer[4096],		// Compressed data buffer
 		*prbuffer,		// Raw buffer (previous line), as needed
 		*psbuffer;		// PNG filter buffer, as needed
+  _pdfio_crypto_cb_t crypto_cb;		// Encryption/descryption callback, if any
+  _pdfio_crypto_ctx_t crypto_ctx;	// Cryptographic context
 };
 
 
@@ -285,18 +326,41 @@ struct _pdfio_stream_s			// Stream
 // Functions...
 //
 
+extern double		_pdfio_strtod(pdfio_file_t *pdf, const char *s) _PDFIO_INTERNAL;
+extern ssize_t		_pdfio_vsnprintf(pdfio_file_t *pdf, char *buffer, size_t bufsize, const char *format, va_list ap) _PDFIO_INTERNAL;
+
+extern bool		_pdfioArrayDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, pdfio_array_t *a, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioArrayDebug(pdfio_array_t *a, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioArrayDelete(pdfio_array_t *a) _PDFIO_INTERNAL;
 extern _pdfio_value_t	*_pdfioArrayGetValue(pdfio_array_t *a, size_t n) _PDFIO_INTERNAL;
-extern pdfio_array_t	*_pdfioArrayRead(pdfio_file_t *pdf, _pdfio_token_t *ts) _PDFIO_INTERNAL;
-extern bool		_pdfioArrayWrite(pdfio_array_t *a) _PDFIO_INTERNAL;
+extern pdfio_array_t	*_pdfioArrayRead(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_token_t *ts, size_t depth) _PDFIO_INTERNAL;
+extern bool		_pdfioArrayWrite(pdfio_array_t *a, pdfio_obj_t *obj) _PDFIO_INTERNAL;
 
+extern void		_pdfioCryptoAESInit(_pdfio_aes_t *ctx, const uint8_t *key, size_t keylen, const uint8_t *iv) _PDFIO_INTERNAL;
+extern size_t		_pdfioCryptoAESDecrypt(_pdfio_aes_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
+extern size_t		_pdfioCryptoAESEncrypt(_pdfio_aes_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
+extern bool		_pdfioCryptoLock(pdfio_file_t *pdf, pdfio_permission_t permissions, pdfio_encryption_t encryption, const char *owner_password, const char *user_password) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoMakeRandom(uint8_t *buffer, size_t bytes) _PDFIO_INTERNAL;
+extern _pdfio_crypto_cb_t _pdfioCryptoMakeReader(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_crypto_ctx_t *ctx, uint8_t *iv, size_t *ivlen) _PDFIO_INTERNAL;
+extern _pdfio_crypto_cb_t _pdfioCryptoMakeWriter(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_crypto_ctx_t *ctx, uint8_t *iv, size_t *ivlen) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoMD5Append(_pdfio_md5_t *pms, const uint8_t *data, size_t nbytes) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoMD5Finish(_pdfio_md5_t *pms, uint8_t digest[16]) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoMD5Init(_pdfio_md5_t *pms) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoRC4Init(_pdfio_rc4_t *ctx, const uint8_t *key, size_t keylen) _PDFIO_INTERNAL;
+extern size_t		_pdfioCryptoRC4Crypt(_pdfio_rc4_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoSHA256Append(_pdfio_sha256_t *, const uint8_t *bytes, size_t bytecount) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoSHA256Init(_pdfio_sha256_t *ctx) _PDFIO_INTERNAL;
+extern void		_pdfioCryptoSHA256Finish(_pdfio_sha256_t *ctx, uint8_t *Message_Digest) _PDFIO_INTERNAL;
+extern bool		_pdfioCryptoUnlock(pdfio_file_t *pdf, pdfio_password_cb_t password_cb, void *password_data) _PDFIO_INTERNAL;
+
+extern void		_pdfioDictClear(pdfio_dict_t *dict, const char *key) _PDFIO_INTERNAL;
+extern bool		_pdfioDictDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, pdfio_dict_t *dict, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioDictDebug(pdfio_dict_t *dict, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioDictDelete(pdfio_dict_t *dict) _PDFIO_INTERNAL;
 extern _pdfio_value_t	*_pdfioDictGetValue(pdfio_dict_t *dict, const char *key) _PDFIO_INTERNAL;
-extern pdfio_dict_t	*_pdfioDictRead(pdfio_file_t *pdf, _pdfio_token_t *ts) _PDFIO_INTERNAL;
+extern pdfio_dict_t	*_pdfioDictRead(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_token_t *ts, size_t depth) _PDFIO_INTERNAL;
 extern bool		_pdfioDictSetValue(pdfio_dict_t *dict, const char *key, _pdfio_value_t *value) _PDFIO_INTERNAL;
-extern bool		_pdfioDictWrite(pdfio_dict_t *dict, off_t *length) _PDFIO_INTERNAL;
+extern bool		_pdfioDictWrite(pdfio_dict_t *dict, pdfio_obj_t *obj, off_t *length) _PDFIO_INTERNAL;
 
 extern bool		_pdfioFileAddMappedObj(pdfio_file_t *pdf, pdfio_obj_t *dst_obj, pdfio_obj_t *src_obj) _PDFIO_INTERNAL;
 extern bool		_pdfioFileAddPage(pdfio_file_t *pdf, pdfio_obj_t *obj) _PDFIO_INTERNAL;
@@ -317,9 +381,11 @@ extern off_t		_pdfioFileTell(pdfio_file_t *pdf) _PDFIO_INTERNAL;
 extern bool		_pdfioFileWrite(pdfio_file_t *pdf, const void *buffer, size_t bytes) _PDFIO_INTERNAL;
 
 extern void		_pdfioObjDelete(pdfio_obj_t *obj) _PDFIO_INTERNAL;
+extern void		*_pdfioObjGetExtension(pdfio_obj_t *obj) _PDFIO_INTERNAL;
 extern bool		_pdfioObjLoad(pdfio_obj_t *obj) _PDFIO_INTERNAL;
+extern void		_pdfioObjSetExtension(pdfio_obj_t *obj, void *data, _pdfio_extfree_t datafree) _PDFIO_INTERNAL;
 
-extern pdfio_stream_t	*_pdfioStreamCreate(pdfio_obj_t *obj, pdfio_filter_t compression) _PDFIO_INTERNAL;
+extern pdfio_stream_t	*_pdfioStreamCreate(pdfio_obj_t *obj, pdfio_obj_t *length_obj, pdfio_filter_t compression) _PDFIO_INTERNAL;
 extern pdfio_stream_t	*_pdfioStreamOpen(pdfio_obj_t *obj, bool decode) _PDFIO_INTERNAL;
 
 extern bool		_pdfioStringIsAllocated(pdfio_file_t *pdf, const char *s) _PDFIO_INTERNAL;
@@ -332,9 +398,11 @@ extern void		_pdfioTokenPush(_pdfio_token_t *tb, const char *token) _PDFIO_INTER
 extern bool		_pdfioTokenRead(_pdfio_token_t *tb, char *buffer, size_t bufsize);
 
 extern _pdfio_value_t	*_pdfioValueCopy(pdfio_file_t *pdfdst, _pdfio_value_t *vdst, pdfio_file_t *pdfsrc, _pdfio_value_t *vsrc) _PDFIO_INTERNAL;
+extern bool		_pdfioValueDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_value_t *v, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioValueDebug(_pdfio_value_t *v, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioValueDelete(_pdfio_value_t *v) _PDFIO_INTERNAL;
-extern _pdfio_value_t	*_pdfioValueRead(pdfio_file_t *pdf, _pdfio_token_t *ts, _pdfio_value_t *v) _PDFIO_INTERNAL;
-extern bool		_pdfioValueWrite(pdfio_file_t *pdf, _pdfio_value_t *v, off_t *length) _PDFIO_INTERNAL;
+extern _pdfio_value_t	*_pdfioValueRead(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_token_t *ts, _pdfio_value_t *v, size_t depth) _PDFIO_INTERNAL;
+extern bool		_pdfioValueWrite(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_value_t *v, off_t *length) _PDFIO_INTERNAL;
+
 
 #endif // !PDFIO_PRIVATE_H

pdfio-rc4.c

@@ -0,0 +1,113 @@
+//
+// RC4 functions for PDFio.
+//
+// Copyright © 2021 by Michael R Sweet.
+//
+// Original code by Tim Martin
+// Copyright © 1999 by Carnegie Mellon University, All Rights Reserved
+//
+// Permission to use, copy, modify, and distribute this software and its
+// documentation for any purpose and without fee is hereby granted,
+// provided that the above copyright notice appear in all copies and that
+// both that copyright notice and this permission notice appear in
+// supporting documentation, and that the name of Carnegie Mellon
+// University not be used in advertising or publicity pertaining to
+// distribution of the software without specific, written prior
+// permission.
+//
+// CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
+// THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR
+// ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+// OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+
+#include "pdfio-private.h"
+
+
+//
+// '_pdfioCryptoRC4Init()' - Initialize an RC4 context with the specified key.
+//
+
+void
+_pdfioCryptoRC4Init(
+    _pdfio_rc4_t  *ctx,			// IO - Context
+    const uint8_t *key,			// I - Key
+    size_t        keylen)		// I - Length of key
+{
+  size_t	i;			// Looping var
+  uint8_t	j,			// S box counter
+		tmp;			// Temporary variable
+
+
+  // Fill in linearly s0=0, s1=1, ...
+  for (i = 0; i < 256; i ++)
+    ctx->sbox[i] = (uint8_t)i;
+
+  for (i = 0, j = 0; i < 256; i ++)
+  {
+    // j = (j + Si + Ki) mod 256
+    j += ctx->sbox[i] + key[i % keylen];
+
+    // Swap Si and Sj...
+    tmp          = ctx->sbox[i];
+    ctx->sbox[i] = ctx->sbox[j];
+    ctx->sbox[j] = tmp;
+  }
+
+  // Initialize counters to 0 and return...
+  ctx->i = 0;
+  ctx->j = 0;
+}
+
+
+//
+// '_pdfioCryptoRC4Crypt()' - De/encrypt the given buffer.
+//
+// "inbuffer" and "outbuffer" can point to the same memory.
+//
+
+size_t					// O - Number of output bytes
+_pdfioCryptoRC4Crypt(
+    _pdfio_rc4_t  *ctx,			// I - Context
+    uint8_t       *outbuffer,		// I - Output buffer
+    const uint8_t *inbuffer,		// I - Input buffer
+    size_t        len)			// I - Size of buffers
+{
+  uint8_t	tmp,			// Swap variable
+		i, j,			// Looping vars
+		t;			// Current S box
+  size_t	outbytes = len;		// Number of output bytes
+
+
+  // Loop through the entire buffer...
+  i = ctx->i;
+  j = ctx->j;
+
+  while (len > 0)
+  {
+    // Get the next S box indices...
+    i ++;
+    j += ctx->sbox[i];
+
+    // Swap Si and Sj...
+    tmp          = ctx->sbox[i];
+    ctx->sbox[i] = ctx->sbox[j];
+    ctx->sbox[j] = tmp;
+
+    // Get the S box index for this byte...
+    t = ctx->sbox[i] + ctx->sbox[j];
+
+    // Encrypt using the S box...
+    *outbuffer++ = *inbuffer++ ^ ctx->sbox[t];
+    len --;
+  }
+
+  // Copy current S box indices back to context...
+  ctx->i = i;
+  ctx->j = j;
+
+  return (outbytes);
+}

pdfio-sha256.c

@@ -0,0 +1,480 @@
+//
+// SHA-256 functions for PDFio.
+//
+// Copyright © 2021-2023 by Michael R Sweet.
+// Copyright © 2011 IETF Trust and the persons identified as authors of the
+// code.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or
+// without modification, are permitted provided that the following
+// conditions are met:
+// 
+// - Redistributions of source code must retain the above
+//   copyright notice, this list of conditions and
+//   the following disclaimer.
+// 
+// - Redistributions in binary form must reproduce the above
+//   copyright notice, this list of conditions and the following
+//   disclaimer in the documentation and/or other materials provided
+//   with the distribution.
+// 
+// - Neither the name of Internet Society, IETF or IETF Trust, nor
+//   the names of specific contributors, may be used to endorse or
+//   promote products derived from this software without specific
+//   prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+/*
+ * Description:
+ *   This file implements the Secure Hash Algorithms SHA-224 and
+ *   SHA-256 as defined in the U.S. National Institute of Standards
+ *   and Technology Federal Information Processing Standards
+ *   Publication (FIPS PUB) 180-3 published in October 2008
+ *   and formerly defined in its predecessors, FIPS PUB 180-1
+ *   and FIP PUB 180-2.
+ *
+ *   A combined document showing all algorithms is available at
+ *       http://csrc.nist.gov/publications/fips/
+ *              fips180-3/fips180-3_final.pdf
+ *
+ *   The SHA-224 and SHA-256 algorithms produce 224-bit and 256-bit
+ *   message digests for a given data stream.  It should take about
+ *   2**n steps to find a message with the same digest as a given
+ *   message and 2**(n/2) to find any two messages with the same
+ *   digest, when n is the digest size in bits.  Therefore, this
+ *   algorithm can serve as a means of providing a
+ *   "fingerprint" for a message.
+ *
+ * Portability Issues:
+ *   SHA-224 and SHA-256 are defined in terms of 32-bit "words".
+ *   This code uses <stdint.h> (included via "sha.h") to define 32-
+ *   and 8-bit unsigned integer types.  If your C compiler does not
+ *   support 32-bit unsigned integers, this code is not
+ *   appropriate.
+ *
+ * Caveats:
+ *   SHA-224 and SHA-256 are designed to work with messages less
+ *   than 2^64 bits long.  This implementation uses SHA224/256Input()
+ *   to hash the bits that are a multiple of the size of an 8-bit
+ *   octet, and then optionally uses SHA224/256FinalBits()
+ *   to hash the final few bits of the input.
+ */
+
+#include "pdfio-private.h"
+
+/* Constants from sha.h */
+enum {
+    SHA256_Message_Block_Size = 64,
+    SHA256HashSize = 32,
+    SHA256HashSizeBits = 256
+};
+
+enum {
+    shaSuccess = 0,
+    shaNull,            /* Null pointer parameter */
+    shaInputTooLong,    /* input data too long */
+    shaStateError,      /* called Input after FinalBits or Result */
+    shaBadParam         /* passed a bad parameter */
+};
+
+/* Macros from sha-private.h */
+#define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
+#define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))
+#define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))
+
+/* Define the SHA shift, rotate left, and rotate right macros */
+#define SHA256_SHR(bits,word)      ((word) >> (bits))
+#define SHA256_ROTL(bits,word)                         \
+  (((word) << (bits)) | ((word) >> (32-(bits))))
+#define SHA256_ROTR(bits,word)                         \
+  (((word) >> (bits)) | ((word) << (32-(bits))))
+
+/* Define the SHA SIGMA and sigma macros */
+#define SHA256_SIGMA0(word)   \
+  (SHA256_ROTR( 2,word) ^ SHA256_ROTR(13,word) ^ SHA256_ROTR(22,word))
+#define SHA256_SIGMA1(word)   \
+  (SHA256_ROTR( 6,word) ^ SHA256_ROTR(11,word) ^ SHA256_ROTR(25,word))
+#define SHA256_sigma0(word)   \
+  (SHA256_ROTR( 7,word) ^ SHA256_ROTR(18,word) ^ SHA256_SHR( 3,word))
+#define SHA256_sigma1(word)   \
+  (SHA256_ROTR(17,word) ^ SHA256_ROTR(19,word) ^ SHA256_SHR(10,word))
+
+/*
+ * Add "length" to the length.
+ * Set Corrupted when overflow has occurred.
+ */
+static uint32_t addTemp;
+#define SHA224_256AddLength(context, length)               \
+  (addTemp = (context)->Length_Low, (context)->Corrupted = \
+    (((context)->Length_Low += (length)) < addTemp) &&     \
+    (++(context)->Length_High == 0) ? shaInputTooLong :    \
+                                      (context)->Corrupted )
+
+/* Local Function Prototypes */
+static int SHA224_256Reset(_pdfio_sha256_t *context, uint32_t *H0);
+static void SHA224_256ProcessMessageBlock(_pdfio_sha256_t *context);
+static void SHA224_256Finalize(_pdfio_sha256_t *context,
+  uint8_t Pad_Byte);
+static void SHA224_256PadMessage(_pdfio_sha256_t *context,
+  uint8_t Pad_Byte);
+static int SHA224_256ResultN(_pdfio_sha256_t *context,
+  uint8_t Message_Digest[ ], int HashSize);
+
+/* Initial Hash Values: FIPS 180-3 section 5.3.3 */
+static uint32_t SHA256_H0[SHA256HashSize/4] = {
+  0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+};
+
+/*
+ * _pdfioCryptoSHA256Init
+ *
+ * Description:
+ *   This function will initialize the _pdfio_sha256_t in preparation
+ *   for computing a new SHA256 message digest.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to reset.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+void _pdfioCryptoSHA256Init(_pdfio_sha256_t *context)
+{
+  SHA224_256Reset(context, SHA256_H0);
+}
+
+/*
+ * _pdfioCryptoSHA256Append
+ *
+ * Description:
+ *   This function accepts an array of octets as the next portion
+ *   of the message.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The SHA context to update.
+ *   message_array[ ]: [in]
+ *     An array of octets representing the next portion of
+ *     the message.
+ *   length: [in]
+ *     The length of the message in message_array.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+void
+_pdfioCryptoSHA256Append(_pdfio_sha256_t *context, const uint8_t *message_array,
+    size_t length)
+{
+  if (!length) return;
+
+  while (length--) {
+    context->Message_Block[context->Message_Block_Index++] =
+            *message_array;
+
+    if ((SHA224_256AddLength(context, 8) == shaSuccess) &&
+      (context->Message_Block_Index == SHA256_Message_Block_Size))
+      SHA224_256ProcessMessageBlock(context);
+
+    message_array++;
+  }
+}
+
+/*
+ * _pdfioCryptoSHA256Finish
+ *
+ * Description:
+ *   This function will return the 256-bit message digest
+ *   into the Message_Digest array provided by the caller.
+ *   NOTE:
+ *    The first octet of hash is stored in the element with index 0,
+ *    the last octet of hash in the element with index 31.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to use to calculate the SHA hash.
+ *   Message_Digest[ ]: [out]
+ *     Where the digest is returned.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+void
+_pdfioCryptoSHA256Finish(_pdfio_sha256_t *context,
+                 uint8_t *Message_Digest)
+{
+  SHA224_256ResultN(context, Message_Digest, SHA256HashSize);
+}
+
+/*
+ * SHA224_256Reset
+ *
+ * Description:
+ *   This helper function will initialize the _pdfio_sha256_t in
+ *   preparation for computing a new SHA-224 or SHA-256 message digest.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to reset.
+ *   H0[ ]: [in]
+ *     The initial hash value array to use.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+static int SHA224_256Reset(_pdfio_sha256_t *context, uint32_t *H0)
+{
+  if (!context) return shaNull;
+
+  context->Length_High = context->Length_Low = 0;
+  context->Message_Block_Index  = 0;
+
+  context->Intermediate_Hash[0] = H0[0];
+  context->Intermediate_Hash[1] = H0[1];
+  context->Intermediate_Hash[2] = H0[2];
+  context->Intermediate_Hash[3] = H0[3];
+  context->Intermediate_Hash[4] = H0[4];
+  context->Intermediate_Hash[5] = H0[5];
+  context->Intermediate_Hash[6] = H0[6];
+  context->Intermediate_Hash[7] = H0[7];
+
+  context->Computed  = 0;
+  context->Corrupted = shaSuccess;
+
+  return shaSuccess;
+}
+
+/*
+ * SHA224_256ProcessMessageBlock
+ *
+ * Description:
+ *   This helper function will process the next 512 bits of the
+ *   message stored in the Message_Block array.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The SHA context to update.
+ *
+ * Returns:
+ *   Nothing.
+ *
+ * Comments:
+ *   Many of the variable names in this code, especially the
+ *   single character names, were used because those were the
+ *   names used in the Secure Hash Standard.
+ */
+static void SHA224_256ProcessMessageBlock(_pdfio_sha256_t *context)
+{
+  /* Constants defined in FIPS 180-3, section 4.2.2 */
+  static const uint32_t K[64] = {
+      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
+      0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
+      0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
+      0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
+      0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+      0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
+      0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+      0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
+      0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+      0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  };
+  int        t, t4;                   /* Loop counter */
+  uint32_t   temp1, temp2;            /* Temporary word value */
+  uint32_t   W[64];                   /* Word sequence */
+  uint32_t   A, B, C, D, E, F, G, H;  /* Word buffers */
+
+  /*
+   * Initialize the first 16 words in the array W
+   */
+  for (t = t4 = 0; t < 16; t++, t4 += 4)
+    W[t] = (((uint32_t)context->Message_Block[t4]) << 24) |
+           (((uint32_t)context->Message_Block[t4 + 1]) << 16) |
+           (((uint32_t)context->Message_Block[t4 + 2]) << 8) |
+           (((uint32_t)context->Message_Block[t4 + 3]));
+
+  for (t = 16; t < 64; t++)
+    W[t] = SHA256_sigma1(W[t-2]) + W[t-7] +
+        SHA256_sigma0(W[t-15]) + W[t-16];
+
+  A = context->Intermediate_Hash[0];
+  B = context->Intermediate_Hash[1];
+  C = context->Intermediate_Hash[2];
+  D = context->Intermediate_Hash[3];
+  E = context->Intermediate_Hash[4];
+  F = context->Intermediate_Hash[5];
+  G = context->Intermediate_Hash[6];
+  H = context->Intermediate_Hash[7];
+
+  for (t = 0; t < 64; t++) {
+    temp1 = H + SHA256_SIGMA1(E) + SHA_Ch(E,F,G) + K[t] + W[t];
+    temp2 = SHA256_SIGMA0(A) + SHA_Maj(A,B,C);
+    H = G;
+    G = F;
+    F = E;
+    E = D + temp1;
+    D = C;
+    C = B;
+    B = A;
+    A = temp1 + temp2;
+  }
+
+  context->Intermediate_Hash[0] += A;
+  context->Intermediate_Hash[1] += B;
+  context->Intermediate_Hash[2] += C;
+  context->Intermediate_Hash[3] += D;
+  context->Intermediate_Hash[4] += E;
+  context->Intermediate_Hash[5] += F;
+  context->Intermediate_Hash[6] += G;
+  context->Intermediate_Hash[7] += H;
+
+  context->Message_Block_Index = 0;
+}
+
+/*
+ * SHA224_256Finalize
+ *
+ * Description:
+ *   This helper function finishes off the digest calculations.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The SHA context to update.
+ *   Pad_Byte: [in]
+ *     The last byte to add to the message block before the 0-padding
+ *     and length.  This will contain the last bits of the message
+ *     followed by another single bit.  If the message was an
+ *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+static void SHA224_256Finalize(_pdfio_sha256_t *context,
+    uint8_t Pad_Byte)
+{
+  int i;
+  SHA224_256PadMessage(context, Pad_Byte);
+  /* message may be sensitive, so clear it out */
+  for (i = 0; i < SHA256_Message_Block_Size; ++i)
+    context->Message_Block[i] = 0;
+  context->Length_High = 0;     /* and clear length */
+  context->Length_Low = 0;
+  context->Computed = 1;
+}
+
+/*
+ * SHA224_256PadMessage
+ *
+ * Description:
+ *   According to the standard, the message must be padded to the next
+ *   even multiple of 512 bits.  The first padding bit must be a '1'.
+ *   The last 64 bits represent the length of the original message.
+ *   All bits in between should be 0.  This helper function will pad
+ *   the message according to those rules by filling the
+ *   Message_Block array accordingly.  When it returns, it can be
+ *   assumed that the message digest has been computed.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to pad.
+ *   Pad_Byte: [in]
+ *     The last byte to add to the message block before the 0-padding
+ *     and length.  This will contain the last bits of the message
+ *     followed by another single bit.  If the message was an
+ *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
+ *
+ * Returns:
+ *   Nothing.
+ */
+static void SHA224_256PadMessage(_pdfio_sha256_t *context,
+    uint8_t Pad_Byte)
+{
+  /*
+   * Check to see if the current message block is too small to hold
+   * the initial padding bits and length.  If so, we will pad the
+   * block, process it, and then continue padding into a second
+   * block.
+   */
+  if (context->Message_Block_Index >= (SHA256_Message_Block_Size-8)) {
+    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
+    while (context->Message_Block_Index < SHA256_Message_Block_Size)
+      context->Message_Block[context->Message_Block_Index++] = 0;
+    SHA224_256ProcessMessageBlock(context);
+  } else
+    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
+
+  while (context->Message_Block_Index < (SHA256_Message_Block_Size-8))
+    context->Message_Block[context->Message_Block_Index++] = 0;
+
+  /*
+   * Store the message length as the last 8 octets
+   */
+  context->Message_Block[56] = (uint8_t)(context->Length_High >> 24);
+  context->Message_Block[57] = (uint8_t)(context->Length_High >> 16);
+  context->Message_Block[58] = (uint8_t)(context->Length_High >> 8);
+  context->Message_Block[59] = (uint8_t)(context->Length_High);
+  context->Message_Block[60] = (uint8_t)(context->Length_Low >> 24);
+  context->Message_Block[61] = (uint8_t)(context->Length_Low >> 16);
+  context->Message_Block[62] = (uint8_t)(context->Length_Low >> 8);
+  context->Message_Block[63] = (uint8_t)(context->Length_Low);
+
+  SHA224_256ProcessMessageBlock(context);
+}
+
+/*
+ * SHA224_256ResultN
+ *
+ * Description:
+ *   This helper function will return the 224-bit or 256-bit message
+ *   digest into the Message_Digest array provided by the caller.
+ *   NOTE:
+ *    The first octet of hash is stored in the element with index 0,
+ *    the last octet of hash in the element with index 27/31.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to use to calculate the SHA hash.
+ *   Message_Digest[ ]: [out]
+ *     Where the digest is returned.
+ *   HashSize: [in]
+ *     The size of the hash, either 28 or 32.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+static int SHA224_256ResultN(_pdfio_sha256_t *context,
+    uint8_t Message_Digest[ ], int HashSize)
+{
+  int i;
+
+  if (!context) return shaNull;
+  if (!Message_Digest) return shaNull;
+  if (context->Corrupted) return context->Corrupted;
+
+  if (!context->Computed)
+    SHA224_256Finalize(context, 0x80);
+
+  for (i = 0; i < HashSize; ++i)
+    Message_Digest[i] = (uint8_t)
+      (context->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) ));
+
+  return shaSuccess;
+}

pdfio-stream.c

@@ -1,16 +1,12 @@
 //
 // PDF stream functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -54,6 +50,10 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
 
       while ((status = deflate(&st->flate, Z_FINISH)) != Z_STREAM_END)
       {
+        size_t	bytes = sizeof(st->cbuffer) - st->flate.avail_out,
+					// Bytes to write
+		outbytes;		// Actual bytes written
+
 	if (status < Z_OK && status != Z_BUF_ERROR)
 	{
 	  _pdfioFileError(st->pdf, "Flate compression failed: %s", zstrerror(status));
@@ -61,25 +61,70 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
 	  goto done;
 	}
 
-	if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
+	if (st->crypto_cb)
+	{
+	  // Encrypt it first...
+	  outbytes = (st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, bytes & (size_t)~15);
+	}
+	else
+	{
+	  // No encryption
+	  outbytes = bytes;
+	}
+
+	if (!_pdfioFileWrite(st->pdf, st->cbuffer, outbytes))
 	{
 	  ret = false;
 	  goto done;
 	}
 
-	st->flate.next_out  = (Bytef *)st->cbuffer;
-	st->flate.avail_out = (uInt)sizeof(st->cbuffer);
+        if (bytes > outbytes)
+        {
+          bytes -= outbytes;
+          memmove(st->cbuffer, st->cbuffer + outbytes, bytes);
+        }
+        else
+        {
+          bytes = 0;
+        }
+
+	st->flate.next_out  = (Bytef *)st->cbuffer + bytes;
+	st->flate.avail_out = (uInt)(sizeof(st->cbuffer) - bytes);
       }
 
       if (st->flate.avail_out < (uInt)sizeof(st->cbuffer))
       {
         // Write any residuals...
-	if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
+        size_t bytes = sizeof(st->cbuffer) - st->flate.avail_out;
+					// Bytes to write
+
+	if (st->crypto_cb)
+	{
+	  // Encrypt it first...
+	  bytes = (st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, bytes);
+	}
+
+	if (!_pdfioFileWrite(st->pdf, st->cbuffer, bytes))
 	{
 	  ret = false;
 	  goto done;
 	}
       }
+
+      deflateEnd(&st->flate);
+    }
+    else if (st->crypto_cb && st->bufptr > st->buffer)
+    {
+      // Encrypt and flush
+      uint8_t	temp[8192];		// Temporary buffer
+      size_t	outbytes;		// Output bytes
+
+      outbytes = (st->crypto_cb)(&st->crypto_ctx, temp, (uint8_t *)st->buffer, (size_t)(st->bufptr - st->buffer));
+      if (!_pdfioFileWrite(st->pdf, temp, outbytes))
+      {
+        ret = false;
+        goto done;
+      }
     }
 
     // Save the length of this stream...
@@ -93,7 +138,12 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
     }
 
     // Update the length as needed...
-    if (st->obj->length_offset)
+    if (st->length_obj)
+    {
+      st->length_obj->value.value.number = st->obj->stream_length;
+      pdfioObjClose(st->length_obj);
+    }
+    else if (st->obj->length_offset)
     {
       // Seek back to the "/Length 9999999999" we wrote...
       if (_pdfioFileSeek(st->pdf, st->obj->length_offset, SEEK_SET) < 0)
@@ -120,6 +170,8 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
 
   done:
 
+  st->pdf->current_obj = NULL;
+
   free(st->prbuffer);
   free(st->psbuffer);
   free(st);
@@ -137,6 +189,7 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
 pdfio_stream_t *			// O - Stream or `NULL` on error
 _pdfioStreamCreate(
     pdfio_obj_t    *obj,		// I - Object
+    pdfio_obj_t    *length_obj,		// I - Length object, if any
     pdfio_filter_t compression)		// I - Compression to apply
 {
   pdfio_stream_t	*st;		// Stream
@@ -149,9 +202,28 @@ _pdfioStreamCreate(
     return (NULL);
   }
 
-  st->pdf    = obj->pdf;
-  st->obj    = obj;
-  st->filter = compression;
+  st->pdf        = obj->pdf;
+  st->obj        = obj;
+  st->length_obj = length_obj;
+  st->filter     = compression;
+  st->bufptr     = st->buffer;
+  st->bufend     = st->buffer + sizeof(st->buffer);
+
+  if (obj->pdf->encryption)
+  {
+    uint8_t	iv[64];			// Initialization vector
+    size_t	ivlen = sizeof(iv);	// Length of initialization vector, if any
+
+    if ((st->crypto_cb = _pdfioCryptoMakeWriter(st->pdf, obj, &st->crypto_ctx, iv, &ivlen)) == NULL)
+    {
+      // TODO: Add error message?
+      free(st);
+      return (NULL);
+    }
+
+    if (ivlen > 0)
+      _pdfioFileWrite(st->pdf, iv, ivlen);
+  }
 
   if (compression == PDFIO_FILTER_FLATE)
   {
@@ -290,6 +362,13 @@ pdfioStreamConsume(pdfio_stream_t *st,	// I - Stream
 //
 // 'pdfioStreamGetToken()' - Read a single PDF token from a stream.
 //
+// This function reads a single PDF token from a stream.  Operator tokens,
+// boolean values, and numbers are returned as-is in the provided string buffer.
+// String values start with the opening parenthesis ('(') but have all escaping
+// resolved and the terminating parenthesis removed.  Hexadecimal string values
+// start with the opening angle bracket ('<') and have all whitespace and the
+// terminating angle bracket removed.
+//
 
 bool					// O - `true` on success, `false` on EOF
 pdfioStreamGetToken(
@@ -298,6 +377,7 @@ pdfioStreamGetToken(
     size_t         bufsize)		// I - Size of string buffer
 {
   _pdfio_token_t	tb;		// Token buffer/stack
+  bool			ret;		// Return value
 
 
   // Range check input...
@@ -307,7 +387,10 @@ pdfioStreamGetToken(
   // Read using the token engine...
   _pdfioTokenInit(&tb, st->pdf, (_pdfio_tconsume_cb_t)pdfioStreamConsume, (_pdfio_tpeek_cb_t)pdfioStreamPeek, st);
 
-  return (_pdfioTokenRead(&tb, buffer, bufsize));
+  ret = _pdfioTokenRead(&tb, buffer, bufsize);
+  _pdfioTokenFlush(&tb);
+
+  return (ret);
 }
 
 
@@ -325,6 +408,7 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
   pdfio_stream_t	*st;		// Stream
   pdfio_dict_t		*dict = pdfioObjGetDict(obj);
 					// Object dictionary
+  const char		*type;		// Object type
 
 
   PDFIO_DEBUG("_pdfioStreamOpen(obj=%p(%u), decode=%s)\n", obj, (unsigned)obj->number, decode ? "true" : "false");
@@ -351,16 +435,48 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
     return (NULL);
   }
 
+  type = pdfioObjGetType(obj);
+
+  if (obj->pdf->encryption && (!type || strcmp(type, "XRef")))
+  {
+    uint8_t	iv[64];			// Initialization vector
+    size_t	ivlen;			// Length of initialization vector, if any
+
+    ivlen = (size_t)_pdfioFilePeek(st->pdf, iv, sizeof(iv));
+
+    if ((st->crypto_cb = _pdfioCryptoMakeReader(st->pdf, obj, &st->crypto_ctx, iv, &ivlen)) == NULL)
+    {
+      // TODO: Add error message?
+      free(st);
+      return (NULL);
+    }
+
+    PDFIO_DEBUG("_pdfioStreamOpen: ivlen=%d\n", (int)ivlen);
+    if (ivlen > 0)
+      _pdfioFileConsume(st->pdf, ivlen);
+
+    if (st->pdf->encryption >= PDFIO_ENCRYPTION_AES_128)
+      st->remaining = (st->remaining + 15) & (size_t)~15;
+  }
+
   if (decode)
   {
     // Try to decode/decompress the contents of this object...
     const char	*filter = pdfioDictGetName(dict, "Filter");
 					// Filter value
+    pdfio_array_t *fa = pdfioDictGetArray(dict, "Filter");
+					// Filter array
+
+    if (!filter && fa && pdfioArrayGetSize(fa) == 1)
+    {
+      // Support single-valued arrays...
+      filter = pdfioArrayGetName(fa, 0);
+    }
 
     if (!filter)
     {
       // No single filter name, do we have a compound filter?
-      if (pdfioDictGetArray(dict, "Filter"))
+      if (fa)
       {
 	// TODO: Implement compound filters...
 	_pdfioFileError(st->pdf, "Unsupported compound stream filter.");
@@ -451,6 +567,7 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
       else
         st->predictor = _PDFIO_PREDICTOR_NONE;
 
+      PDFIO_DEBUG("_pdfioStreamOpen: pos=%ld\n", (long)_pdfioFileTell(st->pdf));
       if (sizeof(st->cbuffer) > st->remaining)
 	rbytes = _pdfioFileRead(st->pdf, st->cbuffer, st->remaining);
       else
@@ -465,15 +582,12 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
 	return (NULL);
       }
 
+      if (st->crypto_cb)
+        rbytes = (ssize_t)(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, (size_t)rbytes);
+
       st->flate.next_in  = (Bytef *)st->cbuffer;
       st->flate.avail_in = (uInt)rbytes;
 
-      if (st->cbuffer[0] == 0x0a)
-      {
-        st->flate.next_in ++;		// Skip newline
-        st->flate.avail_in --;
-      }
-
       PDFIO_DEBUG("_pdfioStreamOpen: avail_in=%u, cbuffer=<%02X%02X%02X%02X%02X%02X%02X%02X...>\n", st->flate.avail_in, st->cbuffer[0], st->cbuffer[1], st->cbuffer[2], st->cbuffer[3], st->cbuffer[4], st->cbuffer[5], st->cbuffer[6], st->cbuffer[7]);
 
       if ((status = inflateInit(&(st->flate))) != Z_OK)
@@ -576,7 +690,7 @@ pdfioStreamPrintf(
 
   // Format the string...
   va_start(ap, format);
-  vsnprintf(buffer, sizeof(buffer), format, ap);
+  _pdfio_vsnprintf(st->pdf, buffer, sizeof(buffer), format, ap);
   va_end(ap);
 
   // Write the string...
@@ -585,7 +699,7 @@ pdfioStreamPrintf(
 
 
 //
-// '()' - Write a single character to a stream.
+// 'pdfioStreamPutChar()' - Write a single character to a stream.
 //
 
 bool					// O - `true` on success, `false` on failure
@@ -715,8 +829,63 @@ pdfioStreamWrite(
   // Write it...
   if (st->filter == PDFIO_FILTER_NONE)
   {
-    // No filtering so just write it...
-    return (_pdfioFileWrite(st->pdf, buffer, bytes));
+    // No filtering...
+    if (st->crypto_cb)
+    {
+      // Encrypt data before writing...
+      uint8_t	temp[8192];		// Temporary buffer
+      size_t	cbytes,			// Current bytes
+		outbytes;		// Output bytes
+
+      bufptr = (const unsigned char *)buffer;
+
+      while (bytes > 0)
+      {
+        if (st->bufptr > st->buffer || bytes < 16)
+        {
+          // Write through the stream's buffer...
+          if ((cbytes = bytes) > (size_t)(st->bufend - st->bufptr))
+            cbytes = (size_t)(st->bufend - st->bufptr);
+
+          memcpy(st->bufptr, bufptr, cbytes);
+          st->bufptr += cbytes;
+          if (st->bufptr >= st->bufend)
+          {
+            // Encrypt and flush
+	    outbytes = (st->crypto_cb)(&st->crypto_ctx, temp, (uint8_t *)st->buffer, sizeof(st->buffer));
+	    if (!_pdfioFileWrite(st->pdf, temp, outbytes))
+	      return (false);
+
+	    st->bufptr = st->buffer;
+          }
+        }
+        else
+        {
+          // Write directly up to sizeof(temp) bytes...
+          if ((cbytes = bytes) > sizeof(temp))
+            cbytes = sizeof(temp);
+          if (cbytes & 15)
+          {
+            // AES has a 16-byte block size, so save the last few bytes...
+            cbytes &= (size_t)~15;
+          }
+
+	  outbytes = (st->crypto_cb)(&st->crypto_ctx, temp, bufptr, cbytes);
+	  if (!_pdfioFileWrite(st->pdf, temp, outbytes))
+	    return (false);
+        }
+
+        bytes -= cbytes;
+        bufptr += cbytes;
+      }
+
+      return (true);
+    }
+    else
+    {
+      // Write unencrypted...
+      return (_pdfioFileWrite(st->pdf, buffer, bytes));
+    }
   }
 
   pbline = st->pbsize - 1;
@@ -842,6 +1011,7 @@ stream_read(pdfio_stream_t *st,		// I - Stream
             size_t         bytes)	// I - Number of bytes to read
 {
   ssize_t	rbytes;			// Bytes read
+  uInt		avail_in, avail_out;	// Previous flate values
 
 
   if (st->filter == PDFIO_FILTER_NONE)
@@ -853,8 +1023,13 @@ stream_read(pdfio_stream_t *st,		// I - Stream
       rbytes = _pdfioFileRead(st->pdf, buffer, bytes);
 
     if (rbytes > 0)
+    {
       st->remaining -= (size_t)rbytes;
 
+      if (st->crypto_cb)
+        (st->crypto_cb)(&st->crypto_ctx, (uint8_t *)buffer, (uint8_t *)buffer, (size_t)rbytes);
+    }
+
     return (rbytes);
   }
   else if (st->filter == PDFIO_FILTER_FLATE)
@@ -878,6 +1053,9 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 	if (rbytes <= 0)
 	  return (-1);			// End of file...
 
+	if (st->crypto_cb)
+	  rbytes = (ssize_t)(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, (size_t)rbytes);
+
 	st->remaining      -= (size_t)rbytes;
 	st->flate.next_in  = (Bytef *)st->cbuffer;
 	st->flate.avail_in = (uInt)rbytes;
@@ -888,7 +1066,7 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 
       if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
       {
-	_pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	_pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
 	return (-1);
       }
 
@@ -931,17 +1109,23 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 	  if (rbytes <= 0)
 	    return (-1);		// End of file...
 
+	  if (st->crypto_cb)
+	    rbytes = (ssize_t)(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, (size_t)rbytes);
+
 	  st->remaining      -= (size_t)rbytes;
 	  st->flate.next_in  = (Bytef *)st->cbuffer;
 	  st->flate.avail_in = (uInt)rbytes;
 	}
 
+        avail_in  = st->flate.avail_in;
+        avail_out = st->flate.avail_out;
+
 	if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
 	{
-	  _pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	  _pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
 	  return (-1);
 	}
-	else if (status == Z_STREAM_END)
+	else if (status == Z_STREAM_END || (avail_in == st->flate.avail_in && avail_out == st->flate.avail_out))
 	  break;
       }
 
@@ -995,17 +1179,23 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 	  if (rbytes <= 0)
 	    return (-1);		// End of file...
 
+	  if (st->crypto_cb)
+	    rbytes = (ssize_t)(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, (size_t)rbytes);
+
 	  st->remaining      -= (size_t)rbytes;
 	  st->flate.next_in  = (Bytef *)st->cbuffer;
 	  st->flate.avail_in = (uInt)rbytes;
 	}
 
+        avail_in  = st->flate.avail_in;
+        avail_out = st->flate.avail_out;
+
 	if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
 	{
-	  _pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	  _pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
 	  return (-1);
 	}
-	else if (status == Z_STREAM_END)
+	else if (status == Z_STREAM_END || (avail_in == st->flate.avail_in && avail_out == st->flate.avail_out))
 	  break;
       }
 
@@ -1091,11 +1281,36 @@ stream_write(pdfio_stream_t *st,	// I - Stream
     if (st->flate.avail_out < (sizeof(st->cbuffer) / 8))
     {
       // Flush the compression buffer...
-      if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
+      size_t	cbytes = sizeof(st->cbuffer) - st->flate.avail_out,
+		outbytes;
+
+      if (st->crypto_cb)
+      {
+        // Encrypt it first...
+        outbytes = (st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, cbytes & (size_t)~15);
+      }
+      else
+      {
+        outbytes = cbytes;
+      }
+
+//      fprintf(stderr, "stream_write: bytes=%u, outbytes=%u\n", (unsigned)bytes, (unsigned)outbytes);
+
+      if (!_pdfioFileWrite(st->pdf, st->cbuffer, outbytes))
         return (false);
 
-      st->flate.next_out  = (Bytef *)st->cbuffer;
-      st->flate.avail_out = sizeof(st->cbuffer);
+      if (cbytes > outbytes)
+      {
+        cbytes -= outbytes;
+        memmove(st->cbuffer, st->cbuffer + outbytes, cbytes);
+      }
+      else
+      {
+        cbytes = 0;
+      }
+
+      st->flate.next_out  = (Bytef *)st->cbuffer + cbytes;
+      st->flate.avail_out = (uInt)(sizeof(st->cbuffer) - cbytes);
     }
 
     // Deflate what we can this time...

pdfio-string.c

@@ -1,16 +1,12 @@
 //
-// PDF dictionary functions for PDFio.
+// PDF string functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -18,7 +14,360 @@
 // Local functions...
 //
 
-static int	compare_strings(char **a, char **b);
+static size_t	find_string(pdfio_file_t *pdf, const char *s, int *rdiff);
+
+
+//
+// '_pdfio_strtod()' - Convert a string to a double value.
+//
+// This function wraps strtod() to avoid locale issues.
+//
+
+double					// O - Double value
+_pdfio_strtod(pdfio_file_t *pdf,	// I - PDF file
+              const char   *s)		// I - String
+{
+  char	temp[64],			// Temporary buffer
+	*tempptr;			// Pointer into temporary buffer
+
+
+  // See if the locale has a special decimal point string...
+  if (!pdf->loc)
+    return (strtod(s, NULL));
+
+  // Copy leading sign, numbers, period, and then numbers...
+  tempptr                = temp;
+  temp[sizeof(temp) - 1] = '\0';
+
+  while (*s && *s != '.')
+  {
+    if (tempptr < (temp + sizeof(temp) - 1))
+      *tempptr++ = *s++;
+    else
+      return (0.0);
+  }
+
+  if (*s == '.')
+  {
+    // Convert decimal point to locale equivalent...
+    size_t	declen = strlen(pdf->loc->decimal_point);
+					// Length of decimal point
+    s ++;
+
+    if (declen <= (sizeof(temp) - (size_t)(tempptr - temp)))
+    {
+      memcpy(tempptr, pdf->loc->decimal_point, declen);
+      tempptr += declen;
+    }
+    else
+    {
+      return (0.0);
+    }
+  }
+
+  // Copy any remaining characters...
+  while (*s)
+  {
+    if (tempptr < (temp + sizeof(temp) - 1))
+      *tempptr++ = *s++;
+    else
+      return (0.0);
+  }
+
+  // Nul-terminate the temporary string and convert the string...
+  *tempptr = '\0';
+
+  return (strtod(temp, NULL));
+}
+
+
+//
+// '_pdfio_vsnprintf()' - Format a string.
+//
+// This function emulates vsnprintf() to avoid locale issues.
+//
+
+ssize_t					// O - Number of bytes
+_pdfio_vsnprintf(pdfio_file_t *pdf,	// I - PDF file
+                 char         *buffer,	// I - Output buffer
+                 size_t       bufsize,	// I - Size of output buffer
+                 const char   *format,	// I - printf-style format string
+                 va_list      ap)	// I - Pointer to additional arguments
+{
+  char		*bufptr,		// Pointer to position in buffer
+		*bufend,		// Pointer to end of buffer
+		size,			// Size character (h, l, L)
+		type;			// Format type character
+  int		width,			// Width of field
+		prec;			// Number of characters of precision
+  char		tformat[100],		// Temporary format string for snprintf()
+		*tptr,			// Pointer into temporary format
+		temp[1024],		// Buffer for formatted numbers
+		*tempptr;		// Pointer into buffer
+  char		*s;			// Pointer to string
+  ssize_t	bytes;			// Total number of bytes needed
+  const char	*dec = pdf->loc ? pdf->loc->decimal_point : ".";
+					// Decimal point string
+  char		*decptr;		// Pointer to decimal point
+
+
+  // Loop through the format string, formatting as needed...
+  bufptr  = buffer;
+  bufend  = buffer + bufsize - 1;
+  *bufend = '\0';
+  bytes   = 0;
+
+  while (*format)
+  {
+    if (*format == '%')
+    {
+      // Format character...
+      tptr = tformat;
+      *tptr++ = *format++;
+
+      if (*format == '%')
+      {
+        if (bufptr < bufend)
+	  *bufptr++ = *format;
+        bytes ++;
+        format ++;
+	continue;
+      }
+      else if (strchr(" -+#\'", *format))
+      {
+        *tptr++ = *format++;
+      }
+
+      if (*format == '*')
+      {
+        // Get width from argument...
+	format ++;
+	width = va_arg(ap, int);
+
+	snprintf(tptr, sizeof(tformat) - (size_t)(tptr - tformat), "%d", width);
+	tptr += strlen(tptr);
+      }
+      else
+      {
+	width = 0;
+
+	while (isdigit(*format & 255))
+	{
+	  if (tptr < (tformat + sizeof(tformat) - 1))
+	    *tptr++ = *format;
+
+	  width = width * 10 + *format++ - '0';
+	}
+      }
+
+      if (*format == '.')
+      {
+	if (tptr < (tformat + sizeof(tformat) - 1))
+	  *tptr++ = *format;
+
+        format ++;
+
+        if (*format == '*')
+	{
+          // Get precision from argument...
+	  format ++;
+	  prec = va_arg(ap, int);
+
+	  snprintf(tptr, sizeof(tformat) - (size_t)(tptr - tformat), "%d", prec);
+	  tptr += strlen(tptr);
+	}
+	else
+	{
+	  prec = 0;
+
+	  while (isdigit(*format & 255))
+	  {
+	    if (tptr < (tformat + sizeof(tformat) - 1))
+	      *tptr++ = *format;
+
+	    prec = prec * 10 + *format++ - '0';
+	  }
+	}
+      }
+
+      if (*format == 'l' && format[1] == 'l')
+      {
+        size = 'L';
+
+	if (tptr < (tformat + sizeof(tformat) - 2))
+	{
+	  *tptr++ = 'l';
+	  *tptr++ = 'l';
+	}
+
+	format += 2;
+      }
+      else if (*format == 'h' || *format == 'l' || *format == 'L')
+      {
+	if (tptr < (tformat + sizeof(tformat) - 1))
+	  *tptr++ = *format;
+
+        size = *format++;
+      }
+      else
+      {
+        size = 0;
+      }
+
+      if (!*format)
+        break;
+
+      if (tptr < (tformat + sizeof(tformat) - 1))
+        *tptr++ = *format;
+
+      type  = *format++;
+      *tptr = '\0';
+
+      switch (type)
+      {
+	case 'E' : // Floating point formats
+	case 'G' :
+	case 'e' :
+	case 'f' :
+	case 'g' :
+	    if ((size_t)(width + 2) > sizeof(temp))
+	      break;
+
+	    snprintf(temp, sizeof(temp), tformat, va_arg(ap, double));
+
+	    if ((decptr = strstr(temp, dec)) != NULL)
+	    {
+	      // Convert locale decimal point to "."
+	      PDFIO_DEBUG("_pdfio_vsnprintf: Before \"%s\"\n", temp);
+	      tempptr = decptr + strlen(dec);
+	      if (tempptr > (decptr + 1))
+	        memmove(decptr + 1, tempptr, strlen(tempptr) + 1);
+	      *decptr = '.';
+
+	      // Strip trailing 0's...
+	      for (tempptr = temp + strlen(temp) - 1; tempptr > temp && *tempptr == '0'; tempptr --)
+		*tempptr = '\0';
+
+	      if (*tempptr == '.')
+		*tempptr = '\0';	// Strip trailing decimal point
+
+	      PDFIO_DEBUG("_pdfio_vsnprintf: After \"%s\"\n", temp);
+	    }
+
+            // Copy to the output buffer
+            bytes += (int)strlen(temp);
+
+            if (bufptr < bufend)
+	    {
+	      strncpy(bufptr, temp, (size_t)(bufend - bufptr - 1));
+	      bufptr += strlen(bufptr);
+	    }
+	    break;
+
+        case 'B' : // Integer formats
+	case 'X' :
+	case 'b' :
+        case 'd' :
+	case 'i' :
+	case 'o' :
+	case 'u' :
+	case 'x' :
+	    if ((size_t)(width + 2) > sizeof(temp))
+	      break;
+
+#  ifdef HAVE_LONG_LONG
+            if (size == 'L')
+	      snprintf(temp, sizeof(temp), tformat, va_arg(ap, long long));
+	    else
+#  endif // HAVE_LONG_LONG
+            if (size == 'l')
+	      snprintf(temp, sizeof(temp), tformat, va_arg(ap, long));
+	    else
+	      snprintf(temp, sizeof(temp), tformat, va_arg(ap, int));
+
+            bytes += (int)strlen(temp);
+
+	    if (bufptr < bufend)
+	    {
+	      strncpy(bufptr, temp, (size_t)(bufend - bufptr - 1));
+	      bufptr += strlen(bufptr);
+	    }
+	    break;
+
+	case 'p' : // Pointer value
+	    if ((size_t)(width + 2) > sizeof(temp))
+	      break;
+
+	    snprintf(temp, sizeof(temp), tformat, va_arg(ap, void *));
+
+            bytes += (int)strlen(temp);
+
+	    if (bufptr < bufend)
+	    {
+	      strncpy(bufptr, temp, (size_t)(bufend - bufptr - 1));
+	      bufptr += strlen(bufptr);
+	    }
+	    break;
+
+        case 'c' : // Character or character array
+	    bytes += width;
+
+	    if (bufptr < bufend)
+	    {
+	      if (width <= 1)
+	      {
+	        *bufptr++ = (char)va_arg(ap, int);
+	      }
+	      else
+	      {
+		if ((bufptr + width) > bufend)
+		  width = (int)(bufend - bufptr);
+
+		memcpy(bufptr, va_arg(ap, char *), (size_t)width);
+		bufptr += width;
+	      }
+	    }
+	    break;
+
+	case 's' : // String
+	    if ((s = va_arg(ap, char *)) == NULL)
+	      s = "(null)";
+
+            bytes += strlen(s);
+
+	    if (bufptr < bufend)
+	    {
+	      strncpy(bufptr, s, (size_t)(bufend - bufptr - 1));
+	      bufptr += strlen(bufptr);
+	    }
+	    break;
+
+	case 'n' : // Output number of chars so far
+	    *(va_arg(ap, int *)) = (int)bytes;
+	    break;
+      }
+    }
+    else
+    {
+      // Literal character...
+      bytes ++;
+
+      if (bufptr < bufend)
+        *bufptr++ = *format++;
+    }
+  }
+
+  // Nul-terminate the string and return the number of characters needed.
+  if (bufptr < bufend)
+  {
+    // Everything fit in the buffer...
+    *bufptr = '\0';
+  }
+
+  PDFIO_DEBUG("_pdfio_vsnprintf: Returning %ld \"%s\"\n", (long)bytes, buffer);
+
+  return (bytes);
+}
 
 
 //
@@ -36,8 +385,9 @@ pdfioStringCreate(
     pdfio_file_t *pdf,			// I - PDF file
     const char   *s)			// I - Nul-terminated string
 {
-  char	*news;				// New string
-  char	**match;			// Matching string
+  char		*news;			// New string
+  size_t	idx;			// Index into strings
+  int		diff;			// Different
 
 
   PDFIO_DEBUG("pdfioStringCreate(pdf=%p, s=\"%s\")\n", pdf, s);
@@ -47,8 +397,17 @@ pdfioStringCreate(
     return (NULL);
 
   // See if the string has already been added...
-  if (pdf->num_strings > 0 && (match = (char **)bsearch(&s, pdf->strings, pdf->num_strings, sizeof(char *), (int (*)(const void *, const void *))compare_strings)) != NULL)
-    return (*match);
+  if (pdf->num_strings > 0)
+  {
+    idx = find_string(pdf, s, &diff);
+    if (diff == 0)
+      return (pdf->strings[idx]);
+  }
+  else
+  {
+    idx  = 0;
+    diff = -1;
+  }
 
   // Not already added, so add it...
   if ((news = strdup(s)) == NULL)
@@ -69,11 +428,17 @@ pdfioStringCreate(
     pdf->alloc_strings += 128;
   }
 
-  // TODO: Change to insertion sort as needed...
-  pdf->strings[pdf->num_strings ++] = news;
+  // Insert the string...
+  if (diff > 0)
+    idx ++;
 
-  if (pdf->num_strings > 1)
-    qsort(pdf->strings, pdf->num_strings, sizeof(char *), (int (*)(const void *, const void *))compare_strings);
+  PDFIO_DEBUG("pdfioStringCreate: Inserting \"%s\" at %u\n", news, (unsigned)idx);
+
+  if (idx < pdf->num_strings)
+    memmove(pdf->strings + idx + 1, pdf->strings + idx, (pdf->num_strings - idx) * sizeof(char *));
+
+  pdf->strings[idx] = news;
+  pdf->num_strings ++;
 
   PDFIO_DEBUG("pdfioStringCreate: %lu strings\n", (unsigned long)pdf->num_strings);
 
@@ -124,17 +489,67 @@ _pdfioStringIsAllocated(
     pdfio_file_t *pdf,			// I - PDF file
     const char   *s)			// I - String
 {
-  return (pdf->num_strings > 0 && bsearch(&s, pdf->strings, pdf->num_strings, sizeof(char *), (int (*)(const void *, const void *))compare_strings) != NULL);
+  int	diff;				// Difference
+
+
+  if (pdf->num_strings == 0)
+    return (false);
+
+  find_string(pdf, s, &diff);
+
+  return (diff == 0);
 }
 
 
 //
-// 'compare_strings()' - Compare two strings.
+// 'find_string()' - Find an element in the array.
 //
 
-static int				// O - Result of comparison
-compare_strings(char **a,		// I - First string
-                char **b)		// I - Second string
+static size_t				// O - Index of match
+find_string(pdfio_file_t *pdf,		// I - PDF file
+	    const char   *s,		// I - String to find
+	    int          *rdiff)	// O - Difference of match
 {
-  return (strcmp(*a, *b));
+  size_t	left,			// Left side of search
+		right,			// Right side of search
+		current;		// Current element
+  int		diff;			// Comparison with current element
+
+
+  // Do a binary search for the string...
+  left  = 0;
+  right = pdf->num_strings - 1;
+
+  do
+  {
+    current = (left + right) / 2;
+    diff    = strcmp(s, pdf->strings[current]);
+
+    if (diff == 0)
+      break;
+    else if (diff < 0)
+      right = current;
+    else
+      left = current;
+  }
+  while ((right - left) > 1);
+
+  if (diff != 0)
+  {
+    // Check the last 1 or 2 elements...
+    if ((diff = strcmp(s, pdf->strings[left])) <= 0)
+    {
+      current = left;
+    }
+    else
+    {
+      diff    = strcmp(s, pdf->strings[right]);
+      current = right;
+    }
+  }
+
+  // Return the closest string and the difference...
+  *rdiff = diff;
+
+  return (current);
 }

pdfio-token.c

@@ -1,16 +1,12 @@
 //
 // PDF token parsing functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -129,9 +125,20 @@ _pdfioTokenGet(_pdfio_token_t *tb,	// I - Token buffer/stack
   if (tb->num_tokens > 0)
   {
     // Yes, return it...
+    size_t len;				// Length of token
+
     tb->num_tokens --;
-    strncpy(buffer, tb->tokens[tb->num_tokens], bufsize - 1);
-    buffer[bufsize - 1] = '\0';
+
+    if ((len = strlen(tb->tokens[tb->num_tokens])) > (bufsize - 1))
+    {
+      // Value too large...
+      PDFIO_DEBUG("_pdfioTokenGet(tb=%p, buffer=%p, bufsize=%u): Token '%s' from stack too large.\n", tb, buffer, (unsigned)bufsize, tb->tokens[tb->num_tokens]);
+      *buffer = '\0';
+      return (false);
+    }
+
+    memcpy(buffer, tb->tokens[tb->num_tokens], len);
+    buffer[len] = '\0';
 
     PDFIO_DEBUG("_pdfioTokenGet(tb=%p, buffer=%p, bufsize=%u): Popping '%s' from stack.\n", tb, buffer, (unsigned)bufsize, buffer);
 
@@ -200,9 +207,11 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
   char	*bufptr,			// Pointer into buffer
 	*bufend,			// End of buffer
 	state = '\0';			// Current state
+  bool	saw_nul = false;		// Did we see a nul character?
+  size_t count = 0;			// Number of whitespace/comment bytes
+
 
 
-  //
   // "state" is:
   //
   // - '\0' for idle
@@ -221,21 +230,45 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
   // Skip leading whitespace...
   while ((ch = get_char(tb)) != EOF)
   {
+    count ++;
+
     if (ch == '%')
     {
       // Skip comment
+      PDFIO_DEBUG("_pdfioTokenRead: Skipping comment...\n");
       while ((ch = get_char(tb)) != EOF)
       {
+        count ++;
+
 	if (ch == '\n' || ch == '\r')
+	{
 	  break;
+	}
+	else if (count > 2048)
+	{
+	  _pdfioFileError(tb->pdf, "Comment too long.");
+	  *bufptr = '\0';
+	  return (false);
+	}
       }
     }
     else if (!isspace(ch))
+    {
       break;
+    }
+    else if (count > 2048)
+    {
+      _pdfioFileError(tb->pdf, "Too much whitespace.");
+      *bufptr = '\0';
+      return (false);
+    }
   }
 
   if (ch == EOF)
+  {
+    *bufptr = '\0';
     return (false);
+  }
 
   // Check for delimiters...
   if (strchr(PDFIO_DELIM_CHARS, ch) != NULL)
@@ -255,11 +288,16 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
     *bufptr++ = (char)ch;
   }
 
+  PDFIO_DEBUG("_pdfioTokenRead: state='%c'\n", state);
+
   switch (state)
   {
     case '(' : // Literal string
 	while ((ch = get_char(tb)) != EOF)
 	{
+	  if (ch == 0)
+	    saw_nul = true;
+
 	  if (ch == '\\')
 	  {
 	    // Quoted character...
@@ -280,7 +318,9 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 		    int tch = get_char(tb);	// Next char
 
 		    if (tch >= '0' && tch <= '7')
+		    {
 		      ch = (char)((ch << 3) | (tch - '0'));
+		    }
 		    else
 		    {
 		      tb->bufptr --;
@@ -341,6 +381,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
@@ -348,8 +389,40 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	if (ch != ')')
 	{
 	  _pdfioFileError(tb->pdf, "Unterminated string literal.");
+	  *bufptr = '\0';
 	  return (false);
 	}
+
+	if (saw_nul)
+	{
+	  // Convert to a hex (binary) string...
+	  char	*litptr,		// Pointer to literal character
+		*hexptr;		// Pointer to hex character
+	  size_t bytes = (size_t)(bufptr - buffer - 1);
+					// Bytes of data...
+          static const char *hexchars = "0123456789ABCDEF";
+					// Hex digits
+
+          PDFIO_DEBUG("_pdfioTokenRead: Converting nul-containing string to binary.\n");
+
+          if ((2 * (bytes + 1)) > bufsize)
+          {
+	    // Out of space...
+	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
+	    return (false);
+          }
+
+	  *buffer = '<';
+	  for (litptr = bufptr - 1, hexptr = buffer + 2 * bytes - 1; litptr > buffer; litptr --, hexptr -= 2)
+	  {
+	    int litch = *litptr;	// Grab the character
+
+	    hexptr[0] = hexchars[(litch >> 4) & 15];
+	    hexptr[1] = hexchars[litch & 15];
+	  }
+	  bufptr = buffer + 2 * bytes + 1;
+	}
 	break;
 
     case 'K' : // keyword
@@ -370,9 +443,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space...
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
+
+	if (ch == '\r')
+	{
+	  // Look for a trailing LF
+	  if ((ch = get_char(tb)) != EOF && ch != '\n')
+	    tb->bufptr --;
+	}
 	break;
 
     case 'N' : // number
@@ -381,6 +462,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  if (!isdigit(ch) && ch != '.')
 	  {
 	    // End of number...
+	    PDFIO_DEBUG("_pdfioTokenRead: End of number with ch=0x%02x\n", ch);
 	    tb->bufptr --;
 	    break;
 	  }
@@ -393,6 +475,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space...
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
@@ -419,12 +502,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	      if (!isxdigit(tch & 255))
 	      {
 		_pdfioFileError(tb->pdf, "Bad # escape in name.");
+		*bufptr = '\0';
 		return (false);
 	      }
 	      else if (isdigit(tch))
+	      {
 		ch = ((ch & 255) << 4) | (tch - '0');
+	      }
 	      else
+	      {
 		ch = ((ch & 255) << 4) | (tolower(tch) - 'a' + 10);
+	      }
 	    }
 	  }
 
@@ -436,9 +524,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
+
+	if (bufptr == (buffer + 1))
+	{
+	  _pdfioFileError(tb->pdf, "Empty name.");
+	  *bufptr = '\0';
+	  return (false);
+	}
 	break;
 
     case '<' : // Potential hex string
@@ -448,13 +544,23 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  *bufptr++ = (char)ch;
 	  break;
 	}
+	else if (ch == '>')
+	{
+	  // Issue #46: Empty hex string from Microsoft PDF generator; treat as
+	  // empty literal string...
+	  *buffer = '(';
+	  break;
+	}
 	else if (!isspace(ch & 255) && !isxdigit(ch & 255))
 	{
 	  _pdfioFileError(tb->pdf, "Syntax error: '<%c'", ch);
+	  *bufptr = '\0';
 	  return (false);
 	}
 
-	while ((ch = get_char(tb)) != EOF && ch != '>')
+        count = 0;
+
+        do
 	{
 	  if (isxdigit(ch))
 	  {
@@ -462,24 +568,39 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	    {
 	      // Hex digit
 	      *bufptr++ = (char)ch;
+	      count = 0;
 	    }
 	    else
 	    {
 	      // Too large
 	      _pdfioFileError(tb->pdf, "Token too large.");
+	      *bufptr = '\0';
 	      return (false);
 	    }
 	  }
 	  else if (!isspace(ch))
 	  {
 	    _pdfioFileError(tb->pdf, "Invalid hex string character '%c'.", ch);
+	    *bufptr = '\0';
 	    return (false);
 	  }
+	  else
+	  {
+	    count ++;
+	    if (count > 2048)
+	    {
+	      _pdfioFileError(tb->pdf, "Too much whitespace.");
+	      *bufptr = '\0';
+	      return (false);
+	    }
+	  }
 	}
+	while ((ch = get_char(tb)) != EOF && ch != '>');
 
 	if (ch == EOF)
 	{
 	  _pdfioFileError(tb->pdf, "Unterminated hex string.");
+	  *bufptr = '\0';
 	  return (false);
 	}
 	break;
@@ -492,14 +613,12 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	else
 	{
 	  _pdfioFileError(tb->pdf, "Syntax error: '>%c'.", ch);
+	  *bufptr = '\0';
 	  return (false);
 	}
 	break;
   }
 
-  while (tb->bufptr < tb->bufend && isspace(*(tb->bufptr)))
-    tb->bufptr ++;
-
   *bufptr = '\0';
 
   PDFIO_DEBUG("_pdfioTokenRead: Read '%s'.\n", buffer);

pdfio-value.c

@@ -1,17 +1,20 @@
 //
 // PDF value functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
+#include "pdfio-private.h"
+
+
 //
-// Include necessary headers...
+// Local functions...
 //
 
-#include "pdfio-private.h"
+static time_t	get_date_time(const char *s);
 
 
 //
@@ -109,6 +112,101 @@ _pdfioValueCopy(pdfio_file_t   *pdfdst,	// I - Destination PDF file
 }
 
 
+//
+// '_pdfioValueDecrypt()' - Decrypt a value.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioValueDecrypt(pdfio_file_t   *pdf,	// I - PDF file
+                   pdfio_obj_t    *obj,	// I - Object
+                   _pdfio_value_t *v,	// I - Value
+                   size_t         depth)// I - Depth
+{
+  _pdfio_crypto_ctx_t	ctx;		// Decryption context
+  _pdfio_crypto_cb_t	cb;		// Decryption callback
+  size_t		ivlen;		// Number of initialization vector bytes
+  uint8_t		temp[32768];	// Temporary buffer for decryption
+  size_t		templen;	// Number of actual data bytes
+  time_t		timeval;	// Date/time value
+
+
+  if (depth > PDFIO_MAX_DEPTH)
+  {
+    _pdfioFileError(pdf, "Value too deep.");
+    return (false);
+  }
+
+  switch (v->type)
+  {
+    default :
+        // Do nothing
+        break;
+
+    case PDFIO_VALTYPE_ARRAY :
+        return (_pdfioArrayDecrypt(pdf, obj, v->value.array, depth + 1));
+        break;
+
+    case PDFIO_VALTYPE_DICT :
+        return (_pdfioDictDecrypt(pdf, obj, v->value.dict, depth + 1));
+        break;
+
+    case PDFIO_VALTYPE_BINARY :
+	// Decrypt the binary string...
+	if (v->value.binary.datalen > (sizeof(temp) - 32))
+	{
+	  _pdfioFileError(pdf, "Unable to read encrypted binary string - too long.");
+	  return (false);
+	}
+
+	ivlen = v->value.binary.datalen;
+	if ((cb = _pdfioCryptoMakeReader(pdf, obj, &ctx, v->value.binary.data, &ivlen)) == NULL)
+	  return (false);
+
+	templen = (cb)(&ctx, temp, v->value.binary.data + ivlen, v->value.binary.datalen - ivlen);
+
+	// Copy the decrypted string back to the value and adjust the length...
+	memcpy(v->value.binary.data, temp, templen);
+
+	if (pdf->encryption >= PDFIO_ENCRYPTION_AES_128)
+	  v->value.binary.datalen = templen - temp[templen - 1];
+	else
+	  v->value.binary.datalen = templen;
+	break;
+
+    case PDFIO_VALTYPE_STRING :
+        // Decrypt regular string...
+        templen = strlen(v->value.string);
+	if (templen > (sizeof(temp) - 33))
+	{
+	  _pdfioFileError(pdf, "Unable to read encrypted string - too long.");
+	  return (false);
+	}
+
+	ivlen = templen;
+	if ((cb = _pdfioCryptoMakeReader(pdf, obj, &ctx, (uint8_t *)v->value.string, &ivlen)) == NULL)
+	  return (false);
+
+	templen = (cb)(&ctx, temp, (uint8_t *)v->value.string + ivlen, templen - ivlen);
+	temp[templen] = '\0';
+
+        if ((timeval = get_date_time((char *)temp)) != 0)
+        {
+          // Change the type to date...
+          v->type       = PDFIO_VALTYPE_DATE;
+          v->value.date = timeval;
+        }
+        else
+        {
+          // Copy the decrypted string back to the value...
+	  v->value.string = pdfioStringCreate(pdf, (char *)temp);
+	}
+        break;
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioValueDebug()' - Print the contents of a value.
 //
@@ -117,6 +215,9 @@ void
 _pdfioValueDebug(_pdfio_value_t *v,	// I - Value
 		 FILE           *fp)	// I - Output file
 {
+  if (!v)
+    return;
+
   switch (v->type)
   {
     case PDFIO_VALTYPE_ARRAY :
@@ -194,10 +295,13 @@ _pdfioValueDelete(_pdfio_value_t *v)	// I - Value
 
 _pdfio_value_t *			// O - Value or `NULL` on error/EOF
 _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
+                pdfio_obj_t    *obj,	// I - Object, if any
                 _pdfio_token_t *tb,	// I - Token buffer/stack
-                _pdfio_value_t *v)	// I - Value
+                _pdfio_value_t *v,	// I - Value
+                size_t         depth)	// I - Depth of value
 {
   char		token[32768];		// Token buffer
+  time_t	timeval;		// Date/time value
 #ifdef DEBUG
   static const char * const valtypes[] =
   {
@@ -216,7 +320,7 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
 #endif // DEBUG
 
 
-  PDFIO_DEBUG("_pdfioValueRead(pdf=%p, v=%p)\n", pdf, v);
+  PDFIO_DEBUG("_pdfioValueRead(pdf=%p, obj=%p, v=%p)\n", pdf, obj, v);
 
   if (!_pdfioTokenGet(tb, token, sizeof(token)))
     return (NULL);
@@ -224,81 +328,33 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
   if (!strcmp(token, "["))
   {
     // Start of array
+    if (depth >= PDFIO_MAX_DEPTH)
+    {
+      _pdfioFileError(pdf, "Too many nested arrays.");
+      return (NULL);
+    }
+
     v->type = PDFIO_VALTYPE_ARRAY;
-    if ((v->value.array = _pdfioArrayRead(pdf, tb)) == NULL)
+    if ((v->value.array = _pdfioArrayRead(pdf, obj, tb, depth + 1)) == NULL)
       return (NULL);
   }
   else if (!strcmp(token, "<<"))
   {
     // Start of dictionary
+    if (depth >= PDFIO_MAX_DEPTH)
+    {
+      _pdfioFileError(pdf, "Too many nested dictionaries.");
+      return (NULL);
+    }
+
     v->type = PDFIO_VALTYPE_DICT;
-    if ((v->value.dict = _pdfioDictRead(pdf, tb)) == NULL)
+    if ((v->value.dict = _pdfioDictRead(pdf, obj, tb, depth + 1)) == NULL)
       return (NULL);
   }
-  else if (!strncmp(token, "(D:", 3))
+  else if (!strncmp(token, "(D:", 3) && (timeval = get_date_time(token + 1)) != 0)
   {
-    // Possible date value of the form:
-    //
-    //   (D:YYYYMMDDhhmmssZ)
-    //   (D:YYYYMMDDhhmmss+HH'mm)
-    //   (D:YYYYMMDDhhmmss-HH'mm)
-    //
-    int		i;			// Looping var
-    struct tm	dateval;		// Date value
-    int		offset;			// Date offset
-
-    for (i = 3; i < 17; i ++)
-    {
-      if (!isdigit(token[i] & 255))
-        break;
-    }
-
-    if (i >= 17)
-    {
-      if (token[i] == 'Z')
-      {
-        i ++;
-      }
-      else if (token[i] == '-' || token[i] == '+')
-      {
-        if (isdigit(token[i + 1] & 255) && isdigit(token[i + 2] & 255) && token[i + 3] == '\'' && isdigit(token[i + 4] & 255) && isdigit(token[i + 5] & 255))
-        {
-          i += 6;
-          if (token[i] == '\'')
-            i ++;
-	}
-      }
-    }
-    if (token[i])
-    {
-      // Just a string...
-      v->type         = PDFIO_VALTYPE_STRING;
-      v->value.string = pdfioStringCreate(pdf, token + 1);
-    }
-    else
-    {
-      // Date value...
-      dateval.tm_year = (token[3] - '0') * 1000 + (token[4] - '0') * 100 + (token[5] - '0') * 10 + token[6] - '0' - 1900;
-      dateval.tm_mon  = (token[7] - '0') * 10 + token[8] - '0' - 1;
-      dateval.tm_mday = (token[9] - '0') * 10 + token[10] - '0';
-      dateval.tm_hour = (token[11] - '0') * 10 + token[12] - '0';
-      dateval.tm_min  = (token[13] - '0') * 10 + token[14] - '0';
-      dateval.tm_sec  = (token[15] - '0') * 10 + token[16] - '0';
-
-      if (token[17] == 'Z')
-      {
-        offset = 0;
-      }
-      else
-      {
-        offset = (token[18] - '0') * 600 + (token[19] - '0') * 60 + (token[20] - '0') * 10 + token[21] - '0';
-        if (token[17] == '-')
-          offset = -offset;
-      }
-
-      v->type       = PDFIO_VALTYPE_DATE;
-      v->value.date = mktime(&dateval) + offset;
-    }
+    v->type       = PDFIO_VALTYPE_DATE;
+    v->value.date = timeval;
   }
   else if (token[0] == '(')
   {
@@ -396,6 +452,9 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
 
       tempptr = tb->bufptr;
 
+      while (tempptr < tb->bufend && isspace(*tempptr & 255))
+        tempptr ++;			// Skip whitespace as needed...
+
       if (tempptr < tb->bufend && isdigit(*tempptr & 255))
       {
         // Integer...
@@ -408,7 +467,7 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
         }
 
 	while (tempptr < tb->bufend && isspace(*tempptr & 255))
-	  tempptr ++;
+	  tempptr ++;			// Skip whitespace
 
 	if (tempptr < tb->bufend && *tempptr == 'R')
 	{
@@ -441,7 +500,7 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
 
     // If we get here, we have a number...
     v->type         = PDFIO_VALTYPE_NUMBER;
-    v->value.number = (double)strtod(token, NULL);
+    v->value.number = _pdfio_strtod(pdf, token);
   }
   else if (!strcmp(token, "true") || !strcmp(token, "false"))
   {
@@ -472,6 +531,7 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
 
 bool					// O - `true` on success, `false` on failure
 _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
+                 pdfio_obj_t    *obj,	// I - Object, if any
                  _pdfio_value_t *v,	// I - Value
                  off_t          *length)// O - Offset to /Length value, if any
 {
@@ -481,23 +541,47 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
         return (false);
 
     case PDFIO_VALTYPE_ARRAY :
-        return (_pdfioArrayWrite(v->value.array));
+        return (_pdfioArrayWrite(v->value.array, obj));
 
     case PDFIO_VALTYPE_BINARY :
         {
-          size_t	i;		// Looping var
-          unsigned char	*dataptr;	// Pointer into data
+          size_t	databytes;	// Bytes to write
+          uint8_t	temp[32768],	// Temporary buffer for encryption
+			*dataptr;	// Pointer into data
+
+          if (obj && pdf->encryption)
+          {
+	    // Write encrypted string...
+	    _pdfio_crypto_ctx_t ctx;	// Encryption context
+	    _pdfio_crypto_cb_t cb;	// Encryption callback
+	    size_t	ivlen;		// Number of initialization vector bytes
+
+            if (v->value.binary.datalen > (sizeof(temp) - 32))
+            {
+	      _pdfioFileError(pdf, "Unable to write encrypted binary string - too long.");
+	      return (false);
+            }
+
+	    cb        = _pdfioCryptoMakeWriter(pdf, obj, &ctx, temp, &ivlen);
+	    databytes = (cb)(&ctx, temp + ivlen, v->value.binary.data, v->value.binary.datalen) + ivlen;
+	    dataptr   = temp;
+          }
+          else
+          {
+            dataptr   = v->value.binary.data;
+            databytes = v->value.binary.datalen;
+          }
 
           if (!_pdfioFilePuts(pdf, "<"))
             return (false);
 
-          for (i = v->value.binary.datalen, dataptr = v->value.binary.data; i > 1; i -= 2, dataptr += 2)
+          for (; databytes > 1; databytes -= 2, dataptr += 2)
           {
             if (!_pdfioFilePrintf(pdf, "%02X%02X", dataptr[0], dataptr[1]))
               return (false);
           }
 
-          if (i > 0)
+          if (databytes > 0)
             return (_pdfioFilePrintf(pdf, "%02X>", dataptr[0]));
           else
             return (_pdfioFilePuts(pdf, ">"));
@@ -512,6 +596,7 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
     case PDFIO_VALTYPE_DATE :
         {
           struct tm	date;		// Date values
+          char		datestr[32];	// Formatted date value
 
 #ifdef _WIN32
           gmtime_s(&date, &v->value.date);
@@ -519,11 +604,45 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
 	  gmtime_r(&v->value.date, &date);
 #endif // _WIN32
 
-          return (_pdfioFilePrintf(pdf, "(D:%04d%02d%02d%02d%02d%02dZ)", date.tm_year + 1900, date.tm_mon + 1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec));
+	  snprintf(datestr, sizeof(datestr), "D:%04d%02d%02d%02d%02d%02dZ", date.tm_year + 1900, date.tm_mon + 1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
+
+	  if (obj && pdf->encryption)
+	  {
+	    // Write encrypted string...
+	    uint8_t	temp[32768],	// Encrypted bytes
+			*tempptr;	// Pointer into encrypted bytes
+	    _pdfio_crypto_ctx_t ctx;	// Encryption context
+	    _pdfio_crypto_cb_t cb;	// Encryption callback
+	    size_t	len = strlen(datestr),
+					  // Length of value
+			ivlen,		// Number of initialization vector bytes
+			tempbytes;	// Number of output bytes
+
+	    cb        = _pdfioCryptoMakeWriter(pdf, obj, &ctx, temp, &ivlen);
+	    tempbytes = (cb)(&ctx, temp + ivlen, (const uint8_t *)datestr, len) + ivlen;
+
+	    if (!_pdfioFilePuts(pdf, "<"))
+	      return (false);
+
+	    for (tempptr = temp; tempbytes > 1; tempbytes -= 2, tempptr += 2)
+	    {
+	      if (!_pdfioFilePrintf(pdf, "%02X%02X", tempptr[0], tempptr[1]))
+		return (false);
+	    }
+
+            if (tempbytes > 0)
+              return (_pdfioFilePrintf(pdf, "%02X>", *tempptr));
+            else
+	      return (_pdfioFilePuts(pdf, ">"));
+	  }
+	  else
+	  {
+	    return (_pdfioFilePrintf(pdf, "(%s)", datestr));
+	  }
         }
 
     case PDFIO_VALTYPE_DICT :
-        return (_pdfioDictWrite(v->value.dict, length));
+        return (_pdfioDictWrite(v->value.dict, obj, length));
 
     case PDFIO_VALTYPE_INDIRECT :
         return (_pdfioFilePrintf(pdf, " %lu %u R", (unsigned long)v->value.indirect.number, v->value.indirect.generation));
@@ -538,7 +657,44 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
         return (_pdfioFilePrintf(pdf, " %g", v->value.number));
 
     case PDFIO_VALTYPE_STRING :
+        if (obj && pdf->encryption)
         {
+          // Write encrypted string...
+          uint8_t	temp[32768],	// Encrypted bytes
+			*tempptr;	// Pointer into encrypted bytes
+          _pdfio_crypto_ctx_t ctx;	// Encryption context
+          _pdfio_crypto_cb_t cb;	// Encryption callback
+          size_t	len = strlen(v->value.string),
+					// Length of value
+			ivlen,		// Number of initialization vector bytes
+			tempbytes;	// Number of output bytes
+
+          if (len > (sizeof(temp) - 32))
+          {
+            _pdfioFileError(pdf, "Unable to write encrypted string - too long.");
+            return (false);
+          }
+
+          cb        = _pdfioCryptoMakeWriter(pdf, obj, &ctx, temp, &ivlen);
+          tempbytes = (cb)(&ctx, temp + ivlen, (const uint8_t *)v->value.string, len) + ivlen;
+
+          if (!_pdfioFilePuts(pdf, "<"))
+            return (false);
+
+          for (tempptr = temp; tempbytes > 1; tempbytes -= 2, tempptr += 2)
+          {
+            if (!_pdfioFilePrintf(pdf, "%02X%02X", tempptr[0], tempptr[1]))
+              return (false);
+          }
+
+          if (tempbytes > 0)
+            return (_pdfioFilePrintf(pdf, "%02X>", *tempptr));
+          else
+	    return (_pdfioFilePuts(pdf, ">"));
+        }
+        else
+        {
+          // Write unencrypted string...
           const char *start,		// Start of fragment
 		     *end;		// End of fragment
 
@@ -585,3 +741,76 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
 
   return (false);
 }
+
+
+//
+// 'get_date_time()' - Convert PDF date/time value to time_t.
+//
+
+static time_t				// O - Time in seconds
+get_date_time(const char *s)		// I - PDF date/time value
+{
+  int		i;			// Looping var
+  struct tm	dateval;		// Date value
+  int		offset;			// Date offset
+
+
+  // Possible date value of the form:
+  //
+  //   (D:YYYYMMDDhhmmssZ)
+  //   (D:YYYYMMDDhhmmss+HH'mm)
+  //   (D:YYYYMMDDhhmmss-HH'mm)
+  //
+
+  for (i = 2; i < 16; i ++)
+  {
+    if (!isdigit(s[i] & 255) || !s[i])
+      break;
+  }
+
+  if (i >= 16)
+  {
+    if (s[i] == 'Z')
+    {
+      i ++;
+    }
+    else if (s[i] == '-' || s[i] == '+')
+    {
+      if (isdigit(s[i + 1] & 255) && isdigit(s[i + 2] & 255) && s[i + 3] == '\'' && isdigit(s[i + 4] & 255) && isdigit(s[i + 5] & 255))
+      {
+	i += 6;
+	if (s[i] == '\'')
+	  i ++;
+      }
+    }
+  }
+
+  if (s[i])
+  {
+    // Just a string...
+    return (0);
+  }
+
+  // Date value...
+  memset(&dateval, 0, sizeof(dateval));
+
+  dateval.tm_year = (s[2] - '0') * 1000 + (s[3] - '0') * 100 + (s[4] - '0') * 10 + s[5] - '0' - 1900;
+  dateval.tm_mon  = (s[6] - '0') * 10 + s[7] - '0' - 1;
+  dateval.tm_mday = (s[8] - '0') * 10 + s[9] - '0';
+  dateval.tm_hour = (s[10] - '0') * 10 + s[11] - '0';
+  dateval.tm_min  = (s[12] - '0') * 10 + s[13] - '0';
+  dateval.tm_sec  = (s[14] - '0') * 10 + s[15] - '0';
+
+  if (s[16] == 'Z')
+  {
+    offset = 0;
+  }
+  else
+  {
+    offset = (s[17] - '0') * 600 + (s[18] - '0') * 60 + (s[19] - '0') * 10 + s[20] - '0';
+    if (s[16] == '-')
+      offset = -offset;
+  }
+
+  return (mktime(&dateval) + offset);
+}

pdfio.h

@@ -1,7 +1,7 @@
 //
 // Public header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,27 +9,23 @@
 
 #ifndef PDFIO_H
 #  define PDFIO_H
-
-//
-// Include necessary headers...
-//
-
 #  include <stdio.h>
 #  include <stdlib.h>
 #  include <stdbool.h>
 #  include <sys/types.h>
 #  include <time.h>
-
-
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 extern "C" {
 #  endif // __cplusplus
 
 
+//
+// Version number...
+//
+
+#  define PDFIO_VERSION		"1.3.1"
+
+
 //
 // Visibility and other annotations...
 //
@@ -37,9 +33,11 @@ extern "C" {
 #  if defined(__has_extension) || defined(__GNUC__)
 #    define _PDFIO_PUBLIC	__attribute__ ((visibility("default")))
 #    define _PDFIO_FORMAT(a,b)	__attribute__ ((__format__(__printf__, a,b)))
+#    define _PDFIO_DEPRECATED	__attribute__ ((deprecated)) _PDFIO_PUBLIC
 #  else
 #    define _PDFIO_PUBLIC
 #    define _PDFIO_FORMAT(a,b)
+#    define _PDFIO_DEPRECATED
 #  endif // __has_extension || __GNUC__
 
 
@@ -55,10 +53,20 @@ typedef struct _pdfio_array_s pdfio_array_t;
 					// Array of PDF values
 typedef struct _pdfio_dict_s pdfio_dict_t;
 					// Key/value dictionary
+typedef bool (*pdfio_dict_cb_t)(pdfio_dict_t *dict, const char *key, void *cb_data);
+					// Dictionary iterator callback
 typedef struct _pdfio_file_s pdfio_file_t;
 					// PDF file
 typedef bool (*pdfio_error_cb_t)(pdfio_file_t *pdf, const char *message, void *data);
 					// Error callback
+typedef enum pdfio_encryption_e		// PDF encryption modes
+{
+  PDFIO_ENCRYPTION_NONE = 0,		// No encryption
+  PDFIO_ENCRYPTION_RC4_40,		// 40-bit RC4 encryption (PDF 1.3)
+  PDFIO_ENCRYPTION_RC4_128,		// 128-bit RC4 encryption (PDF 1.4)
+  PDFIO_ENCRYPTION_AES_128,		// 128-bit AES encryption (PDF 1.6)
+  PDFIO_ENCRYPTION_AES_256		// 256-bit AES encryption (PDF 2.0) @exclude all@
+} pdfio_encryption_t;
 typedef enum pdfio_filter_e		// Compression/decompression filters for streams
 {
   PDFIO_FILTER_NONE,			// No filter
@@ -74,6 +82,24 @@ typedef enum pdfio_filter_e		// Compression/decompression filters for streams
   PDFIO_FILTER_RUNLENGTH,		// RunLengthDecode filter (reading only)
 } pdfio_filter_t;
 typedef struct _pdfio_obj_s pdfio_obj_t;// Numbered object in PDF file
+typedef ssize_t (*pdfio_output_cb_t)(void *ctx, const void *data, size_t datalen);
+					// Output callback for pdfioFileCreateOutput
+typedef const char *(*pdfio_password_cb_t)(void *data, const char *filename);
+					// Password callback for pdfioFileOpen
+enum pdfio_permission_e			// PDF permission bits
+{
+  PDFIO_PERMISSION_NONE = 0,		// No permissions
+  PDFIO_PERMISSION_PRINT = 0x0004,	// PDF allows printing
+  PDFIO_PERMISSION_MODIFY = 0x0008,	// PDF allows modification
+  PDFIO_PERMISSION_COPY = 0x0010,	// PDF allows copying
+  PDFIO_PERMISSION_ANNOTATE = 0x0020,	// PDF allows annotation
+  PDFIO_PERMISSION_FORMS = 0x0100,	// PDF allows filling in forms
+  PDFIO_PERMISSION_READING = 0x0200,	// PDF allows screen reading/accessibility (deprecated in PDF 2.0)
+  PDFIO_PERMISSION_ASSEMBLE = 0x0400,	// PDF allows assembly (insert, delete, or rotate pages, add document outlines and thumbnails)
+  PDFIO_PERMISSION_PRINT_HIGH = 0x0800,	// PDF allows high quality printing
+  PDFIO_PERMISSION_ALL = ~0		// All permissions
+};
+typedef int pdfio_permission_t;		// PDF permission bitfield
 typedef struct pdfio_rect_s		// PDF rectangle
 {
   double	x1;			// Lower-left X coordinate
@@ -139,6 +165,7 @@ extern pdfio_obj_t	*pdfioDictGetObj(pdfio_dict_t *dict, const char *key) _PDFIO_
 extern pdfio_rect_t	*pdfioDictGetRect(pdfio_dict_t *dict, const char *key, pdfio_rect_t *rect) _PDFIO_PUBLIC;
 extern const char	*pdfioDictGetString(pdfio_dict_t *dict, const char *key) _PDFIO_PUBLIC;
 extern pdfio_valtype_t	pdfioDictGetType(pdfio_dict_t *dict, const char *key) _PDFIO_PUBLIC;
+extern void		pdfioDictIterateKeys(pdfio_dict_t *dict, pdfio_dict_cb_t cb, void *cb_data) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetArray(pdfio_dict_t *dict, const char *key, pdfio_array_t *value) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetBinary(pdfio_dict_t *dict, const char *key, const unsigned char *value, size_t valuelen) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetBoolean(pdfio_dict_t *dict, const char *key, bool value) _PDFIO_PUBLIC;
@@ -155,11 +182,17 @@ extern bool		pdfioDictSetStringf(pdfio_dict_t *dict, const char *key, const char
 extern bool		pdfioFileClose(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern pdfio_file_t	*pdfioFileCreate(const char *filename, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileCreateArrayObj(pdfio_file_t *pdf, pdfio_array_t *array) _PDFIO_PUBLIC;
+extern pdfio_obj_t	*pdfioFileCreateNameObj(pdfio_file_t *pdf, const char *name) _PDFIO_PUBLIC;
+extern pdfio_obj_t	*pdfioFileCreateNumberObj(pdfio_file_t *pdf, double number) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileCreateObj(pdfio_file_t *pdf, pdfio_dict_t *dict) _PDFIO_PUBLIC;
+extern pdfio_file_t	*pdfioFileCreateOutput(pdfio_output_cb_t output_cb, void *output_ctx, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 // TODO: Add number, array, string, etc. versions of pdfioFileCreateObject?
 extern pdfio_stream_t	*pdfioFileCreatePage(pdfio_file_t *pdf, pdfio_dict_t *dict) _PDFIO_PUBLIC;
+extern pdfio_obj_t	*pdfioFileCreateStringObj(pdfio_file_t *pdf, const char *s) _PDFIO_PUBLIC;
+extern pdfio_file_t	*pdfioFileCreateTemporary(char *buffer, size_t bufsize, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileFindObj(pdfio_file_t *pdf, size_t number) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetAuthor(pdfio_file_t *pdf) _PDFIO_PUBLIC;
+extern pdfio_dict_t	*pdfioFileGetCatalog(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern time_t		pdfioFileGetCreationDate(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetCreator(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern pdfio_array_t	*pdfioFileGetID(pdfio_file_t *pdf) _PDFIO_PUBLIC;
@@ -169,15 +202,17 @@ extern size_t		pdfioFileGetNumObjs(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern size_t		pdfioFileGetNumPages(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileGetObj(pdfio_file_t *pdf, size_t n) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileGetPage(pdfio_file_t *pdf, size_t n) _PDFIO_PUBLIC;
+extern pdfio_permission_t pdfioFileGetPermissions(pdfio_file_t *pdf, pdfio_encryption_t *encryption) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetProducer(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetSubject(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetTitle(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetVersion(pdfio_file_t *pdf) _PDFIO_PUBLIC;
-extern pdfio_file_t	*pdfioFileOpen(const char *filename, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
+extern pdfio_file_t	*pdfioFileOpen(const char *filename, pdfio_password_cb_t password_cb, void *password_data, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 extern void		pdfioFileSetAuthor(pdfio_file_t *pdf, const char *value) _PDFIO_PUBLIC;
 extern void		pdfioFileSetCreationDate(pdfio_file_t *pdf, time_t value) _PDFIO_PUBLIC;
 extern void		pdfioFileSetCreator(pdfio_file_t *pdf, const char *value) _PDFIO_PUBLIC;
 extern void		pdfioFileSetKeywords(pdfio_file_t *pdf, const char *value) _PDFIO_PUBLIC;
+extern bool		pdfioFileSetPermissions(pdfio_file_t *pdf, pdfio_permission_t permissions, pdfio_encryption_t encryption, const char *owner_password, const char *user_password) _PDFIO_PUBLIC;
 extern void		pdfioFileSetSubject(pdfio_file_t *pdf, const char *value) _PDFIO_PUBLIC;
 extern void		pdfioFileSetTitle(pdfio_file_t *pdf, const char *value) _PDFIO_PUBLIC;
 
@@ -188,6 +223,7 @@ extern pdfio_array_t	*pdfioObjGetArray(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern pdfio_dict_t	*pdfioObjGetDict(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern unsigned short	pdfioObjGetGeneration(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern size_t		pdfioObjGetLength(pdfio_obj_t *obj) _PDFIO_PUBLIC;
+extern const char	*pdfioObjGetName(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern size_t		pdfioObjGetNumber(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern const char	*pdfioObjGetSubtype(pdfio_obj_t *obj) _PDFIO_PUBLIC;
 extern const char	*pdfioObjGetType(pdfio_obj_t *obj) _PDFIO_PUBLIC;
@@ -211,10 +247,6 @@ extern char		*pdfioStringCreate(pdfio_file_t *pdf, const char *s)  _PDFIO_PUBLIC
 extern char		*pdfioStringCreatef(pdfio_file_t *pdf, const char *format, ...) _PDFIO_FORMAT(2,3) _PDFIO_PUBLIC;
 
 
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus

pdfio.pc.in

@@ -1,6 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
 Name: pdfio
 Description: PDF read/write library
+Version: @PDFIO_VERSION@
 URL: https://www.msweet.org/pdfio
-Requires: zlib >= 1.0
-Libs: -L${prefix}/lib -lpdfio
-Cflags: -I${prefix}/include
+Requires: @PKGCONFIG_REQUIRES@
+Libs: @PKGCONFIG_LIBS@
+Libs.private: @PKGCONFIG_LIBS_PRIVATE@
+Cflags: @PKGCONFIG_CFLAGS@

pdfio.vcxproj

@@ -87,7 +87,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0b1";WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -101,7 +101,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0b1";WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -115,7 +115,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0b1";_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -130,7 +130,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0b1";NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -148,13 +148,18 @@
     <ClInclude Include="ttf.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="pdfio-aes.c" />
     <ClCompile Include="pdfio-array.c" />
     <ClCompile Include="pdfio-common.c" />
     <ClCompile Include="pdfio-content.c" />
+    <ClCompile Include="pdfio-crypto.c" />
     <ClCompile Include="pdfio-dict.c" />
     <ClCompile Include="pdfio-file.c" />
+    <ClCompile Include="pdfio-md5.c" />
     <ClCompile Include="pdfio-object.c" />
     <ClCompile Include="pdfio-page.c" />
+    <ClCompile Include="pdfio-rc4.c" />
+    <ClCompile Include="pdfio-sha256.c" />
     <ClCompile Include="pdfio-stream.c" />
     <ClCompile Include="pdfio-string.c" />
     <ClCompile Include="pdfio-token.c" />

pdfio.vcxproj.filters

@@ -65,6 +65,21 @@
     <ClCompile Include="ttf.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="pdfio-aes.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pdfio-crypto.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pdfio-md5.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pdfio-rc4.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pdfio-sha256.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

pdfio.xcodeproj/project.pbxproj

@@ -25,7 +25,12 @@
 		279E1035267D043B00D3A349 /* ttf.h in Headers */ = {isa = PBXBuildFile; fileRef = 279E1033267D043B00D3A349 /* ttf.h */; };
 		279E1036267D043B00D3A349 /* ttf.c in Sources */ = {isa = PBXBuildFile; fileRef = 279E1034267D043B00D3A349 /* ttf.c */; };
 		279E103B267D04E600D3A349 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 279E103A267D04E600D3A349 /* libz.tbd */; };
+		27CF90442711DFFE00E50FE4 /* pdfio-aes.c in Sources */ = {isa = PBXBuildFile; fileRef = 27CF90432711DFFE00E50FE4 /* pdfio-aes.c */; };
 		27ECBD8926419DAB0025312A /* libpdfio.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 273440B0263D6FE200FBFD63 /* libpdfio.a */; };
+		27F2F0602710BE92008ECD36 /* pdfio-md5.c in Sources */ = {isa = PBXBuildFile; fileRef = 27F2F05D2710BE92008ECD36 /* pdfio-md5.c */; };
+		27F2F0612710BE92008ECD36 /* pdfio-rc4.c in Sources */ = {isa = PBXBuildFile; fileRef = 27F2F05E2710BE92008ECD36 /* pdfio-rc4.c */; };
+		27F2F0622710BE92008ECD36 /* pdfio-crypto.c in Sources */ = {isa = PBXBuildFile; fileRef = 27F2F05F2710BE92008ECD36 /* pdfio-crypto.c */; };
+		27F2F0642711243D008ECD36 /* pdfio-sha256.c in Sources */ = {isa = PBXBuildFile; fileRef = 27F2F0632711243D008ECD36 /* pdfio-sha256.c */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -79,6 +84,11 @@
 		279E1033267D043B00D3A349 /* ttf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ttf.h; sourceTree = "<group>"; };
 		279E1034267D043B00D3A349 /* ttf.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ttf.c; sourceTree = "<group>"; };
 		279E103A267D04E600D3A349 /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
+		27CF90432711DFFE00E50FE4 /* pdfio-aes.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "pdfio-aes.c"; sourceTree = "<group>"; };
+		27F2F05D2710BE92008ECD36 /* pdfio-md5.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "pdfio-md5.c"; sourceTree = "<group>"; };
+		27F2F05E2710BE92008ECD36 /* pdfio-rc4.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "pdfio-rc4.c"; sourceTree = "<group>"; };
+		27F2F05F2710BE92008ECD36 /* pdfio-crypto.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "pdfio-crypto.c"; sourceTree = "<group>"; };
+		27F2F0632711243D008ECD36 /* pdfio-sha256.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = "pdfio-sha256.c"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -150,19 +160,24 @@
 		279E1038267D045C00D3A349 /* Library */ = {
 			isa = PBXGroup;
 			children = (
+				27CF90432711DFFE00E50FE4 /* pdfio-aes.c */,
 				273440BA263D727800FBFD63 /* pdfio-array.c */,
 				273440BB263D727800FBFD63 /* pdfio-common.c */,
 				271EA703265B2B1000ACDD39 /* pdfio-content.c */,
+				27F2F05F2710BE92008ECD36 /* pdfio-crypto.c */,
 				273440BE263D727800FBFD63 /* pdfio-dict.c */,
 				273440BD263D727800FBFD63 /* pdfio-file.c */,
+				27F2F05D2710BE92008ECD36 /* pdfio-md5.c */,
 				273440BC263D727800FBFD63 /* pdfio-object.c */,
 				273440C2263D727800FBFD63 /* pdfio-page.c */,
+				27F2F05E2710BE92008ECD36 /* pdfio-rc4.c */,
+				27F2F0632711243D008ECD36 /* pdfio-sha256.c */,
 				273440BF263D727800FBFD63 /* pdfio-stream.c */,
 				273440B9263D727800FBFD63 /* pdfio-string.c */,
 				273440E3263DD7EA00FBFD63 /* pdfio-token.c */,
 				273440C0263D727800FBFD63 /* pdfio-value.c */,
-				279E1033267D043B00D3A349 /* ttf.h */,
 				279E1034267D043B00D3A349 /* ttf.c */,
+				279E1033267D043B00D3A349 /* ttf.h */,
 			);
 			name = Library;
 			sourceTree = "<group>";
@@ -241,7 +256,7 @@
 		273440A8263D6FE200FBFD63 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 1250;
+				LastUpgradeCheck = 1300;
 				TargetAttributes = {
 					273440AF263D6FE200FBFD63 = {
 						CreatedOnToolsVersion = 12.5;
@@ -281,11 +296,16 @@
 				273440CB263D727800FBFD63 /* pdfio-value.c in Sources */,
 				273440CA263D727800FBFD63 /* pdfio-stream.c in Sources */,
 				273440CD263D727800FBFD63 /* pdfio-page.c in Sources */,
+				27F2F0622710BE92008ECD36 /* pdfio-crypto.c in Sources */,
+				27F2F0642711243D008ECD36 /* pdfio-sha256.c in Sources */,
 				273440C5263D727800FBFD63 /* pdfio-array.c in Sources */,
 				273440E4263DD7EA00FBFD63 /* pdfio-token.c in Sources */,
 				273440C7263D727800FBFD63 /* pdfio-object.c in Sources */,
+				27F2F0602710BE92008ECD36 /* pdfio-md5.c in Sources */,
 				273440C4263D727800FBFD63 /* pdfio-string.c in Sources */,
+				27CF90442711DFFE00E50FE4 /* pdfio-aes.c in Sources */,
 				271EA705265B2B1000ACDD39 /* pdfio-content.c in Sources */,
+				27F2F0612710BE92008ECD36 /* pdfio-rc4.c in Sources */,
 				273440C6263D727800FBFD63 /* pdfio-common.c in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -350,9 +370,9 @@
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				CODE_SIGN_IDENTITY = "Developer ID Application";
+				CODE_SIGN_IDENTITY = "Apple Development";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1.0;
+				CURRENT_PROJECT_VERSION = 1.1.2;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -361,7 +381,6 @@
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"$(inherited)",
 					"DEBUG=1",
-					"'PDFIO_VERSION=\"$(CURRENT_PROJECT_VERSION)\"'",
 				);
 				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -377,7 +396,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -428,9 +447,9 @@
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				CODE_SIGN_IDENTITY = "Developer ID Application";
+				CODE_SIGN_IDENTITY = "Apple Development";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1.0;
+				CURRENT_PROJECT_VERSION = 1.1.2;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_NS_ASSERTIONS = NO;
@@ -439,7 +458,6 @@
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"$(inherited)",
-					"'PDFIO_VERSION=\"$(CURRENT_PROJECT_VERSION)\"'",
 				);
 				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -455,7 +473,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				RUN_CLANG_STATIC_ANALYZER = YES;
@@ -495,7 +513,7 @@
 				ENABLE_HARDENED_RUNTIME = YES;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				PRODUCT_BUNDLE_IDENTIFIER = org.msweet.testpdfio;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -509,7 +527,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				DEVELOPMENT_TEAM = "";
 				ENABLE_HARDENED_RUNTIME = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				PRODUCT_BUNDLE_IDENTIFIER = org.msweet.testpdfio;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";

pdfio1.def

@@ -1,9 +1,74 @@
 LIBRARY pdfio1
-VERSION 1.0
+VERSION 1.3
 EXPORTS
+_pdfioArrayDebug
+_pdfioArrayDecrypt
+_pdfioArrayDelete
+_pdfioArrayGetValue
+_pdfioArrayRead
+_pdfioArrayWrite
+_pdfioCryptoAESDecrypt
+_pdfioCryptoAESEncrypt
+_pdfioCryptoAESInit
+_pdfioCryptoLock
+_pdfioCryptoMD5Append
+_pdfioCryptoMD5Finish
+_pdfioCryptoMD5Init
+_pdfioCryptoMakeRandom
+_pdfioCryptoMakeReader
+_pdfioCryptoMakeWriter
+_pdfioCryptoRC4Crypt
+_pdfioCryptoRC4Init
+_pdfioCryptoSHA256Append
+_pdfioCryptoSHA256Finish
+_pdfioCryptoSHA256Init
+_pdfioCryptoUnlock
+_pdfioDictClear
+_pdfioDictDebug
+_pdfioDictDecrypt
+_pdfioDictDelete
+_pdfioDictGetValue
+_pdfioDictRead
+_pdfioDictSetValue
+_pdfioDictWrite
+_pdfioFileAddMappedObj
+_pdfioFileAddPage
+_pdfioFileConsume
+_pdfioFileCreateObj
+_pdfioFileDefaultError
+_pdfioFileError
+_pdfioFileFindMappedObj
+_pdfioFileFlush
+_pdfioFileGetChar
+_pdfioFileGets
+_pdfioFilePeek
+_pdfioFilePrintf
+_pdfioFilePuts
+_pdfioFileRead
+_pdfioFileSeek
+_pdfioFileTell
+_pdfioFileWrite
+_pdfioObjDelete
+_pdfioObjGetExtension
+_pdfioObjLoad
+_pdfioObjSetExtension
+_pdfioStreamCreate
+_pdfioStreamOpen
+_pdfioStringIsAllocated
+_pdfioTokenClear
+_pdfioTokenFlush
+_pdfioTokenGet
 _pdfioTokenInit
+_pdfioTokenPush
+_pdfioTokenRead
+_pdfioValueCopy
 _pdfioValueDebug
+_pdfioValueDecrypt
+_pdfioValueDelete
 _pdfioValueRead
+_pdfioValueWrite
+_pdfio_strtod
+_pdfio_vsnprintf
 pdfioArrayAppendArray
 pdfioArrayAppendBinary
 pdfioArrayAppendBoolean
@@ -43,6 +108,7 @@ pdfioContentPathClose
 pdfioContentPathCurve
 pdfioContentPathCurve13
 pdfioContentPathCurve23
+pdfioContentPathEnd
 pdfioContentPathLineTo
 pdfioContentPathMoveTo
 pdfioContentPathRect
@@ -77,8 +143,12 @@ pdfioContentSetTextXScaling
 pdfioContentStroke
 pdfioContentTextBegin
 pdfioContentTextEnd
+pdfioContentTextMeasure
 pdfioContentTextMoveLine
 pdfioContentTextMoveTo
+pdfioContentTextNewLine
+pdfioContentTextNewLineShow
+pdfioContentTextNewLineShowf
 pdfioContentTextNextLine
 pdfioContentTextShow
 pdfioContentTextShowJustified
@@ -96,6 +166,7 @@ pdfioDictGetObj
 pdfioDictGetRect
 pdfioDictGetString
 pdfioDictGetType
+pdfioDictIterateKeys
 pdfioDictSetArray
 pdfioDictSetBinary
 pdfioDictSetBoolean
@@ -116,10 +187,15 @@ pdfioFileCreateFontObjFromFile
 pdfioFileCreateICCObjFromFile
 pdfioFileCreateImageObjFromData
 pdfioFileCreateImageObjFromFile
+pdfioFileCreateNumberObj
 pdfioFileCreateObj
+pdfioFileCreateOutput
 pdfioFileCreatePage
+pdfioFileCreateStringObj
+pdfioFileCreateTemporary
 pdfioFileFindObj
 pdfioFileGetAuthor
+pdfioFileGetCatalog
 pdfioFileGetCreationDate
 pdfioFileGetCreator
 pdfioFileGetID
@@ -129,6 +205,7 @@ pdfioFileGetNumObjs
 pdfioFileGetNumPages
 pdfioFileGetObj
 pdfioFileGetPage
+pdfioFileGetPermissions
 pdfioFileGetProducer
 pdfioFileGetSubject
 pdfioFileGetTitle
@@ -138,6 +215,7 @@ pdfioFileSetAuthor
 pdfioFileSetCreationDate
 pdfioFileSetCreator
 pdfioFileSetKeywords
+pdfioFileSetPermissions
 pdfioFileSetSubject
 pdfioFileSetTitle
 pdfioImageGetBytesPerLine
@@ -158,6 +236,8 @@ pdfioPageCopy
 pdfioPageDictAddColorSpace
 pdfioPageDictAddFont
 pdfioPageDictAddImage
+pdfioPageGetNumStreams
+pdfioPageOpenStream
 pdfioStreamClose
 pdfioStreamConsume
 pdfioStreamGetToken

pdfio_native.nuspec

@@ -3,7 +3,7 @@
     <metadata>
         <id>pdfio_native</id>
         <title>PDFio Library for VS2019+</title>
-        <version>1.0.0-b2</version>
+        <version>1.3.2</version>
         <authors>Michael R Sweet</authors>
         <owners>michaelrsweet</owners>
         <projectUrl>https://github.com/michaelrsweet/pappl</projectUrl>
@@ -12,9 +12,13 @@
         <readme>build/native/README.md</readme>
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
         <description>PDFio Library for VS2019+</description>
-        <summary>PDFio is a simple C library for reading and writing PDF files. PDFio is licensed under the Apache License Version 2.0 with an exception to allow linking against GNU GPL2-only software.</summary>
-        <copyright>Copyright © 2019-2021 by Michael R Sweet</copyright>
+        <summary>PDFio is a simple C library for reading and writing PDF files. PDFio is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GNU GPL2-only software.</summary>
+        <copyright>Copyright © 2019-2024 by Michael R Sweet</copyright>
         <tags>pdf file native</tags>
+	<dependencies>
+	    <dependency id="pdfio_native.redist" version="1.3.2" />
+	    <dependency id="zlib_native.redist" version="1.2.11" />
+	</dependencies>
     </metadata>
     <files>
         <file src="doc\pdfio-128.png" target="build\native" />
@@ -22,7 +26,7 @@
         <file src="pdfio_native.props" target="build\native" />
         <file src="pdfio.h" target="build\native\include" />
         <file src="pdfio-content.h" target="build\native\include" />
-        <!--<file src="Win32\**\pdfio*.lib" target="build\native\lib\Win32" />-->
-        <file src="x64\**\pdfio.lib" target="build\native\lib\x64" />
+        <!--<file src="Win32\**\pdfio1.lib" target="build\native\lib\Win32" />-->
+        <file src="x64\**\pdfio1.lib" target="build\native\lib\x64" />
     </files>
 </package>

pdfio_native.props

@@ -5,7 +5,7 @@
       <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)\include</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>$(MSBuildThisFileDirectory)\lib\$(Platform)\$(Configuration)\pdfio.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>$(MSBuildThisFileDirectory)\lib\$(Platform)\$(Configuration)\pdfio1.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
 </Project>

pdfio_native.redist.nuspec

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
+    <metadata>
+        <id>pdfio_native.redist</id>
+        <title>PDFio Library for VS2019+</title>
+        <version>1.3.2</version>
+        <authors>Michael R Sweet</authors>
+        <owners>michaelrsweet</owners>
+        <projectUrl>https://github.com/michaelrsweet/pappl</projectUrl>
+        <license type="expression">Apache-2.0</license>
+        <icon>build/native/pdfio-128.png</icon>
+        <readme>build/native/README.md</readme>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>PDFio Library for VS2019+</description>
+        <summary>PDFio is a simple C library for reading and writing PDF files. This package provides the redistributable content for the PDFio library. PDFio is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GNU GPL2-only software.</summary>
+        <copyright>Copyright © 2019-2024 by Michael R Sweet</copyright>
+        <tags>pdf file native</tags>
+	<dependencies>
+	    <dependency id="zlib_native.redist" version="1.2.11" />
+	</dependencies>
+    </metadata>
+    <files>
+        <file src="doc\pdfio-128.png" target="build\native" />
+        <file src="README.md" target="build\native" />
+        <!--<file src="Win32\**\pdfio1.dll" target="build\native\bin\Win32" />-->
+        <file src="x64\**\pdfio1.dll" target="build\native\bin\x64" />
+    </files>
+</package>

pdfiototext.c

@@ -0,0 +1,95 @@
+//
+// PDF to text program for PDFio.
+//
+// Copyright © 2022 by Michael R Sweet.
+//
+// Licensed under Apache License v2.0.  See the file "LICENSE" for more
+// information.
+//
+// Usage:
+//
+//   ./pdfiototext FILENAME.pdf > FILENAME.txt
+//
+
+#include "pdfio.h"
+#include <string.h>
+
+
+//
+// 'main()' - Main entry.
+//
+
+int					// O - Exit status
+main(int  argc,				// I - Number of command-line arguments
+     char *argv[])			// I - Command-line arguments
+{
+  pdfio_file_t	*file;			// PDF file
+  size_t	i, j,			// Looping vars
+		num_pages,		// Number of pages
+		num_streams;		// Number of streams for page
+  pdfio_obj_t	*obj;			// Current page object
+  pdfio_stream_t *st;			// Current page content stream
+  char		buffer[1024];		// String buffer
+  bool		first;			// First string token?
+
+
+  // Verify command-line arguments...
+  if (argc != 2)
+  {
+    puts("Usage: pdfiototext FILENAME.pdf > FILENAME.txt");
+    return (1);
+  }
+
+  // Open the PDF file...
+  if ((file = pdfioFileOpen(argv[1], NULL, NULL, NULL, NULL)) == NULL)
+    return (1);
+
+//  printf("%s: %u pages\n", argv[1], (unsigned)pdfioFileGetNumPages(file));
+
+  // Try grabbing content from all of the pages...
+  for (i = 0, num_pages = pdfioFileGetNumPages(file); i < num_pages; i ++)
+  {
+    if ((obj = pdfioFileGetPage(file, i)) == NULL)
+      continue;
+
+    num_streams = pdfioPageGetNumStreams(obj);
+
+//    printf("%s: page%u=%p, num_streams=%u\n", argv[1], (unsigned)i, obj, (unsigned)num_streams);
+
+    for (j = 0; j < num_streams; j ++)
+    {
+      if ((st = pdfioPageOpenStream(obj, j, true)) == NULL)
+	continue;
+
+//      printf("%s: page%u st%u=%p\n", argv[1], (unsigned)i, (unsigned)j, st);
+
+      first = true;
+      while (pdfioStreamGetToken(st, buffer, sizeof(buffer)))
+      {
+	if (buffer[0] == '(')
+	{
+	  if (first)
+	    first = false;
+	  else
+	    putchar(' ');
+
+	  fputs(buffer + 1, stdout);
+	}
+	else if (!strcmp(buffer, "Td") || !strcmp(buffer, "TD") || !strcmp(buffer, "T*") || !strcmp(buffer, "\'") || !strcmp(buffer, "\""))
+	{
+	  putchar('\n');
+	  first = true;
+	}
+      }
+
+      if (!first)
+	putchar('\n');
+
+      pdfioStreamClose(st);
+    }
+  }
+
+  pdfioFileClose(file);
+
+  return (0);
+}

runtests.bat

@@ -0,0 +1,16 @@
+:: Script to run unit test program
+::
+:: Usage:
+::
+::   .\runtests.bat x64\{Debug|Release}
+::
+
+:: Copy dependent DLLs to the named build directory
+echo Copying DLLs
+copy packages\zlib_native.redist.1.2.11\build\native\bin\x64\Debug\*.dll %1
+copy packages\zlib_native.redist.1.2.11\build\native\bin\x64\Release\*.dll %1
+
+:: Run unit test program
+echo Running %1\testpdfio.exe
+cd %1
+testpdfio.exe

testttf.c

@@ -0,0 +1,305 @@
+//
+// Unit test program for TTF library
+//
+//     https://github.com/michaelrsweet/ttf
+//
+// Copyright © 2018-2024 by Michael R Sweet.
+//
+// Licensed under Apache License v2.0.  See the file "LICENSE" for more
+// information.
+//
+// Usage:
+//
+//   ./testttf [FILENAME]
+//
+
+#include <stdio.h>
+#include "ttf.h"
+
+
+//
+// Local functions...
+//
+
+static void	error_cb(void *data, const char *message);
+static int	test_font(const char *filename);
+
+
+//
+// 'main()' - Main entry for unit tests.
+//
+
+int					// O - Exit status
+main(int  argc,				// I - Number of command-line arguments
+     char *argv[])			// I - Command-line arguments
+{
+  int		i;			// Looping var
+  int		errors = 0;		// Number of errors
+
+
+  if (argc > 1)
+  {
+    for (i = 1; i < argc; i ++)
+      errors += test_font(argv[i]);
+  }
+  else
+  {
+    // Test with the bundled TrueType files...
+    errors += test_font("testfiles/OpenSans-Bold.ttf");
+    errors += test_font("testfiles/OpenSans-Regular.ttf");
+    errors += test_font("testfiles/NotoSansJP-Regular.otf");
+  }
+
+  if (!errors)
+    puts("\nALL TESTS PASSED");
+  else
+    printf("\n%d TEST(S) FAILED\n", errors);
+
+  return (errors);
+}
+
+
+//
+// 'error_cb()' - Error callback.
+//
+
+static void
+error_cb(void       *data,		// I - User data (not used)
+         const char *message)		// I - Message string
+{
+  fprintf(stderr, "FAIL (%s)\n", message);
+}
+
+
+//
+// 'test_font()' - Test a font file.
+//
+
+static int				// O - Number of errors
+test_font(const char *filename)		// I - Font filename
+{
+  int		i,			// Looping var
+		errors = 0;		// Number of errors
+  ttf_t		*font;			// Font
+  const char	*value;			// Font (string) value
+  int		intvalue;		// Font (integer) value
+  float		realvalue;		// Font (real) value
+  ttf_rect_t	bounds;			// Bounds
+  ttf_rect_t	extents;		// Extents
+  size_t	num_fonts;		// Number of fonts
+  ttf_style_t	style;			// Font style
+  ttf_weight_t	weight;			// Font weight
+  static const char * const stretches[] =
+  {					// Font stretch strings
+    "TTF_STRETCH_NORMAL",		// normal
+    "TTF_STRETCH_ULTRA_CONDENSED",	// ultra-condensed
+    "TTF_STRETCH_EXTRA_CONDENSED",	// extra-condensed
+    "TTF_STRETCH_CONDENSED",		// condensed
+    "TTF_STRETCH_SEMI_CONDENSED",	// semi-condensed
+    "TTF_STRETCH_SEMI_EXPANDED",	// semi-expanded
+    "TTF_STRETCH_EXPANDED",		// expanded
+    "TTF_STRETCH_EXTRA_EXPANDED",	// extra-expanded
+    "TTF_STRETCH_ULTRA_EXPANDED"	// ultra-expanded
+  };
+  static const char * const strings[] =	// Test strings
+  {
+    "Hello, World!",			// English
+    "مرحبا بالعالم!",			// Arabic
+    "Bonjour le monde!",		// French
+    "Γειά σου Κόσμε!",			// Greek
+    "שלום עולם!",			// Hebrew
+    "Привет мир!",			// Russian
+    "こんにちは世界！"			// Japanese
+  };
+  static const char * const styles[] =	// Font style names
+  {
+    "TTF_STYLE_NORMAL",
+    "TTF_STYLE_ITALIC",
+    "TTF_STYLE_OBLIQUE"
+  };
+
+
+  printf("ttfCreate(\"%s\"): ", filename);
+  fflush(stdout);
+  if ((font = ttfCreate(filename, 0, error_cb, NULL)) != NULL)
+    puts("PASS");
+  else
+    errors ++;
+
+  fputs("ttfGetAscent: ", stdout);
+  if ((intvalue = ttfGetAscent(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetBounds: ", stdout);
+  if (ttfGetBounds(font, &bounds))
+  {
+    printf("PASS (%g %g %g %g)\n", bounds.left, bounds.bottom, bounds.right, bounds.top);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetCapHeight: ", stdout);
+  if ((intvalue = ttfGetCapHeight(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetCopyright: ", stdout);
+  if ((value = ttfGetCopyright(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("WARNING (no copyright found)");
+  }
+
+  for (i = 0; i < (int)(sizeof(strings) / sizeof(strings[0])); i ++)
+  {
+    printf("ttfGetExtents(\"%s\"): ", strings[i]);
+    if (ttfGetExtents(font, 12.0f, strings[i], &extents))
+    {
+      printf("PASS (%.1f %.1f %.1f %.1f)\n", extents.left, extents.bottom, extents.right, extents.top);
+    }
+    else
+    {
+      puts("FAIL");
+      errors ++;
+    }
+  }
+
+  fputs("ttfGetFamily: ", stdout);
+  if ((value = ttfGetFamily(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetItalicAngle: ", stdout);
+  if ((realvalue = ttfGetItalicAngle(font)) >= -180.0 && realvalue <= 180.0)
+  {
+    printf("PASS (%g)\n", realvalue);
+  }
+  else
+  {
+    printf("FAIL (%g)\n", realvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetNumFonts: ", stdout);
+  if ((num_fonts = ttfGetNumFonts(font)) > 0)
+  {
+    printf("PASS (%u)\n", (unsigned)num_fonts);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetPostScriptName: ", stdout);
+  if ((value = ttfGetPostScriptName(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetStretch: ", stdout);
+  if ((intvalue = (int)ttfGetStretch(font)) >= TTF_STRETCH_NORMAL && intvalue <= TTF_STRETCH_ULTRA_EXPANDED)
+  {
+    printf("PASS (%s)\n", stretches[intvalue]);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetStyle: ", stdout);
+  if ((style = ttfGetStyle(font)) >= TTF_STYLE_NORMAL && style <= TTF_STYLE_ITALIC)
+  {
+    printf("PASS (%s)\n", styles[style]);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetVersion: ", stdout);
+  if ((value = ttfGetVersion(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetWeight: ", stdout);
+  if ((weight = ttfGetWeight(font)) >= 0)
+  {
+    printf("PASS (%u)\n", (unsigned)weight);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetWidth(' '): ", stdout);
+  if ((intvalue = ttfGetWidth(font, ' ')) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetXHeight: ", stdout);
+  if ((intvalue = ttfGetXHeight(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfIsFixedPitch: ", stdout);
+  if (ttfIsFixedPitch(font))
+    puts("PASS (true)");
+  else
+    puts("PASS (false)");
+
+  ttfDelete(font);
+
+  return (errors);
+}

ttf.c

@@ -3,16 +3,12 @@
 //
 //     https://github.com/michaelrsweet/ttf
 //
-// Copyright © 2018-2021 by Michael R Sweet.
+// Copyright © 2018-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #ifdef _WIN32
 #  define _CRT_SECURE_NO_WARNINGS
 #endif // _WIN32
@@ -66,7 +62,7 @@
 #  define O_CREAT	_O_CREAT
 #  define O_TRUNC	_O_TRUNC
 
-typedef __int64 ssize_t;		// POSIX type not present on Windows...
+typedef __int64 ssize_t;		// POSIX type not present on Windows... @private@
 
 #else
 #  include <unistd.h>
@@ -75,7 +71,7 @@ typedef __int64 ssize_t;		// POSIX type not present on Windows...
 
 
 //
-// DEBUG is typically defined for debug builds.  TTF_DEBUG maps to printf when
+// DEBUG is typically defined for debug builds.  TTF_DEBUG maps to fprintf when
 // DEBUG is defined and is a no-op otherwise...
 //
 
@@ -103,6 +99,8 @@ typedef __int64 ssize_t;		// POSIX type not present on Windows...
 //
 
 #define TTF_FONT_MAX_CHAR	262144	// Maximum number of character values
+#define TTF_FONT_MAX_GROUPS	65536	// Maximum number of sub-groups
+#define TTF_FONT_MAX_NAMES	16777216// Maximum size of names table we support
 
 
 //
@@ -258,7 +256,7 @@ typedef struct _ttf_off_hhea_s		// Horizontal header
 {
   short		ascender,		// Ascender
 		descender;		// Descender
-  int		numberOfHMetrics;	// Number of horizontal metrics
+  unsigned short numberOfHMetrics;	// Number of horizontal metrics
 } _ttf_off_hhea_t;
 
 typedef struct _ttf_off_os_2_s		// OS/2 information
@@ -301,7 +299,28 @@ static unsigned	seek_table(ttf_t *font, unsigned tag, unsigned offset, bool requ
 
 
 //
-// 'ttfCreate()' - Create a new font object for the named font family.
+// 'ttfCreate()' - Create a new font object for the named font file.
+//
+// This function creates a new font object for the named TrueType or OpenType
+// font file or collection.  The "filename" argument specifies the name of the
+// file to read.
+//
+// The "idx" argument specifies the font to load from a collection - the first
+// font is number `0`.  Once created, you can call the @link ttfGetNumFonts@
+// function to determine whether the loaded font file is a collection with more
+// than one font.
+//
+// The "err_cb" and "err_data" arguments specify a callback function and data
+// pointer for receiving error messages.  If `NULL`, errors are sent to the
+// `stderr` file.  The callback function receives the data pointer and a text
+// message string, for example:
+//
+// ```
+// void my_err_cb(void *err_data, const char *message)
+// {
+//   fprintf(stderr, "ERROR: %s\n", message);
+// }
+// ```
 //
 
 ttf_t *					// O - New font object
@@ -420,7 +439,7 @@ ttfCreate(const char   *filename,	// I - Filename
   if (read_os_2(font, &os_2))
   {
     // Copy key values from OS/2 table...
-    static const ttf_stretch_t widths[] =
+    static const ttf_stretch_t stretches[] =
     {
       TTF_STRETCH_ULTRA_CONDENSED,	// ultra-condensed
       TTF_STRETCH_EXTRA_CONDENSED,	// extra-condensed
@@ -433,8 +452,8 @@ ttfCreate(const char   *filename,	// I - Filename
       TTF_STRETCH_ULTRA_EXPANDED	// ultra-expanded
     };
 
-    if (os_2.usWidthClass >= 1 && os_2.usWidthClass <= (int)(sizeof(widths) / sizeof(widths[0])))
-      font->stretch = widths[os_2.usWidthClass - 1];
+    if (os_2.usWidthClass >= 1 && os_2.usWidthClass <= (int)(sizeof(stretches) / sizeof(stretches[0])))
+      font->stretch = stretches[os_2.usWidthClass - 1];
 
     font->weight     = (short)os_2.usWeightClass;
     font->cap_height = os_2.sCapHeight;
@@ -452,7 +471,7 @@ ttfCreate(const char   *filename,	// I - Filename
     font->cap_height = font->ascent;
 
   if (font->x_height == 0)
-    font->x_height   = 3 * font->ascent / 5;
+    font->x_height = 3 * font->ascent / 5;
 
   // Build a sparse glyph widths table...
   font->min_char = -1;
@@ -481,6 +500,11 @@ ttfCreate(const char   *filename,	// I - Filename
       else
 	font->widths[bin][i & 255] = widths[glyph];
     }
+
+#ifdef DEBUG
+    if (i >= ' ' && i < 127 && font->widths[0])
+      TTF_DEBUG("ttfCreate: width['%c']=%d(%d)\n", (char)i, font->widths[0][i].width, font->widths[0][i].left_bearing);
+#endif // DEBUG
   }
 
   // Cleanup and return the font...
@@ -513,7 +537,8 @@ ttfDelete(ttf_t *font)			// I - Font
     return;
 
   // Close the font file...
-  close(font->fd);
+  if (font->fd >= 0)
+    close(font->fd);
 
   // Free all memory used...
   free(font->copyright);
@@ -548,6 +573,10 @@ ttfGetAscent(ttf_t *font)		// I - Font
 //
 // 'ttfGetBounds()' - Get the bounds of all characters in a font.
 //
+// This function gets the bounds of all characters in a font.  The "bounds"
+// argument is a pointer to a `ttf_rect_t` structure that will be filled with
+// the limits for characters in the font scaled to a 1000x1000 unit square.
+//
 
 ttf_rect_t *				// O - Bounds or `NULL` on error
 ttfGetBounds(ttf_t      *font,		// I - Font
@@ -629,8 +658,11 @@ ttfGetDescent(ttf_t *font)		// I - Font
 //
 // 'ttfGetExtents()' - Get the extents of a UTF-8 string.
 //
-// This function computes the extents of a UTF-8 string when rendered using the
-// specified font and size.
+// This function computes the extents of the UTF-8 string "s" when rendered
+// using the specified font "font" and size "size".  The "extents" argument is
+// a pointer to a `ttf_rect_t` structure that is filled with the extents of a
+// simple rendering of the string with no kerning or rewriting applied.  The
+// values are scaled using the specified font size.
 //
 
 ttf_rect_t *				// O - Pointer to extents or `NULL` on error
@@ -736,17 +768,6 @@ ttfGetFamily(ttf_t *font)		// I - Font
 }
 
 
-//
-// 'ttfIsFixedPitch()' - Determine whether a font is fixedpitch.
-//
-
-bool					// O - `true` if fixed pitch, `false` otherwise
-ttfIsFixedPitch(ttf_t *font)		// I - Font
-{
-  return (font ? font->is_fixed : false);
-}
-
-
 //
 // 'ttfGetItalicAngle()' - Get the italic angle.
 //
@@ -855,13 +876,14 @@ int					// O - Width in 1000ths
 ttfGetWidth(ttf_t *font,		// I - Font
             int   ch)			// I - Unicode character
 {
-  int	bin = ch >> 8;			// Bin in widths array
+  int	bin =  ch >> 8;			// Bin in widths array
 
 
   // Range check input...
   if (!font || ch < ' ' || ch == 0x7f)
     return (0);
-  else if (font->widths[bin])
+
+  if (font->widths[bin])
     return ((int)(1000.0f * font->widths[bin][ch & 255].width / font->units));
   else if (font->widths[0])		// .notdef
     return ((int)(1000.0f * font->widths[0][0].width / font->units));
@@ -881,6 +903,17 @@ ttfGetXHeight(ttf_t *font)		// I - Font
 }
 
 
+//
+// 'ttfIsFixedPitch()' - Determine whether a font is fixedpitch.
+//
+
+bool					// O - `true` if fixed pitch, `false` otherwise
+ttfIsFixedPitch(ttf_t *font)		// I - Font
+{
+  return (font ? font->is_fixed : false);
+}
+
+
 //
 // 'copy_name()' - Copy a name string from a font.
 //
@@ -1269,20 +1302,38 @@ read_cmap(ttf_t *font)			// I - Font
           for (i = 0; i < numGlyphIdArray; i ++)
             glyphIdArray[i] = read_ushort(font);
 
-#ifdef DEBUG
-          for (i = 0; i < segCount; i ++)
-            TTF_DEBUG("read_cmap: segment[%d].startCode=%d, endCode=%d, idDelta=%d, idRangeOffset=%d\n", i, segments[i].startCode, segments[i].endCode, segments[i].idDelta, segments[i].idRangeOffset);
+          for (i = 0, segment = segments; i < segCount; i ++, segment ++)
+          {
+            TTF_DEBUG("read_cmap: segment[%d].startCode=%d, endCode=%d, idDelta=%d, idRangeOffset=%d\n", i, segment->startCode, segment->endCode, segment->idDelta, segment->idRangeOffset);
 
+            if (segment->startCode > segment->endCode)
+            {
+	      errorf(font, "Bad cmap table segment %u to %u.", segments->startCode, segment->endCode);
+	      free(segments);
+	      free(glyphIdArray);
+	      return (false);
+            }
+
+            // Based on the end code of the segment table, allocate space for the
+            // uncompressed cmap table...
+            if (segment->endCode >= font->num_cmap)
+	      font->num_cmap = segment->endCode + 1;
+          }
+
+#ifdef DEBUG
           for (i = 0; i < numGlyphIdArray; i ++)
             TTF_DEBUG("read_cmap: glyphIdArray[%d]=%d\n", i, glyphIdArray[i]);
 #endif /* DEBUG */
 
-          // Based on the end code of the segent table, allocate space for the
-          // uncompressed cmap table...
-          segCount --;			// Last segment is not used (sigh)
+	  if (font->num_cmap == 0 || font->num_cmap > TTF_FONT_MAX_CHAR)
+	  {
+	    errorf(font, "Invalid cmap table with %u characters.", (unsigned)font->num_cmap);
+	    free(segments);
+	    free(glyphIdArray);
+	    return (false);
+	  }
 
-	  font->num_cmap = segments[segCount - 1].endCode + 1;
-	  font->cmap     = cmapptr = (int *)malloc(font->num_cmap * sizeof(int));
+	  font->cmap = cmapptr = (int *)malloc(font->num_cmap * sizeof(int));
 
 	  if (!font->cmap)
           {
@@ -1304,17 +1355,18 @@ read_cmap(ttf_t *font)			// I - Font
               {
                 // Use an "obscure indexing trick" (words from the spec, not
                 // mine) to look up the glyph index...
-                temp = segment->idRangeOffset / 2 + ch - segment->startCode + seg - segCount - 1;
+                temp = (int)(segment->idRangeOffset / 2 - segCount + (ch - segment->startCode) + (segment - segments));
 
-                if (temp < 0 || temp >= numGlyphIdArray || !glyphIdArray[temp])
+                TTF_DEBUG("read_cmap: ch=%d, temp=%d\n", ch, temp);
+                if (temp < 0 || temp >= numGlyphIdArray)
                   glyph = -1;
 		else
-		  glyph = ((glyphIdArray[temp] + segment->idDelta) & 65535) - 1;
+		  glyph = (glyphIdArray[temp] + segment->idDelta) & 65535;
               }
               else
               {
                 // Just use idDelta to compute a glyph index...
-                glyph = ((ch + segment->idDelta) & 65535) - 1;
+                glyph = (ch + segment->idDelta) & 65535;
 	      }
 
 	      cmapptr[ch] = glyph;
@@ -1352,6 +1404,12 @@ read_cmap(ttf_t *font)			// I - Font
 
 	  TTF_DEBUG("read_cmap: nGroups=%u\n", nGroups);
 
+	  if (nGroups > TTF_FONT_MAX_GROUPS)
+	  {
+	    errorf(font, "Invalid cmap table with %u groups.", nGroups);
+	    return (false);
+	  }
+
 	  if ((groups = (_ttf_off_cmap12_t *)calloc(nGroups, sizeof(_ttf_off_cmap12_t))) == NULL)
           {
             errorf(font, "Unable to allocate memory for cmap.");
@@ -1365,6 +1423,13 @@ read_cmap(ttf_t *font)			// I - Font
 	    group->startGlyphID  = read_ulong(font);
 	    TTF_DEBUG("read_cmap: [%u] startCharCode=%u, endCharCode=%u, startGlyphID=%u\n", gidx, group->startCharCode, group->endCharCode, group->startGlyphID);
 
+            if (group->startCharCode > group->endCharCode)
+            {
+	      errorf(font, "Bad cmap table segment %u to %u.", group->startCharCode, group->endCharCode);
+	      free(groups);
+	      return (false);
+            }
+
             if (group->endCharCode >= font->num_cmap)
               font->num_cmap = group->endCharCode + 1;
 	  }
@@ -1372,6 +1437,14 @@ read_cmap(ttf_t *font)			// I - Font
 	  // Based on the end code of the segent table, allocate space for the
 	  // uncompressed cmap table...
           TTF_DEBUG("read_cmap: num_cmap=%u\n", (unsigned)font->num_cmap);
+
+	  if (font->num_cmap == 0 || font->num_cmap > TTF_FONT_MAX_CHAR)
+	  {
+	    errorf(font, "Invalid cmap table with %u characters.", (unsigned)font->num_cmap);
+	    free(groups);
+	    return (false);
+	  }
+
 	  font->cmap = cmapptr = (int *)malloc(font->num_cmap * sizeof(int));
 
 	  if (!font->cmap)
@@ -1422,6 +1495,12 @@ read_cmap(ttf_t *font)			// I - Font
 
 	  TTF_DEBUG("read_cmap: nGroups=%u\n", nGroups);
 
+	  if (nGroups > TTF_FONT_MAX_GROUPS)
+	  {
+	    errorf(font, "Invalid cmap table with %u groups.", nGroups);
+	    return (false);
+	  }
+
 	  if ((groups = (_ttf_off_cmap13_t *)calloc(nGroups, sizeof(_ttf_off_cmap13_t))) == NULL)
 	  {
 	    errorf(font, "Unable to allocate memory for cmap.");
@@ -1435,6 +1514,13 @@ read_cmap(ttf_t *font)			// I - Font
 	    group->glyphID       = read_ulong(font);
 	    TTF_DEBUG("read_cmap: [%u] startCharCode=%u, endCharCode=%u, glyphID=%u\n", gidx, group->startCharCode, group->endCharCode, group->glyphID);
 
+            if (group->startCharCode > group->endCharCode)
+            {
+	      errorf(font, "Bad cmap table segment %u to %u.", group->startCharCode, group->endCharCode);
+	      free(groups);
+	      return (false);
+            }
+
             if (group->endCharCode >= font->num_cmap)
               font->num_cmap = group->endCharCode + 1;
 	  }
@@ -1442,6 +1528,14 @@ read_cmap(ttf_t *font)			// I - Font
 	  // Based on the end code of the segent table, allocate space for the
 	  // uncompressed cmap table...
           TTF_DEBUG("read_cmap: num_cmap=%u\n", (unsigned)font->num_cmap);
+
+	  if (font->num_cmap == 0 || font->num_cmap > TTF_FONT_MAX_CHAR)
+	  {
+	    errorf(font, "Invalid cmap table with %u characters.", (unsigned)font->num_cmap);
+	    free(groups);
+	    return (false);
+	  }
+
 	  font->cmap = cmapptr = (int *)malloc(font->num_cmap * sizeof(int));
 
 	  if (!font->cmap)
@@ -1561,7 +1655,7 @@ read_hmtx(ttf_t           *font,	// I - Font
           _ttf_off_hhea_t *hhea)	// O - hhea table data
 {
   unsigned	length;			// Length of hmtx table
-  int		i;			// Looping var
+  unsigned	i;			// Looping var
   _ttf_metric_t	*widths;		// Glyph metrics array
 
 
@@ -1581,6 +1675,8 @@ read_hmtx(ttf_t           *font,	// I - Font
   {
     widths[i].width        = (short)read_ushort(font);
     widths[i].left_bearing = (short)read_short(font);
+
+    TTF_DEBUG("read_hmtx: widths[%d].width=%d, .left_bearing=%d\n", i, widths[i].width, widths[i].left_bearing);
   }
 
   return (widths);
@@ -1638,8 +1734,15 @@ read_names(ttf_t *font)			// I - Font
     return (false);
 
   font->names.storage_size = length - (unsigned)offset;
+  if (font->names.storage_size > TTF_FONT_MAX_NAMES)
+  {
+    errorf(font, "Name table too large - %u bytes.", (unsigned)font->names.storage_size);
+    return (false);
+  }
+
   if ((font->names.storage = malloc(font->names.storage_size)) == NULL)
     return (false);
+
   memset(font->names.storage, 'A', font->names.storage_size);
 
   for (i = font->names.num_names, name = font->names.names; i > 0; i --, name ++)

ttf.h

@@ -3,7 +3,7 @@
 //
 //     https://github.com/michaelrsweet/ttf
 //
-// Copyright © 2018-2021 by Michael R Sweet.
+// Copyright © 2018-2024 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -11,29 +11,23 @@
 
 #ifndef TTF_H
 #  define TTF_H
-
-//
-// Include necessary headers...
-//
-
 #  include <stdbool.h>
 #  include <sys/types.h>
-
 #  ifdef __cplusplus
 extern "C" {
-#  endif //
+#  endif // __cplusplus
 
 
 //
 // Types...
 //
 
-typedef struct _ttf_s ttf_t;	//// Font object
+typedef struct _ttf_s ttf_t;	// Font object
 
 typedef void (*ttf_err_cb_t)(void *data, const char *message);
-				//// Font error callback
+				// Font error callback
 
-typedef enum ttf_stretch_e	//// Font stretch
+typedef enum ttf_stretch_e	// Font stretch
 {
   TTF_STRETCH_NORMAL,		// normal
   TTF_STRETCH_ULTRA_CONDENSED,	// ultra-condensed
@@ -46,20 +40,20 @@ typedef enum ttf_stretch_e	//// Font stretch
   TTF_STRETCH_ULTRA_EXPANDED	// ultra-expanded
 } ttf_stretch_t;
 
-typedef enum ttf_style_e	//// Font style
+typedef enum ttf_style_e	// Font style
 {
   TTF_STYLE_NORMAL,		// Normal font
   TTF_STYLE_ITALIC,		// Italic font
   TTF_STYLE_OBLIQUE		// Oblique (angled) font
 } ttf_style_t;
 
-typedef enum ttf_variant_e	//// Font variant
+typedef enum ttf_variant_e	// Font variant
 {
   TTF_VARIANT_NORMAL,		// Normal font
   TTF_VARIANT_SMALL_CAPS	// Font whose lowercase letters are small capitals
 } ttf_variant_t;
 
-typedef enum ttf_weight_e	//// Font weight
+typedef enum ttf_weight_e	// Font weight
 {
   TTF_WEIGHT_100 = 100,		// Weight 100 (Thin)
   TTF_WEIGHT_200 = 200,		// Weight 200 (Extra/Ultra-Light)
@@ -72,7 +66,7 @@ typedef enum ttf_weight_e	//// Font weight
   TTF_WEIGHT_900 = 900		// Weight 900 (Black/Heavy)
 } ttf_weight_t;
 
-typedef struct ttf_rect_s	//// Bounding rectangle
+typedef struct ttf_rect_s	// Bounding rectangle
 {
   float	left;			// Left offset
   float	top;			// Top offset
@@ -89,8 +83,8 @@ extern ttf_t		*ttfCreate(const char *filename, size_t idx, ttf_err_cb_t err_cb,
 extern void		ttfDelete(ttf_t *font);
 extern int		ttfGetAscent(ttf_t *font);
 extern ttf_rect_t	*ttfGetBounds(ttf_t *font, ttf_rect_t *bounds);
-extern int		ttfGetCapHeight(ttf_t *font);
 extern const int	*ttfGetCMap(ttf_t *font, size_t *num_cmap);
+extern int		ttfGetCapHeight(ttf_t *font);
 extern const char	*ttfGetCopyright(ttf_t *font);
 extern int		ttfGetDescent(ttf_t *font);
 extern ttf_rect_t	*ttfGetExtents(ttf_t *font, float size, const char *s, ttf_rect_t *extents);
@@ -112,5 +106,4 @@ extern bool		ttfIsFixedPitch(ttf_t *font);
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus
-
 #endif // !TTF_H