diff options
Diffstat (limited to 'libqpdf/QPDFJob_argv.cc')
-rw-r--r-- | libqpdf/QPDFJob_argv.cc | 2394 |
1 files changed, 2394 insertions, 0 deletions
diff --git a/libqpdf/QPDFJob_argv.cc b/libqpdf/QPDFJob_argv.cc new file mode 100644 index 00000000..421099d1 --- /dev/null +++ b/libqpdf/QPDFJob_argv.cc @@ -0,0 +1,2394 @@ +#include <qpdf/QPDFJob.hh> + +#include <iostream> +#include <string.h> +#include <stdlib.h> +#include <cstdio> +#include <ctype.h> +#include <memory> + +#include <qpdf/QUtil.hh> +#include <qpdf/QTC.hh> +#include <qpdf/QPDFCryptoProvider.hh> +#include <qpdf/QPDFArgParser.hh> +#include <qpdf/QPDFJob.hh> +#include <qpdf/QIntC.hh> + +namespace +{ + class ArgParser + { + public: + ArgParser(QPDFArgParser& ap, QPDFJob& o); + void parseOptions(); + + private: + static constexpr char const* O_PAGES = "pages"; + static constexpr char const* O_ENCRYPT = "encryption"; + static constexpr char const* O_ENCRYPT_40 = "40-bit encryption"; + static constexpr char const* O_ENCRYPT_128 = "128-bit encryption"; + static constexpr char const* O_ENCRYPT_256 = "256-bit encryption"; + static constexpr char const* O_UNDER_OVERLAY = "underlay/overlay"; + static constexpr char const* O_ATTACHMENT = "attachment"; + static constexpr char const* O_COPY_ATTACHMENT = "copy attachment"; + + void argHelp(); + void argVersion(); + void argCopyright(); + void argJsonHelp(); + void argShowCrypto(); + void argPositional(char* arg); + void argPassword(char* parameter); + void argPasswordFile(char* parameter); + void argEmpty(); + void argLinearize(); + void argEncrypt(); + void argDecrypt(); + void argPasswordIsHexKey(); + void argAllowInsecure(); + void argAllowWeakCrypto(); + void argPasswordMode(char* parameter); + void argSuppressPasswordRecovery(); + void argCopyEncryption(char* parameter); + void argEncryptionFilePassword(char* parameter); + void argPages(); + void argPagesPassword(char* parameter); + void argPagesPositional(char* parameter); + void argEndPages(); + void argUnderlay(); + void argOverlay(); + void argRotate(char* parameter); + void argCollate(char* parameter); + void argFlattenRotation(); + void argListAttachments(); + void argShowAttachment(char* parameter); + void argRemoveAttachment(char* parameter); + void argAddAttachment(); + void argCopyAttachments(); + void argStreamData(char* parameter); + void argCompressStreams(char* parameter); + void argRecompressFlate(); + void argCompressionLevel(char* parameter); + void argDecodeLevel(char* parameter); + void argNormalizeContent(char* parameter); + void argSuppressRecovery(); + void argObjectStreams(char* parameter); + void argIgnoreXrefStreams(); + void argQdf(); + void argPreserveUnreferenced(); + void argPreserveUnreferencedResources(); + void argRemoveUnreferencedResources(char* parameter); + void argKeepFilesOpen(char* parameter); + void argKeepFilesOpenThreshold(char* parameter); + void argNewlineBeforeEndstream(); + void argLinearizePass1(char* parameter); + void argCoalesceContents(); + void argFlattenAnnotations(char* parameter); + void argGenerateAppearances(); + void argMinVersion(char* parameter); + void argForceVersion(char* parameter); + void argSplitPages(char* parameter); + void argVerbose(); + void argProgress(); + void argNoWarn(); + void argWarningExitZero(); + void argDeterministicId(); + void argStaticId(); + void argStaticAesIv(); + void argNoOriginalObjectIds(); + void argShowEncryption(); + void argShowEncryptionKey(); + void argCheckLinearization(); + void argShowLinearization(); + void argShowXref(); + void argShowObject(char* parameter); + void argRawStreamData(); + void argFilteredStreamData(); + void argShowNpages(); + void argShowPages(); + void argWithImages(); + void argJson(); + void argJsonKey(char* parameter); + void argJsonObject(char* parameter); + void argCheck(); + void argOptimizeImages(); + void argExternalizeInlineImages(); + void argKeepInlineImages(); + void argRemovePageLabels(); + void argOiMinWidth(char* parameter); + void argOiMinHeight(char* parameter); + void argOiMinArea(char* parameter); + void argIiMinBytes(char* parameter); + void arg40Print(char* parameter); + void arg40Modify(char* parameter); + void arg40Extract(char* parameter); + void arg40Annotate(char* parameter); + void arg128Accessibility(char* parameter); + void arg128Extract(char* parameter); + void arg128Print(char* parameter); + void arg128Modify(char* parameter); + void arg128ClearTextMetadata(); + void arg128Assemble(char* parameter); + void arg128Annotate(char* parameter); + void arg128Form(char* parameter); + void arg128ModOther(char* parameter); + void arg128UseAes(char* parameter); + void arg128ForceV4(); + void arg256ForceR5(); + void argEncryptPositional(char* arg); + void argEndEncrypt(); + void argUOpositional(char* arg); + void argUOto(char* parameter); + void argUOfrom(char* parameter); + void argUOrepeat(char* parameter); + void argUOpassword(char* parameter); + void argEndUnderOverlay(); + void argReplaceInput(); + void argIsEncrypted(); + void argRequiresPassword(); + void argAApositional(char* arg); + void argAAKey(char* parameter); + void argAAFilename(char* parameter); + void argAACreationDate(char* parameter); + void argAAModDate(char* parameter); + void argAAMimeType(char* parameter); + void argAADescription(char* parameter); + void argAAReplace(); + void argEndAddAttachment(); + void argCApositional(char* arg); + void argCAprefix(char* parameter); + void argCApassword(char* parameter); + void argEndCopyAttachments(); + + void usage(std::string const& message); + void initOptionTable(); + void doFinalChecks(); + void parseUnderOverlayOptions(QPDFJob::UnderOverlay*); + void parseRotationParameter(std::string const&); + std::vector<int> parseNumrange(char const* range, int max, + bool throw_error = false); + + QPDFArgParser ap; + QPDFJob& o; + std::vector<char*> accumulated_args; // points to member in ap + char* pages_password; + }; +} + +ArgParser::ArgParser(QPDFArgParser& ap, QPDFJob& o) : + ap(ap), + o(o), + pages_password(nullptr) +{ + initOptionTable(); +} + +void +ArgParser::initOptionTable() +{ + auto b = [this](void (ArgParser::*f)()) { + return QPDFArgParser::bindBare(f, this); + }; + auto p = [this](void (ArgParser::*f)(char *)) { + return QPDFArgParser::bindParam(f, this); + }; + + this->ap.addFinalCheck(b(&ArgParser::doFinalChecks)); + + this->ap.selectHelpOptionTable(); + this->ap.addBare("help", b(&ArgParser::argHelp)); + this->ap.addBare("version", b(&ArgParser::argVersion)); + this->ap.addBare("copyright", b(&ArgParser::argCopyright)); + this->ap.addBare("json-help", b(&ArgParser::argJsonHelp)); + this->ap.addBare("show-crypto", b(&ArgParser::argShowCrypto)); + + this->ap.selectMainOptionTable(); + char const* yn[] = {"y", "n", 0}; + this->ap.addPositional(p(&ArgParser::argPositional)); + this->ap.addRequiredParameter("password", + p(&ArgParser::argPassword), "password"); + this->ap.addRequiredParameter("password-file", + p(&ArgParser::argPasswordFile), "password-file"); + this->ap.addBare("empty", b(&ArgParser::argEmpty)); + this->ap.addBare("linearize", b(&ArgParser::argLinearize)); + this->ap.addBare("decrypt", b(&ArgParser::argDecrypt)); + this->ap.addBare("password-is-hex-key", b(&ArgParser::argPasswordIsHexKey)); + this->ap.addBare("suppress-password-recovery", + b(&ArgParser::argSuppressPasswordRecovery)); + char const* password_mode_choices[] = + {"bytes", "hex-bytes", "unicode", "auto", 0}; + this->ap.addRequiredChoices("password-mode", + p(&ArgParser::argPasswordMode), password_mode_choices); + this->ap.addRequiredParameter("copy-encryption", + p(&ArgParser::argCopyEncryption), "file"); + this->ap.addRequiredParameter("encryption-file-password", + p(&ArgParser::argEncryptionFilePassword), "password"); + this->ap.addRequiredParameter("rotate", + p(&ArgParser::argRotate), "[+|-]angle:page-range"); + char const* stream_data_choices[] = + {"compress", "preserve", "uncompress", 0}; + this->ap.addOptionalParameter("collate",p(&ArgParser::argCollate)); + this->ap.addBare("flatten-rotation", b(&ArgParser::argFlattenRotation)); + this->ap.addBare("list-attachments", b(&ArgParser::argListAttachments)); + this->ap.addRequiredParameter("show-attachment", + p(&ArgParser::argShowAttachment), "attachment-key"); + this->ap.addRequiredParameter("remove-attachment", + p(&ArgParser::argRemoveAttachment), "attachment-key"); + this->ap.addBare("add-attachment", b(&ArgParser::argAddAttachment)); + this->ap.addBare( + "copy-attachments-from", b(&ArgParser::argCopyAttachments)); + this->ap.addRequiredChoices("stream-data", + p(&ArgParser::argStreamData), stream_data_choices); + this->ap.addRequiredChoices("compress-streams", + p(&ArgParser::argCompressStreams), yn); + this->ap.addBare("recompress-flate", b(&ArgParser::argRecompressFlate)); + this->ap.addRequiredParameter("compression-level", + p(&ArgParser::argCompressionLevel), "level"); + char const* decode_level_choices[] = + {"none", "generalized", "specialized", "all", 0}; + this->ap.addRequiredChoices("decode-level", + p(&ArgParser::argDecodeLevel), decode_level_choices); + this->ap.addRequiredChoices("normalize-content", + p(&ArgParser::argNormalizeContent), yn); + this->ap.addBare("suppress-recovery", b(&ArgParser::argSuppressRecovery)); + char const* object_streams_choices[] = { + "disable", "preserve", "generate", 0}; + this->ap.addRequiredChoices("object-streams", + p(&ArgParser::argObjectStreams), object_streams_choices); + this->ap.addBare( + "ignore-xref-streams", b(&ArgParser::argIgnoreXrefStreams)); + this->ap.addBare("qdf", b(&ArgParser::argQdf)); + this->ap.addBare( + "preserve-unreferenced", b(&ArgParser::argPreserveUnreferenced)); + this->ap.addBare( + "preserve-unreferenced-resources", + b(&ArgParser::argPreserveUnreferencedResources)); + char const* remove_unref_choices[] = { + "auto", "yes", "no", 0}; + this->ap.addRequiredChoices("remove-unreferenced-resources", + p(&ArgParser::argRemoveUnreferencedResources), remove_unref_choices); + this->ap.addRequiredChoices("keep-files-open", + p(&ArgParser::argKeepFilesOpen), yn); + this->ap.addRequiredParameter("keep-files-open-threshold", + p(&ArgParser::argKeepFilesOpenThreshold), "count"); + this->ap.addBare("newline-before-endstream", b(&ArgParser::argNewlineBeforeEndstream)); + this->ap.addRequiredParameter("linearize-pass1", + p(&ArgParser::argLinearizePass1), "filename"); + this->ap.addBare("coalesce-contents", b(&ArgParser::argCoalesceContents)); + char const* flatten_choices[] = {"all", "print", "screen", 0}; + this->ap.addRequiredChoices("flatten-annotations", + p(&ArgParser::argFlattenAnnotations), flatten_choices); + this->ap.addBare("generate-appearances", b(&ArgParser::argGenerateAppearances)); + this->ap.addRequiredParameter("min-version", + p(&ArgParser::argMinVersion), "version"); + this->ap.addRequiredParameter("force-version", + p(&ArgParser::argForceVersion), "version"); + this->ap.addOptionalParameter("split-pages",p(&ArgParser::argSplitPages)); + this->ap.addBare("verbose", b(&ArgParser::argVerbose)); + this->ap.addBare("progress", b(&ArgParser::argProgress)); + this->ap.addBare("no-warn", b(&ArgParser::argNoWarn)); + this->ap.addBare("warning-exit-0", b(&ArgParser::argWarningExitZero)); + this->ap.addBare("deterministic-id", b(&ArgParser::argDeterministicId)); + this->ap.addBare("static-id", b(&ArgParser::argStaticId)); + this->ap.addBare("static-aes-iv", b(&ArgParser::argStaticAesIv)); + this->ap.addBare("no-original-object-ids", b(&ArgParser::argNoOriginalObjectIds)); + this->ap.addBare("show-encryption", b(&ArgParser::argShowEncryption)); + this->ap.addBare("show-encryption-key", b(&ArgParser::argShowEncryptionKey)); + this->ap.addBare("check-linearization", b(&ArgParser::argCheckLinearization)); + this->ap.addBare("show-linearization", b(&ArgParser::argShowLinearization)); + this->ap.addBare("show-xref", b(&ArgParser::argShowXref)); + this->ap.addRequiredParameter("show-object", + p(&ArgParser::argShowObject), "trailer|obj[,gen]"); + this->ap.addBare("raw-stream-data", b(&ArgParser::argRawStreamData)); + this->ap.addBare("filtered-stream-data", b(&ArgParser::argFilteredStreamData)); + this->ap.addBare("show-npages", b(&ArgParser::argShowNpages)); + this->ap.addBare("show-pages", b(&ArgParser::argShowPages)); + this->ap.addBare("with-images", b(&ArgParser::argWithImages)); + this->ap.addBare("json", b(&ArgParser::argJson)); + // QXXXQ + // The list of selectable top-level keys id duplicated in three + // places: json_schema, do_json, and initOptionTable. + char const* json_key_choices[] = { + "objects", "objectinfo", "pages", "pagelabels", "outlines", + "acroform", "encrypt", "attachments", 0}; + this->ap.addRequiredChoices("json-key", + p(&ArgParser::argJsonKey), json_key_choices); + this->ap.addRequiredParameter("json-object", + p(&ArgParser::argJsonObject), "trailer|obj[,gen]"); + this->ap.addBare("check", b(&ArgParser::argCheck)); + this->ap.addBare("optimize-images", b(&ArgParser::argOptimizeImages)); + this->ap.addBare("externalize-inline-images", b(&ArgParser::argExternalizeInlineImages)); + this->ap.addBare("keep-inline-images", b(&ArgParser::argKeepInlineImages)); + this->ap.addBare("remove-page-labels", b(&ArgParser::argRemovePageLabels)); + this->ap.addRequiredParameter("oi-min-width", + p(&ArgParser::argOiMinWidth), "minimum-width"); + this->ap.addRequiredParameter("oi-min-height", + p(&ArgParser::argOiMinHeight), "minimum-height"); + this->ap.addRequiredParameter("oi-min-area", + p(&ArgParser::argOiMinArea), "minimum-area"); + this->ap.addRequiredParameter("ii-min-bytes", + p(&ArgParser::argIiMinBytes), "minimum-bytes"); + this->ap.addBare("overlay", b(&ArgParser::argOverlay)); + this->ap.addBare("underlay", b(&ArgParser::argUnderlay)); + this->ap.addBare("replace-input", b(&ArgParser::argReplaceInput)); + this->ap.addBare("is-encrypted", b(&ArgParser::argIsEncrypted)); + this->ap.addBare("requires-password", b(&ArgParser::argRequiresPassword)); + this->ap.addBare("allow-weak-crypto", b(&ArgParser::argAllowWeakCrypto)); + + this->ap.selectMainOptionTable(); + this->ap.addBare("pages", b(&ArgParser::argPages)); + this->ap.registerOptionTable(O_PAGES, b(&ArgParser::argEndPages)); + this->ap.addRequiredParameter( + "password", p(&ArgParser::argPagesPassword), "password"); + this->ap.addPositional(p(&ArgParser::argPagesPositional)); + + this->ap.selectMainOptionTable(); + this->ap.addBare("encrypt", b(&ArgParser::argEncrypt)); + this->ap.registerOptionTable(O_ENCRYPT, b(&ArgParser::argEndEncrypt)); + this->ap.addPositional(p(&ArgParser::argEncryptPositional)); + this->ap.registerOptionTable(O_ENCRYPT_40, b(&ArgParser::argEndEncrypt)); + this->ap.addRequiredChoices("extract",p(&ArgParser::arg40Extract), yn); + this->ap.addRequiredChoices("annotate",p(&ArgParser::arg40Annotate), yn); + this->ap.addRequiredChoices("print",p(&ArgParser::arg40Print), yn); + this->ap.addRequiredChoices("modify",p(&ArgParser::arg40Modify), yn); + this->ap.registerOptionTable(O_ENCRYPT_128, b(&ArgParser::argEndEncrypt)); + this->ap.registerOptionTable(O_ENCRYPT_256, b(&ArgParser::argEndEncrypt)); + for (char const* k: {O_ENCRYPT_128, O_ENCRYPT_256}) + { + this->ap.selectOptionTable(k); + this->ap.addRequiredChoices("accessibility", + p(&ArgParser::arg128Accessibility), yn); + this->ap.addRequiredChoices("extract", p(&ArgParser::arg128Extract), yn); + char const* print128_choices[] = {"full", "low", "none", 0}; + this->ap.addRequiredChoices("print", + p(&ArgParser::arg128Print), print128_choices); + this->ap.addRequiredChoices("assemble",p(&ArgParser::arg128Assemble), yn); + this->ap.addRequiredChoices("annotate",p(&ArgParser::arg128Annotate), yn); + this->ap.addRequiredChoices("form",p(&ArgParser::arg128Form), yn); + this->ap.addRequiredChoices("modify-other",p(&ArgParser::arg128ModOther), yn); + char const* modify128_choices[] = + {"all", "annotate", "form", "assembly", "none", 0}; + this->ap.addRequiredChoices("modify", + p(&ArgParser::arg128Modify), modify128_choices); + this->ap.addBare("cleartext-metadata", b(&ArgParser::arg128ClearTextMetadata)); + } + + this->ap.selectOptionTable(O_ENCRYPT_128); + this->ap.addRequiredChoices("use-aes",p(&ArgParser::arg128UseAes), yn); + this->ap.addBare("force-V4", b(&ArgParser::arg128ForceV4)); + + this->ap.selectOptionTable(O_ENCRYPT_256); + this->ap.addBare("force-R5", b(&ArgParser::arg256ForceR5)); + this->ap.addBare("allow-insecure", b(&ArgParser::argAllowInsecure)); + + this->ap.registerOptionTable(O_UNDER_OVERLAY, b(&ArgParser::argEndUnderOverlay)); + this->ap.addPositional(p(&ArgParser::argUOpositional)); + this->ap.addRequiredParameter("to", + p(&ArgParser::argUOto), "page-range"); + this->ap.addRequiredParameter("from", + p(&ArgParser::argUOfrom), "page-range"); + this->ap.addRequiredParameter("repeat", + p(&ArgParser::argUOrepeat), "page-range"); + this->ap.addRequiredParameter("password", + p(&ArgParser::argUOpassword), "password"); + + this->ap.registerOptionTable(O_ATTACHMENT, b(&ArgParser::argEndAddAttachment)); + this->ap.addPositional(p(&ArgParser::argAApositional)); + this->ap.addRequiredParameter("key", + p(&ArgParser::argAAKey), "attachment-key"); + this->ap.addRequiredParameter("filename", + p(&ArgParser::argAAFilename), "filename"); + this->ap.addRequiredParameter("creationdate", + p(&ArgParser::argAACreationDate), "creation-date"); + this->ap.addRequiredParameter("moddate", + p(&ArgParser::argAAModDate), "modification-date"); + this->ap.addRequiredParameter("mimetype", + p(&ArgParser::argAAMimeType), "mime/type"); + this->ap.addRequiredParameter("description", + p(&ArgParser::argAADescription), "description"); + this->ap.addBare("replace", b(&ArgParser::argAAReplace)); + + this->ap.registerOptionTable(O_COPY_ATTACHMENT, b(&ArgParser::argEndCopyAttachments)); + this->ap.addPositional(p(&ArgParser::argCApositional)); + this->ap.addRequiredParameter("prefix", + p(&ArgParser::argCAprefix), "prefix"); + this->ap.addRequiredParameter("password", + p(&ArgParser::argCApassword), "password"); +} + +void +ArgParser::argPositional(char* arg) +{ + if (o.infilename == 0) + { + o.infilename = arg; + } + else if (o.outfilename == 0) + { + o.outfilename = arg; + } + else + { + usage(std::string("unknown argument ") + arg); + } +} + +void +ArgParser::argVersion() +{ + auto whoami = this->ap.getProgname(); + std::cout + << whoami << " version " << QPDF::QPDFVersion() << std::endl + << "Run " << whoami << " --copyright to see copyright and license information." + << std::endl; +} + +void +ArgParser::argCopyright() +{ + // Make sure the output looks right on an 80-column display. + // 1 2 3 4 5 6 7 8 + // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 + std::cout + << this->ap.getProgname() + << " version " << QPDF::QPDFVersion() << std::endl + << std::endl + << "Copyright (c) 2005-2021 Jay Berkenbilt" + << std::endl + << "QPDF is licensed under the Apache License, Version 2.0 (the \"License\");" + << std::endl + << "you may not use this file except in compliance with the License." + << std::endl + << "You may obtain a copy of the License at" + << std::endl + << std::endl + << " http://www.apache.org/licenses/LICENSE-2.0" + << std::endl + << std::endl + << "Unless required by applicable law or agreed to in writing, software" + << std::endl + << "distributed under the License is distributed on an \"AS IS\" BASIS," + << std::endl + << "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied." + << std::endl + << "See the License for the specific language governing permissions and" + << std::endl + << "limitations under the License." + << std::endl + << std::endl + << "Versions of qpdf prior to version 7 were released under the terms" + << std::endl + << "of version 2.0 of the Artistic License. At your option, you may" + << std::endl + << "continue to consider qpdf to be licensed under those terms. Please" + << std::endl + << "see the manual for additional information." + << std::endl; +} + +void +ArgParser::argHelp() +{ + std::cout + // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 + << "Usage: qpdf [options] {infile | --empty} [page_selection_options] outfile\n" + << "\n" + << "An option summary appears below. Please see the documentation for details.\n" + << "\n" + << "If @filename appears anywhere in the command-line, each line of filename\n" + << "will be interpreted as an argument. No interpolation is done. Line\n" + << "terminators are stripped, but leading and trailing whitespace is\n" + << "intentionally preserved. @- can be specified to read from standard input.\n" + << "\n" + << "The output file can be - to indicate writing to standard output, or it can\n" + << "be --replace-input to cause qpdf to replace the input file with the output.\n" + << "\n" + << "Note that when contradictory options are provided, whichever options are\n" + << "provided last take precedence.\n" + << "\n" + << "\n" + << "Basic Options\n" + << "-------------\n" + << "\n" + << "--version show version of qpdf\n" + << "--copyright show qpdf's copyright and license information\n" + << "--help show command-line argument help\n" + << "--show-crypto show supported crypto providers; default is first\n" + << "--completion-bash output a bash complete command you can eval\n" + << "--completion-zsh output a zsh complete command you can eval\n" + << "--password=password specify a password for accessing encrypted files\n" + << "--password-file=file get the password the first line \"file\"; use \"-\"\n" + << " to read the password from stdin (without prompt or\n" + << " disabling echo, so use with caution)\n" + << "--is-encrypted silently exit 0 if the file is encrypted or 2\n" + << " if not; useful for shell scripts\n" + << "--requires-password silently exit 0 if a password (other than as\n" + << " supplied) is required, 2 if the file is not\n" + << " encrypted, or 3 if the file is encrypted\n" + << " but requires no password or the supplied password\n" + << " is correct; useful for shell scripts\n" + << "--verbose provide additional informational output\n" + << "--progress give progress indicators while writing output\n" + << "--no-warn suppress warnings\n" + << "--warning-exit-0 exit with code 0 instead of 3 if there are warnings\n" + << "--linearize generated a linearized (web optimized) file\n" + << "--replace-input use in place of specifying an output file; qpdf will\n" + << " replace the input file with the output\n" + << "--copy-encryption=file copy encryption parameters from specified file\n" + << "--encryption-file-password=password\n" + << " password used to open the file from which encryption\n" + << " parameters are being copied\n" + << "--allow-weak-crypto allow creation of files using weak cryptographic\n" + << " algorithms\n" + << "--encrypt options -- generate an encrypted file\n" + << "--decrypt remove any encryption on the file\n" + << "--password-is-hex-key treat primary password option as a hex-encoded key\n" + << "--suppress-password-recovery\n" + << " do not attempt recovering from password string\n" + << " encoding errors\n" + << "--password-mode=mode control qpdf's encoding of passwords\n" + << "--pages options -- select specific pages from one or more files\n" + << "--collate=n causes files specified in --pages to be collated\n" + << " in groups of n pages (default 1) rather than\n" + << " concatenated\n" + << "--flatten-rotation move page rotation from /Rotate key to content\n" + << "--rotate=[+|-]angle[:page-range]\n" + << " rotate each specified page 0, 90, 180, or 270\n" + << " degrees; rotate all pages if no page range is given\n" + << "--split-pages=[n] write each output page to a separate file\n" + << "--overlay options -- overlay pages from another file\n" + << "--underlay options -- underlay pages from another file\n" + << "\n" + << "Note that you can use the @filename or @- syntax for any argument at any\n" + << "point in the command. This provides a good way to specify a password without\n" + << "having to explicitly put it on the command line. @filename or @- must be a\n" + << "word by itself. Syntax such as --arg=@filename doesn't work.\n" + << "\n" + << "If none of --copy-encryption, --encrypt or --decrypt are given, qpdf will\n" + << "preserve any encryption data associated with a file.\n" + << "\n" + << "Note that when copying encryption parameters from another file, all\n" + << "parameters will be copied, including both user and owner passwords, even\n" + << "if the user password is used to open the other file. This works even if\n" + << "the owner password is not known.\n" + << "\n" + << "The --password-is-hex-key option overrides the normal computation of\n" + << "encryption keys. It only applies to the password used to open the main\n" + << "file. This option is not ordinarily useful but can be helpful for forensic\n" + << "or investigatory purposes. See manual for further discussion.\n" + << "\n" + << "The --rotate flag can be used to specify pages to rotate pages either\n" + << "0, 90, 180, or 270 degrees. The page range is specified in the same\n" + << "format as with the --pages option, described below. Repeat the option\n" + << "to rotate multiple groups of pages. If the angle is preceded by + or -,\n" + << "it is added to or subtracted from the original rotation. Otherwise, the\n" + << "rotation angle is set explicitly to the given value. You almost always\n" + << "want to use + or - unless you are certain about the internals of the PDF\n" + << "you are working with.\n" + << "\n" + << "If --split-pages is specified, each page is written to a separate output\n" + << "file. File names are generated as follows:\n" + << "* If the string %d appears in the output file name, it is replaced with a\n" + << " zero-padded page range starting from 1\n" + << "* Otherwise, if the output file name ends in .pdf (case insensitive), a\n" + << " zero-padded page range, preceded by a dash, is inserted before the file\n" + << " extension\n" + << "* Otherwise, the file name is appended with a zero-padded page range\n" + << " preceded by a dash.\n" + << "Page ranges are single page numbers for single-page groups or first-last\n" + << "for multipage groups.\n" + << "\n" + << "\n" + << "Encryption Options\n" + << "------------------\n" + << "\n" + << " --encrypt user-password owner-password key-length flags --\n" + << "\n" + << "Note that -- terminates parsing of encryption flags.\n" + << "\n" + << "Either or both of the user password and the owner password may be\n" + << "empty strings.\n" + << "\n" + << "key-length may be 40, 128, or 256\n" + << "\n" + << "Additional flags are dependent upon key length.\n" + << "\n" + << " If 40:\n" + << "\n" + << " --print=[yn] allow printing\n" + << " --modify=[yn] allow document modification\n" + << " --extract=[yn] allow text/graphic extraction\n" + << " --annotate=[yn] allow comments and form fill-in and signing\n" + << "\n" + << " If 128:\n" + << "\n" + << " --accessibility=[yn] allow accessibility to visually impaired\n" + << " --extract=[yn] allow other text/graphic extraction\n" + << " --print=print-opt control printing access\n" + << " --assemble=[yn] allow document assembly\n" + << " --annotate=[yn] allow commenting/filling form fields\n" + << " --form=[yn] allow filling form fields\n" + << " --modify-other=[yn] allow other modifications\n" + << " --modify=modify-opt control modify access (old way)\n" + << " --cleartext-metadata prevents encryption of metadata\n" + << " --use-aes=[yn] indicates whether to use AES encryption\n" + << " --force-V4 forces use of V=4 encryption handler\n" + << "\n" + << " If 256, options are the same as 128 with these exceptions:\n" + << " --force-V4 this option is not available with 256-bit keys\n" + << " --use-aes this option is always on with 256-bit keys\n" + << " --force-R5 forces use of deprecated R=5 encryption\n" + << " --allow-insecure allow the owner password to be empty when the\n" + << " user password is not empty\n" + << "\n" + << " print-opt may be:\n" + << "\n" + << " full allow full printing\n" + << " low allow only low-resolution printing\n" + << " none disallow printing\n" + << "\n" + << " modify-opt may be:\n" + << "\n" + << " all allow full document modification\n" + << " annotate allow comment authoring and form operations\n" + << " form allow form field fill-in and signing\n" + << " assembly allow document assembly only\n" + << " none allow no modifications\n" + << "\n" + << "The default for each permission option is to be fully permissive. Please\n" + << "refer to the manual for more details on the modify options.\n" + << "\n" + << "Specifying cleartext-metadata forces the PDF version to at least 1.5.\n" + << "Specifying use of AES forces the PDF version to at least 1.6. These\n" + << "options are both off by default.\n" + << "\n" + << "The --force-V4 flag forces the V=4 encryption handler introduced in PDF 1.5\n" + << "to be used even if not otherwise needed. This option is primarily useful\n" + << "for testing qpdf and has no other practical use.\n" + << "\n" + << "A warning will be issued if you attempt to encrypt a file with a format that\n" + << "uses a weak cryptographic algorithm such as RC4. To suppress the warning,\n" + << "specify the option --allow-weak-crypto. This option is outside of encryption\n" + << "options (e.g. --allow-week-crypto --encrypt u o 128 --)\n" + << "\n" + << "\n" + << "Password Modes\n" + << "--------------\n" + << "\n" + << "The --password-mode controls how qpdf interprets passwords supplied\n" + << "on the command-line. qpdf's default behavior is correct in almost all\n" + << "cases, but you can fine-tune with this option.\n" + << "\n" + << " bytes: use the password literally as supplied\n" + << " hex-bytes: interpret the password as a hex-encoded byte string\n" + << " unicode: interpret the password as a UTF-8 encoded string\n" + << " auto: attempt to infer the encoding and adjust as needed\n" + << "\n" + << "This is a complex topic. See the manual for a complete discussion.\n" + << "\n" + << "\n" + << "Page Selection Options\n" + << "----------------------\n" + << "\n" + << "These options allow pages to be selected from one or more PDF files.\n" + << "Whatever file is given as the primary input file is used as the\n" + << "starting point, but its pages are replaced with pages as specified.\n" + << "\n" + << "--keep-files-open=[yn]\n" + << "--keep-files-open-threshold=count\n" + << "--pages file [ --password=password ] [ page-range ] ... --\n" + << "\n" + << "For each file that pages should be taken from, specify the file, a\n" + << "password needed to open the file (if any), and a page range. The\n" + << "password needs to be given only once per file. If any of the input\n" + << "files are the same as the primary input file or the file used to copy\n" + << "encryption parameters (if specified), you do not need to repeat the\n" + << "password here. The same file can be repeated multiple times. The\n" + << "filename \".\" may be used to refer to the current input file. All\n" + << "non-page data (info, outlines, page numbers, etc. are taken from the\n" + << "primary input file. To discard this, use --empty as the primary\n" + << "input.\n" + << "\n" + << "By default, when more than 200 distinct files are specified, qpdf will\n" + << "close each file when not being referenced. With 200 files or fewer, all\n" + << "files will be kept open at the same time. This behavior can be overridden\n" + << "by specifying --keep-files-open=[yn]. Closing and opening files can have\n" + << "very high overhead on certain file systems, especially networked file\n" + << "systems. The threshold of 200 can be modified with\n" + << "--keep-files-open-threshold\n" + << "\n" + << "The page range is a set of numbers separated by commas, ranges of\n" + << "numbers separated dashes, or combinations of those. The character\n" + << "\"z\" represents the last page. A number preceded by an \"r\" indicates\n" + << "to count from the end, so \"r3-r1\" would be the last three pages of the\n" + << "document. Pages can appear in any order. Ranges can appear with a\n" + << "high number followed by a low number, which causes the pages to appear in\n" + << "reverse. Numbers may be repeated. A page range may be appended with :odd\n" + << "to indicate odd pages in the selected range or :even to indicate even\n" + << "pages.\n" + << "\n" + << "If the page range is omitted, the range of 1-z is assumed. qpdf decides\n" + << "that the page range is omitted if the range argument is either -- or a\n" + << "valid file name and not a valid range.\n" + << "\n" + << "The usual behavior of --pages is to add all pages from the first file,\n" + << "then all pages from the second file, and so on. If the --collate option\n" + << "is specified, then pages are collated instead. In other words, qpdf takes\n" + << "the first page from the first file, the first page from the second file,\n" + << "and so on until it runs out of files; then it takes the second page from\n" + << "each file, etc. When a file runs out of pages, it is skipped until all\n" + << "specified pages are taken from all files.\n" + << "\n" + << "See the manual for examples and a discussion of additional subtleties.\n" + << "\n" + << "\n" + << "Overlay and Underlay Options\n" + << "----------------------------\n" + << "\n" + << "These options allow pages from another file to be overlaid or underlaid\n" + << "on the primary output. Overlaid pages are drawn on top of the destination\n" + << "page and may obscure the page. Underlaid pages are drawn below the\n" + << "destination page.\n" + << "\n" + << "{--overlay | --underlay } file\n" + " [ --password=password ]\n" + " [ --to=page-range ]\n" + " [ --from=[page-range] ]\n" + " [ --repeat=page-range ]\n" + " --\n" + << "\n" + << "For overlay and underlay, a file and optional password are specified, along\n" + << "with a series of optional page ranges. The default behavior is that each\n" + << "page of the overlay or underlay file is imposed on the corresponding page\n" + << "of the primary output until it runs out of pages, and any extra pages are\n" + << "ignored. The page range options all take page ranges in the same form as\n" + << "the --pages option. They have the following meanings:\n" + << "\n" + << " --to: the pages in the primary output to which overlay/underlay is\n" + << " applied\n" + << " --from: the pages from the overlay/underlay file that are used\n" + << " --repeat: pages from the overlay/underlay that are repeated after\n" + << " any \"from\" pages have been exhausted\n" + << "\n" + << "\n" + << "Embedded Files/Attachments Options\n" + << "----------------------------------\n" + << "\n" + << "These options can be used to work with embedded files, also known as\n" + << "attachments.\n" + << "\n" + << "--list-attachments show key and stream number for embedded files;\n" + << " combine with --verbose for more detailed information\n" + << "--show-attachment=key write the contents of the specified attachment to\n" + << " standard output as binary data\n" + << "--add-attachment file options --\n" + << " add or replace an attachment\n" + << "--remove-attachment=key remove the specified attachment; repeatable\n" + << "--copy-attachments-from file options --\n" + << " copy attachments from another file\n" + << "\n" + << "The \"key\" option is the unique name under which the attachment is registered\n" + << "within the PDF file. You can get this using the --list-attachments option. This\n" + << "is usually the same as the filename, but it doesn't have to be.\n" + << "\n" + << "Options for adding attachments:\n" + << "\n" + << " file path to the file to attach\n" + << " --key=key the name of this in the embedded files table;\n" + << " defaults to the last path element of file\n" + << " --filename=name the file name of the attachment; this is what is\n" + << " usually displayed to the user; defaults to the\n" + << " last path element of file\n" + << " --creationdate=date creation date in PDF format; defaults to the\n" + << " current time\n" + << " --moddate=date modification date in PDF format; defaults to the\n" + << " current time\n" + << " --mimetype=type/subtype mime type of attachment (e.g. application/pdf)\n" + << " --description=\"text\" attachment description\n" + << " --replace replace any existing attachment with the same key\n" + << "\n" + << "Options for copying attachments:\n" + << "\n" + << " file file whose attachments should be copied\n" + << " --password=password password to open the other file, if needed\n" + << " --prefix=prefix a prefix to insert in front of each key;\n" + << " required if needed to ensure each attachment\n" + << " has a unique key\n" + << "\n" + << "Date format: D:yyyymmddhhmmss<z> where <z> is either Z for UTC or a timezone\n" + << "offset in the form -hh'mm' or +hh'mm'.\n" + << "Examples: D:20210207161528-05'00', D:20210207211528Z\n" + << "\n" + << "\n" + << "Advanced Parsing Options\n" + << "------------------------\n" + << "\n" + << "These options control aspects of how qpdf reads PDF files. Mostly these are\n" + << "of use to people who are working with damaged files. There is little reason\n" + << "to use these options unless you are trying to solve specific problems.\n" + << "\n" + << "--suppress-recovery prevents qpdf from attempting to recover damaged files\n" + << "--ignore-xref-streams tells qpdf to ignore any cross-reference streams\n" + << "\n" + << "\n" + << "Advanced Transformation Options\n" + << "-------------------------------\n" + << "\n" + << "These transformation options control fine points of how qpdf creates\n" + << "the output file. Mostly these are of use only to people who are very\n" + << "familiar with the PDF file format or who are PDF developers.\n" + << "\n" + << "--stream-data=option controls transformation of stream data (below)\n" + << "--compress-streams=[yn] controls whether to compress streams on output\n" + << "--decode-level=option controls how to filter streams from the input\n" + << "--recompress-flate recompress streams already compressed with Flate\n" + << "--compression-level=n set zlib compression level; most effective with\n" + << " --recompress-flate --object-streams=generate\n" + << "--normalize-content=[yn] enables or disables normalization of content streams\n" + << "--object-streams=mode controls handing of object streams\n" + << "--preserve-unreferenced preserve unreferenced objects\n" + << "--remove-unreferenced-resources={auto,yes,no}\n" + << " whether to remove unreferenced page resources\n" + << "--preserve-unreferenced-resources\n" + << " synonym for --remove-unreferenced-resources=no\n" + << "--newline-before-endstream always put a newline before endstream\n" + << "--coalesce-contents force all pages' content to be a single stream\n" + << "--flatten-annotations=option\n" + << " incorporate rendering of annotations into page\n" + << " contents including those for interactive form\n" + << " fields; may also want --generate-appearances\n" + << "--generate-appearances generate appearance streams for form fields\n" + << "--optimize-images compress images with DCT (JPEG) when advantageous\n" + << "--oi-min-width=w do not optimize images whose width is below w;\n" + << " default is 128. Use 0 to mean no minimum\n" + << "--oi-min-height=h do not optimize images whose height is below h\n" + << " default is 128. Use 0 to mean no minimum\n" + << "--oi-min-area=a do not optimize images whose pixel count is below a\n" + << " default is 16,384. Use 0 to mean no minimum\n" + << "--externalize-inline-images convert inline images to regular images; by\n" + << " default, images of at least 1,024 bytes are\n" + << " externalized\n" + << "--ii-min-bytes=bytes specify minimum size of inline images to be\n" + << " converted to regular images\n" + << "--keep-inline-images exclude inline images from image optimization\n" + << "--remove-page-labels remove any page labels present in the output file\n" + << "--qdf turns on \"QDF mode\" (below)\n" + << "--linearize-pass1=file write intermediate pass of linearized file\n" + << " for debugging\n" + << "--min-version=version sets the minimum PDF version of the output file\n" + << "--force-version=version forces this to be the PDF version of the output file\n" + << "\n" + << "Options for --flatten-annotations are all, print, or screen. If the option\n" + << "is print, only annotations marked as print are included. If the option is\n" + << "screen, options marked as \"no view\" are excluded. Otherwise, annotations\n" + << "are flattened regardless of the presence of print or NoView flags. It is\n" + << "common for PDF files to have a flag set that appearance streams need to be\n" + << "regenerated. This happens when someone changes a form value with software\n" + << "that does not know how to render the new value. qpdf will not flatten form\n" + << "fields in files like this. If you get this warning, you have two choices:\n" + << "either use qpdf's --generate-appearances flag to tell qpdf to go ahead and\n" + << "regenerate appearances, or use some other tool to generate the appearances.\n" + << "qpdf does a pretty good job with most forms when only ASCII and \"Windows\n" + << "ANSI\" characters are used in form field values, but if your form fields\n" + << "contain other characters, rich text, or are other than left justified, you\n" + << "will get better results first saving with other software.\n" + << "\n" + << "Version numbers may be expressed as major.minor.extension-level, so 1.7.3\n" + << "means PDF version 1.7 at extension level 3.\n" + << "\n" + << "Values for stream data options:\n" + << "\n" + << " compress recompress stream data when possible (default)\n" + << " preserve leave all stream data as is\n" + << " uncompress uncompress stream data when possible\n" + << "\n" + << "Values for object stream mode:\n" + << "\n" + << " preserve preserve original object streams (default)\n" + << " disable don't write any object streams\n" + << " generate use object streams wherever possible\n" + << "\n" + << "When --compress-streams=n is specified, this overrides the default behavior\n" + << "of qpdf, which is to attempt compress uncompressed streams. Setting\n" + << "stream data mode to uncompress or preserve has the same effect.\n" + << "\n" + << "The --decode-level parameter may be set to one of the following values:\n" + << " none do not decode streams\n" + << " generalized decode streams compressed with generalized filters\n" + << " including LZW, Flate, and the ASCII encoding filters.\n" + << " specialized additionally decode streams with non-lossy specialized\n" + << " filters including RunLength\n" + << " all additionally decode streams with lossy filters\n" + << " including DCT (JPEG)\n" + << "\n" + << "In qdf mode, by default, content normalization is turned on, and the\n" + << "stream data mode is set to uncompress. QDF mode does not support\n" + << "linearized files. The --linearize flag disables qdf mode.\n" + << "\n" + << "Setting the minimum PDF version of the output file may raise the version\n" + << "but will never lower it. Forcing the PDF version of the output file may\n" + << "set the PDF version to a lower value than actually allowed by the file's\n" + << "contents. You should only do this if you have no other possible way to\n" + << "open the file or if you know that the file definitely doesn't include\n" + << "features not supported later versions.\n" + << "\n" + << "Testing, Inspection, and Debugging Options\n" + << "------------------------------------------\n" + << "\n" + << "These options can be useful for digging into PDF files or for use in\n" + << "automated test suites for software that uses the qpdf library.\n" + << "\n" + << "--deterministic-id generate deterministic /ID\n" + << "--static-id generate static /ID: FOR TESTING ONLY!\n" + << "--static-aes-iv use a static initialization vector for AES-CBC\n" + << " This is option is not secure! FOR TESTING ONLY!\n" + << "--no-original-object-ids suppress original object ID comments in qdf mode\n" + << "--show-encryption quickly show encryption parameters\n" + << "--show-encryption-key when showing encryption, reveal the actual key\n" + << "--check-linearization check file integrity and linearization status\n" + << "--show-linearization check and show all linearization data\n" + << "--show-xref show the contents of the cross-reference table\n" + << "--show-object=trailer|obj[,gen]\n" + << " show the contents of the given object\n" + << " --raw-stream-data show raw stream data instead of object contents\n" + << " --filtered-stream-data show filtered stream data instead of object contents\n" + << "--show-npages print the number of pages in the file\n" + << "--show-pages shows the object/generation number for each page\n" + << " --with-images also shows the object IDs for images on each page\n" + << "--check check file structure + encryption, linearization\n" + << "--json generate a json representation of the file\n" + << "--json-help describe the format of the json representation\n" + << "--json-key=key repeatable; prune json structure to include only\n" + << " specified keys. If absent, all keys are shown\n" + << "--json-object=trailer|[obj,gen]\n" + << " repeatable; include only specified objects in the\n" + << " \"objects\" section of the json. If absent, all\n" + << " objects are shown\n" + << "\n" + << "The json representation generated by qpdf is designed to facilitate\n" + << "processing of qpdf from other programming languages that have a hard\n" + << "time calling C++ APIs. Run qpdf --json-help for details on the format.\n" + << "The manual has more in-depth information about the json representation\n" + << "and certain compatibility guarantees that qpdf provides.\n" + << "\n" + << "The --raw-stream-data and --filtered-stream-data options are ignored\n" + << "unless --show-object is given. Either of these options will cause the\n" + << "stream data to be written to standard output.\n" + << "\n" + << "If --filtered-stream-data is given and --normalize-content=y is also\n" + << "given, qpdf will attempt to normalize the stream data as if it is a\n" + << "page content stream. This attempt will be made even if it is not a\n" + << "page content stream, in which case it will produce unusable results.\n" + << "\n" + << "Ordinarily, qpdf exits with a status of 0 on success or a status of 2\n" + << "if any errors occurred. If there were warnings but not errors, qpdf\n" + << "exits with a status of 3. If warnings would have been issued but --no-warn\n" + << "was given, an exit status of 3 is still used. If you want qpdf to exit\n" + << "with status 0 when there are warnings, use the --warning-exit-0 flag.\n" + << "When --no-warn and --warning-exit-0 are used together, the effect is for\n" + << "qpdf to completely ignore warnings. qpdf does not use exit status 1,\n" + << "since that is used by the shell if it can't execute qpdf.\n"; +} + +void +ArgParser::argJsonHelp() +{ + // Make sure the output looks right on an 80-column display. + // 1 2 3 4 5 6 7 8 + // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 + std::cout + << "The json block below contains the same structure with the same keys as the" + << std::endl + << "json generated by qpdf. In the block below, the values are descriptions of" + << std::endl + << "the meanings of those entries. The specific contract guaranteed by qpdf in" + << std::endl + << "its json representation is explained in more detail in the manual. You can" + << std::endl + << "specify a subset of top-level keys when you invoke qpdf, but the \"version\"" + << std::endl + << "and \"parameters\" keys will always be present. Note that the \"encrypt\"" + << std::endl + << "key's values will be populated for non-encrypted files. Some values will" + << std::endl + << "be null, and others will have values that apply to unencrypted files." + << std::endl + << QPDFJob::json_schema().unparse() + << std::endl; +} + +void +ArgParser::argShowCrypto() +{ + auto crypto = QPDFCryptoProvider::getRegisteredImpls(); + std::string default_crypto = QPDFCryptoProvider::getDefaultProvider(); + std::cout << default_crypto << std::endl; + for (auto const& iter: crypto) + { + if (iter != default_crypto) + { + std::cout << iter << std::endl; + } + } +} + +void +ArgParser::argPassword(char* parameter) +{ + o.password = parameter; +} + +void +ArgParser::argPasswordFile(char* parameter) +{ + std::list<std::string> lines; + if (strcmp(parameter, "-") == 0) + { + QTC::TC("qpdf", "qpdf password stdin"); + lines = QUtil::read_lines_from_file(std::cin); + } + else + { + QTC::TC("qpdf", "qpdf password file"); + lines = QUtil::read_lines_from_file(parameter); + } + if (lines.size() >= 1) + { + // Make sure the memory for this stays in scope. + o.password_alloc = std::shared_ptr<char>( + QUtil::copy_string(lines.front().c_str()), + std::default_delete<char[]>()); + o.password = o.password_alloc.get(); + + if (lines.size() > 1) + { + std::cerr << this->ap.getProgname() + << ": WARNING: all but the first line of" + << " the password file are ignored" << std::endl; + } + } +} + +void +ArgParser::argEmpty() +{ + o.infilename = ""; +} + +void +ArgParser::argLinearize() +{ + o.linearize = true; +} + +void +ArgParser::argEncrypt() +{ + this->accumulated_args.clear(); + if (this->ap.isCompleting() && this->ap.argsLeft() == 0) + { + this->ap.insertCompletion("user-password"); + } + this->ap.selectOptionTable(O_ENCRYPT); +} + +void +ArgParser::argEncryptPositional(char* arg) +{ + this->accumulated_args.push_back(arg); + size_t n_args = this->accumulated_args.size(); + if (n_args < 3) + { + if (this->ap.isCompleting() && (this->ap.argsLeft() == 0)) + { + if (n_args == 1) + { + this->ap.insertCompletion("owner-password"); + } + else if (n_args == 2) + { + this->ap.insertCompletion("40"); + this->ap.insertCompletion("128"); + this->ap.insertCompletion("256"); + } + } + return; + } + o.user_password = this->accumulated_args.at(0); + o.owner_password = this->accumulated_args.at(1); + std::string len_str = this->accumulated_args.at(2); + if (len_str == "40") + { + o.keylen = 40; + this->ap.selectOptionTable(O_ENCRYPT_40); + } + else if (len_str == "128") + { + o.keylen = 128; + this->ap.selectOptionTable(O_ENCRYPT_128); + } + else if (len_str == "256") + { + o.keylen = 256; + o.use_aes = true; + this->ap.selectOptionTable(O_ENCRYPT_256); + } + else + { + usage("encryption key length must be 40, 128, or 256"); + } +} + +void +ArgParser::argDecrypt() +{ + o.decrypt = true; + o.encrypt = false; + o.copy_encryption = false; +} + +void +ArgParser::argPasswordIsHexKey() +{ + o.password_is_hex_key = true; +} + +void +ArgParser::argSuppressPasswordRecovery() +{ + o.suppress_password_recovery = true; +} + +void +ArgParser::argPasswordMode(char* parameter) +{ + if (strcmp(parameter, "bytes") == 0) + { + o.password_mode = QPDFJob::pm_bytes; + } + else if (strcmp(parameter, "hex-bytes") == 0) + { + o.password_mode = QPDFJob::pm_hex_bytes; + } + else if (strcmp(parameter, "unicode") == 0) + { + o.password_mode = QPDFJob::pm_unicode; + } + else if (strcmp(parameter, "auto") == 0) + { + o.password_mode = QPDFJob::pm_auto; + } + else + { + usage("invalid password-mode option"); + } +} + +void +ArgParser::argAllowInsecure() +{ + o.allow_insecure = true; +} + +void +ArgParser::argAllowWeakCrypto() +{ + o.allow_weak_crypto = true; +} + +void +ArgParser::argCopyEncryption(char* parameter) +{ + o.encryption_file = parameter; + o.copy_encryption = true; + o.encrypt = false; + o.decrypt = false; +} + +void +ArgParser::argEncryptionFilePassword(char* parameter) +{ + o.encryption_file_password = parameter; +} + +void +ArgParser::argCollate(char* parameter) +{ + auto n = ((parameter == 0) ? 1 : + QUtil::string_to_uint(parameter)); + o.collate = QIntC::to_size(n); +} + +void +ArgParser::argPages() +{ + if (! o.page_specs.empty()) + { + usage("the --pages may only be specified one time"); + } + this->accumulated_args.clear(); + this->ap.selectOptionTable(O_PAGES); +} + +void +ArgParser::argPagesPassword(char* parameter) +{ + if (this->pages_password != nullptr) + { + QTC::TC("qpdf", "qpdf duplicated pages password"); + usage("--password already specified for this file"); + } + if (this->accumulated_args.size() != 1) + { + QTC::TC("qpdf", "qpdf misplaced pages password"); + usage("in --pages, --password must immediately follow a file name"); + } + this->pages_password = parameter; +} + +void +ArgParser::argPagesPositional(char* arg) +{ + if (arg == nullptr) + { + if (this->accumulated_args.empty()) + { + return; + } + } + else + { + this->accumulated_args.push_back(arg); + } + + char const* file = this->accumulated_args.at(0); + char const* range = nullptr; + + size_t n_args = this->accumulated_args.size(); + if (n_args >= 2) + { + range = this->accumulated_args.at(1); + } + + // See if the user omitted the range entirely, in which case we + // assume "1-z". + char* next_file = nullptr; + if (range == nullptr) + { + if (arg == nullptr) + { + // The filename or password was the last argument + QTC::TC("qpdf", "qpdf pages range omitted at end", + this->pages_password == nullptr ? 0 : 1); + } + else + { + // We need to accumulate some more arguments + return; + } + } + else + { + try + { + parseNumrange(range, 0, true); + } + catch (std::runtime_error& e1) + { + // The range is invalid. Let's see if it's a file. + if (strcmp(range, ".") == 0) + { + // "." means the input file. + QTC::TC("qpdf", "qpdf pages range omitted with ."); + } + else if (QUtil::file_can_be_opened(range)) + { + QTC::TC("qpdf", "qpdf pages range omitted in middle"); + // Yup, it's a file. + } + else + { + // Give the range error + usage(e1.what()); + } + next_file = const_cast<char*>(range); + range = nullptr; + } + } + if (range == nullptr) + { + range = "1-z"; + } + o.page_specs.push_back(QPDFJob::PageSpec(file, this->pages_password, range)); + this->accumulated_args.clear(); + this->pages_password = nullptr; + if (next_file != nullptr) + { + this->accumulated_args.push_back(next_file); + } +} + +void +ArgParser::argEndPages() +{ + argPagesPositional(nullptr); + if (o.page_specs.empty()) + { + usage("--pages: no page specifications given"); + } +} + +void +ArgParser::argUnderlay() +{ + parseUnderOverlayOptions(&o.underlay); +} + +void +ArgParser::argOverlay() +{ + parseUnderOverlayOptions(&o.overlay); +} + +void +ArgParser::argRotate(char* parameter) +{ + parseRotationParameter(parameter); +} + +void +ArgParser::argFlattenRotation() +{ + o.flatten_rotation = true; +} + +void +ArgParser::argListAttachments() +{ + o.list_attachments = true; + o.require_outfile = false; +} + +void +ArgParser::argShowAttachment(char* parameter) +{ + o.attachment_to_show = parameter; + o.require_outfile = false; +} + +void +ArgParser::argRemoveAttachment(char* parameter) +{ + o.attachments_to_remove.push_back(parameter); +} + +void +ArgParser::argAddAttachment() +{ + o.attachments_to_add.push_back(QPDFJob::AddAttachment()); + this->ap.selectOptionTable(O_ATTACHMENT); +} + +void +ArgParser::argCopyAttachments() +{ + o.attachments_to_copy.push_back(QPDFJob::CopyAttachmentFrom()); + this->ap.selectOptionTable(O_COPY_ATTACHMENT); +} + +void +ArgParser::argStreamData(char* parameter) +{ + o.stream_data_set = true; + if (strcmp(parameter, "compress") == 0) + { + o.stream_data_mode = qpdf_s_compress; + } + else if (strcmp(parameter, "preserve") == 0) + { + o.stream_data_mode = qpdf_s_preserve; + } + else if (strcmp(parameter, "uncompress") == 0) + { + o.stream_data_mode = qpdf_s_uncompress; + } + else + { + // If this happens, it means streamDataChoices in + // ArgParser::initOptionTable is wrong. + usage("invalid stream-data option"); + } +} + +void +ArgParser::argCompressStreams(char* parameter) +{ + o.compress_streams_set = true; + o.compress_streams = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::argRecompressFlate() +{ + o.recompress_flate_set = true; + o.recompress_flate = true; +} + +void +ArgParser::argCompressionLevel(char* parameter) +{ + o.compression_level = QUtil::string_to_int(parameter); +} + +void +ArgParser::argDecodeLevel(char* parameter) +{ + o.decode_level_set = true; + if (strcmp(parameter, "none") == 0) + { + o.decode_level = qpdf_dl_none; + } + else if (strcmp(parameter, "generalized") == 0) + { + o.decode_level = qpdf_dl_generalized; + } + else if (strcmp(parameter, "specialized") == 0) + { + o.decode_level = qpdf_dl_specialized; + } + else if (strcmp(parameter, "all") == 0) + { + o.decode_level = qpdf_dl_all; + } + else + { + // If this happens, it means decodeLevelChoices in + // ArgParser::initOptionTable is wrong. + usage("invalid option"); + } +} + +void +ArgParser::argNormalizeContent(char* parameter) +{ + o.normalize_set = true; + o.normalize = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::argSuppressRecovery() +{ + o.suppress_recovery = true; +} + +void +ArgParser::argObjectStreams(char* parameter) +{ + o.object_stream_set = true; + if (strcmp(parameter, "disable") == 0) + { + o.object_stream_mode = qpdf_o_disable; + } + else if (strcmp(parameter, "preserve") == 0) + { + o.object_stream_mode = qpdf_o_preserve; + } + else if (strcmp(parameter, "generate") == 0) + { + o.object_stream_mode = qpdf_o_generate; + } + else + { + // If this happens, it means objectStreamsChoices in + // ArgParser::initOptionTable is wrong. + usage("invalid object stream mode"); + } +} + +void +ArgParser::argIgnoreXrefStreams() +{ + o.ignore_xref_streams = true; +} + +void +ArgParser::argQdf() +{ + o.qdf_mode = true; +} + +void +ArgParser::argPreserveUnreferenced() +{ + o.preserve_unreferenced_objects = true; +} + +void +ArgParser::argPreserveUnreferencedResources() +{ + o.remove_unreferenced_page_resources = QPDFJob::re_no; +} + +void +ArgParser::argRemoveUnreferencedResources(char* parameter) +{ + if (strcmp(parameter, "auto") == 0) + { + o.remove_unreferenced_page_resources = QPDFJob::re_auto; + } + else if (strcmp(parameter, "yes") == 0) + { + o.remove_unreferenced_page_resources = QPDFJob::re_yes; + } + else if (strcmp(parameter, "no") == 0) + { + o.remove_unreferenced_page_resources = QPDFJob::re_no; + } + else + { + // If this happens, it means remove_unref_choices in + // ArgParser::initOptionTable is wrong. + usage("invalid value for --remove-unreferenced-page-resources"); + } +} + +void +ArgParser::argKeepFilesOpen(char* parameter) +{ + o.keep_files_open_set = true; + o.keep_files_open = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::argKeepFilesOpenThreshold(char* parameter) +{ + o.keep_files_open_threshold = QUtil::string_to_uint(parameter); +} + +void +ArgParser::argNewlineBeforeEndstream() +{ + o.newline_before_endstream = true; +} + +void +ArgParser::argLinearizePass1(char* parameter) +{ + o.linearize_pass1 = parameter; +} + +void +ArgParser::argCoalesceContents() +{ + o.coalesce_contents = true; +} + +void +ArgParser::argFlattenAnnotations(char* parameter) +{ + o.flatten_annotations = true; + if (strcmp(parameter, "screen") == 0) + { + o.flatten_annotations_forbidden |= an_no_view; + } + else if (strcmp(parameter, "print") == 0) + { + o.flatten_annotations_required |= an_print; + } +} + +void +ArgParser::argGenerateAppearances() +{ + o.generate_appearances = true; +} + +void +ArgParser::argMinVersion(char* parameter) +{ + o.min_version = parameter; +} + +void +ArgParser::argForceVersion(char* parameter) +{ + o.force_version = parameter; +} + +void +ArgParser::argSplitPages(char* parameter) +{ + int n = ((parameter == 0) ? 1 : + QUtil::string_to_int(parameter)); + o.split_pages = n; +} + +void +ArgParser::argVerbose() +{ + o.verbose = true; +} + +void +ArgParser::argProgress() +{ + o.progress = true; +} + +void +ArgParser::argNoWarn() +{ + o.suppress_warnings = true; +} + +void +ArgParser::argWarningExitZero() +{ + o.warnings_exit_zero = true; +} + +void +ArgParser::argDeterministicId() +{ + o.deterministic_id = true; +} + +void +ArgParser::argStaticId() +{ + o.static_id = true; +} + +void +ArgParser::argStaticAesIv() +{ + o.static_aes_iv = true; +} + +void +ArgParser::argNoOriginalObjectIds() +{ + o.suppress_original_object_id = true; +} + +void +ArgParser::argShowEncryption() +{ + o.show_encryption = true; + o.require_outfile = false; +} + +void +ArgParser::argShowEncryptionKey() +{ + o.show_encryption_key = true; +} + +void +ArgParser::argCheckLinearization() +{ + o.check_linearization = true; + o.require_outfile = false; +} + +void +ArgParser::argShowLinearization() +{ + o.show_linearization = true; + o.require_outfile = false; +} + +void +ArgParser::argShowXref() +{ + o.show_xref = true; + o.require_outfile = false; +} + +void +ArgParser::argShowObject(char* parameter) +{ + QPDFJob::parse_object_id(parameter, o.show_trailer, o.show_obj, o.show_gen); + o.require_outfile = false; +} + +void +ArgParser::argRawStreamData() +{ + o.show_raw_stream_data = true; +} + +void +ArgParser::argFilteredStreamData() +{ + o.show_filtered_stream_data = true; +} + +void +ArgParser::argShowNpages() +{ + o.show_npages = true; + o.require_outfile = false; +} + +void +ArgParser::argShowPages() +{ + o.show_pages = true; + o.require_outfile = false; +} + +void +ArgParser::argWithImages() +{ + o.show_page_images = true; +} + +void +ArgParser::argJson() +{ + o.json = true; + o.require_outfile = false; +} + +void +ArgParser::argJsonKey(char* parameter) +{ + o.json_keys.insert(parameter); +} + +void +ArgParser::argJsonObject(char* parameter) +{ + o.json_objects.insert(parameter); +} + +void +ArgParser::argCheck() +{ + o.check = true; + o.require_outfile = false; +} + +void +ArgParser::argOptimizeImages() +{ + o.optimize_images = true; +} + +void +ArgParser::argExternalizeInlineImages() +{ + o.externalize_inline_images = true; +} + +void +ArgParser::argKeepInlineImages() +{ + o.keep_inline_images = true; +} + +void +ArgParser::argRemovePageLabels() +{ + o.remove_page_labels = true; +} + +void +ArgParser::argOiMinWidth(char* parameter) +{ + o.oi_min_width = QUtil::string_to_uint(parameter); +} + +void +ArgParser::argOiMinHeight(char* parameter) +{ + o.oi_min_height = QUtil::string_to_uint(parameter); +} + +void +ArgParser::argOiMinArea(char* parameter) +{ + o.oi_min_area = QUtil::string_to_uint(parameter); +} + +void +ArgParser::argIiMinBytes(char* parameter) +{ + o.ii_min_bytes = QUtil::string_to_uint(parameter); +} + +void +ArgParser::arg40Print(char* parameter) +{ + o.r2_print = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg40Modify(char* parameter) +{ + o.r2_modify = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg40Extract(char* parameter) +{ + o.r2_extract = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg40Annotate(char* parameter) +{ + o.r2_annotate = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128Accessibility(char* parameter) +{ + o.r3_accessibility = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128Extract(char* parameter) +{ + o.r3_extract = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128Print(char* parameter) +{ + if (strcmp(parameter, "full") == 0) + { + o.r3_print = qpdf_r3p_full; + } + else if (strcmp(parameter, "low") == 0) + { + o.r3_print = qpdf_r3p_low; + } + else if (strcmp(parameter, "none") == 0) + { + o.r3_print = qpdf_r3p_none; + } + else + { + usage("invalid print option"); + } +} + +void +ArgParser::arg128Modify(char* parameter) +{ + if (strcmp(parameter, "all") == 0) + { + o.r3_assemble = true; + o.r3_annotate_and_form = true; + o.r3_form_filling = true; + o.r3_modify_other = true; + } + else if (strcmp(parameter, "annotate") == 0) + { + o.r3_assemble = true; + o.r3_annotate_and_form = true; + o.r3_form_filling = true; + o.r3_modify_other = false; + } + else if (strcmp(parameter, "form") == 0) + { + o.r3_assemble = true; + o.r3_annotate_and_form = false; + o.r3_form_filling = true; + o.r3_modify_other = false; + } + else if (strcmp(parameter, "assembly") == 0) + { + o.r3_assemble = true; + o.r3_annotate_and_form = false; + o.r3_form_filling = false; + o.r3_modify_other = false; + } + else if (strcmp(parameter, "none") == 0) + { + o.r3_assemble = false; + o.r3_annotate_and_form = false; + o.r3_form_filling = false; + o.r3_modify_other = false; + } + else + { + usage("invalid modify option"); + } +} + +void +ArgParser::arg128ClearTextMetadata() +{ + o.cleartext_metadata = true; +} + +void +ArgParser::arg128Assemble(char* parameter) +{ + o.r3_assemble = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128Annotate(char* parameter) +{ + o.r3_annotate_and_form = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128Form(char* parameter) +{ + o.r3_form_filling = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128ModOther(char* parameter) +{ + o.r3_modify_other = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128UseAes(char* parameter) +{ + o.use_aes = (strcmp(parameter, "y") == 0); +} + +void +ArgParser::arg128ForceV4() +{ + o.force_V4 = true; +} + +void +ArgParser::arg256ForceR5() +{ + o.force_R5 = true; +} + +void +ArgParser::argEndEncrypt() +{ + o.encrypt = true; + o.decrypt = false; + o.copy_encryption = false; +} + +void +ArgParser::argUOpositional(char* arg) +{ + if (o.under_overlay->filename) + { + usage(o.under_overlay->which + " file already specified"); + } + else + { + o.under_overlay->filename = arg; + } +} + +void +ArgParser::argUOto(char* parameter) +{ + parseNumrange(parameter, 0); + o.under_overlay->to_nr = parameter; +} + +void +ArgParser::argUOfrom(char* parameter) +{ + if (strlen(parameter)) + { + parseNumrange(parameter, 0); + } + o.under_overlay->from_nr = parameter; +} + +void +ArgParser::argUOrepeat(char* parameter) +{ + if (strlen(parameter)) + { + parseNumrange(parameter, 0); + } + o.under_overlay->repeat_nr = parameter; +} + +void +ArgParser::argUOpassword(char* parameter) +{ + o.under_overlay->password = parameter; +} + +void +ArgParser::argEndUnderOverlay() +{ + if (0 == o.under_overlay->filename) + { + usage(o.under_overlay->which + " file not specified"); + } + o.under_overlay = 0; +} + +void +ArgParser::argReplaceInput() +{ + o.replace_input = true; +} + +void +ArgParser::argIsEncrypted() +{ + o.check_is_encrypted = true; + o.require_outfile = false; +} + +void +ArgParser::argRequiresPassword() +{ + o.check_requires_password = true; + o.require_outfile = false; +} + +void +ArgParser::argAApositional(char* arg) +{ + o.attachments_to_add.back().path = arg; +} + +void +ArgParser::argAAKey(char* parameter) +{ + o.attachments_to_add.back().key = parameter; +} + +void +ArgParser::argAAFilename(char* parameter) +{ + o.attachments_to_add.back().filename = parameter; +} + +void +ArgParser::argAACreationDate(char* parameter) +{ + if (! QUtil::pdf_time_to_qpdf_time(parameter)) + { + usage(std::string(parameter) + " is not a valid PDF timestamp"); + } + o.attachments_to_add.back().creationdate = parameter; +} + +void +ArgParser::argAAModDate(char* parameter) +{ + if (! QUtil::pdf_time_to_qpdf_time(parameter)) + { + usage(std::string(parameter) + " is not a valid PDF timestamp"); + } + o.attachments_to_add.back().moddate = parameter; +} + +void +ArgParser::argAAMimeType(char* parameter) +{ + if (strchr(parameter, '/') == nullptr) + { + usage("mime type should be specified as type/subtype"); + } + o.attachments_to_add.back().mimetype = parameter; +} + +void +ArgParser::argAADescription(char* parameter) +{ + o.attachments_to_add.back().description = parameter; +} + +void +ArgParser::argAAReplace() +{ + o.attachments_to_add.back().replace = true; +} + +void +ArgParser::argEndAddAttachment() +{ + static std::string now = QUtil::qpdf_time_to_pdf_time( + QUtil::get_current_qpdf_time()); + auto& cur = o.attachments_to_add.back(); + if (cur.path.empty()) + { + usage("add attachment: no path specified"); + } + std::string last_element = QUtil::path_basename(cur.path); + if (last_element.empty()) + { + usage("path for --add-attachment may not be empty"); + } + if (cur.filename.empty()) + { + cur.filename = last_element; + } + if (cur.key.empty()) + { + cur.key = last_element; + } + if (cur.creationdate.empty()) + { + cur.creationdate = now; + } + if (cur.moddate.empty()) + { + cur.moddate = now; + } +} + +void +ArgParser::argCApositional(char* arg) +{ + o.attachments_to_copy.back().path = arg; +} + +void +ArgParser::argCAprefix(char* parameter) +{ + o.attachments_to_copy.back().prefix = parameter; +} + +void +ArgParser::argCApassword(char* parameter) +{ + o.attachments_to_copy.back().password = parameter; +} + +void +ArgParser::argEndCopyAttachments() +{ + if (o.attachments_to_copy.back().path.empty()) + { + usage("copy attachments: no path specified"); + } +} + +void +ArgParser::usage(std::string const& message) +{ + if (this->ap.isCompleting()) + { + // This will cause bash to fall back to regular file completion. + exit(0); + } + else + { + throw QPDFArgParser::Usage(message); + } +} + +std::vector<int> +ArgParser::parseNumrange(char const* range, int max, bool throw_error) +{ + try + { + return QUtil::parse_numrange(range, max); + } + catch (std::runtime_error& e) + { + if (throw_error) + { + throw(e); + } + else + { + usage(e.what()); + } + } + return std::vector<int>(); +} + +void +ArgParser::parseUnderOverlayOptions(QPDFJob::UnderOverlay* uo) +{ + o.under_overlay = uo; + this->ap.selectOptionTable(O_UNDER_OVERLAY); +} + +void +ArgParser::parseRotationParameter(std::string const& parameter) +{ + std::string angle_str; + std::string range; + size_t colon = parameter.find(':'); + int relative = 0; + if (colon != std::string::npos) + { + if (colon > 0) + { + angle_str = parameter.substr(0, colon); + } + if (colon + 1 < parameter.length()) + { + range = parameter.substr(colon + 1); + } + } + else + { + angle_str = parameter; + } + if (angle_str.length() > 0) + { + char first = angle_str.at(0); + if ((first == '+') || (first == '-')) + { + relative = ((first == '+') ? 1 : -1); + angle_str = angle_str.substr(1); + } + else if (! QUtil::is_digit(angle_str.at(0))) + { + angle_str = ""; + } + } + if (range.empty()) + { + range = "1-z"; + } + bool range_valid = false; + try + { + parseNumrange(range.c_str(), 0, true); + range_valid = true; + } + catch (std::runtime_error const&) + { + // ignore + } + if (range_valid && + ((angle_str == "0") ||(angle_str == "90") || + (angle_str == "180") || (angle_str == "270"))) + { + int angle = QUtil::string_to_int(angle_str.c_str()); + if (relative == -1) + { + angle = -angle; + } + o.rotations[range] = QPDFJob::RotationSpec(angle, (relative != 0)); + } + else + { + usage("invalid parameter to rotate: " + parameter); + } +} + +void +ArgParser::parseOptions() +{ + try + { + this->ap.parseArgs(); + } + catch (QPDFArgParser::Usage& e) + { + usage(e.what()); + } +} + +void +ArgParser::doFinalChecks() +{ + if (o.replace_input) + { + if (o.outfilename) + { + usage("--replace-input may not be used when" + " an output file is specified"); + } + else if (o.split_pages) + { + usage("--split-pages may not be used with --replace-input"); + } + } + if (o.infilename == 0) + { + usage("an input file name is required"); + } + else if (o.require_outfile && (o.outfilename == 0) && (! o.replace_input)) + { + usage("an output file name is required; use - for standard output"); + } + else if ((! o.require_outfile) && + ((o.outfilename != 0) || o.replace_input)) + { + usage("no output file may be given for this option"); + } + if (o.optimize_images && (! o.keep_inline_images)) + { + // QXXXQ this is not a check and doesn't belong here + o.externalize_inline_images = true; + } + if (o.check_requires_password && o.check_is_encrypted) + { + usage("--requires-password and --is-encrypted may not be given" + " together"); + } + + if (o.encrypt && (! o.allow_insecure) && + (o.owner_password.empty() && + (! o.user_password.empty()) && + (o.keylen == 256))) + { + // Note that empty owner passwords for R < 5 are copied from + // the user password, so this lack of security is not an issue + // for those files. Also we are consider only the ability to + // open the file without a password to be insecure. We are not + // concerned about whether the viewer enforces security + // settings when the user and owner password match. + usage("A PDF with a non-empty user password and an empty owner" + " password encrypted with a 256-bit key is insecure as it" + " can be opened without a password. If you really want to" + " do this, you must also give the --allow-insecure option" + " before the -- that follows --encrypt."); + } + + if (o.require_outfile && o.outfilename && + (strcmp(o.outfilename, "-") == 0)) + { + if (o.split_pages) + { + usage("--split-pages may not be used when" + " writing to standard output"); + } + if (o.verbose) // QXXXQ + { + usage("--verbose may not be used when" + " writing to standard output"); + } + if (o.progress) + { + usage("--progress may not be used when" + " writing to standard output"); + } + } + + if ((! o.split_pages) && QUtil::same_file(o.infilename, o.outfilename)) + { + QTC::TC("qpdf", "qpdf same file error"); + usage("input file and output file are the same;" + " use --replace-input to intentionally overwrite the input file"); + } +} + +void +QPDFJob::initializeFromArgv(int argc, char* argv[], char const* progname_env) +{ + if (progname_env == nullptr) + { + progname_env = "QPDF_EXECUTABLE"; + } + // QPDFArgParser must stay in scope for the life of the QPDFJob + // object since it holds dynamic memory used for argv, which is + // pointed to by other member variables. + this->m->ap = new QPDFArgParser(argc, argv, progname_env); + setMessagePrefix(this->m->ap->getProgname()); + ArgParser ap(*this->m->ap, *this); + ap.parseOptions(); +} |