unrar/Archive.java

kerry001

/* * Copyright (c) 2007 innoSysTec (R) GmbH, Germany. All rights reserved. * Original author: Edmund Wagner * Creation date: 22.05.2007 * * Source: $HeadURL$ * Last changed: $LastChangedDate$ * * the unrar licence applies to all junrar source and binary distributions * you are not allowed to use this source to re-create the RAR compression * algorithm * * Here some html entities which can be used for escaping javadoc tags: * "&":  "&" or "&" * "<":  "<" or "<" * ">":  ">" or ">" * "@":  "@" */package de.innosystec.unrar;import java.io.Closeable;import java.io.File;import java.io.IOException;import java.io.OutputStream;import java.util.ArrayList;import java.util.List;import java.util.logging.Level;import java.util.logging.Logger;import de.innosystec.unrar.exception.RarException;import de.innosystec.unrar.exception.RarException.RarExceptionType;import de.innosystec.unrar.io.IReadOnlyAccess;import de.innosystec.unrar.io.ReadOnlyAccessFile;import de.innosystec.unrar.rarfile.AVHeader;import de.innosystec.unrar.rarfile.BaseBlock;import de.innosystec.unrar.rarfile.BlockHeader;import de.innosystec.unrar.rarfile.CommentHeader;import de.innosystec.unrar.rarfile.EAHeader;import de.innosystec.unrar.rarfile.EndArcHeader;import de.innosystec.unrar.rarfile.FileHeader;import de.innosystec.unrar.rarfile.MacInfoHeader;import de.innosystec.unrar.rarfile.MainHeader;import de.innosystec.unrar.rarfile.MarkHeader;import de.innosystec.unrar.rarfile.ProtectHeader;import de.innosystec.unrar.rarfile.SignHeader;import de.innosystec.unrar.rarfile.SubBlockHeader;import de.innosystec.unrar.rarfile.UnixOwnersHeader;import de.innosystec.unrar.rarfile.UnrarHeadertype;import de.innosystec.unrar.unpack.ComprDataIO;import de.innosystec.unrar.unpack.Unpack;/** * DOCUMENT ME * * @author $LastChangedBy$ * @version $LastChangedRevision$ */public class Archive implements Closeable {        private static Logger logger = Logger.getLogger(Archive.class.getName());    private File file;    private IReadOnlyAccess rof;    private final UnrarCallback unrarCallback;    private final ComprDataIO dataIO;    private final List<BaseBlock> headers = new ArrayList<BaseBlock>();    private MarkHeader markHead = null;    private MainHeader newMhd = null;        private EndArcHeader endHeader = null;        private Unpack unpack;    /** Archive data CRC. */    private long arcDataCRC = 0xffffffff;    private int currentHeaderIndex;    private boolean encrypted = false;    private int sfxSize = 0;    /** Size of packed data in current file. */    private long totalPackedSize = 0L;    /** Number of bytes of compressed data read from current file. */    private long totalPackedRead = 0L;    public Archive(File file) throws RarException, IOException {        this(file, null);    }    /**     * create a new archive object using the given file     * @param file the file to extract     * @throws RarException     */    public Archive(File file, UnrarCallback unrarCallback)            throws RarException, IOException {        setFile(file);        this.unrarCallback = unrarCallback;        dataIO = new ComprDataIO(this);    }    public File getFile() {        return file;    }    void setFile(File file) throws IOException {        this.file = file;        totalPackedSize = 0L;        totalPackedRead = 0L;        close();        rof = new ReadOnlyAccessFile(file);        try {            readHeaders();        }        catch (Exception e) {            logger.log(Level.WARNING,                    "exception in archive constructor maybe file is encrypted " +                    "or currupt", e);            //ignore exceptions to allow exraction of working files in            //corrupt archive        }        // Calculate size of packed data        for (BaseBlock block : headers) {            if (block.getHeaderType() == UnrarHeadertype.FileHeader) {                totalPackedSize += ((FileHeader)block).getFullPackSize();            }        }        if (unrarCallback != null) {            unrarCallback.volumeProgressChanged(totalPackedRead,                    totalPackedSize);        }    }    public void bytesReadRead(int count) {        if (count > 0) {            totalPackedRead += count;            if (unrarCallback != null) {                unrarCallback.volumeProgressChanged(totalPackedRead,                        totalPackedSize);            }        }    }    public IReadOnlyAccess getRof() {        return rof;    }        /** * @return returns all file headers of the archive */public List<FileHeader> getFileHeaders(){List<FileHeader> list = new ArrayList<FileHeader>();for (BaseBlock block: headers) {if(block.getHeaderType().equals(UnrarHeadertype.FileHeader)){list.add((FileHeader)block);}}return list;}        public FileHeader nextFileHeader() {        int n = headers.size();        while (currentHeaderIndex < n) {            BaseBlock block = headers.get(currentHeaderIndex++);            if (block.getHeaderType() == UnrarHeadertype.FileHeader) {                return (FileHeader)block;            }        }        return null;    }    public UnrarCallback getUnrarCallback() {        return unrarCallback;    }    /**     *     * @return whether the archive is encrypted     */    public boolean isEncrypted() {        if(newMhd!=null){            return newMhd.isEncrypted();        }else{            throw new NullPointerException("mainheader is null");        }    }        /**     * Read the headers of the archive     * @throws RarException     */    private void readHeaders() throws IOException, RarException{        markHead = null;        newMhd = null;        endHeader = null;        headers.clear();        currentHeaderIndex = 0;        int toRead = 0;                long fileLength = this.file.length();        while(true){            int size = 0;            long newpos = 0;            byte[] baseBlockBuffer =new byte[BaseBlock.BaseBlockSize];                        long position = rof.getPosition();                        // Weird, but is trying to read beyond the end of the file            if (position >= fileLength) {            break;            }            //            logger.info("\n--------reading header--------");            size = rof.readFully(baseBlockBuffer, BaseBlock.BaseBlockSize);            if (size == 0){                break;            }            BaseBlock block = new BaseBlock(baseBlockBuffer);                        block.setPositionInFile(position);                                    switch(block.getHeaderType()) {                                case MarkHeader:                    markHead = new MarkHeader(block);                    if (!markHead.isSignature()) {                        throw new RarException(                                RarException.RarExceptionType.badRarArchive);                    }                    headers.add(markHead);//                    markHead.print();                    break;                                    case MainHeader:                    int mainHeaderSize = 0;                    toRead = block.hasEncryptVersion() ?                            MainHeader.mainHeaderSizeWithEnc :                            MainHeader.mainHeaderSize;                    byte[] mainbuff = new byte[toRead];                    mainHeaderSize = rof.readFully(mainbuff, toRead);                    MainHeader mainhead =new MainHeader(block,mainbuff);                    headers.add(mainhead);                    this.newMhd = mainhead;                    if(newMhd.isEncrypted()){                        throw new RarException(                                RarExceptionType.rarEncryptedException);                    }//                    mainhead.print();                    break;                                    case SignHeader:                    int signHeaderSize = 0;                    toRead = SignHeader.signHeaderSize;                    byte[] signBuff = new byte[toRead];                    signHeaderSize = rof.readFully(signBuff, toRead);                    SignHeader signHead = new SignHeader(block,signBuff);                    headers.add(signHead);//                    logger.info("HeaderType: SignHeader");                                        break;                                    case AvHeader:                    int avHeaderSize = 0;                    toRead = AVHeader.avHeaderSize;                    byte[] avBuff = new byte[toRead];                    avHeaderSize = rof.readFully(avBuff, toRead);                    AVHeader avHead = new AVHeader(block,avBuff);                    headers.add(avHead);//                    logger.info("headertype: AVHeader");                    break;                                    case CommHeader:                    int commHeaderSize = 0;                    toRead = CommentHeader.commentHeaderSize;                    byte[] commBuff = new byte[toRead];                    commHeaderSize = rof.readFully(commBuff, toRead);                    CommentHeader commHead = new CommentHeader(block,commBuff);                    headers.add(commHead);//                    logger.info("method: "+commHead.getUnpMethod()+"; 0x"+//                            Integer.toHexString(commHead.getUnpMethod()));                    newpos = commHead.getPositionInFile() +                            commHead.getHeaderSize();                    rof.setPosition(newpos);                                        break;                case EndArcHeader:                                        toRead = 0;                    if (block.hasArchiveDataCRC()) {                        toRead += EndArcHeader.endArcArchiveDataCrcSize;                    }                    if (block.hasVolumeNumber()) {                        toRead += EndArcHeader.endArcVolumeNumberSize;                    }                    EndArcHeader endArcHead;                    if(toRead > 0){                        int endArcHeaderSize = 0;                        byte[] endArchBuff = new byte[toRead];                        endArcHeaderSize = rof.readFully(endArchBuff, toRead);                        endArcHead = new EndArcHeader(block,endArchBuff);//                        logger.info("HeaderType: endarch\ndatacrc:"+//                                endArcHead.getArchiveDataCRC());                    }else{//                        logger.info("HeaderType: endarch - no Data");                        endArcHead = new EndArcHeader(block,null);                    }                    headers.add(endArcHead);                    this.endHeader = endArcHead;//                    logger.info("\n--------end header--------");                    return;                                    default:                    byte[] blockHeaderBuffer =                            new byte[BlockHeader.blockHeaderSize];                    int bhsize = rof.readFully(blockHeaderBuffer,                            BlockHeader.blockHeaderSize);                    BlockHeader blockHead = new BlockHeader(block,                            blockHeaderBuffer);                                        switch(blockHead.getHeaderType()) {                        case NewSubHeader:                        case FileHeader:                            toRead = blockHead.getHeaderSize()-                                    BlockHeader.BaseBlockSize-                                    BlockHeader.blockHeaderSize;                            byte[] fileHeaderBuffer = new byte[toRead];                            int fhsize = rof.readFully(fileHeaderBuffer,                                    toRead);                                                        FileHeader fh = new FileHeader(blockHead,                                    fileHeaderBuffer);//                            if (DEBUG) {//                                fh.print();//                            }                            headers.add(fh);                            newpos = fh.getPositionInFile() +                                    fh.getHeaderSize() + fh.getFullPackSize();                            rof.setPosition(newpos);                            break;                                                    case ProtectHeader:                            toRead = blockHead.getHeaderSize()-                                    BlockHeader.BaseBlockSize-                                    BlockHeader.blockHeaderSize;                            byte[] protectHeaderBuffer = new byte[toRead];                            int phsize = rof.readFully(protectHeaderBuffer,                                    toRead);                            ProtectHeader ph = new ProtectHeader(blockHead,                                    protectHeaderBuffer);                            //                            logger.info("totalblocks"+ph.getTotalBlocks());                            newpos = ph.getPositionInFile() +                                    ph.getHeaderSize();                            rof.setPosition(newpos);                            break;                                                    case SubHeader:{byte[] subHeadbuffer = new byte[SubBlockHeader.SubBlockHeaderSize];int subheadersize = rof.readFully(subHeadbuffer, SubBlockHeader.SubBlockHeaderSize);SubBlockHeader subHead = new SubBlockHeader(blockHead,subHeadbuffer);subHead.print();switch (subHead.getSubType()) {case MAC_HEAD:{byte[] macHeaderbuffer = new byte[MacInfoHeader.MacInfoHeaderSize];int macheadersize = rof.readFully(macHeaderbuffer, MacInfoHeader.MacInfoHeaderSize);MacInfoHeader macHeader = new MacInfoHeader(subHead,macHeaderbuffer);macHeader.print();headers.add(macHeader);break;}//TODO implement other subheaderscase BEEA_HEAD:break;case EA_HEAD:{byte[] eaHeaderBuffer = new byte[EAHeader.EAHeaderSize];int eaheadersize = rof.readFully(eaHeaderBuffer, EAHeader.EAHeaderSize);EAHeader eaHeader = new EAHeader(subHead,eaHeaderBuffer);eaHeader.print();headers.add(eaHeader);break;}case NTACL_HEAD:break;case STREAM_HEAD:break;case UO_HEAD:toRead = subHead.getHeaderSize();toRead -= BaseBlock.BaseBlockSize;toRead -= BlockHeader.blockHeaderSize;toRead -= SubBlockHeader.SubBlockHeaderSize;byte[] uoHeaderBuffer = new byte[toRead];int uoHeaderSize = rof.readFully(uoHeaderBuffer, toRead);UnixOwnersHeader uoHeader = new UnixOwnersHeader(subHead,uoHeaderBuffer);uoHeader.print();headers.add(uoHeader);break;default:break;}break;}                        default:                            logger.warning("Unknown Header");                            throw new RarException(                                    RarExceptionType.notRarArchive);                                                }            }//            logger.info("\n--------end header--------");        }    }    /**     * Extract the file specified by the given header and write it     * to the supplied output stream     *     * @param header the header to be extracted     * @param os the outputstream     * @throws RarException     */    public void extractFile(FileHeader hd, OutputStream os)            throws RarException{        if (!headers.contains(hd)){            throw new RarException(RarExceptionType.headerNotInArchive);        }        try {            doExtractFile(hd, os);        }        catch (Exception e) {            if (e instanceof RarException){                throw (RarException)e;            } else{                throw new RarException(e);            }        }    }    private void doExtractFile(FileHeader hd, OutputStream os)            throws RarException, IOException {        dataIO.init(os);        dataIO.init(hd);        dataIO.setUnpFileCRC(this.isOldFormat()?0:0xffFFffFF);        if(unpack==null){            unpack = new Unpack(dataIO);        }        if(!hd.isSolid()){            unpack.init(null);        }        unpack.setDestSize(hd.getFullUnpackSize());        try {            unpack.doUnpack(hd.getUnpVersion(), hd.isSolid());            // Verify file CRC            hd = dataIO.getSubHeader();            long actualCRC = hd.isSplitAfter() ?                    ~dataIO.getPackedCRC() : ~dataIO.getUnpFileCRC();            int expectedCRC = hd.getFileCRC();            if(actualCRC != expectedCRC){                throw new RarException(RarExceptionType.crcError);            }//            if (!hd.isSplitAfter()) {//                // Verify file CRC//                if(~dataIO.getUnpFileCRC() != hd.getFileCRC()){//                    throw new RarException(RarExceptionType.crcError);//                }//            }        }        catch (Exception e) {        unpack.cleanUp();            if (e instanceof RarException){                //throw new RarException((RarException)e);                throw (RarException)e;            }            else{                throw new RarException(e);            }        }    }        /**     * @return returns the main header of this archive     */    public MainHeader getMainHeader() {        return newMhd;    }        /**     * @return whether the archive is old format     */    public boolean isOldFormat() {        return markHead.isOldFormat();    }    /** Close the underlying compressed file. */    public void close() throws IOException {        if (rof != null) {            rof.close();            rof = null;        }    }}
URL：http://svn.atlassian.com/svn/public/atlassian/vendor/java-unrar/trunk/src/main/java/de/innosystec/unrar/Archive.java