OfficeZip.java

Go to the documentation of this file.

/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
package org.openoffice.xmerge.converter.xml;
 
import java.util.List;
import java.util.ListIterator;
import java.util.LinkedList;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.CRC32;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.ByteArrayOutputStream;
 
import org.openoffice.xmerge.util.Debug;
 
class OfficeZip {
 
    private static final String CONTENTXML = "content.xml";
 
    private static final String STYLEXML = "styles.xml";
    private static final String METAXML = "meta.xml";
    private static final String SETTINGSXML = "settings.xml";
    private static final String MANIFESTXML = "META-INF/manifest.xml";
 
    private static final int BUFFERSIZE = 1024;
 
    private final List<Entry> entryList;
 
    private int contentIndex = -1;
    private int styleIndex = -1;
    private int metaIndex = -1;
    private int settingsIndex = -1;
    private int manifestIndex = -1;
 
    OfficeZip() {
 
        entryList = new LinkedList<Entry>();
    }
 
    void read(InputStream is) throws IOException {
 
        ZipInputStream zis = new ZipInputStream(is);
        ZipEntry ze;
        int i = -1;
 
        while ((ze = zis.getNextEntry()) != null) {
 
            String name = ze.getName();
 
            Debug.log(Debug.TRACE, "reading entry: " + name);
 
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
            int len;
            byte buffer[] = new byte[BUFFERSIZE];
 
            while ((len = zis.read(buffer)) > 0) {
                baos.write(buffer, 0, len);
            }
 
            byte bytes[] = baos.toByteArray();
            Entry entry = new Entry(ze,bytes);
 
            entryList.add(entry);
 
            i++;
 
            if (name.equalsIgnoreCase(CONTENTXML)) {
                contentIndex = i;
            }
            else if (name.equalsIgnoreCase(STYLEXML)) {
                styleIndex = i;
            }
            else if (name.equalsIgnoreCase(METAXML)) {
                metaIndex = i;
            }
            else if (name.equalsIgnoreCase(SETTINGSXML)) {
                settingsIndex = i;
            }
            else if (name.equalsIgnoreCase(MANIFESTXML)) {
                manifestIndex = i;
            }
 
        }
 
        zis.close();
    }
 
    byte[] getContentXMLBytes() {
 
        return getEntryBytes(contentIndex);
    }
 
    byte[] getStyleXMLBytes() {
 
        return getEntryBytes(styleIndex);
    }
 
    byte[] getMetaXMLBytes() {
        return getEntryBytes(metaIndex);
    }
 
    byte[] getSettingsXMLBytes() {
        return getEntryBytes(settingsIndex);
    }
 
    byte[] getManifestXMLBytes() {
        return getEntryBytes(manifestIndex);
    }
 
    byte[] getNamedBytes(String name) {
 
        // The list is not sorted, and sorting it for a binary search would
        // invalidate the indices stored for the main files.
 
        // Could improve performance by caching the name and index when
        // iterating through the ZipFile in read().
        for (int i = 0; i < entryList.size(); i++) {
            Entry e = entryList.get(i);
 
            if (e.zipEntry.getName().equals(name)) {
                return getEntryBytes(i);
            }
        }
 
        return null;
    }
 
    void setNamedBytes(String name, byte[] bytes) {
        for (int i = 0; i < entryList.size(); i++) {
            Entry e = entryList.get(i);
 
            if (e.zipEntry.getName().equals(name)) {
                setEntryBytes(i, bytes, name);
                return;
            }
        }
 
        // If we're here, no entry was found.  Call setEntryBytes with an index
        // of -1 to insert a new entry.
        setEntryBytes(-1, bytes, name);
    }
 
    private byte[] getEntryBytes(int index) {
 
        byte[] bytes = null;
 
        if (index > -1) {
            Entry entry = entryList.get(index);
            bytes = entry.bytes;
        }
        return bytes;
    }
 
    void setContentXMLBytes(byte bytes[]) {
 
        contentIndex = setEntryBytes(contentIndex, bytes, CONTENTXML);
    }
 
    void setStyleXMLBytes(byte bytes[]) {
 
        styleIndex = setEntryBytes(styleIndex, bytes, STYLEXML);
    }
 
    void setMetaXMLBytes(byte bytes[]) {
 
        metaIndex = setEntryBytes(metaIndex, bytes, METAXML);
    }
 
    void setSettingsXMLBytes(byte bytes[]) {
 
        settingsIndex = setEntryBytes(settingsIndex, bytes, SETTINGSXML);
    }
 
    void setManifestXMLBytes(byte bytes[]) {
        manifestIndex = setEntryBytes(manifestIndex, bytes, MANIFESTXML);
    }
 
    private int setEntryBytes(int index, byte bytes[], String name) {
 
        if (index > -1) {
            // replace existing entry in entryList
            Entry entry = entryList.get(index);
            name = entry.zipEntry.getName();
            int method = entry.zipEntry.getMethod();
 
            ZipEntry ze = createZipEntry(name, bytes, method);
 
            entry.zipEntry = ze;
            entry.bytes= bytes;
 
        } else {
            // add a new entry into entryList
            ZipEntry ze = createZipEntry(name, bytes, ZipEntry.DEFLATED);
            Entry entry = new Entry(ze, bytes);
            entryList.add(entry);
            index = entryList.size() - 1;
        }
 
        return index;
    }
 
    void write(OutputStream os) throws IOException {
 
        Debug.log(Debug.TRACE, "Writing out the following entries into zip.");
 
        ZipOutputStream zos = new ZipOutputStream(os);
 
        ListIterator<Entry> iterator = entryList.listIterator();
        while (iterator.hasNext()) {
 
            Entry entry = iterator.next();
            ZipEntry ze = entry.zipEntry;
 
            String name = ze.getName();
 
            Debug.log(Debug.TRACE, "... " + name);
 
            zos.putNextEntry(ze);
            zos.write(entry.bytes);
        }
 
        zos.close();
    }
 
    private ZipEntry createZipEntry(String name, byte bytes[], int method) {
 
        ZipEntry ze = new ZipEntry(name);
 
        ze.setMethod(method);
        ze.setSize(bytes.length);
 
        CRC32 crc = new CRC32();
        crc.reset();
        crc.update(bytes);
        ze.setCrc(crc.getValue());
 
        ze.setTime(System.currentTimeMillis());
 
        return ze;
    }
 
    private static class Entry {
 
        ZipEntry zipEntry = null;
        byte bytes[] = null;
 
        Entry(ZipEntry zipEntry, byte bytes[]) {
            this.zipEntry = zipEntry;
            this.bytes = bytes;
        }
    }
}