shell/source/all/zipfile/zipfile.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: zipfile.cxx,v $
  10  * $Revision: 1.8 $
  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_shell.hxx"
  33 #include "zipexcptn.hxx"
  34 #include "internal/zipfile.hxx"
  35 #include "internal/global.hxx"
  36
  37 #include <malloc.h>
  38 #include <algorithm>
  39 #include <functional>
  40
  41 #include <string.h>
  42
  43 #ifdef OS2
  44 #include <alloca.h>
  45 #define _alloca alloca
  46 #define ERROR_NOT_ENOUGH_MEMORY 8
  47 #endif
  48
  49 namespace internal
  50 {
  51     /* for case in-sensitive string comparison */
  52     struct stricmp : public std::unary_function<std::string, bool>
  53     {
  54         stricmp(const std::string& str) : str_(str)
  55         {}
  56
  57         bool operator() (const std::string& other)
  58         { return (0 == _stricmp(str_.c_str(), other.c_str())); }
  59
  60         std::string str_;
  61     };
  62 } // namespace internal
  63
  64 /** Checks whether a file is a zip file or not
  65
  66     @precond    The given parameter must be a string with length > 0
  67             The file must exist
  68             The file must be readable for the current user
  69
  70     @returns    true if the file is a zip file
  71             false if the file is not a zip file
  72
  73     @throws     ParameterException if the given file name is empty
  74             IOException if the specified file doesn't exist
  75             AccessViolationException if read access to the file is denied
  76 */
  77 bool ZipFile::IsZipFile(const std::string& /*FileName*/)
  78 {
  79     return true;
  80 }
  81
  82 bool ZipFile::IsZipFile(void* /*stream*/)
  83 {
  84     return true;
  85 }
  86
  87
  88 /** Returns wheter the version of the specified zip file may be uncompressed with the
  89           currently used zlib version or not
  90
  91     @precond    The given parameter must be a string with length > 0
  92             The file must exist
  93             The file must be readable for the current user
  94             The file must be a valid zip file
  95
  96     @returns    true if the file may be uncompressed with the currently used zlib
  97             false if the file may not be uncompressed with the currently used zlib
  98
  99     @throws     ParameterException if the given file name is empty
 100             IOException if the specified file doesn't exist or is no zip file
 101             AccessViolationException if read access to the file is denied
 102 */
 103 bool ZipFile::IsValidZipFileVersionNumber(const std::string& /*FileName*/)
 104 {
 105     return true;
 106 }
 107
 108 bool ZipFile::IsValidZipFileVersionNumber(void* /* stream*/)
 109 {
 110     return true;
 111 }
 112
 113
 114 /** Constructs a zip file from a zip file
 115
 116     @precond    The given parameter must be a string with length > 0
 117             The file must exist
 118             The file must be readable for the current user
 119
 120     @throws     ParameterException if the given file name is empty
 121             IOException if the specified file doesn't exist or is no valid zip file
 122             AccessViolationException if read access to the file is denied
 123             WrongZipVersionException if the zip file cannot be uncompressed
 124             with the used zlib version
 125 */
 126 ZipFile::ZipFile(const std::string& FileName)
 127 {
 128     m_uzFile = unzOpen(FileName.c_str());
 129
 130     if (0 == m_uzFile)
 131         throw IOException(-1);
 132 }
 133
 134 ZipFile::ZipFile(void* stream, zlib_filefunc_def* fa)
 135 {
 136     fa->opaque = stream;
 137     m_uzFile = unzOpen2((const char *)NULL, fa);
 138
 139     if (0 == m_uzFile)
 140         throw IOException(-1);
 141 }
 142
 143
 144 /** Destroys a zip file
 145 */
 146 ZipFile::~ZipFile()
 147 {
 148     unzClose(m_uzFile);
 149 }
 150
 151 /** Provides an interface to read the uncompressed data of a content of the zip file
 152
 153     @precond    The specified content must exist in this file
 154             ppstm must not be NULL
 155 */
 156 void ZipFile::GetUncompressedContent(
 157     const std::string& ContentName, /*inout*/ ZipContentBuffer_t& ContentBuffer)
 158 {
 159     int rc = unzLocateFile(m_uzFile, ContentName.c_str(), 0);
 160
 161     if (UNZ_END_OF_LIST_OF_FILE == rc)
 162         throw ZipContentMissException(rc);
 163
 164     unz_file_info finfo;
 165     unzGetCurrentFileInfo(m_uzFile, &finfo, 0, 0, 0, 0, 0, 0);
 166
 167     ContentBuffer.resize(finfo.uncompressed_size);
 168
 169     rc = unzOpenCurrentFile(m_uzFile);
 170
 171     if (UNZ_OK != rc)
 172         throw ZipException(rc);
 173
 174     rc = unzReadCurrentFile(m_uzFile, &ContentBuffer[0], finfo.uncompressed_size);
 175
 176     if (rc < 0)
 177         throw ZipException(rc);
 178
 179     rc = unzCloseCurrentFile(m_uzFile);
 180
 181     if (rc < 0)
 182         throw ZipException(rc);
 183 }
 184
 185 /** Returns a list with the content names contained within this file
 186
 187 */
 188 ZipFile::DirectoryPtr_t ZipFile::GetDirectory() const
 189 {
 190     DirectoryPtr_t dir(new Directory_t());
 191
 192     long lmax = GetFileLongestFileNameLength() + 1;
 193     char* szFileName = reinterpret_cast<char*>(_alloca(lmax));
 194
 195     if (!szFileName)
 196         throw ZipException(ERROR_NOT_ENOUGH_MEMORY);
 197
 198     int rc = unzGoToFirstFile(m_uzFile);
 199
 200     while (UNZ_OK == rc && UNZ_END_OF_LIST_OF_FILE != rc)
 201     {
 202         unzGetCurrentFileInfo(
 203             m_uzFile, 0, szFileName, lmax, 0, 0, 0, 0);
 204
 205         dir->push_back(szFileName);
 206
 207         rc = unzGoToNextFile(m_uzFile);
 208     }
 209
 210     if (UNZ_OK != rc && UNZ_END_OF_LIST_OF_FILE != rc)
 211         throw ZipException(rc);
 212
 213     return dir;
 214 }
 215
 216 /** Convinience query function may even realized with
 217     iterating over a ZipFileDirectory returned by
 218     GetDirectory */
 219 bool ZipFile::HasContent(const std::string& ContentName) const
 220 {
 221     //#i34314# we need to compare package content names
 222     //case in-sensitive as it is not defined that such
 223     //names must be handled case sensitive
 224     DirectoryPtr_t dir = GetDirectory();
 225     Directory_t::iterator iter =
 226         std::find_if(dir->begin(), dir->end(), internal::stricmp(ContentName));
 227
 228     return (iter != dir->end());
 229 }
 230
 231
 232 /** Returns the length of the longest file name
 233         in the current zip file
 234 */
 235 long ZipFile::GetFileLongestFileNameLength() const
 236 {
 237     long lmax = 0;
 238     unz_file_info finfo;
 239
 240     int rc = unzGoToFirstFile(m_uzFile);
 241
 242     while (UNZ_OK == rc && UNZ_END_OF_LIST_OF_FILE != rc)
 243     {
 244         unzGetCurrentFileInfo(m_uzFile, &finfo, 0, 0, 0, 0, 0, 0);
 245         lmax = std::max<long>(lmax, finfo.size_filename);
 246         rc = unzGoToNextFile(m_uzFile);
 247     }
 248
 249     if (UNZ_OK != rc && UNZ_END_OF_LIST_OF_FILE != rc)
 250         throw ZipException(rc);
 251
 252     return lmax;
 253 }
 254