util/GZip.java

   1 /*
   2  * Copyright (c) 2000-2005 CyberFOX Software, Inc. All Rights Reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Library General Public License as published
   6  * by the Free Software Foundation; either version 2 of the License, or (at
   7  * your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11  * FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
  12  * details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.
  17  *  59 Temple Place
  18  *  Suite 330
  19  *  Boston, MA 02111-1307
  20  *  USA
  21  */
  22
  23 package org.de.metux.util;
  24
  25 import java.io.*;
  26 import java.util.zip.*;
  27
  28 public class GZip
  29 {
  30     private static byte[] _byteHold = new byte[1];
  31     private static final Boolean _sync = Boolean.TRUE;
  32     private static final byte[] gzipHdrData = { 0x1f, -117, 0x08, 0x00,
  33                                                 0x00, 0x00, 0x00, 0x00,
  34                                                 0x02, -1 };
  35     byte[] _gzTest = new byte[2];
  36     byte[] _data;
  37     int _uclength;
  38     int _uccrc32;
  39     boolean nowrap = true;
  40     CRC32 _crc32Calculator = new CRC32();
  41     static int incrementme;
  42
  43     public byte[] getCompressedData() { return _data; }
  44
  45     public StringBuffer getUncompressedData()
  46         throws FileNotFoundException, DataFormatException, IOException
  47     {
  48         return uncompress(_data, nowrap);
  49     }
  50
  51     public StringBuffer getUncompressedData(boolean xt_nowrap)
  52         throws DataFormatException, FileNotFoundException, IOException
  53     {
  54         return uncompress(_data, xt_nowrap);
  55     }
  56
  57     public long getLength() { return _uclength; }
  58     public long getCRC() { return _uccrc32; }
  59     public void reset() { _data = null; _uclength = 0; _uccrc32 = 0; _crc32Calculator.reset(); }
  60
  61     public void setData(byte[] newData, int len, int crc)
  62     {
  63         _data = newData;
  64         _uclength = len;
  65         _uccrc32 = crc;
  66     }
  67
  68     public void setData(byte[] newData)
  69     {
  70         _crc32Calculator.reset();
  71         _crc32Calculator.update(newData);
  72         _uccrc32 = (int) _crc32Calculator.getValue();
  73         _uclength = newData.length;
  74         _data = compress(newData);
  75     }
  76
  77     public int readInt(FileInputStream fis) throws IOException
  78     {
  79         int a, b, c, d;
  80
  81         a = fis.read();
  82         b = fis.read();
  83         c = fis.read();
  84         d = fis.read();
  85
  86         return(a + b << 8 + c << 16 + d << 24);
  87     }
  88
  89     public void load(File fp) throws IOException
  90     {
  91         FileInputStream fis = new FileInputStream(fp);
  92
  93         fis.read(_gzTest);
  94         //  If it's a 'real' GZipped file...
  95         if(_gzTest[0] == 0x1f && _gzTest[1] == -117)
  96         {
  97             if(fis.skip(8)==8)
  98             {
  99                 _data = new byte[(int)fp.length() - 18 + 16];
 100                 fis.read(_data, 0, (int)fp.length() - 18);
 101
 102                 _uccrc32 = readInt(fis);
 103                 _uclength= readInt(fis);
 104                 nowrap = true;
 105             }
 106         }
 107         else
 108         {
 109             _data = new byte[(int)fp.length()];
 110             System.arraycopy(_gzTest, 0, _data, 0, 2);
 111             nowrap = false;
 112             fis.read(_data, 2, _data.length-2);
 113         }
 114         fis.close();
 115     }
 116
 117     private byte[] compress(byte[] inBytes)
 118     {
 119         Deflater df = new Deflater(9);
 120         byte[] newData = null;
 121         int deflatedBytes = 0;
 122
 123         //  We can't compress null.
 124         if(inBytes == null) return null;
 125
 126         synchronized(_sync)
 127         {
 128             if(_byteHold == null || _byteHold.length < inBytes.length) {
 129                 _byteHold = new byte[inBytes.length * 2];
 130             }
 131
 132             df.setInput(inBytes);
 133             df.finish();
 134             deflatedBytes = df.deflate(_byteHold);
 135
 136             deflatedBytes -= 4;
 137
 138             newData = new byte[deflatedBytes];
 139             System.arraycopy(_byteHold, 0, newData, 0, deflatedBytes);
 140         }
 141         return newData;
 142     }
 143
 144   public static StringBuffer uncompress(byte[] curPage, boolean nowrap)
 145     throws DataFormatException, FileNotFoundException, IOException
 146   {
 147     Inflater infl = new Inflater(nowrap);
 148     byte[] outdata = null;
 149     StringBuffer sb = null;
 150     int accumOutputBytes=0, inflatedBytes=0;
 151     int prevLength;
 152
 153     //  We can't uncompress null.
 154     if(curPage == null) return null;
 155
 156     synchronized(_sync) {
 157       prevLength = _byteHold.length;
 158
 159       if(prevLength < curPage.length) {
 160         _byteHold = new byte[curPage.length];
 161       }
 162       infl.setInput(curPage);
 163 //      try {
 164         inflatedBytes = infl.inflate(_byteHold);
 165         accumOutputBytes = inflatedBytes;
 166         while(!infl.finished() && inflatedBytes != 0) {
 167           outdata = _byteHold;
 168           prevLength = _byteHold.length;
 169           if(accumOutputBytes >= (prevLength - 2048)) {
 170 //            try {
 171               inflatedBytes = 0;
 172               _byteHold = new byte[_byteHold.length * 3];
 173               System.arraycopy(outdata, 0, _byteHold, 0, accumOutputBytes);
 174               inflatedBytes = infl.inflate(_byteHold, accumOutputBytes, prevLength * 2);
 175 //            } catch(OutOfMemoryError oome) {
 176 //              ErrorManagement.handleException("FAILING to allocate more bytes @ " + _byteHold.length * 3, oome);
 177 //            }
 178           } else {
 179             inflatedBytes = infl.inflate(_byteHold, accumOutputBytes, prevLength - accumOutputBytes);
 180           }
 181           accumOutputBytes += inflatedBytes;
 182         }
 183         return new StringBuffer(new String(_byteHold, 0, accumOutputBytes));
 184 //      } catch(DataFormatException dfe) {
 185 //        ErrorManagement.handleException("Failed to uncompress data: " + dfe, dfe);
 186 //        return null;
 187 //      }
 188     }
 189   }
 190
 191   /**
 192    * Write out the given int in LSB->MSB format.
 193    *
 194    * @param fos - Output stream to write to.
 195    * @param outie - Int value to write out in LSB->MSB format.
 196    */
 197     private void writeInt(FileOutputStream fos, int outie) throws IOException
 198     {
 199         byte a = (byte) ((outie & 0xff000000) >> 24);
 200         byte b = (byte) ((outie & 0x00ff0000) >> 16);
 201         byte c = (byte) ((outie & 0x0000ff00) >> 8);
 202         byte d = (byte) (outie & 0x000000ff);
 203
 204         fos.write(d);
 205         fos.write(c);
 206         fos.write(b);
 207         fos.write(a);
 208     }
 209
 210     public void save(String fileName)
 211         throws FileNotFoundException, IOException
 212     {
 213         File fp = new File(fileName);
 214
 215         if (fp.exists())
 216         {
 217             File oldFP = new File(fileName + "~");
 218             if(oldFP.exists())
 219                 oldFP.delete();
 220
 221             fp.renameTo(oldFP);
 222         }
 223
 224 //    try {
 225         FileOutputStream fos = new FileOutputStream(fp);
 226         //  Write 0x1f,0x8b,0x8,0x0,0x00000000,2,255,{Data},crc32,{datalen}
 227         fos.write(gzipHdrData, 0, gzipHdrData.length);
 228         fos.write(_data, 2, _data.length-2);
 229         writeInt(fos, _uccrc32);
 230         writeInt(fos, _uclength);
 231         fos.close();
 232 //    } catch(IOException ioe) {
 233       //  We dont throw the exception back up the chain, and let
 234       //  something with UI put up a display box because this can
 235       //  happen during unattended operation.
 236       //
 237       //  In fact, this can occur because the user deleted the
 238       //  directory, and many other reasons, so we do NOT report the
 239       //  error anymore, unless debugging.  This caused one user
 240       //  to have >28 megs of error logs.  Stop that!
 241 //      if(JConfig.debugging) {
 242 //        ErrorManagement.handleException("Error writing " + fileName, ioe);
 243 //      }
 244 //    }
 245   }
 246 }