filter/source/placeware/zip.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: zip.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_filter.hxx"
  33
  34 /*
  35 #include <tools/datetime.hxx>
  36 */
  37 #include <osl/diagnose.h>
  38 #include <rtl/crc.h>
  39
  40 #include "zip.hxx"
  41 #include "zipfile.hxx"
  42
  43 using namespace rtl;
  44
  45 /** this struct describes one entry in a zip file */
  46 struct ZipEntry
  47 {
  48     OString name;                       /* the name we used */
  49     sal_Int32 offset;           /* where the header starts */
  50     sal_Int32 endOffset;        /* where the file data ends */
  51     sal_Int32 crc;
  52     sal_Int32 modTime;          /* dos mod time & date */
  53     sal_Int32 fileLen;          /* file size, in bytes */
  54 };
  55
  56 /** put one byte inside this stream */
  57 static osl::File::RC putC( unsigned char c, osl::File& rFile )
  58 {
  59     sal_uInt64 nBytesWritten;
  60     osl::File::RC nRC = rFile.write( &c, 1, nBytesWritten );
  61
  62     OSL_ASSERT( nBytesWritten == 1 );
  63     return nRC;
  64 }
  65
  66 /** write a short to the ZipFile */
  67 void ZipFile::writeShort( sal_Int16 s)
  68 {
  69     if( !isError() )
  70     {
  71         mnRC = putC( static_cast< unsigned char >( s & 0xff ), mrFile );
  72         if( !isError() )
  73             mnRC = putC( static_cast< unsigned char >( (s >> 8) & 0xff ), mrFile );
  74     }
  75 }
  76
  77 /** write a long to the ZipFile */
  78
  79 void ZipFile::writeLong( sal_Int32 l )
  80 {
  81     if( !isError() )
  82     {
  83         mnRC = putC( static_cast< unsigned char >( l & 0xff ), mrFile);
  84         if( !isError() )
  85         {
  86             mnRC = putC( static_cast< unsigned char >( (l >> 8) & 0xff ), mrFile);
  87             if( !isError() )
  88             {
  89                 mnRC = putC( static_cast< unsigned char >( (l >> 16) & 0xff ), mrFile);
  90                 if( !isError() )
  91                 {
  92                     mnRC = putC( static_cast< unsigned char >( (l >> 24) & 0xff ), mrFile);
  93                 }
  94             }
  95         }
  96     }
  97 }
  98
  99 /** copy the zipentries file to the zipfile and updates the crc of that zipentry */
 100 void ZipFile::copyAndCRC(ZipEntry *e, osl::File& rFile)
 101 {
 102     char buf[2048];
 103     sal_uInt64 n, nWritten;
 104
 105     e->crc = rtl_crc32( 0, 0L, 0 );
 106
 107     while( !isError() )
 108     {
 109         mnRC = rFile.read( buf, sizeof(buf), n );
 110         if(n == 0)
 111             break;
 112
 113         if( !isError() )
 114         {
 115             sal_uInt32 nTemp = static_cast<sal_uInt32>(n);
 116             e->crc = rtl_crc32( e->crc, (const void *) buf, nTemp );
 117             mnRC = mrFile.write( buf, n, nWritten );
 118             OSL_ASSERT( n == nWritten );
 119         }
 120     }
 121
 122     if( !isError() )
 123     {
 124         sal_uInt64 nPosition = 0;
 125         mnRC = mrFile.getPos( nPosition );
 126         if( !isError() )
 127         {
 128             e->endOffset = static_cast< sal_Int32 >( nPosition );
 129         }
 130     }
 131 }
 132
 133 /** write a yet empty local header for a zipentry to the zipfile */
 134 void ZipFile::writeDummyLocalHeader(ZipEntry *e)
 135 {
 136     sal_Int32 len = zf_lfhSIZE + e->name.getLength();
 137     sal_Int32 i;
 138
 139     sal_uInt64 nPosition = 0;
 140     mnRC = mrFile.getPos( nPosition );
 141     if( !isError() )
 142     {
 143         e->offset = static_cast< sal_Int32 >( nPosition );
 144
 145         for (i = 0; (i < len) && !isError(); ++i)
 146             mnRC = putC(0, mrFile);
 147     }
 148 }
 149
 150 /** write the local header for a zipentry to the zipfile */
 151 void ZipFile::writeLocalHeader(ZipEntry *e)
 152 {
 153     TimeValue aTime;
 154     osl_getSystemTime( &aTime );
 155
 156     oslDateTime aDate;
 157     osl_getDateTimeFromTimeValue( &aTime, &aDate );
 158
 159     e->modTime = ((aDate.Year - 1980) << 25) | (aDate.Month << 21) |    (aDate.Day << 16) |
 160     (aDate.Hours << 11) | (aDate.Minutes << 5) | (aDate.Seconds >> 1);
 161
 162     e->fileLen = e->endOffset - e->offset - zf_lfhSIZE - e->name.getLength();
 163
 164     if(!isError())
 165     {
 166         mnRC = mrFile.setPos( Pos_Absolut, e->offset );
 167
 168         writeLong(zf_LFHSIGValue);                                                              // magic number
 169         writeShort(zf_Vers(1, 0));                                                              // extract version
 170         writeShort(0);                                                                                  // flags
 171         writeShort(zf_compNone);                                                                // compression method
 172         writeLong(e->modTime);                                                                  // file mod date & time
 173         writeLong(e->crc);                                                                              // file crc
 174         writeLong(e->fileLen);                                                                  // compressed size
 175         writeLong(e->fileLen);                                                                  // uncompressed size
 176         writeShort((sal_Int16) e->name.getLength());                                    // name length
 177         writeShort(0);                                                                                  // extra length field
 178
 179         if( !isError() )
 180         {
 181             sal_uInt64 nWritten;
 182             mnRC = mrFile.write( e->name.getStr(), e->name.getLength(), nWritten );     // file name
 183             OSL_ASSERT( nWritten == (sal_uInt64)e->name.getLength() );
 184             if( !isError() )
 185             {
 186                 mnRC = mrFile.setPos( Pos_Absolut, e->endOffset );
 187             }
 188         }
 189     }
 190 }
 191
 192 /* write a zipentry in the central dir to the zipfile */
 193 void ZipFile::writeCentralDir(ZipEntry *e)
 194 {
 195     writeLong(zf_CDHSIGValue);                          // magic number
 196     writeShort(zf_Vers(1, 0));                          // version made by
 197     writeShort(zf_Vers(1, 0));                          // vers to extract
 198     writeShort(0);                                                      // flags
 199     writeShort(zf_compNone);                            // compression method
 200     writeLong(e->modTime);                                      // file mod time & date
 201     writeLong(e->crc);
 202     writeLong(e->fileLen);                                      // compressed file size
 203     writeLong(e->fileLen);                                      // uncompressed file size
 204     writeShort((sal_Int16) e->name.getLength());        // name length
 205     writeShort(0);                                                      // extra field length
 206     writeShort(0);                                                      // file comment length
 207     writeShort(0);                                                      // disk number start
 208     writeShort(0);                                                      // internal file attributes
 209     writeLong(0);                                                       // external file attributes
 210     writeLong(e->offset);                                       // offset w.r.t disk
 211     if( !isError() )
 212     {
 213         sal_uInt64 nWritten;
 214         mrFile.write( e->name.getStr(), e->name.getLength(), nWritten );        // file name
 215         OSL_ASSERT( nWritten == (sal_uInt64)e->name.getLength() );
 216     }
 217 }
 218
 219 /* write the end of the central dir to the zipfile */
 220 void ZipFile::writeEndCentralDir(sal_Int32 nCdOffset, sal_Int32 nCdSize)
 221 {
 222     writeLong(zf_ECDSIGValue);          // magic number
 223     writeShort(0);                                      // disk num
 224     writeShort(0);                                      // disk with central dir
 225     writeShort( static_cast< sal_Int16 >( maEntries.size() ) ); // number of file entries
 226     writeShort( static_cast< sal_Int16 >( maEntries.size() ) ); // number of file entries
 227     writeLong(nCdSize);                         // central dir size
 228     writeLong(nCdOffset);
 229     writeShort(0);                                      // comment len
 230 }
 231
 232
 233 /****************************************************************
 234  * The exported functions
 235  ****************************************************************/
 236
 237 /* Create a zip file for writing, return a handle for it.
 238  * RETURNS: A new zip-file output object, or NULL if it failed, in
 239  *   which case *errMsgBuffer will contain an error message string. */
 240 ZipFile::ZipFile(osl::File& rFile )
 241 : mrFile( rFile ), mbOpen( true ), mnRC( osl::File::E_None )
 242 {
 243 }
 244
 245 ZipFile::~ZipFile()
 246 {
 247     if( mbOpen )
 248         close();
 249 }
 250
 251 /* Add a file to this zip with the given name.
 252  * RETURNS: true if successful, else false. If false, the caller should
 253  *   call zip_Close() and delete the bum zip file.
 254 */
 255 bool ZipFile::addFile( osl::File& rFile, const OString& rName )
 256 {
 257     OSL_ASSERT( mbOpen );
 258
 259     if( !mbOpen )
 260         return false;
 261
 262     OSL_ASSERT( 0 != rName.getLength() );
 263
 264     if(0 == rName.getLength())
 265         return false;
 266
 267     mnRC = rFile.open( osl_File_OpenFlag_Read );
 268
 269     if( !isError() )
 270     {
 271         ZipEntry *e = new ZipEntry;
 272         e->name = rName;
 273         maEntries.push_back(e);
 274
 275         writeDummyLocalHeader(e);
 276         if( !isError() )
 277         {
 278             copyAndCRC(e, rFile);
 279             if(!isError())
 280             {
 281                 writeLocalHeader(e);
 282             }
 283         }
 284
 285         rFile.close();
 286     }
 287
 288     return !isError();
 289 }
 290
 291 /* Finish up the zip file, close it, and deallocate the zip file object.
 292  * RETURNS: true if successful, else false.
 293 */
 294 bool ZipFile::close()
 295 {
 296     OSL_ASSERT( mbOpen );
 297
 298     if( !mbOpen )
 299         return false;
 300
 301     if( !isError() )
 302     {
 303         sal_uInt64 nCdOffset;
 304         mrFile.getPos( nCdOffset );
 305
 306         std::vector< ZipEntry* >::iterator aIter( maEntries.begin() );
 307         while((aIter != maEntries.end()) && !isError())
 308         {
 309             writeCentralDir( (*aIter++) );
 310         }
 311
 312         if( !isError() )
 313         {
 314             sal_uInt64 nCdSize;
 315             mrFile.getPos( nCdSize );
 316
 317             nCdSize -= nCdOffset;
 318
 319             if( !isError() )
 320             {
 321                 writeEndCentralDir(static_cast<sal_Int32>(nCdOffset), static_cast<sal_Int32>(nCdSize));
 322             }
 323         }
 324     }
 325
 326     std::vector< ZipEntry* >::iterator aIter( maEntries.begin() );
 327     while( aIter != maEntries.end() )
 328     {
 329         delete (*aIter++);
 330     }
 331
 332     mbOpen = false;
 333
 334     return !isError();
 335 }