/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.tika.parser.microsoft;
import static org.apache.tika.mime.MediaType.application;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Pattern;
import org.apache.commons.io.IOUtils;
import org.apache.poi.poifs.filesystem.DirectoryEntry;
import org.apache.poi.poifs.filesystem.DirectoryNode;
import org.apache.poi.poifs.filesystem.DocumentInputStream;
import org.apache.poi.poifs.filesystem.DocumentNode;
import org.apache.poi.poifs.filesystem.Entry;
import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
import org.apache.tika.detect.Detector;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.mime.MediaType;
/**
* A detector that works on a POIFS OLE2 document
* to figure out exactly what the file is.
* This should work for all OLE2 documents, whether
* they are ones supported by POI or not.
*/
public class POIFSContainerDetector implements Detector {
/**
* The OLE base file format
*/
public static final MediaType OLE = application("x-tika-msoffice");
/**
* The protected OOXML base file format
*/
public static final MediaType OOXML_PROTECTED = application("x-tika-ooxml-protected");
/**
* General embedded document type within an OLE2 container
*/
public static final MediaType GENERAL_EMBEDDED = application("x-tika-msoffice-embedded");
/**
* An OLE10 Native embedded document within another OLE2 document
*/
public static final MediaType OLE10_NATIVE =
new MediaType(GENERAL_EMBEDDED, "format", "ole10_native");
/**
* Some other kind of embedded document, in a CompObj container within another OLE2 document
*/
public static final MediaType COMP_OBJ =
new MediaType(GENERAL_EMBEDDED, "format", "comp_obj");
/**
* Graph/Charts embedded in PowerPoint and Excel
*/
public static final MediaType MS_GRAPH_CHART = application("vnd.ms-graph");
/**
* Equation embedded in Office docs
*/
public static final MediaType MS_EQUATION = application("vnd.ms-equation");
/**
* Microsoft Excel
*/
public static final MediaType XLS = application("vnd.ms-excel");
/**
* Microsoft Word
*/
public static final MediaType DOC = application("msword");
/**
* Microsoft PowerPoint
*/
public static final MediaType PPT = application("vnd.ms-powerpoint");
/**
* Microsoft Publisher
*/
public static final MediaType PUB = application("x-mspublisher");
/**
* Microsoft Visio
*/
public static final MediaType VSD = application("vnd.visio");
/**
* Microsoft Works
*/
public static final MediaType WPS = application("vnd.ms-works");
/**
* Microsoft Works Spreadsheet 7.0
*/
public static final MediaType XLR = application("x-tika-msworks-spreadsheet");
/**
* Microsoft Outlook
*/
public static final MediaType MSG = application("vnd.ms-outlook");
/**
* Microsoft Project
*/
public static final MediaType MPP = application("vnd.ms-project");
/**
* StarOffice Calc
*/
public static final MediaType SDC = application("vnd.stardivision.calc");
/**
* StarOffice Draw
*/
public static final MediaType SDA = application("vnd.stardivision.draw");
/**
* StarOffice Impress
*/
public static final MediaType SDD = application("vnd.stardivision.impress");
/**
* StarOffice Writer
*/
public static final MediaType SDW = application("vnd.stardivision.writer");
/**
* SolidWorks CAD file
*/
public static final MediaType SLDWORKS = application("sldworks");
/**
* Hangul Word Processor (Korean)
*/
public static final MediaType HWP = application("x-hwp-v5");
/**
* Base QuattroPro mime
*/
public static final MediaType QUATTROPRO = application("x-quattro-pro");
/**
* Serial version UID
*/
private static final long serialVersionUID = -3028021741663605293L;
/**
* An ASCII String "StarImpress"
*/
private static final byte[] STAR_IMPRESS = new byte[]{
0x53, 0x74, 0x61, 0x72, 0x49, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73
};
/**
* An ASCII String "StarDraw"
*/
private static final byte[] STAR_DRAW = new byte[]{
0x53, 0x74, 0x61, 0x72, 0x44, 0x72, 0x61, 0x77
};
/**
* An ASCII String "Quill96" for Works Files
*/
private static final byte[] WORKS_QUILL96 = new byte[]{
0x51, 0x75, 0x69, 0x6c, 0x6c, 0x39, 0x36
};
/**
* An ASCII String "MSGraph.Chart" for embedded MSGraph files
* The full designator includes a version, e.g. MSGraph.Chart.8
*/
private static final byte[] MS_GRAPH_CHART_BYTES = new byte[]{
0x4D, 0x53, 0x47, 0x72, 0x61, 0x70, 0x68,
0x2E, 0x43, 0x68, 0x61, 0x72, 0x74,
};
/**
* Regexp for matching the MPP Project Data stream
*/
private static final Pattern mppDataMatch = Pattern.compile("\\s\\s\\s\\d+");
/**
* Internal detection of the specific kind of OLE2 document, based on the
* names of the top level streams within the file.
*
* @deprecated Use {@link #detect(Set, DirectoryEntry)} and pass the root
* entry of the filesystem whose type is to be detected, as a
* second argument.
*/
protected static MediaType detect(Set<String> names) {
return detect(names, null);
}
/**
* Internal detection of the specific kind of OLE2 document, based on the
* names of the top-level streams within the file. In some cases the
* detection may need access to the root {@link DirectoryEntry} of that file
* for best results. The entry can be given as a second, optional argument.
*
* @param names
* @param root
* @return
*/
protected static MediaType detect(Set<String> names, DirectoryEntry root) {
if (names != null) {
if (names.contains("SwDocContentMgr") && names.contains("SwDocMgrTempStorage")) {
return SLDWORKS;
} else if (names.contains("StarCalcDocument")) {
// Star Office Calc
return SDC;
} else if (names.contains("StarWriterDocument")) {
return SDW;
} else if (names.contains("StarDrawDocument3")) {
if (root == null) {
/*
* This is either StarOfficeDraw or StarOfficeImpress, we have
* to consult the CompObj to distinguish them, if this method is
* called in "legacy mode", without the root, just return
* x-tika-msoffice. The one-argument method is only for backward
* compatibility, if someone calls old API he/she can get the
* old result.
*/
return OLE;
} else {
return processCompObjFormatType(root);
}
} else if (names.contains("\u0005HwpSummaryInformation")) {
// Hangul Word Processor v5+ (previous aren't OLE2-based)
return HWP;
} else if (names.contains("WksSSWorkBook")) {
// This check has to be before names.contains("Workbook")
// Works 7.0 spreadsheet files contain both
// we want to avoid classifying this as Excel
return XLR;
} else if (names.contains("Workbook") || names.contains("WORKBOOK")) {
MediaType tmp = processCompObjFormatType(root);
if (tmp.equals(MS_GRAPH_CHART)) {
return MS_GRAPH_CHART;
}
return XLS;
} else if (names.contains("Book")) {
// Excel 95 or older, we won't be able to parse this....
return XLS;
} else if (names.contains("EncryptedPackage") &&
names.contains("EncryptionInfo") &&
names.contains("\u0006DataSpaces")) {
// This is a protected OOXML document, which is an OLE2 file
// with an Encrypted Stream which holds the OOXML data
// Without decrypting the stream, we can't tell what kind of
// OOXML file we have. Return a general OOXML Protected type,
// and hope the name based detection can guess the rest!
return OOXML_PROTECTED;
} else if (names.contains("EncryptedPackage")) {
return OLE;
} else if (names.contains("WordDocument")) {
return DOC;
} else if (names.contains("Quill")) {
return PUB;
} else if (names.contains("PowerPoint Document")) {
return PPT;
} else if (names.contains("VisioDocument")) {
return VSD;
} else if (names.contains("\u0001Ole10Native")) {
return OLE10_NATIVE;
} else if (names.contains("MatOST")) {
// this occurs on older Works Word Processor files (versions 3.0 and 4.0)
return WPS;
} else if (names.contains("CONTENTS") && names.contains("SPELLING")) {
// Newer Works files
return WPS;
} else if (names.contains("Contents") && names.contains("\u0003ObjInfo")) {
return COMP_OBJ;
} else if (names.contains("CONTENTS") && names.contains("\u0001CompObj")) {
// CompObj is a general kind of OLE2 embedding, but this may be an old Works file
// If we have the Directory, check
if (root != null) {
MediaType type = processCompObjFormatType(root);
if (type == WPS) {
return WPS;
} else {
// Assume it's a general CompObj embedded resource
return COMP_OBJ;
}
} else {
// Assume it's a general CompObj embedded resource
return COMP_OBJ;
}
} else if (names.contains("CONTENTS")) {
// CONTENTS without SPELLING nor CompObj normally means some sort
// of embedded non-office file inside an OLE2 document
// This is most commonly triggered on nested directories
return OLE;
} else if (names.contains("\u0001CompObj") &&
(names.contains("Props") || names.contains("Props9") || names.contains("Props12"))) {
// Could be Project, look for common name patterns
for (String name : names) {
if (mppDataMatch.matcher(name).matches()) {
return MPP;
}
}
} else if (names.contains("PerfectOffice_MAIN")) {
if (names.contains("SlideShow")) {
return MediaType.application("x-corelpresentations"); // .shw
} else if (names.contains("PerfectOffice_OBJECTS")) {
return new MediaType(QUATTROPRO, "version", "7-8"); // .wb?
}
} else if (names.contains("NativeContent_MAIN")) {
return new MediaType(QUATTROPRO, "version", "9"); // .qpw
} else if (names.contains("Equation Native")) {
return MS_EQUATION;
} else {
for (String name : names) {
if (name.startsWith("__substg1.0_")) {
return MSG;
}
}
}
}
// Couldn't detect a more specific type
return OLE;
}
/**
* Is this one of the kinds of formats which uses CompObj to
* store all of their data, eg Star Draw, Star Impress or
* (older) Works?
* If not, it's likely an embedded resource
*/
private static MediaType processCompObjFormatType(DirectoryEntry root) {
try {
Entry e = root.getEntry("\u0001CompObj");
if (e != null && e.isDocumentEntry()) {
DocumentNode dn = (DocumentNode) e;
DocumentInputStream stream = new DocumentInputStream(dn);
byte[] bytes = IOUtils.toByteArray(stream);
/*
* This array contains a string with a normal ASCII name of the
* application used to create this file. We want to search for that
* name.
*/
if (arrayContains(bytes, MS_GRAPH_CHART_BYTES)) {
return MS_GRAPH_CHART;
} else if (arrayContains(bytes, STAR_DRAW)) {
return SDA;
} else if (arrayContains(bytes, STAR_IMPRESS)) {
return SDD;
} else if (arrayContains(bytes, WORKS_QUILL96)) {
return WPS;
}
}
} catch (Exception e) {
/*
* "root.getEntry" can throw FileNotFoundException. The code inside
* "if" can throw IOExceptions. Theoretically. Practically no
* exceptions will likely ever appear.
*
* Swallow all of them. If any occur, we just assume that we can't
* distinguish between Draw and Impress and return something safe:
* x-tika-msoffice
*/
}
return OLE;
}
// poor man's search for byte arrays, replace with some library call if
// you know one without adding new dependencies
private static boolean arrayContains(byte[] larger, byte[] smaller) {
int largerCounter = 0;
int smallerCounter = 0;
while (largerCounter < larger.length) {
if (larger[largerCounter] == smaller[smallerCounter]) {
largerCounter++;
smallerCounter++;
if (smallerCounter == smaller.length) {
return true;
}
} else {
largerCounter = largerCounter - smallerCounter + 1;
smallerCounter = 0;
}
}
return false;
}
private static Set<String> getTopLevelNames(TikaInputStream stream)
throws IOException {
// Force the document stream to a (possibly temporary) file
// so we don't modify the current position of the stream
File file = stream.getFile();
try {
NPOIFSFileSystem fs = new NPOIFSFileSystem(file, true);
// Optimize a possible later parsing process by keeping
// a reference to the already opened POI file system
stream.setOpenContainer(fs);
return getTopLevelNames(fs.getRoot());
} catch (IOException e) {
// Parse error in POI, so we don't know the file type
return Collections.emptySet();
} catch (RuntimeException e) {
// Another problem in POI
return Collections.emptySet();
}
}
private static Set<String> getTopLevelNames(DirectoryNode root) {
Set<String> names = new HashSet<String>();
for (Entry entry : root) {
names.add(entry.getName());
}
return names;
}
public MediaType detect(InputStream input, Metadata metadata)
throws IOException {
// Check if we have access to the document
if (input == null) {
return MediaType.OCTET_STREAM;
}
// If this is a TikaInputStream wrapping an already
// parsed NPOIFileSystem/DirectoryNode, just get the
// names from the root:
TikaInputStream tis = TikaInputStream.cast(input);
Set<String> names = null;
if (tis != null) {
Object container = tis.getOpenContainer();
if (container instanceof NPOIFSFileSystem) {
names = getTopLevelNames(((NPOIFSFileSystem) container).getRoot());
} else if (container instanceof DirectoryNode) {
names = getTopLevelNames((DirectoryNode) container);
}
}
if (names == null) {
// Check if the document starts with the OLE header
input.mark(8);
try {
if (input.read() != 0xd0 || input.read() != 0xcf
|| input.read() != 0x11 || input.read() != 0xe0
|| input.read() != 0xa1 || input.read() != 0xb1
|| input.read() != 0x1a || input.read() != 0xe1) {
return MediaType.OCTET_STREAM;
}
} finally {
input.reset();
}
}
// We can only detect the exact type when given a TikaInputStream
if (names == null && tis != null) {
// Look for known top level entry names to detect the document type
names = getTopLevelNames(tis);
}
// Detect based on the names (as available)
if (tis != null &&
tis.getOpenContainer() != null &&
tis.getOpenContainer() instanceof NPOIFSFileSystem) {
return detect(names, ((NPOIFSFileSystem) tis.getOpenContainer()).getRoot());
} else {
return detect(names, null);
}
}
}