1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/compressionlibs/ziplib/src/ezip/zipfile.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,907 @@
1.4 +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +
1.20 +#include <caf/content.h>
1.21 +#include <caf/data.h>
1.22 +#include <zipfile.h>
1.23 +
1.24 +// ====================================================================
1.25 +// CZipFile public exported interface
1.26 +// ====================================================================
1.27 +
1.28 +/**
1.29 +Creates a new CZipFile object using the supplied file server session and
1.30 +a valid file handle. The caller must have sufficient rights to
1.31 +access the content of the zipfile, if encrypted/protected.
1.32 +
1.33 +@param aFs File server session used for opening the zipfile
1.34 +@param aFile File handle to be used for accessing the zipfile
1.35 +@return CZipFile object associated with the zipfile if it succeeded
1.36 +@leave KZipArchiveError If file cannot be accessed(invalid handle, corrupt file header, etc.)
1.37 +@leave KZipFileIOError If file cannot be read
1.38 +@leave KCentralDirectoryTrailerNotFound If zip file header doesn't contain information about files inside the archive
1.39 +@leave KCentralDirectoryTrailerInvalid If the information about files inside the archive is corrupt
1.40 +@leave KMultiDiskArchivesNotSupported If zipfile is a multi disk archive
1.41 +@leave ... Any one of the system-wide error codes for other errors.
1.42 +*/
1.43 +EXPORT_C CZipFile* CZipFile::NewL(RFs& aFs, RFile& aFile)
1.44 + {
1.45 + TFileName file;
1.46 + aFile.Name(file);
1.47 + CZipFile* zipFile = new(ELeave) CZipFile(aFs, file);
1.48 + CleanupStack::PushL(zipFile);
1.49 + zipFile->ConstructL(aFile);
1.50 + CleanupStack::Pop(zipFile);
1.51 + return zipFile;
1.52 + }
1.53 +
1.54 +/**
1.55 +Creates a new CZipFile object using the supplied file server session and
1.56 +file name. The caller must have sufficient capabilities to access the directory.
1.57 +The caller must also have sufficient rights to access the content of the
1.58 +zipfile, if encrypted/protected.
1.59 +
1.60 +@param aFs File server session used for opening the zipfile
1.61 +@param aFileName Name of the zipfile
1.62 +@return CZipFile object associated with the zipfile if it succeeded
1.63 +@leave KZipArchiveError If file cannot be accessed(invalid handle, corrupt file header, etc.)
1.64 +@leave KZipFileIOError If file cannot be read
1.65 +@leave KCentralDirectoryTrailerNotFound If zip file header doesn't contain information about files inside the archive
1.66 +@leave KCentralDirectoryTrailerInvalid If the information about files inside the archive is corrupt
1.67 +@leave KMultiDiskArchivesNotSupported If zipfile is a multi disk archive.
1.68 +@leave ... Any one of the system-wide error codes for other errors.
1.69 +*/
1.70 +EXPORT_C CZipFile* CZipFile::NewL(RFs& aFs, const TDesC& aFileName)
1.71 + {
1.72 + CZipFile* zipFile = new(ELeave) CZipFile(aFs, aFileName);
1.73 + CleanupStack::PushL(zipFile);
1.74 + zipFile->ConstructL(aFileName);
1.75 + CleanupStack::Pop(zipFile);
1.76 + return zipFile;
1.77 + }
1.78 +
1.79 +/**
1.80 +Destructor
1.81 +*/
1.82 +EXPORT_C CZipFile::~CZipFile()
1.83 + {
1.84 + DeleteMemberPointers();
1.85 + }
1.86 +
1.87 +/**
1.88 +@deprecated in 7.0
1.89 +*/
1.90 +EXPORT_C CZipFile::CZipFile(RFs& aFs, const TDesC& aFileName)
1.91 + : iFileName(aFileName), iFs(aFs)
1.92 + {
1.93 + }
1.94 +
1.95 +/**
1.96 +@deprecated in 7.0
1.97 +*/
1.98 +EXPORT_C TInt CZipFile::OpenL(void)
1.99 + {
1.100 + if (!iMemberPointers)
1.101 + {
1.102 + ConstructL(iFileName);
1.103 + }
1.104 + return KErrNone;
1.105 + }
1.106 +
1.107 +/**
1.108 +@deprecated in 7.0
1.109 +*/
1.110 +EXPORT_C void CZipFile::Close(void)
1.111 + {
1.112 + DeleteMemberPointers();
1.113 + }
1.114 +
1.115 +/**
1.116 +Second phase of construction. Used by Rfile using NewL overload.
1.117 +
1.118 +@leave ... Any one of the system-wide error codes for other errors.
1.119 +*/
1.120 +EXPORT_C void CZipFile::ConstructL(RFile& aFile)
1.121 + {
1.122 + // Use the full name derived from the session path
1.123 + ContentAccess::CContent* content =
1.124 + ContentAccess::CContent::NewL(aFile);
1.125 + CleanupStack::PushL(content);
1.126 + iData = content->OpenContentL(ContentAccess::EPeek);
1.127 +
1.128 + // Parent content object no longer needed because we only need data
1.129 + CleanupStack::PopAndDestroy(content);
1.130 +
1.131 + // Seek to the end
1.132 + TInt length = 0;
1.133 + User::LeaveIfError(iData->Seek(ESeekEnd, length));
1.134 + iFileLength = length;
1.135 +
1.136 + TInt status;
1.137 + TUint32 offset;
1.138 +
1.139 + if ((status = FindCentralDirectoryTrailer(offset)) != KErrNone)
1.140 + {
1.141 + DeleteMemberPointers();
1.142 + User::Leave(status);
1.143 + }
1.144 +
1.145 + if ((status = ReadCentralDirectoryTrailer(offset, iTrailer)) != KErrNone)
1.146 + {
1.147 + DeleteMemberPointers();
1.148 + User::Leave(status);
1.149 + }
1.150 +
1.151 + if (iTrailer.iStartDiskNumber != iTrailer.iDiskNumber)
1.152 + {
1.153 + DeleteMemberPointers();
1.154 + User::Leave(KMultiDiskArchivesNotSupported);
1.155 + }
1.156 +
1.157 + if ((iTrailer.iOffset + iTrailer.iSize) > iFileLength)
1.158 + {
1.159 + DeleteMemberPointers();
1.160 + User::Leave(KCentralDirectoryTrailerInvalid);
1.161 + }
1.162 +
1.163 + if (LoadMemberPointersL() != KErrNone)
1.164 + {
1.165 + User::Leave(KZipFileIOError);
1.166 + }
1.167 + }
1.168 +
1.169 +/**
1.170 +Second phase of construction. Used by filename using NewL overload
1.171 +
1.172 +@leave ... Any one of the system-wide error codes for other errors.
1.173 +*/
1.174 +EXPORT_C void CZipFile::ConstructL(const TDesC& aFileName)
1.175 + {
1.176 + TInt status;
1.177 + TUint32 offset;
1.178 +
1.179 + TRAP(status, OpenFileL(aFileName));
1.180 + if (status)
1.181 + {
1.182 + User::Leave(KZipArchiveError);
1.183 + }
1.184 + else
1.185 + if ((status = FindCentralDirectoryTrailer(offset)) != KErrNone)
1.186 + {
1.187 + DeleteMemberPointers();
1.188 + User::Leave(status);
1.189 + }
1.190 + else
1.191 + if ((status = ReadCentralDirectoryTrailer(offset, iTrailer)) != KErrNone)
1.192 + {
1.193 + DeleteMemberPointers();
1.194 + User::Leave(status);
1.195 + }
1.196 + else
1.197 + if (iTrailer.iStartDiskNumber != iTrailer.iDiskNumber)
1.198 + {
1.199 + DeleteMemberPointers();
1.200 + User::Leave(KMultiDiskArchivesNotSupported);
1.201 + }
1.202 + else
1.203 + if ((iTrailer.iOffset > iFileLength) ||
1.204 + ((iTrailer.iOffset + iTrailer.iSize) > iFileLength))
1.205 + {
1.206 + DeleteMemberPointers();
1.207 + User::Leave(KCentralDirectoryTrailerInvalid);
1.208 + }
1.209 + else
1.210 + if (LoadMemberPointersL() != KErrNone)
1.211 + {
1.212 + User::Leave(KZipFileIOError);
1.213 + }
1.214 + }
1.215 +
1.216 +/**
1.217 +Gets the size of the compressed data contained in the zip file in bytes
1.218 +Each CZipFile object has a compressed and uncompressed size. This method will
1.219 +return the compressed size of a zip file.
1.220 +
1.221 +@param aSize On return, the size of the compressed data in bytes
1.222 +@return KErrNotReady If object hasn't been properly constructed
1.223 +@return KErrCASizeNotDetermined If size could not be determined
1.224 +@return ... Any one of the system-wide error codes for other errors.
1.225 +*/
1.226 +EXPORT_C TInt CZipFile::Size(TInt& aSize) const
1.227 +{
1.228 + TInt err = KErrNotReady;
1.229 + if (iData)
1.230 + {
1.231 + TRAP(err, iData->DataSizeL(aSize));
1.232 + }
1.233 + return err;
1.234 +}
1.235 +
1.236 +/**
1.237 +Constructs and returns a CZipFileMember object which is used to access
1.238 +information about a compressed file contained in the CZipFile archive.
1.239 +The name of the file to be searched for in the zipfile is case-sensitive.
1.240 +
1.241 +@param aName The name of the file to be searched in the zipfile
1.242 +@return the pointer to CZipFileMember object
1.243 +@return NULL if the file doesn't exist in the zipfile
1.244 +@leave ... Any one of the system-wide error codes for other errors.
1.245 +*/
1.246 +EXPORT_C CZipFileMember* CZipFile::MemberL(const TDesC& aName)
1.247 + {
1.248 + TLocalHeader header;
1.249 + const TMemberPointer* memberPointer;
1.250 + HBufC* localName = aName.AllocL();
1.251 + TInt loop = 0;
1.252 + while (loop < localName->Length())
1.253 + {
1.254 + if ((*localName)[loop] == '\\')
1.255 + {
1.256 + (localName->Des())[loop] = '/';
1.257 + }
1.258 + loop++;
1.259 + }
1.260 +
1.261 + memberPointer = FindMemberPointer(*localName, EFalse);
1.262 + if (memberPointer == NULL)
1.263 + {
1.264 + delete localName;
1.265 + return NULL;
1.266 + }
1.267 + else
1.268 + if (ReadLocalHeader(memberPointer->iLocalHeaderOffset, header) != KErrNone)
1.269 + {
1.270 + delete localName;
1.271 + return NULL;
1.272 + }
1.273 + else
1.274 + {
1.275 + CleanupStack::PushL(localName);
1.276 + CZipFileMember* thisMember = MakeMemberL(*memberPointer, header);
1.277 + CleanupStack::PopAndDestroy(); // localName
1.278 + return thisMember;
1.279 + }
1.280 + }
1.281 +
1.282 +/**
1.283 +Constructs and returns a CZipFileMember object which is used to access
1.284 +information about a compressed file contained in the CZipFile archive.
1.285 +The name of the file to be searched for in the zipfile is case-insensitive.
1.286 +
1.287 +@param aName The name of the file to be searched in the zipfile
1.288 +@return A pointer to a member object of zip file
1.289 +@return NULL If the file doesn't exist in the zipfile
1.290 +@leave ... Any one of the system-wide error codes for other errors.
1.291 +*/
1.292 +EXPORT_C CZipFileMember* CZipFile::CaseInsensitiveMemberL(const TDesC& aName)
1.293 +{
1.294 + TLocalHeader header;
1.295 + const TMemberPointer* memberPointer;
1.296 + HBufC* localName = aName.AllocL();
1.297 + TInt loop=0;
1.298 + while (loop < localName->Length())
1.299 + {
1.300 + if ((*localName)[loop] == '\\')
1.301 + {
1.302 + (localName->Des())[loop] = '/';
1.303 + }
1.304 + loop++;
1.305 + }
1.306 +
1.307 + memberPointer = FindMemberPointer(*localName, ETrue);
1.308 + if (memberPointer == NULL)
1.309 + {
1.310 + delete localName;
1.311 + return NULL;
1.312 + }
1.313 + else
1.314 + if (ReadLocalHeader(memberPointer->iLocalHeaderOffset, header) != KErrNone)
1.315 + {
1.316 + delete localName;
1.317 + return NULL;
1.318 + }
1.319 + else
1.320 + {
1.321 + CleanupStack::PushL(localName);
1.322 + CZipFileMember* thisMember = MakeMemberL(*memberPointer, header);
1.323 + CleanupStack::PopAndDestroy();
1.324 + return thisMember;
1.325 + }
1.326 +
1.327 + }
1.328 +
1.329 +/**
1.330 +Constructs and returns a CZipFileMember object which is used to access
1.331 +information about a compressed file contained in the CZipFile archive.
1.332 +An exact match for the filename is searched for first. If a match is not found,
1.333 +a case-insensitive search is performed. If both filenames exist in the archive,
1.334 +the case-sensitive match will be returned.
1.335 +
1.336 +@param aName The name of the file to be searched in the zipfile
1.337 +@return A pointer to a member object of zip file
1.338 +@return NULL If the file doesn't exist in the zipfile
1.339 +@leave ... Any one of the system-wide error codes for other errors.
1.340 +*/
1.341 +EXPORT_C CZipFileMember* CZipFile::CaseSensitiveOrCaseInsensitiveMemberL(const TDesC& aName)
1.342 +{
1.343 + CZipFileMember* member;
1.344 + member = MemberL(aName);
1.345 + if (member)
1.346 + {
1.347 + return member;
1.348 + }
1.349 + else
1.350 + {
1.351 + return CaseInsensitiveMemberL(aName);
1.352 + }
1.353 +}
1.354 +
1.355 +/**
1.356 +Creates and returns the input stream for a file in the archive. Only files
1.357 +compressed with Stored or Deflated compression methods are supported.
1.358 +
1.359 +@param aMember The compressed file in the archive
1.360 +@param aStream On return, the stream to be used for reading the contents of the compressed file. The caller owns this object and is responsible for deleting it.
1.361 +@return KErrNone if successful
1.362 +@return KCompressionMethodNotSupported if compression format unsupported
1.363 +@return ... Any one of the system-wide error codes for other errors.
1.364 +@leave ... Any one of the system-wide error codes for other errors.
1.365 +*/
1.366 +EXPORT_C TInt CZipFile::GetInputStreamL(const CZipFileMember* aMember, RZipFileMemberReaderStream*& aStream)
1.367 + {
1.368 + TUint32 compressionMethod;
1.369 +
1.370 + compressionMethod = aMember->iCompressionMethod;
1.371 + if ((compressionMethod != EStored) && (compressionMethod != EDeflated))
1.372 + {
1.373 + return KCompressionMethodNotSupported;
1.374 + }
1.375 + aStream = RZipFileMemberReaderStream::NewL(
1.376 + *this,
1.377 + aMember->iDataOffset,
1.378 + aMember->iCompressedSize,
1.379 + aMember->iUncompressedSize,
1.380 + compressionMethod);
1.381 + return KErrNone;
1.382 + }
1.383 +
1.384 +
1.385 +
1.386 +/**
1.387 +Gets the iterator used for iterating through the files contained in the ZIP
1.388 +file. It is the caller's responsibility to release the iterator when finsihed.
1.389 +
1.390 +@return Pointer to a newly allocated CZipFileMemberIterator object
1.391 +@leave ... Any one of the system-wide error codes for other errors.
1.392 +*/
1.393 +EXPORT_C CZipFileMemberIterator* CZipFile::GetMembersL()
1.394 + {
1.395 + return new (ELeave) CZipFileMemberIterator(this);
1.396 + }
1.397 +
1.398 +
1.399 +
1.400 +// Implementation
1.401 +
1.402 +/*
1.403 + * Find the 'end of central directory record'. This is at the 'end' of
1.404 + * the file, but since it is not a fixed length structure, we have to
1.405 + * hunt for it.
1.406 + *
1.407 + * We try assuming that the variable length section of the record is
1.408 + * empty, which usually appears to be the case.
1.409 + *
1.410 + * If this does not work we resort to 'walking backwards' through the
1.411 + * file looking for the signature bytes.
1.412 + *
1.413 + */
1.414 +
1.415 +TInt CZipFile::FindCentralDirectoryTrailer(TUint32& offset)
1.416 +{
1.417 + TBuf8<KSignatureLength> signature;
1.418 +
1.419 + if (iFileLength <= KCentralDirectoryTrailerFixedLength)
1.420 + {
1.421 + return KZipArchiveError;
1.422 + }
1.423 + // Try the obvious place first.Assuming that the comment (variable
1.424 + // length section) is empty,try to find the signature at the offset.
1.425 + offset = iFileLength - KCentralDirectoryTrailerFixedLength;
1.426 + if (Seek(offset) != KErrNone)
1.427 + {
1.428 + return KZipFileIOError;
1.429 + }
1.430 + TInt err = iData->Read(signature);
1.431 +
1.432 + if ( err != KErrNone)
1.433 + {
1.434 + return KZipFileIOError;
1.435 + }
1.436 +
1.437 + if ((signature[0] == 0x50) &&
1.438 + (signature[1] == 0x4b) &&
1.439 + (signature[2] == 0x05) &&
1.440 + (signature[3] == 0x06))
1.441 + {
1.442 + return KErrNone;
1.443 + }
1.444 + else
1.445 + {
1.446 + // There must be some comments, hence the central directory
1.447 + // record > 22 bytes.
1.448 + // This is a slow but fairly obvious way of searching
1.449 + // backwards through the file starting from the offset.
1.450 + TUint EndOfTrailerSearch = 0; //Upto beginning of File
1.451 +
1.452 + if(iFileLength > KMaxTrailerSearchLength+KCentralDirectoryTrailerFixedLength)
1.453 + EndOfTrailerSearch = offset - KMaxTrailerSearchLength; //Upto Last 64K+22 bytes
1.454 +
1.455 + while (offset >= EndOfTrailerSearch)
1.456 + {
1.457 + if (Seek(offset) != KErrNone)
1.458 + {
1.459 + return KZipFileIOError;
1.460 + }
1.461 + if (iData->Read(signature) != KErrNone)
1.462 + {
1.463 + return KZipFileIOError;
1.464 + }
1.465 + if ((signature[0] == 0x50) &&
1.466 + (signature[1] == 0x4b) &&
1.467 + (signature[2] == 0x05) &&
1.468 + (signature[3] == 0x06))
1.469 + {
1.470 + return KErrNone;
1.471 + }
1.472 + --offset;
1.473 + }
1.474 + return KCentralDirectoryTrailerNotFound;
1.475 + }
1.476 + }
1.477 +
1.478 +TInt CZipFile::ReadCentralDirectoryTrailer(TUint32 offset, struct TCentralDirectoryTrailer& r )
1.479 +{
1.480 + // Skip the signature
1.481 + if (Seek(offset + KSignatureLength) != KErrNone)
1.482 + {
1.483 + return KZipFileIOError;
1.484 + }
1.485 + else
1.486 + if (Read(r.iDiskNumber) != KErrNone)
1.487 + {
1.488 + return KZipFileIOError;
1.489 + }
1.490 + else
1.491 + if (Read(r.iStartDiskNumber)!= KErrNone)
1.492 + {
1.493 + return KZipFileIOError;
1.494 + }
1.495 + else
1.496 + if (Read(r.iLocalEntryCount) != KErrNone)
1.497 + {
1.498 + return KZipFileIOError;
1.499 + }
1.500 + else
1.501 + if (Read(r.iTotalEntryCount) != KErrNone)
1.502 + {
1.503 + return KZipFileIOError;
1.504 + }
1.505 + else
1.506 + if (Read(r.iSize) != KErrNone)
1.507 + {
1.508 + return KZipFileIOError;
1.509 + }
1.510 + else
1.511 + if (Read(r.iOffset) != KErrNone)
1.512 + {
1.513 + return KZipFileIOError;
1.514 + }
1.515 + else
1.516 + {
1.517 + return KErrNone;
1.518 + }
1.519 +}
1.520 +
1.521 +TInt CZipFile::LoadMemberPointersL(void)
1.522 + {
1.523 + TCentralDirectoryHeader header;
1.524 + TUint32 i;
1.525 + TUint32 memberPointerCount;
1.526 +
1.527 + if (Seek(iTrailer.iOffset) != KErrNone)
1.528 + {
1.529 + return KZipFileIOError;
1.530 + }
1.531 + memberPointerCount = iTrailer.iTotalEntryCount;
1.532 + iMemberPointers = new (ELeave) TMemberPointer[memberPointerCount];
1.533 + for (i = 0; i < memberPointerCount; i++)
1.534 + {
1.535 + iMemberPointers[i].iName = NULL;
1.536 + }
1.537 + CCnvCharacterSetConverter* converter = CCnvCharacterSetConverter::NewL();
1.538 + CleanupStack::PushL(converter);
1.539 + TInt converterState = CCnvCharacterSetConverter::KStateDefault;
1.540 + for (i = 0; i < memberPointerCount; i++)
1.541 + {
1.542 + if (ReadCentralDirectoryHeaderL(header, iMemberPointers[i], converter, converterState) != KErrNone)
1.543 + {
1.544 + return KZipFileError;
1.545 + }
1.546 + }
1.547 + CleanupStack::PopAndDestroy(converter);
1.548 + return KErrNone;
1.549 + }
1.550 +
1.551 +static void ConvertFileNameToUnicodeL(
1.552 + TDes16& aUnicode,
1.553 + const TDesC8& aForeign,
1.554 + const TUint16& aMadeBy,
1.555 + CCnvCharacterSetConverter* aConverter,
1.556 + TInt aConverterState,
1.557 + RFs aFs)
1.558 +// Have to decide whether filename encoding is CP850 or CP1252. According to tec support
1.559 +// at WinZip, if 'madeby' is set to DOS(0) then the encoding is CP850 and if it's set to
1.560 +// NTFS (11) then it's CP1252. However, if the MS Compressed Folders program was used
1.561 +// to zip, then madeby is always set to NTFS and the encoding is always CP850 - the exact
1.562 +// opposite. Because of this confusion, I have written a very basic decision algorithm
1.563 +// based on the premise that filenames are likely to use alphabet-style extended
1.564 +// characters (rather than box edges or punctuation etc.)
1.565 + {
1.566 + TInt len = aForeign.Length();
1.567 + TInt ANSIpoints = 0;
1.568 + TInt OEMpoints = 0;
1.569 + for (TInt i=0; i<len; i++)
1.570 + {
1.571 + if (aForeign[i] >= 128 && aForeign[i] <= 165)
1.572 + OEMpoints ++;
1.573 + if (aForeign[i] >= 192 && aForeign[i] <= 255)
1.574 + ANSIpoints ++;
1.575 + }
1.576 + if (ANSIpoints == OEMpoints)
1.577 + {
1.578 + if (aMadeBy>>8) //only interested in the upper byte
1.579 + ANSIpoints ++;
1.580 + else
1.581 + OEMpoints ++;
1.582 + }
1.583 + TInt unconvertibleChars = 0;
1.584 +
1.585 + CCnvCharacterSetConverter::TAvailability availabilty = CCnvCharacterSetConverter::EAvailable;
1.586 + if (ANSIpoints > OEMpoints)
1.587 + {
1.588 + // It's probably ANSI (CP1252)
1.589 + availabilty = aConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252,aFs);
1.590 + aConverter->ConvertToUnicode(aUnicode, aForeign, aConverterState, unconvertibleChars);
1.591 +
1.592 + }
1.593 + if (OEMpoints > ANSIpoints || unconvertibleChars)
1.594 + {
1.595 + // It's definitely OEM (CP850)
1.596 + availabilty = aConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierCP850,aFs);
1.597 + if(availabilty != CCnvCharacterSetConverter::EAvailable )
1.598 + {
1.599 + //if cp850 plugin is not available, use cp1252
1.600 + availabilty = aConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252, aFs);
1.601 + if(availabilty != CCnvCharacterSetConverter::EAvailable)
1.602 + User::Leave (KErrNotSupported);
1.603 + }
1.604 +
1.605 + aConverter->ConvertToUnicode(aUnicode, aForeign, aConverterState);
1.606 +
1.607 + }
1.608 + }
1.609 +
1.610 +TInt CZipFile::ReadCentralDirectoryHeaderL(
1.611 + TCentralDirectoryHeader& aHeader,
1.612 + TMemberPointer& aMemberPointer,
1.613 + CCnvCharacterSetConverter* aConverter,
1.614 + TInt aConverterState)
1.615 +/*
1.616 +As this function might be called many times and the request will
1.617 +eventually be translated to calls to server to read the data,
1.618 +so performance is the major issue. Try to minimize calls to server.
1.619 +Read data in a chunk rather than member-by-member.
1.620 +*/
1.621 + {
1.622 + TByte tmpHeader[KCentralDirectoryHeaderFixedLength];
1.623 +
1.624 + if (Read(tmpHeader,KCentralDirectoryHeaderFixedLength) != KErrNone)
1.625 + {
1.626 + return KZipFileIOError;
1.627 + }
1.628 +
1.629 + Mem::Copy(&aHeader.iSignature, &tmpHeader[0], 4);
1.630 +
1.631 + if (aHeader.iSignature != KCentralDirectoryHeaderSignature)
1.632 + {
1.633 + return KZipFileIOError;
1.634 + }
1.635 +
1.636 + Mem::Copy(&aHeader.iMadeBy, &tmpHeader[4], 2);
1.637 + Mem::Copy(&aHeader.iRequired, &tmpHeader[6], 2);
1.638 + Mem::Copy(&aHeader.iFlags, &tmpHeader[8], 2);
1.639 + Mem::Copy(&aHeader.iCompressionMethod, &tmpHeader[10], 2);
1.640 + Mem::Copy(&aHeader.iLastModifiedFileTime, &tmpHeader[12], 2);
1.641 + Mem::Copy(&aHeader.iLastModifiedFileDate, &tmpHeader[14], 2);
1.642 + Mem::Copy(&aHeader.iCRC32, &tmpHeader[16], 4);
1.643 + Mem::Copy(&aHeader.iCompressedSize, &tmpHeader[20], 4);
1.644 + Mem::Copy(&aHeader.iUncompressedSize, &tmpHeader[24], 4);
1.645 + Mem::Copy(&aHeader.iFileNameLength, &tmpHeader[28], 2);
1.646 + Mem::Copy(&aHeader.iExtraFieldLength, &tmpHeader[30], 2);
1.647 + Mem::Copy(&aHeader.iFileCommentLength, &tmpHeader[32], 2);
1.648 + Mem::Copy(&aHeader.iDiskNumberStart, &tmpHeader[34], 2);
1.649 + Mem::Copy(&aHeader.iInternalFileAttributes, &tmpHeader[36], 2);
1.650 + Mem::Copy(&aHeader.iExternalFileAttributes, &tmpHeader[38], 4);
1.651 + Mem::Copy(&aHeader.iLocalHeaderOffset, &tmpHeader[42], 4);
1.652 +
1.653 + aMemberPointer.iCRC32 = aHeader.iCRC32;
1.654 + aMemberPointer.iCompressedSize = aHeader.iCompressedSize;
1.655 + aMemberPointer.iUncompressedSize = aHeader.iUncompressedSize;
1.656 + aMemberPointer.iLocalHeaderOffset = aHeader.iLocalHeaderOffset;
1.657 + aMemberPointer.iName = new(ELeave) TFileName;
1.658 +
1.659 + TBuf8<KMaxFileName> input;
1.660 + if (iData->Read(input, aHeader.iFileNameLength) != KErrNone)
1.661 + {
1.662 + return KZipFileIOError;
1.663 + }
1.664 + ConvertFileNameToUnicodeL(*aMemberPointer.iName, input, aHeader.iMadeBy, aConverter, aConverterState, iFs);
1.665 +
1.666 + // Ignore the remaining fields
1.667 + TInt pos;
1.668 +
1.669 + pos = aHeader.iExtraFieldLength;
1.670 + if (pos != 0)
1.671 + {
1.672 + // Don't pass aHeader.iExtraFieldLength in place of pos
1.673 + // as the below function will update the content of that variable.
1.674 + // In this case, the function is used to ignore the data
1.675 + // by just moving the current file pointer location.
1.676 + if (iData->Seek(ESeekCurrent, pos) != KErrNone)
1.677 + {
1.678 + return KZipFileIOError;
1.679 + }
1.680 + }
1.681 +
1.682 + pos = aHeader.iFileCommentLength;
1.683 + if (pos != 0)
1.684 + {
1.685 + // Don't pass aHeader.iFileCommentLength in place of pos
1.686 + // as the below function will update the content of that variable.
1.687 + // In this case, the function is used to ignore the data
1.688 + // by just moving the current file pointer location.
1.689 + if (iData->Seek(ESeekCurrent, pos) != KErrNone)
1.690 + {
1.691 + return KZipFileIOError;
1.692 + }
1.693 + }
1.694 +
1.695 + return KErrNone;
1.696 +}
1.697 +
1.698 +TInt CZipFile::ReadLocalHeader(TUint32 aOffset, TLocalHeader& aHeader)
1.699 +/*
1.700 +As this function might be called many times and the request will
1.701 +eventually be translated to calls to server to read the data,
1.702 +so performance is the major issue. Try to minimize calls to server.
1.703 +Read data in a chunk rather than member-by-member.
1.704 +*/
1.705 + {
1.706 + TByte tmpHeader[KLocalHeaderFixedLength];
1.707 +
1.708 + if (Seek(aOffset) != KErrNone)
1.709 + {
1.710 + return KZipFileIOError;
1.711 + }
1.712 + if (Read(tmpHeader,KLocalHeaderFixedLength) != KErrNone)
1.713 + {
1.714 + return KZipFileIOError;
1.715 + }
1.716 + Mem::Copy(&aHeader.iSignature, &tmpHeader[0], 4);
1.717 +
1.718 + if (aHeader.iSignature != KLocalHeaderSignature)
1.719 + {
1.720 + return KLocalHeaderSignatureInvalid;
1.721 + }
1.722 +
1.723 + Mem::Copy(&aHeader.iVersionNeeded, &tmpHeader[4], 2);
1.724 + Mem::Copy(&aHeader.iFlags, &tmpHeader[6], 2);
1.725 + Mem::Copy(&aHeader.iCompressionMethod, &tmpHeader[8], 2);
1.726 + Mem::Copy(&aHeader.iLastModifiedFileTime, &tmpHeader[10], 2);
1.727 + Mem::Copy(&aHeader.iLastModifiedFileDate, &tmpHeader[12], 2);
1.728 + Mem::Copy(&aHeader.iCRC32, &tmpHeader[14], 4);
1.729 + Mem::Copy(&aHeader.iCompressedSize, &tmpHeader[18], 4);
1.730 + Mem::Copy(&aHeader.iUncompressedSize, &tmpHeader[22], 4);
1.731 + Mem::Copy(&aHeader.iFileNameLength, &tmpHeader[26], 2);
1.732 + Mem::Copy(&aHeader.iExtraFieldLength, &tmpHeader[28], 2);
1.733 +
1.734 + return KErrNone;
1.735 + }
1.736 +
1.737 +const CZipFile::TMemberPointer* CZipFile::FindMemberPointer(const TDesC& aName, TBool aCaseInsensitive)
1.738 + {
1.739 + for (TUint32 i = 0; i < iTrailer.iTotalEntryCount; i++)
1.740 + {
1.741 + if (aCaseInsensitive && (!aName.CompareF(*iMemberPointers[i].iName)))
1.742 + {
1.743 + return iMemberPointers + i;
1.744 + }
1.745 + else if (aName == *iMemberPointers[i].iName)
1.746 + {
1.747 + return iMemberPointers + i;
1.748 + }
1.749 + }
1.750 + return NULL;
1.751 + }
1.752 +
1.753 +RZipFileMemberReaderStream* CZipFile::MakeInputStreamL(
1.754 + TUint32 aDataOffset,
1.755 + TUint32 aCompressedSize,
1.756 + TUint32 aUncompressedSize,
1.757 + TUint32 aCompressionMethod)
1.758 + {
1.759 + return RZipFileMemberReaderStream::NewL(
1.760 + *this,
1.761 + aDataOffset,
1.762 + aCompressedSize,
1.763 + aUncompressedSize,
1.764 + aCompressionMethod);
1.765 + }
1.766 +
1.767 +CZipFileMember* CZipFile::MakeMemberL(TInt aMemberIndex)
1.768 + {
1.769 + TLocalHeader header;
1.770 + TMemberPointer* memberPointer;
1.771 +
1.772 + if (aMemberIndex >= iTrailer.iTotalEntryCount)
1.773 + {
1.774 + return NULL;
1.775 + }
1.776 + memberPointer = iMemberPointers + aMemberIndex;
1.777 + if (ReadLocalHeader(memberPointer->iLocalHeaderOffset, header) != KErrNone)
1.778 + {
1.779 + return NULL;
1.780 + }
1.781 + else
1.782 + {
1.783 + return MakeMemberL(*memberPointer, header);
1.784 + }
1.785 + }
1.786 +
1.787 +CZipFileMember* CZipFile::MakeMemberL(
1.788 + const TMemberPointer& aMemberPointer,
1.789 + const TLocalHeader& aHeader)
1.790 + {
1.791 + CZipFileMember* member;
1.792 +
1.793 + member = new (ELeave) CZipFileMember;
1.794 + CleanupStack::PushL(member);
1.795 + member->iCRC32 = aMemberPointer.iCRC32;
1.796 + member->iCompressedSize = aMemberPointer.iCompressedSize;
1.797 + member->iCompressionMethod = aHeader.iCompressionMethod;
1.798 + member->iName = new (ELeave) TFileName(*aMemberPointer.iName);
1.799 + TInt loop=0;
1.800 + while (loop < member->iName->Length())
1.801 + {
1.802 + if ((*member->iName)[loop] == '/')
1.803 + {
1.804 + (*member->iName)[loop] = '\\';
1.805 + }
1.806 + loop++;
1.807 + }
1.808 + member->iUncompressedSize = aMemberPointer.iUncompressedSize;
1.809 + member->iDataOffset = aMemberPointer.iLocalHeaderOffset +
1.810 + KLocalHeaderFixedLength +
1.811 + aHeader.iFileNameLength +
1.812 + aHeader.iExtraFieldLength;
1.813 + CleanupStack::Pop();
1.814 + return member;
1.815 + }
1.816 +
1.817 +void CZipFile::DeleteMemberPointers()
1.818 + {
1.819 + if (iMemberPointers)
1.820 + {
1.821 + for (TUint32 i = 0; i < iTrailer.iTotalEntryCount; i++)
1.822 + {
1.823 + delete iMemberPointers[i].iName;
1.824 + }
1.825 + delete[] iMemberPointers;
1.826 + iMemberPointers = 0;
1.827 + }
1.828 +
1.829 + delete iData;
1.830 + iData = NULL;
1.831 + return;
1.832 + }
1.833 +
1.834 +void CZipFile::OpenFileL(const TDesC& aFileName)
1.835 + {
1.836 + // We need to look at the session path of the filesystem passed
1.837 + // in to derive the fullpath of the file to open
1.838 + HBufC* sessionPath = HBufC::NewLC(KMaxFileName);
1.839 + TPtr ptr(sessionPath->Des());
1.840 + User::LeaveIfError(iFs.SessionPath(ptr));
1.841 + TParse parse;
1.842 + User::LeaveIfError(parse.Set(aFileName, sessionPath, NULL));
1.843 +
1.844 + // Use the full name derived from the session path
1.845 + ContentAccess::CContent* content =
1.846 + ContentAccess::CContent::NewL(parse.FullName());
1.847 + CleanupStack::PushL(content);
1.848 + iData = content->OpenContentL(ContentAccess::EPeek);
1.849 +
1.850 + // Parent content object no longer needed because we only need data
1.851 + CleanupStack::PopAndDestroy(content);
1.852 +
1.853 + // Seek to the end
1.854 + TInt length = 0;
1.855 + User::LeaveIfError(iData->Seek(ESeekEnd, length));
1.856 + iFileLength = length;
1.857 + CleanupStack::PopAndDestroy(sessionPath);
1.858 + }
1.859 +
1.860 +TInt CZipFile::Read(TUint16& aUs)
1.861 + {
1.862 + TPckgBuf<TUint16> temp(aUs);
1.863 +
1.864 + if (iData->Read(temp) != KErrNone)
1.865 + {
1.866 + return KZipFileIOError;
1.867 + }
1.868 +
1.869 + aUs=temp();
1.870 + return KErrNone;
1.871 + }
1.872 +
1.873 +TInt CZipFile::Read(TUint32& aUl)
1.874 + {
1.875 + TPckgBuf<TUint32> temp;
1.876 +
1.877 + if (iData->Read(temp) != KErrNone)
1.878 + {
1.879 + return KZipFileIOError;
1.880 + }
1.881 + aUl=temp();
1.882 + return KErrNone;
1.883 + }
1.884 +
1.885 +TInt CZipFile::Read(TByte* aBytes, TUint32 aLength)
1.886 +
1.887 + {
1.888 + TPtr8 ptr(aBytes, aLength);
1.889 + if(iData->Read(ptr, aLength))
1.890 + {
1.891 + return KZipFileIOError;
1.892 + }
1.893 + else
1.894 + {
1.895 + return KErrNone;
1.896 + }
1.897 + }
1.898 +
1.899 +TInt CZipFile::Seek(TInt aOffset)
1.900 + {
1.901 + if (iData->Seek(ESeekStart, aOffset) < 0)
1.902 + {
1.903 + return KZipFileIOError;
1.904 + }
1.905 + else
1.906 + {
1.907 + return KErrNone;
1.908 + }
1.909 + }
1.910 +