summaryrefslogtreecommitdiffstats
path: root/modules/libjar/nsZipArchive.h
blob: 12e4b7ea00242d410468f9f961d1ef844a2147d9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsZipArchive_h_
#define nsZipArchive_h_

#include "mozilla/Attributes.h"

#define ZIP_TABSIZE 256
#define ZIP_BUFLEN \
  (4 * 1024) /* Used as output buffer when deflating items to a file */

#include "zlib.h"
#include "zipstruct.h"
#include "nsIFile.h"
#include "nsISupportsImpl.h"  // For mozilla::ThreadSafeAutoRefCnt
#include "mozilla/ArenaAllocator.h"
#include "mozilla/FileUtils.h"
#include "mozilla/FileLocation.h"
#include "mozilla/Mutex.h"
#include "mozilla/UniquePtr.h"

class nsZipFind;
struct PRFileDesc;

/**
 * This file defines some of the basic structures used by libjar to
 * read Zip files. It makes use of zlib in order to do the decompression.
 *
 * A few notes on the classes/structs:
 * nsZipArchive   represents a single Zip file, and maintains an index
 *                of all the items in the file.
 * nsZipItem      represents a single item (file) in the Zip archive.
 * nsZipFind      represents the metadata involved in doing a search,
 *                and current state of the iteration of found objects.
 * 'MT''safe' reading from the zipfile is performed through JARInputStream,
 * which maintains its own file descriptor, allowing for multiple reads
 * concurrently from the same zip file.
 *
 * nsZipArchives are accessed from multiple threads.
 */

/**
 * nsZipItem -- a helper struct for nsZipArchive
 *
 * each nsZipItem represents one file in the archive and all the
 * information needed to manipulate it.
 */
class nsZipItem final {
 public:
  nsZipItem();

  const char* Name() { return ((const char*)central) + ZIPCENTRAL_SIZE; }

  uint32_t LocalOffset();
  uint32_t Size();
  uint32_t RealSize();
  uint32_t CRC32();
  uint16_t Date();
  uint16_t Time();
  uint16_t Compression();
  bool IsDirectory();
  uint16_t Mode();
  const uint8_t* GetExtraField(uint16_t aTag, uint16_t* aBlockSize);
  PRTime LastModTime();

  nsZipItem* next;
  const ZipCentral* central;
  uint16_t nameLength;
  bool isSynthetic;
};

class nsZipHandle;

/**
 * nsZipArchive -- a class for reading the PKZIP file format.
 *
 */
class nsZipArchive final {
  friend class nsZipFind;

  /** destructing the object closes the archive */
  ~nsZipArchive();

 public:
  static const char* sFileCorruptedReason;

  /**
   * OpenArchive
   *
   * @param   aZipHandle  The nsZipHandle used to access the zip
   * @param   aFd         Optional PRFileDesc for Windows readahead optimization
   * @return  status code
   */
  static already_AddRefed<nsZipArchive> OpenArchive(nsZipHandle* aZipHandle,
                                                    PRFileDesc* aFd = nullptr);

  /**
   * OpenArchive
   *
   * Convenience function that generates nsZipHandle
   *
   * @param   aFile         The file used to access the zip
   * @return  status code
   */
  static already_AddRefed<nsZipArchive> OpenArchive(nsIFile* aFile);

  /**
   * Test the integrity of items in this archive by running
   * a CRC check after extracting each item into a memory
   * buffer.  If an entry name is supplied only the
   * specified item is tested.  Else, if null is supplied
   * then all the items in the archive are tested.
   *
   * @return  status code
   */
  nsresult Test(const char* aEntryName);

  /**
   * GetItem
   * @param   aEntryName Name of file in the archive
   * @return  pointer to nsZipItem
   */
  nsZipItem* GetItem(const char* aEntryName);

  /**
   * ExtractFile
   *
   * @param   zipEntry   Name of file in archive to extract
   * @param   outFD      Filedescriptor to write contents to
   * @param   outname    Name of file to write to
   * @return  status code
   */
  nsresult ExtractFile(nsZipItem* zipEntry, nsIFile* outFile,
                       PRFileDesc* outFD);

  /**
   * FindInit
   *
   * Initializes a search for files in the archive. FindNext() returns
   * the actual matches. The nsZipFind must be deleted when you're done
   *
   * @param   aPattern    a string or RegExp pattern to search for
   *                      (may be nullptr to find all files in archive)
   * @param   aFind       a pointer to a pointer to a structure used
   *                      in FindNext.  In the case of an error this
   *                      will be set to nullptr.
   * @return  status code
   */
  nsresult FindInit(const char* aPattern, nsZipFind** aFind);

  /*
   * Gets an undependent handle to the mapped file.
   */
  nsZipHandle* GetFD() const;

  /**
   * Gets the data offset.
   * @param   aItem       Pointer to nsZipItem
   * returns 0 on failure.
   */
  uint32_t GetDataOffset(nsZipItem* aItem);

  /**
   * Get pointer to the data of the item.
   * @param   aItem       Pointer to nsZipItem
   * reutrns null when zip file is corrupt.
   */
  const uint8_t* GetData(nsZipItem* aItem);

  /**
   * Gets the amount of memory taken up by the archive's mapping.
   * @return the size
   */
  int64_t SizeOfMapping();

  /*
   * Refcounting
   */
  NS_METHOD_(MozExternalRefCountType) AddRef(void);
  NS_METHOD_(MozExternalRefCountType) Release(void);

 private:
  nsZipArchive(nsZipHandle* aZipHandle, PRFileDesc* aFd, nsresult& aRv);

  //--- private members ---
  mozilla::ThreadSafeAutoRefCnt mRefCnt; /* ref count */
  NS_DECL_OWNINGTHREAD

  // These fields are all effectively const after the constructor
  // file handle
  const RefPtr<nsZipHandle> mFd;
  // file URI, for logging
  nsCString mURI;
  // Is true if we use zipLog to log accesses in jar/zip archives. This helper
  // variable avoids grabbing zipLog's lock when not necessary.
  // Effectively const after constructor
  bool mUseZipLog;

  mozilla::Mutex mLock{"nsZipArchive"};
  // all of the following members are guarded by mLock:
  nsZipItem* mFiles[ZIP_TABSIZE] MOZ_GUARDED_BY(mLock);
  mozilla::ArenaAllocator<1024, sizeof(void*)> mArena MOZ_GUARDED_BY(mLock);
  // Whether we synthesized the directory entries
  bool mBuiltSynthetics MOZ_GUARDED_BY(mLock);

 private:
  //--- private methods ---
  nsZipItem* CreateZipItem() MOZ_REQUIRES(mLock);
  nsresult BuildFileList(PRFileDesc* aFd = nullptr);
  nsresult BuildSynthetics();

  nsZipArchive& operator=(const nsZipArchive& rhs) = delete;
  nsZipArchive(const nsZipArchive& rhs) = delete;
};

/**
 * nsZipFind
 *
 * a helper class for nsZipArchive, representing a search
 */
class nsZipFind final {
 public:
  nsZipFind(nsZipArchive* aZip, char* aPattern, bool regExp);
  ~nsZipFind();

  nsresult FindNext(const char** aResult, uint16_t* aNameLen);

 private:
  RefPtr<nsZipArchive> mArchive;
  char* mPattern;
  nsZipItem* mItem;
  uint16_t mSlot;
  bool mRegExp;

  nsZipFind& operator=(const nsZipFind& rhs) = delete;
  nsZipFind(const nsZipFind& rhs) = delete;
};

/**
 * nsZipCursor -- a low-level class for reading the individual items in a zip.
 */
class nsZipCursor final {
 public:
  /**
   * Initializes the cursor
   *
   * @param   aItem       Item of interest
   * @param   aZip        Archive
   * @param   aBuf        Buffer used for decompression.
   *                      This determines the maximum Read() size in the
   *                      compressed case.
   * @param   aBufSize    Buffer size
   * @param   doCRC       When set to true Read() will check crc
   */
  nsZipCursor(nsZipItem* aItem, nsZipArchive* aZip, uint8_t* aBuf = nullptr,
              uint32_t aBufSize = 0, bool doCRC = false);

  ~nsZipCursor();

  /**
   * Performs reads. In the compressed case it uses aBuf(passed in constructor),
   * for stored files it returns a zero-copy buffer.
   *
   * @param   aBytesRead  Outparam for number of bytes read.
   * @return  data read or nullptr if item is corrupted.
   */
  uint8_t* Read(uint32_t* aBytesRead) { return ReadOrCopy(aBytesRead, false); }

  /**
   * Performs a copy. It always uses aBuf(passed in constructor).
   *
   * @param   aBytesRead  Outparam for number of bytes read.
   * @return  data read or nullptr if item is corrupted.
   */
  uint8_t* Copy(uint32_t* aBytesRead) { return ReadOrCopy(aBytesRead, true); }

 private:
  /* Actual implementation for both Read and Copy above */
  uint8_t* ReadOrCopy(uint32_t* aBytesRead, bool aCopy);

  nsZipItem* mItem;
  uint8_t* mBuf;
  uint32_t mBufSize;
  z_stream mZs;
  uint32_t mCRC;
  bool mDoCRC;
};

/**
 * nsZipItemPtr - a RAII convenience class for reading the individual items in a
 * zip. It reads whole files and does zero-copy IO for stored files. A buffer is
 * allocated for decompression. Do not use when the file may be very large.
 */
class nsZipItemPtr_base {
 public:
  /**
   * Initializes the reader
   *
   * @param   aZip        Archive
   * @param   aEntryName  Archive membername
   * @param   doCRC       When set to true Read() will check crc
   */
  nsZipItemPtr_base(nsZipArchive* aZip, const char* aEntryName, bool doCRC);

  uint32_t Length() const { return mReadlen; }

 protected:
  RefPtr<nsZipHandle> mZipHandle;
  mozilla::UniquePtr<uint8_t[]> mAutoBuf;
  uint8_t* mReturnBuf;
  uint32_t mReadlen;
};

template <class T>
class nsZipItemPtr final : public nsZipItemPtr_base {
  static_assert(sizeof(T) == sizeof(char),
                "This class cannot be used with larger T without re-examining"
                " a number of assumptions.");

 public:
  nsZipItemPtr(nsZipArchive* aZip, const char* aEntryName, bool doCRC = false)
      : nsZipItemPtr_base(aZip, aEntryName, doCRC) {}
  /**
   * @return buffer containing the whole zip member or nullptr on error.
   * The returned buffer is owned by nsZipItemReader.
   */
  const T* Buffer() const { return (const T*)mReturnBuf; }

  operator const T*() const { return Buffer(); }

  /**
   * Relinquish ownership of zip member if compressed.
   * Copy member into a new buffer if uncompressed.
   * @return a buffer with whole zip member. It is caller's responsibility to
   * free() it.
   */
  mozilla::UniquePtr<T[]> Forget() {
    if (!mReturnBuf) return nullptr;
    // In uncompressed mmap case, give up buffer
    if (mAutoBuf.get() == mReturnBuf) {
      mReturnBuf = nullptr;
      return mozilla::UniquePtr<T[]>(reinterpret_cast<T*>(mAutoBuf.release()));
    }
    auto ret = mozilla::MakeUnique<T[]>(Length());
    memcpy(ret.get(), mReturnBuf, Length());
    mReturnBuf = nullptr;
    return ret;
  }
};

class nsZipHandle final {
  friend class nsZipArchive;
  friend class nsZipFind;
  friend class mozilla::FileLocation;
  friend class nsJARInputStream;
#if defined(XP_UNIX) && !defined(XP_DARWIN)
  friend class MmapAccessScope;
#endif

 public:
  static nsresult Init(nsIFile* file, nsZipHandle** ret,
                       PRFileDesc** aFd = nullptr);
  static nsresult Init(nsZipArchive* zip, const char* entry, nsZipHandle** ret);
  static nsresult Init(const uint8_t* aData, uint32_t aLen, nsZipHandle** aRet);

  NS_METHOD_(MozExternalRefCountType) AddRef(void);
  NS_METHOD_(MozExternalRefCountType) Release(void);

  int64_t SizeOfMapping();

  nsresult GetNSPRFileDesc(PRFileDesc** aNSPRFileDesc);

 protected:
  const uint8_t* mFileData;    /* pointer to zip data */
  uint32_t mLen;               /* length of zip data */
  mozilla::FileLocation mFile; /* source file if any, for logging */

 private:
  nsZipHandle();
  ~nsZipHandle();

  nsresult findDataStart();

  PRFileMap* mMap; /* nspr datastructure for mmap */
  mozilla::AutoFDClose mNSPRFileDesc;
  mozilla::UniquePtr<nsZipItemPtr<uint8_t> > mBuf;
  mozilla::ThreadSafeAutoRefCnt mRefCnt; /* ref count */
  NS_DECL_OWNINGTHREAD

  const uint8_t* mFileStart; /* pointer to mmaped file */
  uint32_t mTotalLen;        /* total length of the mmaped file */

  /* Magic number for CRX type expressed in Big Endian since it is a literal */
  static const uint32_t kCRXMagic = 0x34327243;
};

nsresult gZlibInit(z_stream* zs);

#endif /* nsZipArchive_h_ */