com.itextpdf.io.source.PdfTokenizer Maven / Gradle / Ivy
/*
This file is part of the iText (R) project.
Copyright (c) 1998-2023 Apryse Group NV
Authors: Apryse Software.
This program is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://itextpdf.com/sales. For AGPL licensing, see below.
AGPL licensing:
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see
* NOTE Due to PdfReference 1.7 part 3.2.3 String value contain ASCII characters,
* so we can convert it directly to byte array.
*
* @param content string bytes to be decoded
* @param from given start index
* @param to given end index
* @param hexWriting true if given string is hex-encoded, e.g. '<69546578…>'.
* False otherwise, e.g. '((iText( some version)…)'
* @return byte[] for decrypting or for creating {@link java.lang.String}.
*/
protected static byte[] decodeStringContent(byte[] content, int from, int to, boolean hexWriting) {
ByteBuffer buffer = new ByteBuffer(to - from + 1);
// <6954657874ae...>
if (hexWriting) {
int i = from;
while (i <= to) {
int v1 = ByteBuffer.getHex(content[i++]);
if (i > to) {
buffer.append(v1 << 4);
break;
}
int v2 = content[i++];
v2 = ByteBuffer.getHex(v2);
buffer.append((v1 << 4) + v2);
}
} else {
// ((iText\( some version)...)
int i = from;
while (i <= to) {
int ch = content[i++];
if (ch == '\\') {
boolean lineBreak = false;
ch = content[i++];
switch (ch) {
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case '(':
case ')':
case '\\':
break;
case '\r':
lineBreak = true;
if (i <= to && content[i++] != '\n') {
i--;
}
break;
case '\n':
lineBreak = true;
break;
default: {
if (ch < '0' || ch > '7') {
break;
}
int octal = ch - '0';
if (i > to) {
ch = octal;
break;
}
ch = content[i++];
octal = (octal << 3) + ch - '0';
if (ch < '0' || ch > '7' || i > to) {
ch = octal;
break;
}
ch = content[i++];
octal = (octal << 3) + ch - '0';
ch = octal & 0xff;
break;
}
}
if (lineBreak)
continue;
} else if (ch == '\r') {
// in this case current char is '\n' and we have to skip next '\n' if it presents.
ch = '\n';
if (i <= to && content[i++] != '\n') {
i--;
}
}
buffer.append(ch);
}
}
return buffer.toByteArray();
}
/**
* Resolve escape symbols or hexadecimal symbols.
*
* NOTE Due to PdfReference 1.7 part 3.2.3 String value contain ASCII characters,
* so we can convert it directly to byte array.
*
* @param content string bytes to be decoded
* @param hexWriting true if given string is hex-encoded, e.g. '<69546578…>'.
* False otherwise, e.g. '((iText( some version)…)'
* @return byte[] for decrypting or for creating {@link java.lang.String}.
*/
public static byte[] decodeStringContent(byte[] content, boolean hexWriting) {
return decodeStringContent(content, 0, content.length - 1, hexWriting);
}
/**
* Is a certain character a whitespace? Currently checks on the following: '0', '9', '10', '12', '13', '32'.
*
* The same as calling {@link #isWhitespace(int, boolean) isWhiteSpace(ch, true)}.
*
* @param ch int
* @return boolean
*/
public static boolean isWhitespace(int ch) {
return isWhitespace(ch, true);
}
/**
* Checks whether a character is a whitespace. Currently checks on the following: '0', '9', '10', '12', '13', '32'.
*
* @param ch int
* @param isWhitespace boolean
* @return boolean
*/
protected static boolean isWhitespace(int ch, boolean isWhitespace) {
return ((isWhitespace && ch == 0) || ch == 9 || ch == 10 || ch == 12 || ch == 13 || ch == 32);
}
protected static boolean isDelimiter(int ch) {
return (ch == '(' || ch == ')' || ch == '<' || ch == '>' || ch == '[' || ch == ']' || ch == '/' || ch == '%');
}
protected static boolean isDelimiterWhitespace(int ch) {
return delims[ch + 1];
}
/**
* Helper method to handle content errors. Add file position to {@code PdfRuntimeException}.
* @param error message.
* @param messageParams error params.
* @throws IOException wrap error message into {@code PdfRuntimeException} and add position in file.
*/
public void throwError(String error, Object... messageParams) {
throw new IOException(IoExceptionMessageConstant.ERROR_AT_FILE_POINTER, new IOException(error).setMessageParams(messageParams))
.setMessageParams(file.getPosition());
}
/**
* Checks whether {@code line} equals to 'trailer'.
*
* @param line for check
*
* @return true, if line is equals to 'trailer', otherwise false
*/
public static boolean checkTrailer(ByteBuffer line) {
if (Trailer.length > line.size())
return false;
for (int i = 0; i < Trailer.length; i++) {
if (Trailer[i] != line.get(i))
return false;
}
return true;
}
/**
* Reads data into the provided byte[]. Checks on leading whitespace.
* See {@link #isWhitespace(int) isWhiteSpace(int)} or {@link #isWhitespace(int, boolean) isWhiteSpace(int, boolean)}
* for a list of whitespace characters.
*
* The same as calling {@link #readLineSegment(com.itextpdf.io.source.ByteBuffer, boolean) readLineSegment(input, true)}.
*
* @param buffer a {@link ByteBuffer} to which the result of reading will be saved
* @return true, if something was read or if the end of the input stream is not reached
* @throws java.io.IOException in case of any reading error
*/
public boolean readLineSegment(ByteBuffer buffer) throws java.io.IOException {
return readLineSegment(buffer, true);
}
/**
* Reads data into the provided byte[]. Checks on leading whitespace.
* See {@link #isWhitespace(int) isWhiteSpace(int)} or {@link #isWhitespace(int, boolean) isWhiteSpace(int, boolean)}
* for a list of whitespace characters.
*
* @param buffer a {@link ByteBuffer} to which the result of reading will be saved
* @param isNullWhitespace boolean to indicate whether '0' is whitespace or not.
* If in doubt, use true or overloaded method {@link #readLineSegment(com.itextpdf.io.source.ByteBuffer) readLineSegment(input)}
* @return true, if something was read or if the end of the input stream is not reached
* @throws java.io.IOException in case of any reading error
*/
public boolean readLineSegment(ByteBuffer buffer, boolean isNullWhitespace) throws java.io.IOException {
int c;
boolean eol = false;
// ssteward, pdftk-1.10, 040922:
// skip initial whitespace; added this because PdfReader.rebuildXref()
// assumes that line provided by readLineSegment does not have init. whitespace;
while (isWhitespace((c = read()), isNullWhitespace)) ;
boolean prevWasWhitespace = false;
while (!eol) {
switch (c) {
case -1:
case '\n':
eol = true;
break;
case '\r':
eol = true;
long cur = getPosition();
if ((read()) != '\n') {
seek(cur);
}
break;
case 9: //whitespaces
case 12:
case 32:
if (prevWasWhitespace)
break;
prevWasWhitespace = true;
buffer.append((byte) c);
break;
default:
prevWasWhitespace = false;
buffer.append((byte) c);
break;
}
// break loop? do it before we read() again
if (eol || buffer.size() == buffer.capacity()) {
eol = true;
} else {
c = read();
}
}
if (buffer.size() == buffer.capacity()) {
eol = false;
while (!eol) {
switch (c = read()) {
case -1:
case '\n':
eol = true;
break;
case '\r':
eol = true;
long cur = getPosition();
if ((read()) != '\n') {
seek(cur);
}
break;
}
}
}
return !(c == -1 && buffer.isEmpty());
}
/**
* Check whether line starts with object declaration.
* @param lineTokenizer tokenizer, built by single line.
* @return object number and generation if check is successful, otherwise - null.
*/
public static int[] checkObjectStart(PdfTokenizer lineTokenizer) {
try {
lineTokenizer.seek(0);
if (!lineTokenizer.nextToken() || lineTokenizer.getTokenType() != TokenType.Number)
return null;
int num = lineTokenizer.getIntValue();
if (!lineTokenizer.nextToken() || lineTokenizer.getTokenType() != TokenType.Number)
return null;
int gen = lineTokenizer.getIntValue();
if (!lineTokenizer.nextToken())
return null;
if (!Arrays.equals(Obj, lineTokenizer.getByteContent()))
return null;
return new int[]{num, gen};
} catch (Exception ioe) {
// empty on purpose
}
return null;
}
}