/**
* Extracts document level attachments
*
* @param filename a file from which document level attachments will be extracted
* @throws IOException
*/
public void extractDocLevelAttachments(String filename) throws IOException {
PdfReader reader = new PdfReader(filename);
PdfDictionary root = reader.getCatalog();
PdfDictionary documentnames = root.getAsDict(PdfName.NAMES);
PdfDictionary embeddedfiles = documentnames.getAsDict(PdfName.EMBEDDEDFILES);
PdfArray filespecs = embeddedfiles.getAsArray(PdfName.NAMES);
PdfDictionary filespec;
PdfDictionary refs;
FileOutputStream fos;
PRStream stream;
for (int i = 0; i < filespecs.size(); ) {
filespecs.getAsString(i++);
filespec = filespecs.getAsDict(i++);
refs = filespec.getAsDict(PdfName.EF);
for (PdfName key : refs.getKeys()) {
fos = new FileOutputStream(String.format(PATH, filespec.getAsString(key).toString()));
stream = (PRStream) PdfReader.getPdfObject(refs.getAsIndirectObject(key));
fos.write(PdfReader.getStreamBytes(stream));
fos.flush();
fos.close();
}
}
reader.close();
}
/**
* Gets a list of X509CRL objects from a Document Security Store.
*
* @return a list of CRLs
* @throws GeneralSecurityException
* @throws IOException
*/
public List<X509CRL> getCRLsFromDSS() throws GeneralSecurityException, IOException {
List<X509CRL> crls = new ArrayList<X509CRL>();
if (dss == null) return crls;
PdfArray crlarray = dss.getAsArray(PdfName.CRLS);
if (crlarray == null) return crls;
CertificateFactory cf = CertificateFactory.getInstance("X.509");
for (int i = 0; i < crlarray.size(); i++) {
PRStream stream = (PRStream) crlarray.getAsStream(i);
X509CRL crl =
(X509CRL) cf.generateCRL(new ByteArrayInputStream(PdfReader.getStreamBytes(stream)));
crls.add(crl);
}
return crls;
}
/** @since 2.1.5; before 2.1.5 the method was private */
protected void updateCalculationOrder(PdfReader reader) {
PdfDictionary catalog = reader.getCatalog();
PdfDictionary acro = catalog.getAsDict(PdfName.ACROFORM);
if (acro == null) return;
PdfArray co = acro.getAsArray(PdfName.CO);
if (co == null || co.size() == 0) return;
AcroFields af = reader.getAcroFields();
for (int k = 0; k < co.size(); ++k) {
PdfObject obj = co.getPdfObject(k);
if (obj == null || !obj.isIndirect()) continue;
String name = getCOName(reader, (PRIndirectReference) obj);
if (af.getFieldItem(name) == null) continue;
name = "." + name;
if (calculationOrder.contains(name)) continue;
calculationOrder.add(name);
}
}
/**
* Gets OCSP responses from the Document Security Store.
*
* @return a list of BasicOCSPResp objects
* @throws IOException
* @throws GeneralSecurityException
*/
public List<BasicOCSPResp> getOCSPResponsesFromDSS()
throws IOException, GeneralSecurityException {
List<BasicOCSPResp> ocsps = new ArrayList<BasicOCSPResp>();
if (dss == null) return ocsps;
PdfArray ocsparray = dss.getAsArray(PdfName.OCSPS);
if (ocsparray == null) return ocsps;
for (int i = 0; i < ocsparray.size(); i++) {
PRStream stream = (PRStream) ocsparray.getAsStream(i);
OCSPResp ocspResponse = new OCSPResp(PdfReader.getStreamBytes(stream));
if (ocspResponse.getStatus() == 0)
try {
ocsps.add((BasicOCSPResp) ocspResponse.getResponseObject());
} catch (OCSPException e) {
throw new GeneralSecurityException(e);
}
}
return ocsps;
}
private void fillFontDesc(PdfDictionary fontDesc) {
if (fontDesc == null) return;
PdfNumber v = fontDesc.getAsNumber(PdfName.ASCENT);
if (v != null) ascender = v.floatValue();
v = fontDesc.getAsNumber(PdfName.CAPHEIGHT);
if (v != null) capHeight = v.floatValue();
v = fontDesc.getAsNumber(PdfName.DESCENT);
if (v != null) descender = v.floatValue();
v = fontDesc.getAsNumber(PdfName.ITALICANGLE);
if (v != null) italicAngle = v.floatValue();
v = fontDesc.getAsNumber(PdfName.FONTWEIGHT);
if (v != null) {
fontWeight = v.floatValue();
}
PdfArray bbox = fontDesc.getAsArray(PdfName.FONTBBOX);
if (bbox != null) {
llx = bbox.getAsNumber(0).floatValue();
lly = bbox.getAsNumber(1).floatValue();
urx = bbox.getAsNumber(2).floatValue();
ury = bbox.getAsNumber(3).floatValue();
if (llx > urx) {
float t = llx;
llx = urx;
urx = t;
}
if (lly > ury) {
float t = lly;
lly = ury;
ury = t;
}
}
float maxAscent = Math.max(ury, ascender);
float minDescent = Math.min(lly, descender);
ascender = maxAscent * 1000 / (maxAscent - minDescent);
descender = minDescent * 1000 / (maxAscent - minDescent);
}
private void doType1TT() {
CMapToUnicode toUnicode = null;
PdfObject enc = PdfReader.getPdfObject(font.get(PdfName.ENCODING));
if (enc == null) {
fillEncoding(null);
try {
toUnicode = processToUnicode();
if (toUnicode != null) {
Map<Integer, Integer> rm = toUnicode.createReverseMapping();
for (Map.Entry<Integer, Integer> kv : rm.entrySet()) {
uni2byte.put(kv.getKey().intValue(), kv.getValue().intValue());
}
}
} catch (Exception ex) {
throw new ExceptionConverter(ex);
}
} else {
if (enc.isName()) fillEncoding((PdfName) enc);
else if (enc.isDictionary()) {
PdfDictionary encDic = (PdfDictionary) enc;
enc = PdfReader.getPdfObject(encDic.get(PdfName.BASEENCODING));
if (enc == null) fillEncoding(null);
else fillEncoding((PdfName) enc);
PdfArray diffs = encDic.getAsArray(PdfName.DIFFERENCES);
if (diffs != null) {
diffmap = new IntHashtable();
int currentNumber = 0;
for (int k = 0; k < diffs.size(); ++k) {
PdfObject obj = diffs.getPdfObject(k);
if (obj.isNumber()) currentNumber = ((PdfNumber) obj).intValue();
else {
int c[] = GlyphList.nameToUnicode(PdfName.decodeName(((PdfName) obj).toString()));
if (c != null && c.length > 0) {
uni2byte.put(c[0], currentNumber);
diffmap.put(c[0], currentNumber);
} else {
if (toUnicode == null) {
toUnicode = processToUnicode();
if (toUnicode == null) {
toUnicode = new CMapToUnicode();
}
}
final String unicode = toUnicode.lookup(new byte[] {(byte) currentNumber}, 0, 1);
if ((unicode != null) && (unicode.length() == 1)) {
this.uni2byte.put(unicode.charAt(0), currentNumber);
this.diffmap.put(unicode.charAt(0), currentNumber);
}
}
++currentNumber;
}
}
}
}
}
PdfArray newWidths = font.getAsArray(PdfName.WIDTHS);
PdfNumber first = font.getAsNumber(PdfName.FIRSTCHAR);
PdfNumber last = font.getAsNumber(PdfName.LASTCHAR);
if (BuiltinFonts14.containsKey(fontName)) {
BaseFont bf;
try {
bf = BaseFont.createFont(fontName, WINANSI, false);
} catch (Exception e) {
throw new ExceptionConverter(e);
}
int e[] = uni2byte.toOrderedKeys();
for (int k = 0; k < e.length; ++k) {
int n = uni2byte.get(e[k]);
widths[n] = bf.getRawWidth(n, GlyphList.unicodeToName(e[k]));
}
if (diffmap != null) { // widths for diffmap must override existing ones
e = diffmap.toOrderedKeys();
for (int k = 0; k < e.length; ++k) {
int n = diffmap.get(e[k]);
widths[n] = bf.getRawWidth(n, GlyphList.unicodeToName(e[k]));
}
diffmap = null;
}
ascender = bf.getFontDescriptor(ASCENT, 1000);
capHeight = bf.getFontDescriptor(CAPHEIGHT, 1000);
descender = bf.getFontDescriptor(DESCENT, 1000);
italicAngle = bf.getFontDescriptor(ITALICANGLE, 1000);
fontWeight = bf.getFontDescriptor(FONT_WEIGHT, 1000);
llx = bf.getFontDescriptor(BBOXLLX, 1000);
lly = bf.getFontDescriptor(BBOXLLY, 1000);
urx = bf.getFontDescriptor(BBOXURX, 1000);
ury = bf.getFontDescriptor(BBOXURY, 1000);
}
if (first != null && last != null && newWidths != null) {
int f = first.intValue();
int nSize = f + newWidths.size();
if (widths.length < nSize) {
int[] tmp = new int[nSize];
System.arraycopy(widths, 0, tmp, 0, f);
widths = tmp;
}
for (int k = 0; k < newWidths.size(); ++k) {
widths[f + k] = newWidths.getAsNumber(k).intValue();
}
}
fillFontDesc(font.getAsDict(PdfName.FONTDESCRIPTOR));
}
@SuppressWarnings("unchecked")
protected PdfArray branchForm(
HashMap<String, Object> level, PdfIndirectReference parent, String fname) throws IOException {
PdfArray arr = new PdfArray();
for (Map.Entry<String, Object> entry : level.entrySet()) {
String name = entry.getKey();
Object obj = entry.getValue();
PdfIndirectReference ind = getPdfIndirectReference();
PdfDictionary dic = new PdfDictionary();
if (parent != null) dic.put(PdfName.PARENT, parent);
dic.put(PdfName.T, new PdfString(name, PdfObject.TEXT_UNICODE));
String fname2 = fname + "." + name;
int coidx = calculationOrder.indexOf(fname2);
if (coidx >= 0) calculationOrderRefs.set(coidx, ind);
if (obj instanceof HashMap) {
dic.put(PdfName.KIDS, branchForm((HashMap<String, Object>) obj, ind, fname2));
arr.add(ind);
addToBody(dic, ind);
} else {
ArrayList<Object> list = (ArrayList<Object>) obj;
dic.mergeDifferent((PdfDictionary) list.get(0));
if (list.size() == 3) {
dic.mergeDifferent((PdfDictionary) list.get(2));
int page = ((Integer) list.get(1)).intValue();
PdfDictionary pageDic = pageDics.get(page - 1);
PdfArray annots = pageDic.getAsArray(PdfName.ANNOTS);
if (annots == null) {
annots = new PdfArray();
pageDic.put(PdfName.ANNOTS, annots);
}
PdfNumber nn = (PdfNumber) dic.get(iTextTag);
dic.remove(iTextTag);
adjustTabOrder(annots, ind, nn);
} else {
PdfArray kids = new PdfArray();
for (int k = 1; k < list.size(); k += 2) {
int page = ((Integer) list.get(k)).intValue();
PdfDictionary pageDic = pageDics.get(page - 1);
PdfArray annots = pageDic.getAsArray(PdfName.ANNOTS);
if (annots == null) {
annots = new PdfArray();
pageDic.put(PdfName.ANNOTS, annots);
}
PdfDictionary widget = new PdfDictionary();
widget.merge((PdfDictionary) list.get(k + 1));
widget.put(PdfName.PARENT, ind);
PdfNumber nn = (PdfNumber) widget.get(iTextTag);
widget.remove(iTextTag);
PdfIndirectReference wref = addToBody(widget).getIndirectReference();
adjustTabOrder(annots, wref, nn);
kids.add(wref);
propagate(widget, null, false);
}
dic.put(PdfName.KIDS, kids);
}
arr.add(ind);
addToBody(dic, ind);
propagate(dic, null, false);
}
}
return arr;
}
