DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (901e88980751)

VCS Links

Line Code
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
/* 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 Zip_h
#define Zip_h

#include <cstring>
#include <stdint.h>
#include <vector>
#include <zlib.h>
#include <pthread.h>
#include "Utils.h"
#include "mozilla/Assertions.h"
#include "mozilla/RefCounted.h"
#include "mozilla/RefPtr.h"

/**
 * Forward declaration
 */
class ZipCollection;

/**
 * Class to handle access to Zip archive streams. The Zip archive is mapped
 * in memory, and streams are direct references to that mapped memory.
 * Zip files are assumed to be correctly formed. No boundary checks are
 * performed, which means hand-crafted malicious Zip archives can make the
 * code fail in bad ways. However, since the only intended use is to load
 * libraries from Zip archives, there is no interest in making this code
 * safe, since the libraries could contain malicious code anyways.
 */
class Zip : public mozilla::external::AtomicRefCounted<Zip> {
 public:
  MOZ_DECLARE_REFCOUNTED_TYPENAME(Zip)
  /**
   * Create a Zip instance for the given file name. Returns nullptr in case
   * of failure.
   */
  static already_AddRefed<Zip> Create(const char* filename);

  /**
   * Create a Zip instance using the given buffer.
   */
  static already_AddRefed<Zip> Create(void* buffer, size_t size) {
    return Create(nullptr, buffer, size);
  }

 private:
  static already_AddRefed<Zip> Create(const char* filename, void* buffer,
                                      size_t size);

  /**
   * Private constructor
   */
  Zip(const char* filename, void* buffer, size_t size);

 public:
  /**
   * Destructor
   */
  ~Zip();

  /**
   * Class used to access Zip archive item streams
   */
  class Stream {
   public:
    /**
     * Stream types
     */
    enum Type { STORE = 0, DEFLATE = 8 };

    /**
     * Constructor
     */
    Stream()
        : compressedBuf(nullptr),
          compressedSize(0),
          uncompressedSize(0),
          CRC32(0),
          type(STORE) {}

    /**
     * Getters
     */
    const void* GetBuffer() { return compressedBuf; }
    size_t GetSize() { return compressedSize; }
    size_t GetUncompressedSize() { return uncompressedSize; }
    size_t GetCRC32() { return CRC32; }
    Type GetType() { return type; }

    /**
     * Returns a z_stream for use with inflate functions using the given
     * buffer as inflate output. The caller is expected to allocate enough
     * memory for the Stream uncompressed size.
     */
    z_stream GetZStream(void* buf) {
      z_stream zStream;
      zStream.avail_in = compressedSize;
      zStream.next_in =
          reinterpret_cast<Bytef*>(const_cast<void*>(compressedBuf));
      zStream.avail_out = uncompressedSize;
      zStream.next_out = static_cast<Bytef*>(buf);
      zStream.zalloc = nullptr;
      zStream.zfree = nullptr;
      zStream.opaque = nullptr;
      return zStream;
    }

   protected:
    friend class Zip;
    const void* compressedBuf;
    size_t compressedSize;
    size_t uncompressedSize;
    size_t CRC32;
    Type type;
  };

  /**
   * Returns a stream from the Zip archive.
   */
  bool GetStream(const char* path, Stream* out) const;

  /**
   * Returns the file name of the archive
   */
  const char* GetName() const { return name; }

  /**
   * Returns whether all files have correct CRC checksum.
   */
  bool VerifyCRCs() const;

 private:
  /* File name of the archive */
  char* name;
  /* Address where the Zip archive is mapped */
  void* mapped;
  /* Size of the archive */
  size_t size;

  /**
   * Strings (file names, comments, etc.) in the Zip headers are NOT zero
   * terminated. This class is a helper around them.
   */
  class StringBuf {
   public:
    /**
     * Constructor
     */
    StringBuf(const char* buf, size_t length) : buf(buf), length(length) {}

    /**
     * Returns whether the string has the same content as the given zero
     * terminated string.
     */
    bool Equals(const char* str) const {
      return (strncmp(str, buf, length) == 0 && str[length] == '\0');
    }

   private:
    const char* buf;
    size_t length;
  };

/* All the following types need to be packed */
#pragma pack(1)
 public:
  /**
   * A Zip archive is an aggregate of entities which all start with a
   * signature giving their type. This template is to be used as a base
   * class for these entities.
   */
  template <typename T>
  class SignedEntity {
   public:
    /**
     * Equivalent to reinterpret_cast<const T *>(buf), with an additional
     * check of the signature.
     */
    static const T* validate(const void* buf) {
      const T* ret = static_cast<const T*>(buf);
      if (ret->signature == T::magic) return ret;
      return nullptr;
    }

    explicit SignedEntity(uint32_t magic) : signature(magic) {}

   private:
    le_uint32 signature;
  };

 private:
  /**
   * Header used to describe a Local File entry. The header is followed by
   * the file name and an extra field, then by the data stream.
   */
  struct LocalFile : public SignedEntity<LocalFile> {
    /* Signature for a Local File header */
    static const uint32_t magic = 0x04034b50;

    /**
     * Returns the file name
     */
    StringBuf GetName() const {
      return StringBuf(reinterpret_cast<const char*>(this) + sizeof(*this),
                       filenameSize);
    }

    /**
     * Returns a pointer to the data associated with this header
     */
    const void* GetData() const {
      return reinterpret_cast<const char*>(this) + sizeof(*this) +
             filenameSize + extraFieldSize;
    }

    le_uint16 minVersion;
    le_uint16 generalFlag;
    le_uint16 compression;
    le_uint16 lastModifiedTime;
    le_uint16 lastModifiedDate;
    le_uint32 CRC32;
    le_uint32 compressedSize;
    le_uint32 uncompressedSize;
    le_uint16 filenameSize;
    le_uint16 extraFieldSize;
  };

  /**
   * In some cases, when a zip archive is created, compressed size and CRC
   * are not known when writing the Local File header. In these cases, the
   * 3rd bit of the general flag in the Local File header is set, and there
   * is an additional header following the compressed data.
   */
  struct DataDescriptor : public SignedEntity<DataDescriptor> {
    /* Signature for a Data Descriptor header */
    static const uint32_t magic = 0x08074b50;

    le_uint32 CRC32;
    le_uint32 compressedSize;
    le_uint32 uncompressedSize;
  };

  /**
   * Header used to describe a Central Directory Entry. The header is
   * followed by the file name, an extra field, and a comment.
   */
  struct DirectoryEntry : public SignedEntity<DirectoryEntry> {
    /* Signature for a Central Directory Entry header */
    static const uint32_t magic = 0x02014b50;

    /**
     * Returns the file name
     */
    StringBuf GetName() const {
      return StringBuf(reinterpret_cast<const char*>(this) + sizeof(*this),
                       filenameSize);
    }

    /**
     * Returns  the Central Directory Entry following this one.
     */
    const DirectoryEntry* GetNext() const {
      return validate(reinterpret_cast<const char*>(this) + sizeof(*this) +
                      filenameSize + extraFieldSize + fileCommentSize);
    }

    le_uint16 creatorVersion;
    le_uint16 minVersion;
    le_uint16 generalFlag;
    le_uint16 compression;
    le_uint16 lastModifiedTime;
    le_uint16 lastModifiedDate;
    le_uint32 CRC32;
    le_uint32 compressedSize;
    le_uint32 uncompressedSize;
    le_uint16 filenameSize;
    le_uint16 extraFieldSize;
    le_uint16 fileCommentSize;
    le_uint16 diskNum;
    le_uint16 internalAttributes;
    le_uint32 externalAttributes;
    le_uint32 offset;
  };

  /**
   * Header used to describe the End of Central Directory Record.
   */
  struct CentralDirectoryEnd : public SignedEntity<CentralDirectoryEnd> {
    /* Signature for the End of Central Directory Record */
    static const uint32_t magic = 0x06054b50;

    le_uint16 diskNum;
    le_uint16 startDisk;
    le_uint16 recordsOnDisk;
    le_uint16 records;
    le_uint32 size;
    le_uint32 offset;
    le_uint16 commentSize;
  };
#pragma pack()

  /**
   * Returns the first Directory entry
   */
  const DirectoryEntry* GetFirstEntry() const;

  /* Pointer to the Local File Entry following the last one GetStream() used.
   * This is used by GetStream to avoid scanning the Directory Entries when the
   * requested entry is that one. */
  mutable const LocalFile* nextFile;

  /* Likewise for the next Directory entry */
  mutable const DirectoryEntry* nextDir;

  /* Pointer to the Directory entries */
  mutable const DirectoryEntry* entries;

  mutable pthread_mutex_t mutex;
};

/**
 * Class for bookkeeping Zip instances
 */
class ZipCollection {
 public:
  static ZipCollection Singleton;

  /**
   * Get a Zip instance for the given path. If there is an existing one
   * already, return that one, otherwise create a new one.
   */
  static already_AddRefed<Zip> GetZip(const char* path);

 protected:
  friend class Zip;
  friend class mozilla::detail::RefCounted<Zip,
                                           mozilla::detail::AtomicRefCount>;

  /**
   * Register the given Zip instance. This method is meant to be called
   * by Zip::Create.
   */
  static void Register(Zip* zip);

  /**
   * Forget about the given Zip instance. This method is meant to be called
   * by the Zip destructor.
   */
  static void Forget(const Zip* zip);

 private:
  /* Zip instances bookkept in this collection */
  std::vector<RefPtr<Zip>> zips;
};

namespace mozilla {
namespace detail {

template <>
inline void RefCounted<Zip, AtomicRefCount>::Release() const {
  MOZ_ASSERT(static_cast<int32_t>(mRefCnt) > 0);
  const auto count = --mRefCnt;
  if (count == 1) {
    // No external references are left, attempt to remove it from the
    // collection. If it's successfully removed from the collection, Release()
    // will be called with mRefCnt = 1, which will finally delete this zip.
    ZipCollection::Forget(static_cast<const Zip*>(this));
  } else if (count == 0) {
#ifdef DEBUG
    mRefCnt = detail::DEAD;
#endif
    delete static_cast<const Zip*>(this);
  }
}

template <>
inline RefCounted<Zip, AtomicRefCount>::~RefCounted() {
  MOZ_ASSERT(mRefCnt == detail::DEAD);
}

}  // namespace detail
}  // namespace mozilla

#endif /* Zip_h */