2022-05-08 17:42:16 +00:00
|
|
|
#include <qpdf/QPDF.hh>
|
|
|
|
|
|
|
|
#include <qpdf/FileInputSource.hh>
|
2022-05-17 23:18:02 +00:00
|
|
|
#include <qpdf/Pl_Base64.hh>
|
2022-05-18 22:22:57 +00:00
|
|
|
#include <qpdf/Pl_StdioFile.hh>
|
2022-05-15 21:38:06 +00:00
|
|
|
#include <qpdf/QIntC.hh>
|
2023-02-09 12:43:56 +00:00
|
|
|
#include <qpdf/QPDFObject_private.hh>
|
|
|
|
#include <qpdf/QPDFValue.hh>
|
2022-05-15 16:34:27 +00:00
|
|
|
#include <qpdf/QTC.hh>
|
|
|
|
#include <qpdf/QUtil.hh>
|
2022-05-17 23:18:02 +00:00
|
|
|
#include <algorithm>
|
2022-05-21 11:41:09 +00:00
|
|
|
#include <cstring>
|
2022-05-15 16:34:27 +00:00
|
|
|
|
2022-05-15 21:38:06 +00:00
|
|
|
// This chart shows an example of the state transitions that would
|
|
|
|
// occur in parsing a minimal file.
|
|
|
|
|
|
|
|
// | st_initial
|
|
|
|
// { | -> st_top
|
2022-08-01 15:31:09 +00:00
|
|
|
// "qpdf": [ | -> st_qpdf
|
|
|
|
// { | -> st_qpdf_meta
|
|
|
|
// ... | ...
|
|
|
|
// }, | ...
|
|
|
|
// { | -> st_objects
|
2022-05-15 21:38:06 +00:00
|
|
|
// "obj:1 0 R": { | -> st_object_top
|
|
|
|
// "value": { | -> st_object
|
|
|
|
// "/Pages": "2 0 R", | ...
|
|
|
|
// "/Type": "/Catalog" | ...
|
|
|
|
// } | <- st_object_top
|
|
|
|
// }, | <- st_objects
|
|
|
|
// "obj:2 0 R": { | -> st_object_top
|
|
|
|
// "value": 12 | -> st_object
|
|
|
|
// } | <- st_object_top
|
|
|
|
// }, | <- st_objects
|
|
|
|
// "obj:4 0 R": { | -> st_object_top
|
|
|
|
// "stream": { | -> st_stream
|
|
|
|
// "data": "cG90YXRv", | ...
|
|
|
|
// "dict": { | -> st_object
|
|
|
|
// "/K": true | ...
|
|
|
|
// } | <- st_stream
|
|
|
|
// } | <- st_object_top
|
|
|
|
// }, | <- st_objects
|
|
|
|
// "trailer": { | -> st_trailer
|
|
|
|
// "value": { | -> st_object
|
|
|
|
// "/Root": "1 0 R", | ...
|
|
|
|
// "/Size": 7 | ...
|
|
|
|
// } | <- st_trailer
|
|
|
|
// } | <- st_objects
|
|
|
|
// } | <- st_qpdf
|
2022-08-01 15:31:09 +00:00
|
|
|
// ] | <- st_top
|
2022-05-15 21:38:06 +00:00
|
|
|
// } | <- st_initial
|
|
|
|
|
|
|
|
static char const* JSON_PDF = (
|
|
|
|
// force line break
|
|
|
|
"%PDF-1.3\n"
|
|
|
|
"xref\n"
|
|
|
|
"0 1\n"
|
|
|
|
"0000000000 65535 f \n"
|
|
|
|
"trailer << /Size 1 >>\n"
|
|
|
|
"startxref\n"
|
|
|
|
"9\n"
|
|
|
|
"%%EOF\n");
|
2022-05-15 16:34:27 +00:00
|
|
|
|
2022-05-21 11:41:09 +00:00
|
|
|
// Validator methods -- these are much more performant than std::regex.
|
|
|
|
static bool
|
|
|
|
is_indirect_object(std::string const& v, int& obj, int& gen)
|
|
|
|
{
|
|
|
|
char const* p = v.c_str();
|
|
|
|
std::string o_str;
|
|
|
|
std::string g_str;
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
o_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
if (*p != ' ') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
while (*p == ' ') {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if (!QUtil::is_digit(*p)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
while (QUtil::is_digit(*p)) {
|
|
|
|
g_str.append(1, *p++);
|
|
|
|
}
|
|
|
|
if (*p != ' ') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
while (*p == ' ') {
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
if (*p++ != 'R') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (*p) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
obj = QUtil::string_to_int(o_str.c_str());
|
|
|
|
gen = QUtil::string_to_int(g_str.c_str());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
is_obj_key(std::string const& v, int& obj, int& gen)
|
|
|
|
{
|
|
|
|
if (v.substr(0, 4) != "obj:") {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return is_indirect_object(v.substr(4), obj, gen);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
is_unicode_string(std::string const& v, std::string& str)
|
|
|
|
{
|
|
|
|
if (v.substr(0, 2) == "u:") {
|
|
|
|
str = v.substr(2);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
is_binary_string(std::string const& v, std::string& str)
|
|
|
|
{
|
|
|
|
if (v.substr(0, 2) == "b:") {
|
|
|
|
str = v.substr(2);
|
|
|
|
int count = 0;
|
|
|
|
for (char c: str) {
|
|
|
|
if (!QUtil::is_hex_digit(c)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
++count;
|
|
|
|
}
|
2022-05-21 21:36:32 +00:00
|
|
|
return (count % 2 == 0);
|
2022-05-21 11:41:09 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
is_name(std::string const& v)
|
|
|
|
{
|
|
|
|
return ((v.length() > 1) && (v.at(0) == '/'));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::test_json_validators()
|
|
|
|
{
|
|
|
|
bool passed = true;
|
|
|
|
auto check_fn = [&passed](char const* msg, bool expr) {
|
|
|
|
if (!expr) {
|
|
|
|
passed = false;
|
|
|
|
std::cerr << msg << std::endl;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
#define check(expr) check_fn(#expr, expr)
|
|
|
|
|
|
|
|
int obj = 0;
|
|
|
|
int gen = 0;
|
|
|
|
check(!is_indirect_object("", obj, gen));
|
|
|
|
check(!is_indirect_object("12", obj, gen));
|
|
|
|
check(!is_indirect_object("x12 0 R", obj, gen));
|
|
|
|
check(!is_indirect_object("12 0 Rx", obj, gen));
|
|
|
|
check(!is_indirect_object("12 0R", obj, gen));
|
|
|
|
check(is_indirect_object("52 1 R", obj, gen));
|
|
|
|
check(obj == 52);
|
|
|
|
check(gen == 1);
|
|
|
|
check(is_indirect_object("53 20 R", obj, gen));
|
|
|
|
check(obj == 53);
|
|
|
|
check(gen == 20);
|
|
|
|
check(!is_obj_key("", obj, gen));
|
|
|
|
check(!is_obj_key("obj:x", obj, gen));
|
|
|
|
check(!is_obj_key("obj:x", obj, gen));
|
|
|
|
check(is_obj_key("obj:12 13 R", obj, gen));
|
|
|
|
check(obj == 12);
|
|
|
|
check(gen == 13);
|
|
|
|
std::string str;
|
|
|
|
check(!is_unicode_string("", str));
|
|
|
|
check(!is_unicode_string("xyz", str));
|
|
|
|
check(!is_unicode_string("x:", str));
|
|
|
|
check(is_unicode_string("u:potato", str));
|
|
|
|
check(str == "potato");
|
|
|
|
check(is_unicode_string("u:", str));
|
|
|
|
check(str == "");
|
|
|
|
check(!is_binary_string("", str));
|
|
|
|
check(!is_binary_string("x:", str));
|
|
|
|
check(!is_binary_string("b:1", str));
|
|
|
|
check(!is_binary_string("b:123", str));
|
|
|
|
check(!is_binary_string("b:gh", str));
|
2022-05-21 21:36:32 +00:00
|
|
|
check(is_binary_string("b:", str));
|
2022-05-21 11:41:09 +00:00
|
|
|
check(is_binary_string("b:12", str));
|
|
|
|
check(is_binary_string("b:123aBC", str));
|
|
|
|
check(!is_name(""));
|
|
|
|
check(!is_name("/"));
|
|
|
|
check(!is_name("xyz"));
|
|
|
|
check(is_name("/Potato"));
|
|
|
|
check(is_name("/Potato Salad"));
|
|
|
|
|
|
|
|
return passed;
|
|
|
|
#undef check_arg
|
|
|
|
}
|
2022-05-17 23:18:02 +00:00
|
|
|
|
|
|
|
static std::function<void(Pipeline*)>
|
2022-05-21 20:11:42 +00:00
|
|
|
provide_data(
|
|
|
|
std::shared_ptr<InputSource> is, qpdf_offset_t start, qpdf_offset_t end)
|
2022-05-17 23:18:02 +00:00
|
|
|
{
|
|
|
|
return [is, start, end](Pipeline* p) {
|
|
|
|
Pl_Base64 decode("base64-decode", p, Pl_Base64::a_decode);
|
|
|
|
p = &decode;
|
2022-05-21 13:05:54 +00:00
|
|
|
size_t bytes = QIntC::to_size(end - start);
|
2022-05-17 23:18:02 +00:00
|
|
|
char buf[8192];
|
2022-05-21 13:05:54 +00:00
|
|
|
is->seek(start, SEEK_SET);
|
2022-05-17 23:18:02 +00:00
|
|
|
size_t len = 0;
|
|
|
|
while ((len = is->read(buf, std::min(bytes, sizeof(buf)))) > 0) {
|
|
|
|
p->write(buf, len);
|
|
|
|
bytes -= len;
|
|
|
|
if (bytes == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
decode.finish();
|
|
|
|
};
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
|
2023-02-09 12:43:56 +00:00
|
|
|
class QPDF::JSONReactor: public JSON::Reactor
|
|
|
|
{
|
|
|
|
public:
|
2023-02-15 17:44:56 +00:00
|
|
|
JSONReactor(
|
|
|
|
QPDF& pdf, std::shared_ptr<InputSource> is, bool must_be_complete) :
|
|
|
|
pdf(pdf),
|
|
|
|
is(is),
|
|
|
|
must_be_complete(must_be_complete),
|
|
|
|
descr(std::make_shared<QPDFValue::Description>(QPDFValue::JSON_Descr(
|
|
|
|
std::make_shared<std::string>(is->getName()), "")))
|
|
|
|
{
|
|
|
|
}
|
2023-02-09 12:43:56 +00:00
|
|
|
virtual ~JSONReactor() = default;
|
|
|
|
virtual void dictionaryStart() override;
|
|
|
|
virtual void arrayStart() override;
|
|
|
|
virtual void containerEnd(JSON const& value) override;
|
|
|
|
virtual void topLevelScalar() override;
|
|
|
|
virtual bool
|
|
|
|
dictionaryItem(std::string const& key, JSON const& value) override;
|
|
|
|
virtual bool arrayItem(JSON const& value) override;
|
|
|
|
|
|
|
|
bool anyErrors() const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
enum state_e {
|
|
|
|
st_initial,
|
|
|
|
st_top,
|
|
|
|
st_qpdf,
|
|
|
|
st_qpdf_meta,
|
|
|
|
st_objects,
|
|
|
|
st_trailer,
|
|
|
|
st_object_top,
|
|
|
|
st_stream,
|
|
|
|
st_object,
|
|
|
|
st_ignore,
|
|
|
|
};
|
|
|
|
|
|
|
|
void containerStart();
|
|
|
|
void nestedState(std::string const& key, JSON const& value, state_e);
|
|
|
|
void setObjectDescription(QPDFObjectHandle& oh, JSON const& value);
|
|
|
|
QPDFObjectHandle makeObject(JSON const& value);
|
|
|
|
void error(qpdf_offset_t offset, std::string const& message);
|
|
|
|
QPDFObjectHandle reserveObject(int obj, int gen);
|
|
|
|
void replaceObject(
|
|
|
|
QPDFObjectHandle to_replace,
|
|
|
|
QPDFObjectHandle replacement,
|
|
|
|
JSON const& value);
|
|
|
|
|
|
|
|
QPDF& pdf;
|
|
|
|
std::shared_ptr<InputSource> is;
|
2023-02-15 17:44:56 +00:00
|
|
|
bool must_be_complete{true};
|
2023-02-09 12:43:56 +00:00
|
|
|
std::shared_ptr<QPDFValue::Description> descr;
|
2023-02-15 17:44:56 +00:00
|
|
|
bool errors{false};
|
|
|
|
bool parse_error{false};
|
|
|
|
bool saw_qpdf{false};
|
|
|
|
bool saw_qpdf_meta{false};
|
|
|
|
bool saw_objects{false};
|
|
|
|
bool saw_json_version{false};
|
|
|
|
bool saw_pdf_version{false};
|
|
|
|
bool saw_trailer{false};
|
|
|
|
state_e state{st_initial};
|
|
|
|
state_e next_state{st_top};
|
2023-02-09 12:43:56 +00:00
|
|
|
std::string cur_object;
|
2023-02-15 17:44:56 +00:00
|
|
|
bool saw_value{false};
|
|
|
|
bool saw_stream{false};
|
|
|
|
bool saw_dict{false};
|
|
|
|
bool saw_data{false};
|
|
|
|
bool saw_datafile{false};
|
|
|
|
bool this_stream_needs_data{false};
|
|
|
|
std::vector<state_e> state_stack{st_initial};
|
2023-02-09 12:43:56 +00:00
|
|
|
std::vector<QPDFObjectHandle> object_stack;
|
|
|
|
std::set<QPDFObjGen> reserved;
|
|
|
|
};
|
|
|
|
|
2022-05-15 21:38:06 +00:00
|
|
|
void
|
2022-05-21 13:05:54 +00:00
|
|
|
QPDF::JSONReactor::error(qpdf_offset_t offset, std::string const& msg)
|
2022-05-15 21:38:06 +00:00
|
|
|
{
|
|
|
|
this->errors = true;
|
2022-05-20 15:10:12 +00:00
|
|
|
std::string object = this->cur_object;
|
|
|
|
if (is->getName() != pdf.getFilename()) {
|
|
|
|
object += " from " + is->getName();
|
|
|
|
}
|
2022-05-21 13:05:54 +00:00
|
|
|
this->pdf.warn(qpdf_e_json, object, offset, msg);
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::JSONReactor::anyErrors() const
|
|
|
|
{
|
|
|
|
return this->errors;
|
|
|
|
}
|
|
|
|
|
2022-05-15 16:34:27 +00:00
|
|
|
void
|
|
|
|
QPDF::JSONReactor::containerStart()
|
|
|
|
{
|
|
|
|
state_stack.push_back(state);
|
|
|
|
state = next_state;
|
|
|
|
}
|
2022-05-08 17:42:16 +00:00
|
|
|
|
2022-05-14 12:49:42 +00:00
|
|
|
void
|
|
|
|
QPDF::JSONReactor::dictionaryStart()
|
|
|
|
{
|
2022-05-15 16:34:27 +00:00
|
|
|
containerStart();
|
2022-05-14 12:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::JSONReactor::arrayStart()
|
|
|
|
{
|
2022-05-15 16:34:27 +00:00
|
|
|
containerStart();
|
|
|
|
if (state == st_top) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json top-level array");
|
|
|
|
throw std::runtime_error("QPDF JSON must be a dictionary");
|
|
|
|
}
|
2022-05-14 12:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::JSONReactor::containerEnd(JSON const& value)
|
|
|
|
{
|
2022-05-20 13:14:52 +00:00
|
|
|
auto from_state = state;
|
2022-05-15 16:34:27 +00:00
|
|
|
state = state_stack.back();
|
|
|
|
state_stack.pop_back();
|
|
|
|
if (state == st_initial) {
|
|
|
|
if (!this->saw_qpdf) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json missing qpdf");
|
2022-05-15 21:38:06 +00:00
|
|
|
error(0, "\"qpdf\" object was not seen");
|
|
|
|
} else {
|
2022-07-30 23:29:55 +00:00
|
|
|
if (!this->saw_json_version) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json missing json version");
|
|
|
|
error(0, "\"qpdf[0].jsonversion\" was not seen");
|
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
if (must_be_complete && !this->saw_pdf_version) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json missing pdf version");
|
2022-07-30 23:29:55 +00:00
|
|
|
error(0, "\"qpdf[0].pdfversion\" was not seen");
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
if (!this->saw_objects) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json missing objects");
|
2022-07-30 23:29:55 +00:00
|
|
|
error(0, "\"qpdf[1]\" was not seen");
|
2022-05-15 21:38:06 +00:00
|
|
|
} else {
|
|
|
|
if (must_be_complete && !this->saw_trailer) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json missing trailer");
|
2022-07-30 23:29:55 +00:00
|
|
|
error(0, "\"qpdf[1].trailer\" was not seen");
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
} else if (state == st_objects) {
|
|
|
|
if (parse_error) {
|
2022-05-20 12:11:14 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json don't check object after parse error");
|
2022-05-15 21:38:06 +00:00
|
|
|
} else if (cur_object == "trailer") {
|
|
|
|
if (!saw_value) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json trailer no value");
|
|
|
|
error(value.getStart(), "\"trailer\" is missing \"value\"");
|
|
|
|
}
|
|
|
|
} else if (saw_value == saw_stream) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json value stream both or neither");
|
|
|
|
error(
|
|
|
|
value.getStart(),
|
|
|
|
"object must have exactly one of \"value\" or \"stream\"");
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
object_stack.clear();
|
|
|
|
this->cur_object = "";
|
|
|
|
this->saw_dict = false;
|
|
|
|
this->saw_data = false;
|
|
|
|
this->saw_datafile = false;
|
|
|
|
this->saw_value = false;
|
|
|
|
this->saw_stream = false;
|
|
|
|
} else if (state == st_object_top) {
|
|
|
|
if (saw_stream) {
|
|
|
|
if (!saw_dict) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json stream no dict");
|
|
|
|
error(value.getStart(), "\"stream\" is missing \"dict\"");
|
|
|
|
}
|
2022-05-20 15:10:12 +00:00
|
|
|
if (saw_data == saw_datafile) {
|
|
|
|
if (this_stream_needs_data) {
|
2022-05-15 21:38:06 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json data datafile both or neither");
|
|
|
|
error(
|
|
|
|
value.getStart(),
|
2022-05-20 15:10:12 +00:00
|
|
|
"new \"stream\" must have exactly one of \"data\" or "
|
|
|
|
"\"datafile\"");
|
|
|
|
} else if (saw_datafile) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json data and datafile");
|
|
|
|
error(
|
|
|
|
value.getStart(),
|
|
|
|
"existing \"stream\" may at most one of \"data\" or "
|
2022-05-15 21:38:06 +00:00
|
|
|
"\"datafile\"");
|
2022-05-20 15:10:12 +00:00
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json no stream data in update mode");
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if ((state == st_stream) || (state == st_object)) {
|
|
|
|
if (!parse_error) {
|
|
|
|
object_stack.pop_back();
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-20 13:14:52 +00:00
|
|
|
} else if ((state == st_top) && (from_state == st_qpdf)) {
|
2022-05-15 21:38:06 +00:00
|
|
|
for (auto const& og: this->reserved) {
|
2022-05-20 13:14:52 +00:00
|
|
|
// Handle dangling indirect object references which the
|
|
|
|
// PDF spec says to treat as nulls. It's tempting to make
|
|
|
|
// this an error, but that would be wrong since valid
|
|
|
|
// input files may have these.
|
|
|
|
QTC::TC("qpdf", "QPDF_json non-trivial null reserved");
|
2022-05-15 21:38:06 +00:00
|
|
|
this->pdf.replaceObject(og, QPDFObjectHandle::newNull());
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
this->reserved.clear();
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
|
2022-05-15 21:38:06 +00:00
|
|
|
QPDFObjectHandle
|
2022-05-21 11:41:09 +00:00
|
|
|
QPDF::JSONReactor::reserveObject(int obj, int gen)
|
2022-05-15 21:38:06 +00:00
|
|
|
{
|
2022-07-23 15:48:28 +00:00
|
|
|
QPDFObjGen og(obj, gen);
|
|
|
|
auto oh = pdf.reserveObjectIfNotExists(og);
|
2022-05-15 21:38:06 +00:00
|
|
|
if (oh.isReserved()) {
|
2022-07-23 15:48:28 +00:00
|
|
|
this->reserved.insert(og);
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
|
|
|
return oh;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::JSONReactor::replaceObject(
|
2022-05-20 18:23:32 +00:00
|
|
|
QPDFObjectHandle to_replace,
|
|
|
|
QPDFObjectHandle replacement,
|
|
|
|
JSON const& value)
|
2022-05-15 21:38:06 +00:00
|
|
|
{
|
|
|
|
auto og = to_replace.getObjGen();
|
|
|
|
this->reserved.erase(og);
|
|
|
|
this->pdf.replaceObject(og, replacement);
|
2022-08-01 18:22:37 +00:00
|
|
|
auto oh = pdf.getObject(og);
|
2022-05-20 18:23:32 +00:00
|
|
|
setObjectDescription(oh, value);
|
2022-05-14 12:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::JSONReactor::topLevelScalar()
|
|
|
|
{
|
2022-05-15 16:34:27 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json top-level scalar");
|
|
|
|
throw std::runtime_error("QPDF JSON must be a dictionary");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::JSONReactor::nestedState(
|
|
|
|
std::string const& key, JSON const& value, state_e next)
|
|
|
|
{
|
|
|
|
// Use this method when the next state is for processing a nested
|
|
|
|
// dictionary.
|
2022-05-15 21:38:06 +00:00
|
|
|
if (value.isDictionary()) {
|
|
|
|
this->next_state = next;
|
|
|
|
} else {
|
|
|
|
error(value.getStart(), "\"" + key + "\" must be a dictionary");
|
|
|
|
this->next_state = st_ignore;
|
|
|
|
this->parse_error = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-14 12:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::JSONReactor::dictionaryItem(std::string const& key, JSON const& value)
|
|
|
|
{
|
2022-05-15 16:34:27 +00:00
|
|
|
if (state == st_ignore) {
|
2022-05-15 21:38:06 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json ignoring in st_ignore");
|
2022-05-15 16:34:27 +00:00
|
|
|
// ignore
|
|
|
|
} else if (state == st_top) {
|
2022-07-30 23:29:55 +00:00
|
|
|
if (key == "qpdf") {
|
2022-05-15 16:34:27 +00:00
|
|
|
this->saw_qpdf = true;
|
2022-07-30 23:29:55 +00:00
|
|
|
if (!value.isArray()) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json qpdf not array");
|
|
|
|
error(value.getStart(), "\"qpdf\" must be an array");
|
|
|
|
next_state = st_ignore;
|
|
|
|
parse_error = true;
|
|
|
|
} else {
|
|
|
|
next_state = st_qpdf;
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
2022-07-30 23:29:55 +00:00
|
|
|
// Ignore all other fields.
|
2022-05-20 12:11:14 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json ignoring unknown top-level key");
|
2022-05-15 16:34:27 +00:00
|
|
|
next_state = st_ignore;
|
|
|
|
}
|
2022-07-30 23:29:55 +00:00
|
|
|
} else if (state == st_qpdf_meta) {
|
2022-05-18 22:22:57 +00:00
|
|
|
if (key == "pdfversion") {
|
2022-05-15 16:34:27 +00:00
|
|
|
this->saw_pdf_version = true;
|
|
|
|
bool version_okay = false;
|
|
|
|
std::string v;
|
|
|
|
if (value.getString(v)) {
|
2022-05-21 11:41:09 +00:00
|
|
|
std::string version;
|
|
|
|
char const* p = v.c_str();
|
|
|
|
if (QPDF::validatePDFVersion(p, version) && (*p == '\0')) {
|
2022-05-15 16:34:27 +00:00
|
|
|
version_okay = true;
|
2022-05-21 11:41:09 +00:00
|
|
|
this->pdf.m->pdf_version = version;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!version_okay) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json bad pdf version");
|
2022-05-15 21:38:06 +00:00
|
|
|
error(value.getStart(), "invalid PDF version (must be x.y)");
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-07-30 23:29:55 +00:00
|
|
|
} else if (key == "jsonversion") {
|
|
|
|
this->saw_json_version = true;
|
|
|
|
bool version_okay = false;
|
|
|
|
std::string v;
|
|
|
|
if (value.getNumber(v)) {
|
|
|
|
std::string version;
|
|
|
|
if (QUtil::string_to_int(v.c_str()) == 2) {
|
|
|
|
version_okay = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!version_okay) {
|
|
|
|
QTC::TC("qpdf", "QPDF_json bad json version");
|
|
|
|
error(value.getStart(), "invalid JSON version (must be 2)");
|
|
|
|
}
|
2022-07-31 19:09:48 +00:00
|
|
|
} else if (key == "pushedinheritedpageresources") {
|
|
|
|
bool v;
|
|
|
|
if (value.getBool(v)) {
|
|
|
|
if ((!this->must_be_complete) && v) {
|
|
|
|
this->pdf.pushInheritedAttributesToPage();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json bad pushedinheritedpageresources");
|
|
|
|
error(
|
|
|
|
value.getStart(),
|
|
|
|
"pushedinheritedpageresources must be a boolean");
|
|
|
|
}
|
|
|
|
} else if (key == "calledgetallpages") {
|
|
|
|
bool v;
|
|
|
|
if (value.getBool(v)) {
|
|
|
|
if ((!this->must_be_complete) && v) {
|
|
|
|
this->pdf.getAllPages();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json bad calledgetallpages");
|
2022-07-31 19:26:24 +00:00
|
|
|
error(value.getStart(), "calledgetallpages must be a boolean");
|
2022-07-31 19:09:48 +00:00
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
2022-05-20 12:11:14 +00:00
|
|
|
// ignore unknown keys for forward compatibility and to
|
|
|
|
// skip keys we don't care about like "maxobjectid".
|
|
|
|
QTC::TC("qpdf", "QPDF_json ignore second-level key");
|
2022-05-15 21:38:06 +00:00
|
|
|
next_state = st_ignore;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
} else if (state == st_objects) {
|
2022-05-21 11:41:09 +00:00
|
|
|
int obj = 0;
|
|
|
|
int gen = 0;
|
2022-05-15 16:34:27 +00:00
|
|
|
if (key == "trailer") {
|
|
|
|
this->saw_trailer = true;
|
2022-05-15 21:38:06 +00:00
|
|
|
nestedState(key, value, st_trailer);
|
|
|
|
this->cur_object = "trailer";
|
2022-05-21 11:41:09 +00:00
|
|
|
} else if (is_obj_key(key, obj, gen)) {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->cur_object = key;
|
2022-05-21 11:41:09 +00:00
|
|
|
auto oh = reserveObject(obj, gen);
|
2022-05-20 18:23:32 +00:00
|
|
|
object_stack.push_back(oh);
|
|
|
|
nestedState(key, value, st_object_top);
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json bad object key");
|
2022-05-15 21:38:06 +00:00
|
|
|
error(
|
|
|
|
value.getStart(),
|
|
|
|
"object key should be \"trailer\" or \"obj:n n R\"");
|
|
|
|
next_state = st_ignore;
|
|
|
|
parse_error = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
|
|
|
} else if (state == st_object_top) {
|
2022-05-15 21:38:06 +00:00
|
|
|
if (object_stack.size() == 0) {
|
|
|
|
throw std::logic_error("no object on stack in st_object_top");
|
|
|
|
}
|
|
|
|
auto tos = object_stack.back();
|
|
|
|
QPDFObjectHandle replacement;
|
2022-05-15 16:34:27 +00:00
|
|
|
if (key == "value") {
|
|
|
|
// Don't use nestedState since this can have any type.
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_value = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
next_state = st_object;
|
2022-05-15 21:38:06 +00:00
|
|
|
replacement = makeObject(value);
|
2022-05-20 18:23:32 +00:00
|
|
|
replaceObject(tos, replacement, value);
|
2022-05-15 16:34:27 +00:00
|
|
|
} else if (key == "stream") {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_stream = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
nestedState(key, value, st_stream);
|
2022-05-20 15:10:12 +00:00
|
|
|
this->this_stream_needs_data = false;
|
2022-05-15 21:38:06 +00:00
|
|
|
if (tos.isStream()) {
|
2022-05-20 15:10:12 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json updating existing stream");
|
2022-05-15 21:38:06 +00:00
|
|
|
} else {
|
2022-05-20 15:10:12 +00:00
|
|
|
this->this_stream_needs_data = true;
|
2022-07-23 15:48:28 +00:00
|
|
|
replacement = pdf.reserveStream(tos.getObjGen());
|
2022-05-20 18:23:32 +00:00
|
|
|
replaceObject(tos, replacement, value);
|
2022-05-15 21:38:06 +00:00
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
|
|
|
// Ignore unknown keys for forward compatibility
|
2022-05-20 12:11:14 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json ignore unknown key in object_top");
|
2022-05-15 21:38:06 +00:00
|
|
|
next_state = st_ignore;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
if (replacement.isInitialized()) {
|
|
|
|
object_stack.pop_back();
|
|
|
|
object_stack.push_back(replacement);
|
|
|
|
}
|
|
|
|
} else if (state == st_trailer) {
|
2022-05-15 16:34:27 +00:00
|
|
|
if (key == "value") {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_value = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
// The trailer must be a dictionary, so we can use nestedState.
|
|
|
|
nestedState("trailer.value", value, st_object);
|
2022-05-15 21:38:06 +00:00
|
|
|
this->pdf.m->trailer = makeObject(value);
|
2022-05-20 18:23:32 +00:00
|
|
|
setObjectDescription(this->pdf.m->trailer, value);
|
2022-05-15 16:34:27 +00:00
|
|
|
} else if (key == "stream") {
|
2022-05-15 21:38:06 +00:00
|
|
|
// Don't need to set saw_stream here since there's already
|
|
|
|
// an error.
|
2022-05-15 16:34:27 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json trailer stream");
|
2022-05-15 21:38:06 +00:00
|
|
|
error(value.getStart(), "the trailer may not be a stream");
|
|
|
|
next_state = st_ignore;
|
|
|
|
parse_error = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
|
|
|
// Ignore unknown keys for forward compatibility
|
2022-05-20 12:11:14 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json ignore unknown key in trailer");
|
2022-05-15 21:38:06 +00:00
|
|
|
next_state = st_ignore;
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
|
|
|
} else if (state == st_stream) {
|
2022-05-15 21:38:06 +00:00
|
|
|
if (object_stack.size() == 0) {
|
|
|
|
throw std::logic_error("no object on stack in st_stream");
|
|
|
|
}
|
|
|
|
auto tos = object_stack.back();
|
|
|
|
if (!tos.isStream()) {
|
2022-05-20 15:10:12 +00:00
|
|
|
throw std::logic_error("top of stack is not stream in st_stream");
|
|
|
|
}
|
|
|
|
auto uninitialized = QPDFObjectHandle();
|
|
|
|
if (key == "dict") {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_dict = true;
|
2022-05-15 16:34:27 +00:00
|
|
|
// Since a stream dictionary must be a dictionary, we can
|
|
|
|
// use nestedState to transition to st_value.
|
|
|
|
nestedState("stream.dict", value, st_object);
|
2022-05-15 21:38:06 +00:00
|
|
|
auto dict = makeObject(value);
|
|
|
|
if (dict.isDictionary()) {
|
|
|
|
tos.replaceDict(dict);
|
|
|
|
} else {
|
|
|
|
// An error had already been given by nestedState
|
|
|
|
QTC::TC("qpdf", "QPDF_json stream dict not dict");
|
|
|
|
parse_error = true;
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else if (key == "data") {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_data = true;
|
2022-05-17 23:18:02 +00:00
|
|
|
std::string v;
|
|
|
|
if (!value.getString(v)) {
|
|
|
|
error(value.getStart(), "\"stream.data\" must be a string");
|
|
|
|
} else {
|
|
|
|
// The range includes the quotes.
|
|
|
|
auto start = value.getStart() + 1;
|
|
|
|
auto end = value.getEnd() - 1;
|
|
|
|
if (end < start) {
|
|
|
|
throw std::logic_error("QPDF_json: JSON string length < 0");
|
|
|
|
}
|
|
|
|
tos.replaceStreamData(
|
|
|
|
provide_data(is, start, end), uninitialized, uninitialized);
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else if (key == "datafile") {
|
2022-05-15 21:38:06 +00:00
|
|
|
this->saw_datafile = true;
|
2022-05-17 23:18:02 +00:00
|
|
|
std::string filename;
|
|
|
|
if (value.getString(filename)) {
|
|
|
|
tos.replaceStreamData(
|
|
|
|
QUtil::file_provider(filename),
|
|
|
|
uninitialized,
|
|
|
|
uninitialized);
|
|
|
|
} else {
|
|
|
|
error(
|
|
|
|
value.getStart(),
|
|
|
|
"\"stream.datafile\" must be a string containing a file "
|
|
|
|
"name");
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
|
|
|
// Ignore unknown keys for forward compatibility.
|
2022-05-20 12:11:14 +00:00
|
|
|
QTC::TC("qpdf", "QPDF_json ignore unknown key in stream");
|
2022-05-15 16:34:27 +00:00
|
|
|
next_state = st_ignore;
|
|
|
|
}
|
|
|
|
} else if (state == st_object) {
|
2022-05-15 21:38:06 +00:00
|
|
|
if (!parse_error) {
|
|
|
|
auto dict = object_stack.back();
|
|
|
|
if (dict.isStream()) {
|
|
|
|
dict = dict.getDict();
|
|
|
|
}
|
|
|
|
dict.replaceKey(key, makeObject(value));
|
|
|
|
}
|
2022-05-15 16:34:27 +00:00
|
|
|
} else {
|
|
|
|
throw std::logic_error(
|
2022-09-21 16:49:21 +00:00
|
|
|
"QPDF_json: unknown state " + std::to_string(state));
|
2022-05-15 16:34:27 +00:00
|
|
|
}
|
2022-05-14 12:49:42 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
QPDF::JSONReactor::arrayItem(JSON const& value)
|
|
|
|
{
|
2022-07-30 23:29:55 +00:00
|
|
|
if (state == st_qpdf) {
|
|
|
|
if (!this->saw_qpdf_meta) {
|
|
|
|
this->saw_qpdf_meta = true;
|
|
|
|
nestedState("qpdf[0]", value, st_qpdf_meta);
|
|
|
|
} else if (!this->saw_objects) {
|
|
|
|
this->saw_objects = true;
|
|
|
|
nestedState("qpdf[1]", value, st_objects);
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json more than two qpdf elements");
|
|
|
|
error(value.getStart(), "\"qpdf\" must have two elements");
|
|
|
|
next_state = st_ignore;
|
|
|
|
parse_error = true;
|
|
|
|
}
|
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
if (state == st_object) {
|
|
|
|
if (!parse_error) {
|
|
|
|
auto tos = object_stack.back();
|
|
|
|
tos.appendItem(makeObject(value));
|
|
|
|
}
|
|
|
|
}
|
2022-05-14 12:49:42 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-05-20 18:23:32 +00:00
|
|
|
void
|
|
|
|
QPDF::JSONReactor::setObjectDescription(QPDFObjectHandle& oh, JSON const& value)
|
|
|
|
{
|
2023-02-09 12:43:56 +00:00
|
|
|
auto j_descr = std::get<QPDFValue::JSON_Descr>(*descr);
|
2023-02-09 12:43:56 +00:00
|
|
|
if (j_descr.object != cur_object) {
|
|
|
|
descr = std::make_shared<QPDFValue::Description>(
|
2023-02-09 12:43:56 +00:00
|
|
|
QPDFValue::JSON_Descr(j_descr.input, cur_object));
|
2022-05-20 18:23:32 +00:00
|
|
|
}
|
2023-02-09 12:43:56 +00:00
|
|
|
|
|
|
|
oh.getObjectPtr()->setDescription(&pdf, descr, value.getStart());
|
2022-05-20 18:23:32 +00:00
|
|
|
}
|
|
|
|
|
2022-05-15 21:38:06 +00:00
|
|
|
QPDFObjectHandle
|
|
|
|
QPDF::JSONReactor::makeObject(JSON const& value)
|
|
|
|
{
|
|
|
|
QPDFObjectHandle result;
|
|
|
|
std::string str_v;
|
|
|
|
bool bool_v = false;
|
|
|
|
if (value.isDictionary()) {
|
|
|
|
result = QPDFObjectHandle::newDictionary();
|
|
|
|
object_stack.push_back(result);
|
|
|
|
} else if (value.isArray()) {
|
|
|
|
result = QPDFObjectHandle::newArray();
|
|
|
|
object_stack.push_back(result);
|
|
|
|
} else if (value.isNull()) {
|
|
|
|
result = QPDFObjectHandle::newNull();
|
|
|
|
} else if (value.getBool(bool_v)) {
|
|
|
|
result = QPDFObjectHandle::newBool(bool_v);
|
|
|
|
} else if (value.getNumber(str_v)) {
|
|
|
|
if (QUtil::is_long_long(str_v.c_str())) {
|
|
|
|
result = QPDFObjectHandle::newInteger(
|
|
|
|
QUtil::string_to_ll(str_v.c_str()));
|
|
|
|
} else {
|
|
|
|
result = QPDFObjectHandle::newReal(str_v);
|
|
|
|
}
|
|
|
|
} else if (value.getString(str_v)) {
|
2022-05-21 11:41:09 +00:00
|
|
|
int obj = 0;
|
|
|
|
int gen = 0;
|
|
|
|
std::string str;
|
|
|
|
if (is_indirect_object(str_v, obj, gen)) {
|
|
|
|
result = reserveObject(obj, gen);
|
|
|
|
} else if (is_unicode_string(str_v, str)) {
|
|
|
|
result = QPDFObjectHandle::newUnicodeString(str);
|
|
|
|
} else if (is_binary_string(str_v, str)) {
|
|
|
|
result = QPDFObjectHandle::newString(QUtil::hex_decode(str));
|
|
|
|
} else if (is_name(str_v)) {
|
2022-05-15 21:38:06 +00:00
|
|
|
result = QPDFObjectHandle::newName(str_v);
|
|
|
|
} else {
|
|
|
|
QTC::TC("qpdf", "QPDF_json unrecognized string value");
|
|
|
|
error(value.getStart(), "unrecognized string value");
|
|
|
|
result = QPDFObjectHandle::newNull();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!result.isInitialized()) {
|
|
|
|
throw std::logic_error(
|
|
|
|
"JSONReactor::makeObject didn't initialize the object");
|
|
|
|
}
|
|
|
|
|
2022-05-20 18:23:32 +00:00
|
|
|
if (!result.hasObjectDescription()) {
|
|
|
|
setObjectDescription(result, value);
|
2022-05-20 15:10:12 +00:00
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2022-05-08 17:42:16 +00:00
|
|
|
void
|
|
|
|
QPDF::createFromJSON(std::string const& json_file)
|
|
|
|
{
|
|
|
|
createFromJSON(std::make_shared<FileInputSource>(json_file.c_str()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-05-14 12:49:42 +00:00
|
|
|
QPDF::createFromJSON(std::shared_ptr<InputSource> is)
|
2022-05-08 17:42:16 +00:00
|
|
|
{
|
2022-05-15 21:38:06 +00:00
|
|
|
processMemoryFile(is->getName().c_str(), JSON_PDF, strlen(JSON_PDF));
|
2022-05-14 12:49:42 +00:00
|
|
|
importJSON(is, true);
|
2022-05-08 17:42:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::updateFromJSON(std::string const& json_file)
|
|
|
|
{
|
|
|
|
updateFromJSON(std::make_shared<FileInputSource>(json_file.c_str()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-05-14 12:49:42 +00:00
|
|
|
QPDF::updateFromJSON(std::shared_ptr<InputSource> is)
|
|
|
|
{
|
|
|
|
importJSON(is, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-05-15 16:34:27 +00:00
|
|
|
QPDF::importJSON(std::shared_ptr<InputSource> is, bool must_be_complete)
|
2022-05-08 17:42:16 +00:00
|
|
|
{
|
2022-05-17 23:18:02 +00:00
|
|
|
JSONReactor reactor(*this, is, must_be_complete);
|
2022-05-15 16:34:27 +00:00
|
|
|
try {
|
|
|
|
JSON::parse(*is, &reactor);
|
|
|
|
} catch (std::runtime_error& e) {
|
|
|
|
throw std::runtime_error(is->getName() + ": " + e.what());
|
|
|
|
}
|
2022-05-15 21:38:06 +00:00
|
|
|
if (reactor.anyErrors()) {
|
|
|
|
throw std::runtime_error(is->getName() + ": errors found in JSON");
|
|
|
|
}
|
2022-05-08 17:42:16 +00:00
|
|
|
}
|
2022-05-18 22:22:57 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::writeJSONStream(
|
|
|
|
int version,
|
|
|
|
Pipeline* p,
|
|
|
|
bool& first,
|
|
|
|
std::string const& key,
|
|
|
|
QPDFObjectHandle& obj,
|
|
|
|
qpdf_stream_decode_level_e decode_level,
|
|
|
|
qpdf_json_stream_data_e json_stream_data,
|
|
|
|
std::string const& file_prefix)
|
|
|
|
{
|
|
|
|
Pipeline* stream_p = nullptr;
|
|
|
|
FILE* f = nullptr;
|
|
|
|
std::shared_ptr<Pl_StdioFile> f_pl;
|
|
|
|
std::string filename;
|
|
|
|
if (json_stream_data == qpdf_sj_file) {
|
2022-09-21 16:49:21 +00:00
|
|
|
filename = file_prefix + "-" + std::to_string(obj.getObjectID());
|
2022-05-18 22:22:57 +00:00
|
|
|
f = QUtil::safe_fopen(filename.c_str(), "wb");
|
|
|
|
f_pl = std::make_shared<Pl_StdioFile>("stream data", f);
|
|
|
|
stream_p = f_pl.get();
|
|
|
|
}
|
|
|
|
auto j = JSON::makeDictionary();
|
|
|
|
j.addDictionaryMember(
|
|
|
|
"stream",
|
|
|
|
obj.getStreamJSON(
|
|
|
|
version, json_stream_data, decode_level, stream_p, filename));
|
|
|
|
|
2022-07-30 17:32:59 +00:00
|
|
|
JSON::writeDictionaryItem(p, first, key, j, 3);
|
2022-05-18 22:22:57 +00:00
|
|
|
if (f) {
|
|
|
|
f_pl->finish();
|
|
|
|
f_pl = nullptr;
|
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF::writeJSONObject(
|
|
|
|
int version,
|
|
|
|
Pipeline* p,
|
|
|
|
bool& first,
|
|
|
|
std::string const& key,
|
|
|
|
QPDFObjectHandle& obj)
|
|
|
|
{
|
|
|
|
auto j = JSON::makeDictionary();
|
|
|
|
j.addDictionaryMember("value", obj.getJSON(version, true));
|
2022-07-30 17:32:59 +00:00
|
|
|
JSON::writeDictionaryItem(p, first, key, j, 3);
|
2022-05-18 22:22:57 +00:00
|
|
|
}
|
|
|
|
|
2022-07-31 19:26:24 +00:00
|
|
|
void
|
|
|
|
QPDF::writeJSON(
|
|
|
|
int version,
|
|
|
|
Pipeline* p,
|
|
|
|
qpdf_stream_decode_level_e decode_level,
|
|
|
|
qpdf_json_stream_data_e json_stream_data,
|
|
|
|
std::string const& file_prefix,
|
|
|
|
std::set<std::string> wanted_objects)
|
|
|
|
{
|
|
|
|
bool first = true;
|
|
|
|
writeJSON(
|
|
|
|
version,
|
|
|
|
p,
|
|
|
|
true,
|
|
|
|
first,
|
|
|
|
decode_level,
|
|
|
|
json_stream_data,
|
|
|
|
file_prefix,
|
|
|
|
wanted_objects);
|
|
|
|
}
|
|
|
|
|
2022-05-18 22:22:57 +00:00
|
|
|
void
|
|
|
|
QPDF::writeJSON(
|
|
|
|
int version,
|
|
|
|
Pipeline* p,
|
2022-07-24 20:54:48 +00:00
|
|
|
bool complete,
|
2022-07-31 00:53:30 +00:00
|
|
|
bool& first_key,
|
2022-05-18 22:22:57 +00:00
|
|
|
qpdf_stream_decode_level_e decode_level,
|
|
|
|
qpdf_json_stream_data_e json_stream_data,
|
|
|
|
std::string const& file_prefix,
|
|
|
|
std::set<std::string> wanted_objects)
|
|
|
|
{
|
2022-07-30 23:29:55 +00:00
|
|
|
int const depth_outer = 1;
|
|
|
|
int const depth_top = 1;
|
|
|
|
int const depth_qpdf = 2;
|
|
|
|
int const depth_qpdf_inner = 3;
|
|
|
|
|
2022-05-18 22:22:57 +00:00
|
|
|
if (version != 2) {
|
|
|
|
throw std::runtime_error(
|
|
|
|
"QPDF::writeJSON: only version 2 is supported");
|
|
|
|
}
|
|
|
|
bool first = true;
|
2022-07-30 17:32:59 +00:00
|
|
|
if (complete) {
|
2022-07-30 23:29:55 +00:00
|
|
|
JSON::writeDictionaryOpen(p, first, depth_outer);
|
2022-07-30 17:32:59 +00:00
|
|
|
} else {
|
|
|
|
first = first_key;
|
|
|
|
}
|
2022-07-30 23:29:55 +00:00
|
|
|
JSON::writeDictionaryKey(p, first, "qpdf", depth_top);
|
2022-05-18 22:22:57 +00:00
|
|
|
bool first_qpdf = true;
|
2022-07-30 23:29:55 +00:00
|
|
|
JSON::writeArrayOpen(p, first_qpdf, depth_top);
|
|
|
|
JSON::writeNext(p, first_qpdf, depth_qpdf);
|
|
|
|
bool first_qpdf_inner = true;
|
|
|
|
JSON::writeDictionaryOpen(p, first_qpdf_inner, depth_qpdf);
|
2022-05-18 22:22:57 +00:00
|
|
|
JSON::writeDictionaryItem(
|
2022-07-30 23:29:55 +00:00
|
|
|
p,
|
|
|
|
first_qpdf_inner,
|
|
|
|
"jsonversion",
|
|
|
|
JSON::makeInt(version),
|
|
|
|
depth_qpdf_inner);
|
|
|
|
JSON::writeDictionaryItem(
|
|
|
|
p,
|
|
|
|
first_qpdf_inner,
|
|
|
|
"pdfversion",
|
|
|
|
JSON::makeString(getPDFVersion()),
|
|
|
|
depth_qpdf_inner);
|
|
|
|
JSON::writeDictionaryItem(
|
|
|
|
p,
|
|
|
|
first_qpdf_inner,
|
|
|
|
"pushedinheritedpageresources",
|
|
|
|
JSON::makeBool(everPushedInheritedAttributesToPages()),
|
|
|
|
depth_qpdf_inner);
|
|
|
|
JSON::writeDictionaryItem(
|
|
|
|
p,
|
|
|
|
first_qpdf_inner,
|
|
|
|
"calledgetallpages",
|
|
|
|
JSON::makeBool(everCalledGetAllPages()),
|
|
|
|
depth_qpdf_inner);
|
2022-05-18 22:22:57 +00:00
|
|
|
JSON::writeDictionaryItem(
|
|
|
|
p,
|
2022-07-30 23:29:55 +00:00
|
|
|
first_qpdf_inner,
|
2022-05-18 22:22:57 +00:00
|
|
|
"maxobjectid",
|
|
|
|
JSON::makeInt(QIntC::to_longlong(getObjectCount())),
|
2022-07-30 23:29:55 +00:00
|
|
|
depth_qpdf_inner);
|
|
|
|
JSON::writeDictionaryClose(p, first_qpdf_inner, depth_qpdf);
|
|
|
|
JSON::writeNext(p, first_qpdf, depth_qpdf);
|
|
|
|
JSON::writeDictionaryOpen(p, first_qpdf_inner, depth_qpdf);
|
2022-05-18 22:22:57 +00:00
|
|
|
bool all_objects = wanted_objects.empty();
|
2022-06-05 18:26:30 +00:00
|
|
|
for (auto& obj: getAllObjects()) {
|
2022-05-18 22:22:57 +00:00
|
|
|
std::string key = "obj:" + obj.unparse();
|
|
|
|
if (all_objects || wanted_objects.count(key)) {
|
|
|
|
if (obj.isStream()) {
|
|
|
|
writeJSONStream(
|
|
|
|
version,
|
|
|
|
p,
|
2022-07-30 23:29:55 +00:00
|
|
|
first_qpdf_inner,
|
2022-05-18 22:22:57 +00:00
|
|
|
key,
|
|
|
|
obj,
|
|
|
|
decode_level,
|
|
|
|
json_stream_data,
|
|
|
|
file_prefix);
|
|
|
|
} else {
|
2022-07-30 23:29:55 +00:00
|
|
|
writeJSONObject(version, p, first_qpdf_inner, key, obj);
|
2022-05-18 22:22:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (all_objects || wanted_objects.count("trailer")) {
|
|
|
|
auto trailer = getTrailer();
|
2022-07-30 23:29:55 +00:00
|
|
|
writeJSONObject(version, p, first_qpdf_inner, "trailer", trailer);
|
2022-05-18 22:22:57 +00:00
|
|
|
}
|
2022-07-30 23:29:55 +00:00
|
|
|
JSON::writeDictionaryClose(p, first_qpdf_inner, depth_qpdf);
|
|
|
|
JSON::writeArrayClose(p, first_qpdf, depth_top);
|
2022-07-24 20:54:48 +00:00
|
|
|
if (complete) {
|
|
|
|
JSON::writeDictionaryClose(p, first, 0);
|
|
|
|
*p << "\n";
|
|
|
|
p->finish();
|
|
|
|
}
|
2022-07-31 00:53:30 +00:00
|
|
|
first_key = false;
|
2022-05-18 22:22:57 +00:00
|
|
|
}
|