archive.java

这是架包java-unrar-0.2.jar的源码

                    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 subheaders
								case 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;
        }
    }
}