GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: node_zlib.cc Lines: 645 709 91.0 %
Date: 2022-10-14 05:16:24 Branches: 455 748 60.8 %

Line Branch Exec Source
1
// Copyright Joyent, Inc. and other Node contributors.
2
//
3
// Permission is hereby granted, free of charge, to any person obtaining a
4
// copy of this software and associated documentation files (the
5
// "Software"), to deal in the Software without restriction, including
6
// without limitation the rights to use, copy, modify, merge, publish,
7
// distribute, sublicense, and/or sell copies of the Software, and to permit
8
// persons to whom the Software is furnished to do so, subject to the
9
// following conditions:
10
//
11
// The above copyright notice and this permission notice shall be included
12
// in all copies or substantial portions of the Software.
13
//
14
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20
// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22
#include "memory_tracker-inl.h"
23
#include "node.h"
24
#include "node_buffer.h"
25
26
#include "async_wrap-inl.h"
27
#include "env-inl.h"
28
#include "node_external_reference.h"
29
#include "threadpoolwork-inl.h"
30
#include "util-inl.h"
31
32
#include "v8.h"
33
34
#include "brotli/encode.h"
35
#include "brotli/decode.h"
36
#include "zlib.h"
37
38
#include <sys/types.h>
39
40
#include <cerrno>
41
#include <cstdlib>
42
#include <cstring>
43
#include <atomic>
44
45
namespace node {
46
47
using v8::ArrayBuffer;
48
using v8::Context;
49
using v8::Function;
50
using v8::FunctionCallbackInfo;
51
using v8::FunctionTemplate;
52
using v8::HandleScope;
53
using v8::Int32;
54
using v8::Integer;
55
using v8::Isolate;
56
using v8::Local;
57
using v8::Object;
58
using v8::Uint32Array;
59
using v8::Value;
60
61
namespace {
62
63
// Fewer than 64 bytes per chunk is not recommended.
64
// Technically it could work with as few as 8, but even 64 bytes
65
// is low.  Usually a MB or more is best.
66
#define Z_MIN_CHUNK 64
67
#define Z_MAX_CHUNK std::numeric_limits<double>::infinity()
68
#define Z_DEFAULT_CHUNK (16 * 1024)
69
#define Z_MIN_MEMLEVEL 1
70
#define Z_MAX_MEMLEVEL 9
71
#define Z_DEFAULT_MEMLEVEL 8
72
#define Z_MIN_LEVEL -1
73
#define Z_MAX_LEVEL 9
74
#define Z_DEFAULT_LEVEL Z_DEFAULT_COMPRESSION
75
#define Z_MIN_WINDOWBITS 8
76
#define Z_MAX_WINDOWBITS 15
77
#define Z_DEFAULT_WINDOWBITS 15
78
79
#define ZLIB_ERROR_CODES(V)      \
80
  V(Z_OK)                        \
81
  V(Z_STREAM_END)                \
82
  V(Z_NEED_DICT)                 \
83
  V(Z_ERRNO)                     \
84
  V(Z_STREAM_ERROR)              \
85
  V(Z_DATA_ERROR)                \
86
  V(Z_MEM_ERROR)                 \
87
  V(Z_BUF_ERROR)                 \
88
  V(Z_VERSION_ERROR)             \
89
90
22
inline const char* ZlibStrerror(int err) {
91
#define V(code) if (err == code) return #code;
92




22
  ZLIB_ERROR_CODES(V)
93
#undef V
94
  return "Z_UNKNOWN_ERROR";
95
}
96
97
enum node_zlib_mode {
98
  NONE,
99
  DEFLATE,
100
  INFLATE,
101
  GZIP,
102
  GUNZIP,
103
  DEFLATERAW,
104
  INFLATERAW,
105
  UNZIP,
106
  BROTLI_DECODE,
107
  BROTLI_ENCODE
108
};
109
110
constexpr uint8_t GZIP_HEADER_ID1 = 0x1f;
111
constexpr uint8_t GZIP_HEADER_ID2 = 0x8b;
112
113
struct CompressionError {
114
24
  CompressionError(const char* message, const char* code, int err)
115
24
      : message(message),
116
        code(code),
117
24
        err(err) {
118
24
    CHECK_NOT_NULL(message);
119
24
  }
120
121
10356
  CompressionError() = default;
122
123
  const char* message = nullptr;
124
  const char* code = nullptr;
125
  int err = 0;
126
127
9292
  inline bool IsError() const { return code != nullptr; }
128
};
129
130
1100
class ZlibContext final : public MemoryRetainer {
131
 public:
132
1220
  ZlibContext() = default;
133
134
  // Streaming-related, should be available for all compression libraries:
135
  void Close();
136
  void DoThreadPoolWork();
137
  void SetBuffers(const char* in, uint32_t in_len, char* out, uint32_t out_len);
138
  void SetFlush(int flush);
139
  void GetAfterWriteOffsets(uint32_t* avail_in, uint32_t* avail_out) const;
140
  CompressionError GetErrorInfo() const;
141
1220
  inline void SetMode(node_zlib_mode mode) { mode_ = mode; }
142
  CompressionError ResetStream();
143
144
  // Zlib-specific:
145
  void Init(int level, int window_bits, int mem_level, int strategy,
146
            std::vector<unsigned char>&& dictionary);
147
  void SetAllocationFunctions(alloc_func alloc, free_func free, void* opaque);
148
  CompressionError SetParams(int level, int strategy);
149
150
  SET_MEMORY_INFO_NAME(ZlibContext)
151
  SET_SELF_SIZE(ZlibContext)
152
153
  void MemoryInfo(MemoryTracker* tracker) const override {
154
    tracker->TrackField("dictionary", dictionary_);
155
  }
156
157
  ZlibContext(const ZlibContext&) = delete;
158
  ZlibContext& operator=(const ZlibContext&) = delete;
159
160
 private:
161
  CompressionError ErrorForMessage(const char* message) const;
162
  CompressionError SetDictionary();
163
  bool InitZlib();
164
165
  Mutex mutex_;  // Protects zlib_init_done_.
166
  bool zlib_init_done_ = false;
167
  int err_ = 0;
168
  int flush_ = 0;
169
  int level_ = 0;
170
  int mem_level_ = 0;
171
  node_zlib_mode mode_ = NONE;
172
  int strategy_ = 0;
173
  int window_bits_ = 0;
174
  unsigned int gzip_id_bytes_read_ = 0;
175
  std::vector<unsigned char> dictionary_;
176
177
  z_stream strm_;
178
};
179
180
// Brotli has different data types for compression and decompression streams,
181
// so some of the specifics are implemented in more specific subclasses
182
231
class BrotliContext : public MemoryRetainer {
183
 public:
184
231
  BrotliContext() = default;
185
186
  void SetBuffers(const char* in, uint32_t in_len, char* out, uint32_t out_len);
187
  void SetFlush(int flush);
188
  void GetAfterWriteOffsets(uint32_t* avail_in, uint32_t* avail_out) const;
189
231
  inline void SetMode(node_zlib_mode mode) { mode_ = mode; }
190
191
  BrotliContext(const BrotliContext&) = delete;
192
  BrotliContext& operator=(const BrotliContext&) = delete;
193
194
 protected:
195
  node_zlib_mode mode_ = NONE;
196
  const uint8_t* next_in_ = nullptr;
197
  uint8_t* next_out_ = nullptr;
198
  size_t avail_in_ = 0;
199
  size_t avail_out_ = 0;
200
  BrotliEncoderOperation flush_ = BROTLI_OPERATION_PROCESS;
201
  // TODO(addaleax): These should not need to be stored here.
202
  // This is currently only done this way to make implementing ResetStream()
203
  // easier.
204
  brotli_alloc_func alloc_ = nullptr;
205
  brotli_free_func free_ = nullptr;
206
  void* alloc_opaque_ = nullptr;
207
};
208
209
234
class BrotliEncoderContext final : public BrotliContext {
210
 public:
211
  void Close();
212
  void DoThreadPoolWork();
213
  CompressionError Init(brotli_alloc_func alloc,
214
                        brotli_free_func free,
215
                        void* opaque);
216
  CompressionError ResetStream();
217
  CompressionError SetParams(int key, uint32_t value);
218
  CompressionError GetErrorInfo() const;
219
220
  SET_MEMORY_INFO_NAME(BrotliEncoderContext)
221
  SET_SELF_SIZE(BrotliEncoderContext)
222
  SET_NO_MEMORY_INFO()  // state_ is covered through allocation tracking.
223
224
 private:
225
  bool last_result_ = false;
226
  DeleteFnPtr<BrotliEncoderState, BrotliEncoderDestroyInstance> state_;
227
};
228
229
228
class BrotliDecoderContext final : public BrotliContext {
230
 public:
231
  void Close();
232
  void DoThreadPoolWork();
233
  CompressionError Init(brotli_alloc_func alloc,
234
                        brotli_free_func free,
235
                        void* opaque);
236
  CompressionError ResetStream();
237
  CompressionError SetParams(int key, uint32_t value);
238
  CompressionError GetErrorInfo() const;
239
240
  SET_MEMORY_INFO_NAME(BrotliDecoderContext)
241
  SET_SELF_SIZE(BrotliDecoderContext)
242
  SET_NO_MEMORY_INFO()  // state_ is covered through allocation tracking.
243
244
 private:
245
  BrotliDecoderResult last_result_ = BROTLI_DECODER_RESULT_SUCCESS;
246
  BrotliDecoderErrorCode error_ = BROTLI_DECODER_NO_ERROR;
247
  std::string error_string_;
248
  DeleteFnPtr<BrotliDecoderState, BrotliDecoderDestroyInstance> state_;
249
};
250
251
template <typename CompressionContext>
252
class CompressionStream : public AsyncWrap, public ThreadPoolWork {
253
 public:
254
  enum InternalFields {
255
    kCompressionStreamBaseField = AsyncWrap::kInternalFieldCount,
256
    kWriteJSCallback,
257
    kInternalFieldCount
258
  };
259
260
1451
  CompressionStream(Environment* env, Local<Object> wrap)
261
      : AsyncWrap(env, wrap, AsyncWrap::PROVIDER_ZLIB),
262
        ThreadPoolWork(env),
263
1451
        write_result_(nullptr) {
264
1451
    MakeWeak();
265
1451
  }
266
267
1331
  ~CompressionStream() override {
268

1331
    CHECK(!write_in_progress_);
269
1331
    Close();
270

1331
    CHECK_EQ(zlib_memory_, 0);
271

1331
    CHECK_EQ(unreported_allocations_, 0);
272
2662
  }
273
274
2520
  void Close() {
275

2520
    if (write_in_progress_) {
276
30
      pending_close_ = true;
277
30
      return;
278
    }
279
280
2490
    pending_close_ = false;
281
2490
    closed_ = true;
282

2490
    CHECK(init_done_ && "close before init");
283
284
4980
    AllocScope alloc_scope(this);
285
2490
    ctx_.Close();
286
  }
287
288
289
1159
  static void Close(const FunctionCallbackInfo<Value>& args) {
290
    CompressionStream* ctx;
291

1159
    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
292
1159
    ctx->Close();
293
  }
294
295
296
  // write(flush, in, in_off, in_len, out, out_off, out_len)
297
  template <bool async>
298
9031
  static void Write(const FunctionCallbackInfo<Value>& args) {
299
9031
    Environment* env = Environment::GetCurrent(args);
300
9031
    Local<Context> context = env->context();
301



9031
    CHECK_EQ(args.Length(), 7);
302
303
    uint32_t in_off, in_len, out_off, out_len, flush;
304
    const char* in;
305
    char* out;
306
307






27093
    CHECK_EQ(false, args[0]->IsUndefined() && "must provide flush value");
308



27093
    if (!args[0]->Uint32Value(context).To(&flush)) return;
309
310






13247
    if (flush != Z_NO_FLUSH &&
311



7954
        flush != Z_PARTIAL_FLUSH &&
312



7234
        flush != Z_SYNC_FLUSH &&
313



4559
        flush != Z_FULL_FLUSH &&
314



1063
        flush != Z_FINISH &&
315
        flush != Z_BLOCK) {
316
      CHECK(0 && "Invalid flush value");
317
    }
318
319



27093
    if (args[1]->IsNull()) {
320
      // just a flush
321
      in = nullptr;
322
      in_len = 0;
323
      in_off = 0;
324
    } else {
325



9031
      CHECK(Buffer::HasInstance(args[1]));
326
18062
      Local<Object> in_buf = args[1].As<Object>();
327



27093
      if (!args[2]->Uint32Value(context).To(&in_off)) return;
328



27093
      if (!args[3]->Uint32Value(context).To(&in_len)) return;
329
330



9031
      CHECK(Buffer::IsWithinBounds(in_off, in_len, Buffer::Length(in_buf)));
331
9031
      in = Buffer::Data(in_buf) + in_off;
332
    }
333
334



9031
    CHECK(Buffer::HasInstance(args[4]));
335
18062
    Local<Object> out_buf = args[4].As<Object>();
336



27093
    if (!args[5]->Uint32Value(context).To(&out_off)) return;
337



27093
    if (!args[6]->Uint32Value(context).To(&out_len)) return;
338



9031
    CHECK(Buffer::IsWithinBounds(out_off, out_len, Buffer::Length(out_buf)));
339
9031
    out = Buffer::Data(out_buf) + out_off;
340
341
    CompressionStream* ctx;
342



9031
    ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
343
344
9031
    ctx->Write<async>(flush, in, in_len, out, out_len);
345
  }
346
347
  template <bool async>
348
9031
  void Write(uint32_t flush,
349
             const char* in, uint32_t in_len,
350
             char* out, uint32_t out_len) {
351
16743
    AllocScope alloc_scope(this);
352
353



9031
    CHECK(init_done_ && "write before init");
354



9031
    CHECK(!closed_ && "already finalized");
355
356



9031
    CHECK_EQ(false, write_in_progress_);
357



9031
    CHECK_EQ(false, pending_close_);
358
9031
    write_in_progress_ = true;
359
9031
    Ref();
360
361
9031
    ctx_.SetBuffers(in, in_len, out, out_len);
362
9031
    ctx_.SetFlush(flush);
363
364
    if constexpr (!async) {
365
      // sync version
366
1319
      AsyncWrap::env()->PrintSyncTrace();
367
1319
      DoThreadPoolWork();
368

1319
      if (CheckError()) {
369
1313
        UpdateWriteResult();
370
1313
        write_in_progress_ = false;
371
      }
372
1319
      Unref();
373

1319
      return;
374
    }
375
376
    // async version
377
7712
    ScheduleWork();
378
7712
  }
379
380
9008
  void UpdateWriteResult() {
381
9008
    ctx_.GetAfterWriteOffsets(&write_result_[1], &write_result_[0]);
382
9008
  }
383
384
  // thread pool!
385
  // This function may be called multiple times on the uv_work pool
386
  // for a single write() call, until all of the input bytes have
387
  // been consumed.
388
9031
  void DoThreadPoolWork() override {
389
9031
    ctx_.DoThreadPoolWork();
390
9031
  }
391
392
393
9031
  bool CheckError() {
394
9031
    const CompressionError err = ctx_.GetErrorInfo();
395

9031
    if (!err.IsError()) return true;
396
23
    EmitError(err);
397
23
    return false;
398
  }
399
400
401
  // v8 land!
402
7712
  void AfterThreadPoolWork(int status) override {
403
    DCHECK(init_done_);
404
15407
    AllocScope alloc_scope(this);
405

23119
    auto on_scope_leave = OnScopeLeave([&]() { Unref(); });
406
407
7712
    write_in_progress_ = false;
408
409

7712
    if (status == UV_ECANCELED) {
410
      Close();
411
      return;
412
    }
413
414

7712
    CHECK_EQ(status, 0);
415
416
7712
    Environment* env = AsyncWrap::env();
417

15407
    HandleScope handle_scope(env->isolate());
418

15407
    Context::Scope context_scope(env->context());
419
420

7712
    if (!CheckError())
421
17
      return;
422
423
7695
    UpdateWriteResult();
424
425
    // call the write() cb
426
23085
    Local<Value> cb = object()->GetInternalField(kWriteJSCallback);
427
15390
    MakeCallback(cb.As<Function>(), 0, nullptr);
428
429

7695
    if (pending_close_)
430
23
      Close();
431
  }
432
433
  // TODO(addaleax): Switch to modern error system (node_errors.h).
434
24
  void EmitError(const CompressionError& err) {
435
24
    Environment* env = AsyncWrap::env();
436
    // If you hit this assertion, you forgot to enter the v8::Context first.
437

48
    CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
438
439
48
    HandleScope scope(env->isolate());
440
168
    Local<Value> args[] = {
441
24
      OneByteString(env->isolate(), err.message),
442
24
      Integer::New(env->isolate(), err.err),
443
24
      OneByteString(env->isolate(), err.code)
444
    };
445
24
    MakeCallback(env->onerror_string(), arraysize(args), args);
446
447
    // no hope of rescue.
448
24
    write_in_progress_ = false;
449

24
    if (pending_close_)
450
7
      Close();
451
24
  }
452
453
14
  static void Reset(const FunctionCallbackInfo<Value> &args) {
454
    CompressionStream* wrap;
455

14
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
456
457
28
    AllocScope alloc_scope(wrap);
458
14
    const CompressionError err = wrap->context()->ResetStream();
459

14
    if (err.IsError())
460
      wrap->EmitError(err);
461
  }
462
463
  void MemoryInfo(MemoryTracker* tracker) const override {
464
    tracker->TrackField("compression context", ctx_);
465
    tracker->TrackFieldWithSize("zlib_memory",
466
                                zlib_memory_ + unreported_allocations_);
467
  }
468
469
 protected:
470
4152
  CompressionContext* context() { return &ctx_; }
471
472
1451
  void InitStream(uint32_t* write_result, Local<Function> write_js_callback) {
473
1451
    write_result_ = write_result;
474
4353
    object()->SetInternalField(kWriteJSCallback, write_js_callback);
475
1451
    init_done_ = true;
476
1451
  }
477
478
  // Allocation functions provided to zlib itself. We store the real size of
479
  // the allocated memory chunk just before the "payload" memory we return
480
  // to zlib.
481
  // Because we use zlib off the thread pool, we can not report memory directly
482
  // to V8; rather, we first store it as "unreported" memory in a separate
483
  // field and later report it back from the main thread.
484
3071
  static void* AllocForZlib(void* data, uInt items, uInt size) {
485
3071
    size_t real_size =
486
3071
        MultiplyWithOverflowCheck(static_cast<size_t>(items),
487
                                  static_cast<size_t>(size));
488
3071
    return AllocForBrotli(data, real_size);
489
  }
490
491
8841
  static void* AllocForBrotli(void* data, size_t size) {
492
8841
    size += sizeof(size_t);
493
8841
    CompressionStream* ctx = static_cast<CompressionStream*>(data);
494
8841
    char* memory = UncheckedMalloc(size);
495

8841
    if (UNLIKELY(memory == nullptr)) return nullptr;
496
8841
    *reinterpret_cast<size_t*>(memory) = size;
497
8841
    ctx->unreported_allocations_.fetch_add(size,
498
                                           std::memory_order_relaxed);
499
8841
    return memory + sizeof(size_t);
500
  }
501
502
11142
  static void FreeForZlib(void* data, void* pointer) {
503

11142
    if (UNLIKELY(pointer == nullptr)) return;
504
8646
    CompressionStream* ctx = static_cast<CompressionStream*>(data);
505
8646
    char* real_pointer = static_cast<char*>(pointer) - sizeof(size_t);
506
8646
    size_t real_size = *reinterpret_cast<size_t*>(real_pointer);
507
8646
    ctx->unreported_allocations_.fetch_sub(real_size,
508
                                           std::memory_order_relaxed);
509
8646
    free(real_pointer);
510
  }
511
512
  // This is called on the main thread after zlib may have allocated something
513
  // in order to report it back to V8.
514
20701
  void AdjustAmountOfExternalAllocatedMemory() {
515
20701
    ssize_t report =
516
20701
        unreported_allocations_.exchange(0, std::memory_order_relaxed);
517

20701
    if (report == 0) return;
518



2782
    CHECK_IMPLIES(report < 0, zlib_memory_ >= static_cast<size_t>(-report));
519
2782
    zlib_memory_ += report;
520
2782
    AsyncWrap::env()->isolate()->AdjustAmountOfExternalAllocatedMemory(report);
521
  }
522
523
  struct AllocScope {
524
20701
    explicit AllocScope(CompressionStream* stream) : stream(stream) {}
525
20701
    ~AllocScope() { stream->AdjustAmountOfExternalAllocatedMemory(); }
526
    CompressionStream* stream;
527
  };
528
529
 private:
530
9031
  void Ref() {
531

9031
    if (++refs_ == 1) {
532
2031
      ClearWeak();
533
    }
534
9031
  }
535
536
9031
  void Unref() {
537

9031
    CHECK_GT(refs_, 0);
538

9031
    if (--refs_ == 0) {
539
2031
      MakeWeak();
540
    }
541
9031
  }
542
543
  bool init_done_ = false;
544
  bool write_in_progress_ = false;
545
  bool pending_close_ = false;
546
  bool closed_ = false;
547
  unsigned int refs_ = 0;
548
  uint32_t* write_result_ = nullptr;
549
  std::atomic<ssize_t> unreported_allocations_{0};
550
  size_t zlib_memory_ = 0;
551
552
  CompressionContext ctx_;
553
};
554
555
2200
class ZlibStream final : public CompressionStream<ZlibContext> {
556
 public:
557
1220
  ZlibStream(Environment* env, Local<Object> wrap, node_zlib_mode mode)
558
1220
    : CompressionStream(env, wrap) {
559
1220
    context()->SetMode(mode);
560
1220
  }
561
562
1220
  static void New(const FunctionCallbackInfo<Value>& args) {
563
1220
    Environment* env = Environment::GetCurrent(args);
564
2440
    CHECK(args[0]->IsInt32());
565
    node_zlib_mode mode =
566
3660
        static_cast<node_zlib_mode>(args[0].As<Int32>()->Value());
567
1220
    new ZlibStream(env, args.This(), mode);
568
1220
  }
569
570
  // just pull the ints out of the args and call the other Init
571
1220
  static void Init(const FunctionCallbackInfo<Value>& args) {
572
    // Refs: https://github.com/nodejs/node/issues/16649
573
    // Refs: https://github.com/nodejs/node/issues/14161
574
1220
    if (args.Length() == 5) {
575
      fprintf(stderr,
576
          "WARNING: You are likely using a version of node-tar or npm that "
577
          "is incompatible with this version of Node.js.\nPlease use "
578
          "either the version of npm that is bundled with Node.js, or "
579
          "a version of npm (> 5.5.1 or < 5.4.0) or node-tar (> 4.0.1) "
580
          "that is compatible with Node.js 9 and above.\n");
581
    }
582

1220
    CHECK(args.Length() == 7 &&
583
      "init(windowBits, level, memLevel, strategy, writeResult, writeCallback,"
584
      " dictionary)");
585
586
    ZlibStream* wrap;
587
1220
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
588
589
1220
    Local<Context> context = args.GetIsolate()->GetCurrentContext();
590
591
    // windowBits is special. On the compression side, 0 is an invalid value.
592
    // But on the decompression side, a value of 0 for windowBits tells zlib
593
    // to use the window size in the zlib header of the compressed stream.
594
    uint32_t window_bits;
595
3660
    if (!args[0]->Uint32Value(context).To(&window_bits)) return;
596
597
    int32_t level;
598
3660
    if (!args[1]->Int32Value(context).To(&level)) return;
599
600
    uint32_t mem_level;
601
3660
    if (!args[2]->Uint32Value(context).To(&mem_level)) return;
602
603
    uint32_t strategy;
604
3660
    if (!args[3]->Uint32Value(context).To(&strategy)) return;
605
606
2440
    CHECK(args[4]->IsUint32Array());
607
2440
    Local<Uint32Array> array = args[4].As<Uint32Array>();
608
1220
    Local<ArrayBuffer> ab = array->Buffer();
609
1220
    uint32_t* write_result = static_cast<uint32_t*>(ab->Data());
610
611
2440
    CHECK(args[5]->IsFunction());
612
2440
    Local<Function> write_js_callback = args[5].As<Function>();
613
614
2440
    std::vector<unsigned char> dictionary;
615
1220
    if (Buffer::HasInstance(args[6])) {
616
      unsigned char* data =
617
51
          reinterpret_cast<unsigned char*>(Buffer::Data(args[6]));
618
102
      dictionary = std::vector<unsigned char>(
619
          data,
620
51
          data + Buffer::Length(args[6]));
621
    }
622
623
1220
    wrap->InitStream(write_result, write_js_callback);
624
625
2440
    AllocScope alloc_scope(wrap);
626
1220
    wrap->context()->SetAllocationFunctions(
627
        AllocForZlib, FreeForZlib, static_cast<CompressionStream*>(wrap));
628
2440
    wrap->context()->Init(level, window_bits, mem_level, strategy,
629
1220
                          std::move(dictionary));
630
  }
631
632
3
  static void Params(const FunctionCallbackInfo<Value>& args) {
633

3
    CHECK(args.Length() == 2 && "params(level, strategy)");
634
    ZlibStream* wrap;
635
3
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
636
3
    Local<Context> context = args.GetIsolate()->GetCurrentContext();
637
    int level;
638
9
    if (!args[0]->Int32Value(context).To(&level)) return;
639
    int strategy;
640
9
    if (!args[1]->Int32Value(context).To(&strategy)) return;
641
642
6
    AllocScope alloc_scope(wrap);
643
3
    const CompressionError err = wrap->context()->SetParams(level, strategy);
644
3
    if (err.IsError())
645
      wrap->EmitError(err);
646
  }
647
648
  SET_MEMORY_INFO_NAME(ZlibStream)
649
  SET_SELF_SIZE(ZlibStream)
650
};
651
652
template <typename CompressionContext>
653
462
class BrotliCompressionStream final :
654
  public CompressionStream<CompressionContext> {
655
 public:
656
231
  BrotliCompressionStream(Environment* env,
657
                          Local<Object> wrap,
658
                          node_zlib_mode mode)
659
231
    : CompressionStream<CompressionContext>(env, wrap) {
660
231
    context()->SetMode(mode);
661
231
  }
662
663
475
  inline CompressionContext* context() {
664
475
    return this->CompressionStream<CompressionContext>::context();
665
  }
666
  typedef typename CompressionStream<CompressionContext>::AllocScope AllocScope;
667
668
231
  static void New(const FunctionCallbackInfo<Value>& args) {
669
231
    Environment* env = Environment::GetCurrent(args);
670

462
    CHECK(args[0]->IsInt32());
671
231
    node_zlib_mode mode =
672
924
        static_cast<node_zlib_mode>(args[0].As<Int32>()->Value());
673
231
    new BrotliCompressionStream(env, args.This(), mode);
674
231
  }
675
676
231
  static void Init(const FunctionCallbackInfo<Value>& args) {
677
    BrotliCompressionStream* wrap;
678

232
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
679


231
    CHECK(args.Length() == 3 && "init(params, writeResult, writeCallback)");
680
681

462
    CHECK(args[1]->IsUint32Array());
682
231
    uint32_t* write_result = reinterpret_cast<uint32_t*>(Buffer::Data(args[1]));
683
684

462
    CHECK(args[2]->IsFunction());
685
462
    Local<Function> write_js_callback = args[2].As<Function>();
686
231
    wrap->InitStream(write_result, write_js_callback);
687
688
461
    AllocScope alloc_scope(wrap);
689
231
    CompressionError err =
690
        wrap->context()->Init(
691
          CompressionStream<CompressionContext>::AllocForBrotli,
692
          CompressionStream<CompressionContext>::FreeForZlib,
693
          static_cast<CompressionStream<CompressionContext>*>(wrap));
694

231
    if (err.IsError()) {
695
      wrap->EmitError(err);
696
      args.GetReturnValue().Set(false);
697
      return;
698
    }
699
700

462
    CHECK(args[0]->IsUint32Array());
701
231
    const uint32_t* data = reinterpret_cast<uint32_t*>(Buffer::Data(args[0]));
702
693
    size_t len = args[0].As<Uint32Array>()->Length();
703
704

2305
    for (int i = 0; static_cast<size_t>(i) < len; i++) {
705

2075
      if (data[i] == static_cast<uint32_t>(-1))
706
2062
        continue;
707
13
      err = wrap->context()->SetParams(i, data[i]);
708

13
      if (err.IsError()) {
709
1
        wrap->EmitError(err);
710
2
        args.GetReturnValue().Set(false);
711
1
        return;
712
      }
713
    }
714
715

460
    args.GetReturnValue().Set(true);
716
  }
717
718
  static void Params(const FunctionCallbackInfo<Value>& args) {
719
    // Currently a no-op, and not accessed from JS land.
720
    // At some point Brotli may support changing parameters on the fly,
721
    // in which case we can implement this and a JS equivalent similar to
722
    // the zlib Params() function.
723
  }
724
725
  SET_MEMORY_INFO_NAME(BrotliCompressionStream)
726
  SET_SELF_SIZE(BrotliCompressionStream)
727
};
728
729
using BrotliEncoderStream = BrotliCompressionStream<BrotliEncoderContext>;
730
using BrotliDecoderStream = BrotliCompressionStream<BrotliDecoderContext>;
731
732
2034
void ZlibContext::Close() {
733
  {
734
3914
    Mutex::ScopedLock lock(mutex_);
735
2034
    if (!zlib_init_done_) {
736
154
      dictionary_.clear();
737
154
      mode_ = NONE;
738
154
      return;
739
    }
740
  }
741
742
1880
  CHECK_LE(mode_, UNZIP);
743
744
1880
  int status = Z_OK;
745

1880
  if (mode_ == DEFLATE || mode_ == GZIP || mode_ == DEFLATERAW) {
746
453
    status = deflateEnd(&strm_);
747


2359
  } else if (mode_ == INFLATE || mode_ == GUNZIP || mode_ == INFLATERAW ||
748
932
             mode_ == UNZIP) {
749
495
    status = inflateEnd(&strm_);
750
  }
751
752

1880
  CHECK(status == Z_OK || status == Z_DATA_ERROR);
753
1880
  mode_ = NONE;
754
755
1880
  dictionary_.clear();
756
}
757
758
759
7656
void ZlibContext::DoThreadPoolWork() {
760
7656
  bool first_init_call = InitZlib();
761

7656
  if (first_init_call && err_ != Z_OK) {
762
    return;
763
  }
764
765
7656
  const Bytef* next_expected_header_byte = nullptr;
766
767
  // If the avail_out is left at 0, then it means that it ran out
768
  // of room.  If there was avail_out left over, then it means
769
  // that all of the input was consumed.
770

7656
  switch (mode_) {
771
1523
    case DEFLATE:
772
    case GZIP:
773
    case DEFLATERAW:
774
1523
      err_ = deflate(&strm_, flush_);
775
1523
      break;
776
232
    case UNZIP:
777
232
      if (strm_.avail_in > 0) {
778
231
        next_expected_header_byte = strm_.next_in;
779
      }
780
781
232
      switch (gzip_id_bytes_read_) {
782
229
        case 0:
783
229
          if (next_expected_header_byte == nullptr) {
784
            break;
785
          }
786
787
229
          if (*next_expected_header_byte == GZIP_HEADER_ID1) {
788
223
            gzip_id_bytes_read_ = 1;
789
223
            next_expected_header_byte++;
790
791
223
            if (strm_.avail_in == 1) {
792
              // The only available byte was already read.
793
2
              break;
794
            }
795
          } else {
796
6
            mode_ = INFLATE;
797
6
            break;
798
          }
799
800
          // fallthrough
801
        case 1:
802
224
          if (next_expected_header_byte == nullptr) {
803
1
            break;
804
          }
805
806
223
          if (*next_expected_header_byte == GZIP_HEADER_ID2) {
807
223
            gzip_id_bytes_read_ = 2;
808
223
            mode_ = GUNZIP;
809
          } else {
810
            // There is no actual difference between INFLATE and INFLATERAW
811
            // (after initialization).
812
            mode_ = INFLATE;
813
          }
814
815
223
          break;
816
        default:
817
          CHECK(0 && "invalid number of gzip magic number bytes read");
818
6133
      }
819
820
      // fallthrough
821
    case INFLATE:
822
    case GUNZIP:
823
    case INFLATERAW:
824
6133
      err_ = inflate(&strm_, flush_);
825
826
      // If data was encoded with dictionary (INFLATERAW will have it set in
827
      // SetDictionary, don't repeat that here)
828

16741
      if (mode_ != INFLATERAW &&
829

6147
          err_ == Z_NEED_DICT &&
830
14
          !dictionary_.empty()) {
831
        // Load it
832
26
        err_ = inflateSetDictionary(&strm_,
833
13
                                    dictionary_.data(),
834
13
                                    dictionary_.size());
835
13
        if (err_ == Z_OK) {
836
          // And try to decode again
837
12
          err_ = inflate(&strm_, flush_);
838
1
        } else if (err_ == Z_DATA_ERROR) {
839
          // Both inflateSetDictionary() and inflate() return Z_DATA_ERROR.
840
          // Make it possible for After() to tell a bad dictionary from bad
841
          // input.
842
1
          err_ = Z_NEED_DICT;
843
        }
844
      }
845
846
6811
      while (strm_.avail_in > 0 &&
847
1232
             mode_ == GUNZIP &&
848

6769
             err_ == Z_STREAM_END &&
849
22
             strm_.next_in[0] != 0x00) {
850
        // Bytes remain in input buffer. Perhaps this is another compressed
851
        // member in the same archive, or just trailing garbage.
852
        // Trailing zero bytes are okay, though, since they are frequently
853
        // used for padding.
854
855
20
        ResetStream();
856
20
        err_ = inflate(&strm_, flush_);
857
      }
858
6133
      break;
859
    default:
860
      UNREACHABLE();
861
  }
862
}
863
864
865
7656
void ZlibContext::SetBuffers(const char* in, uint32_t in_len,
866
                             char* out, uint32_t out_len) {
867
7656
  strm_.avail_in = in_len;
868
7656
  strm_.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(in));
869
7656
  strm_.avail_out = out_len;
870
7656
  strm_.next_out = reinterpret_cast<Bytef*>(out);
871
7656
}
872
873
874
7656
void ZlibContext::SetFlush(int flush) {
875
7656
  flush_ = flush;
876
7656
}
877
878
879
7634
void ZlibContext::GetAfterWriteOffsets(uint32_t* avail_in,
880
                                       uint32_t* avail_out) const {
881
7634
  *avail_in = strm_.avail_in;
882
7634
  *avail_out = strm_.avail_out;
883
7634
}
884
885
886
22
CompressionError ZlibContext::ErrorForMessage(const char* message) const {
887
22
  if (strm_.msg != nullptr)
888
12
    message = strm_.msg;
889
890
22
  return CompressionError { message, ZlibStrerror(err_), err_ };
891
}
892
893
894
7656
CompressionError ZlibContext::GetErrorInfo() const {
895
  // Acceptable error states depend on the type of zlib stream.
896

7656
  switch (err_) {
897
6178
  case Z_OK:
898
  case Z_BUF_ERROR:
899

6178
    if (strm_.avail_out != 0 && flush_ == Z_FINISH) {
900
8
      return ErrorForMessage("unexpected end of file");
901
    }
902
  case Z_STREAM_END:
903
    // normal statuses, not fatal
904
7634
    break;
905
2
  case Z_NEED_DICT:
906
2
    if (dictionary_.empty())
907
1
      return ErrorForMessage("Missing dictionary");
908
    else
909
1
      return ErrorForMessage("Bad dictionary");
910
12
  default:
911
    // something else.
912
12
    return ErrorForMessage("Zlib error");
913
  }
914
915
7634
  return CompressionError {};
916
}
917
918
919
34
CompressionError ZlibContext::ResetStream() {
920
34
  bool first_init_call = InitZlib();
921

34
  if (first_init_call && err_ != Z_OK) {
922
    return ErrorForMessage("Failed to init stream before reset");
923
  }
924
925
34
  err_ = Z_OK;
926
927
34
  switch (mode_) {
928
13
    case DEFLATE:
929
    case DEFLATERAW:
930
    case GZIP:
931
13
      err_ = deflateReset(&strm_);
932
13
      break;
933
21
    case INFLATE:
934
    case INFLATERAW:
935
    case GUNZIP:
936
21
      err_ = inflateReset(&strm_);
937
21
      break;
938
    default:
939
      break;
940
  }
941
942
34
  if (err_ != Z_OK)
943
    return ErrorForMessage("Failed to reset stream");
944
945
34
  return SetDictionary();
946
}
947
948
949
1220
void ZlibContext::SetAllocationFunctions(alloc_func alloc,
950
                                         free_func free,
951
                                         void* opaque) {
952
1220
  strm_.zalloc = alloc;
953
1220
  strm_.zfree = free;
954
1220
  strm_.opaque = opaque;
955
1220
}
956
957
958
1220
void ZlibContext::Init(
959
    int level, int window_bits, int mem_level, int strategy,
960
    std::vector<unsigned char>&& dictionary) {
961

1610
  if (!((window_bits == 0) &&
962
685
        (mode_ == INFLATE ||
963
499
         mode_ == GUNZIP ||
964
204
         mode_ == UNZIP))) {
965

830
    CHECK(
966
        (window_bits >= Z_MIN_WINDOWBITS && window_bits <= Z_MAX_WINDOWBITS) &&
967
        "invalid windowBits");
968
  }
969
970

1220
  CHECK((level >= Z_MIN_LEVEL && level <= Z_MAX_LEVEL) &&
971
    "invalid compression level");
972
973

1220
  CHECK((mem_level >= Z_MIN_MEMLEVEL && mem_level <= Z_MAX_MEMLEVEL) &&
974
        "invalid memlevel");
975
976




1220
  CHECK((strategy == Z_FILTERED || strategy == Z_HUFFMAN_ONLY ||
977
         strategy == Z_RLE || strategy == Z_FIXED ||
978
         strategy == Z_DEFAULT_STRATEGY) &&
979
        "invalid strategy");
980
981
1220
  level_ = level;
982
1220
  window_bits_ = window_bits;
983
1220
  mem_level_ = mem_level;
984
1220
  strategy_ = strategy;
985
986
1220
  flush_ = Z_NO_FLUSH;
987
988
1220
  err_ = Z_OK;
989
990

1220
  if (mode_ == GZIP || mode_ == GUNZIP) {
991
468
    window_bits_ += 16;
992
  }
993
994
1220
  if (mode_ == UNZIP) {
995
230
    window_bits_ += 32;
996
  }
997
998

1220
  if (mode_ == DEFLATERAW || mode_ == INFLATERAW) {
999
243
    window_bits_ *= -1;
1000
  }
1001
1002
1220
  dictionary_ = std::move(dictionary);
1003
1220
}
1004
1005
7693
bool ZlibContext::InitZlib() {
1006
15386
  Mutex::ScopedLock lock(mutex_);
1007
7693
  if (zlib_init_done_) {
1008
6625
    return false;
1009
  }
1010
1011
1068
  switch (mode_) {
1012
453
    case DEFLATE:
1013
    case GZIP:
1014
    case DEFLATERAW:
1015
453
      err_ = deflateInit2(&strm_,
1016
                          level_,
1017
                          Z_DEFLATED,
1018
                          window_bits_,
1019
                          mem_level_,
1020
                          strategy_);
1021
453
      break;
1022
615
    case INFLATE:
1023
    case GUNZIP:
1024
    case INFLATERAW:
1025
    case UNZIP:
1026
615
      err_ = inflateInit2(&strm_, window_bits_);
1027
615
      break;
1028
    default:
1029
      UNREACHABLE();
1030
  }
1031
1032
1068
  if (err_ != Z_OK) {
1033
    dictionary_.clear();
1034
    mode_ = NONE;
1035
    return true;
1036
  }
1037
1038
1068
  SetDictionary();
1039
1068
  zlib_init_done_ = true;
1040
1068
  return true;
1041
}
1042
1043
1044
1102
CompressionError ZlibContext::SetDictionary() {
1045
1102
  if (dictionary_.empty())
1046
1040
    return CompressionError {};
1047
1048
62
  err_ = Z_OK;
1049
1050
62
  switch (mode_) {
1051
36
    case DEFLATE:
1052
    case DEFLATERAW:
1053
72
      err_ = deflateSetDictionary(&strm_,
1054
36
                                  dictionary_.data(),
1055
36
                                  dictionary_.size());
1056
36
      break;
1057
13
    case INFLATERAW:
1058
      // The other inflate cases will have the dictionary set when inflate()
1059
      // returns Z_NEED_DICT in Process()
1060
26
      err_ = inflateSetDictionary(&strm_,
1061
13
                                  dictionary_.data(),
1062
13
                                  dictionary_.size());
1063
13
      break;
1064
13
    default:
1065
13
      break;
1066
  }
1067
1068
62
  if (err_ != Z_OK) {
1069
    return ErrorForMessage("Failed to set dictionary");
1070
  }
1071
1072
62
  return CompressionError {};
1073
}
1074
1075
1076
3
CompressionError ZlibContext::SetParams(int level, int strategy) {
1077
3
  bool first_init_call = InitZlib();
1078

3
  if (first_init_call && err_ != Z_OK) {
1079
    return ErrorForMessage("Failed to init stream before set parameters");
1080
  }
1081
1082
3
  err_ = Z_OK;
1083
1084
3
  switch (mode_) {
1085
2
    case DEFLATE:
1086
    case DEFLATERAW:
1087
2
      err_ = deflateParams(&strm_, level, strategy);
1088
2
      break;
1089
1
    default:
1090
1
      break;
1091
  }
1092
1093

3
  if (err_ != Z_OK && err_ != Z_BUF_ERROR) {
1094
    return ErrorForMessage("Failed to set parameters");
1095
  }
1096
1097
3
  return CompressionError {};
1098
}
1099
1100
1101
1375
void BrotliContext::SetBuffers(const char* in, uint32_t in_len,
1102
                               char* out, uint32_t out_len) {
1103
1375
  next_in_ = reinterpret_cast<const uint8_t*>(in);
1104
1375
  next_out_ = reinterpret_cast<uint8_t*>(out);
1105
1375
  avail_in_ = in_len;
1106
1375
  avail_out_ = out_len;
1107
1375
}
1108
1109
1110
1375
void BrotliContext::SetFlush(int flush) {
1111
1375
  flush_ = static_cast<BrotliEncoderOperation>(flush);
1112
1375
}
1113
1114
1115
1374
void BrotliContext::GetAfterWriteOffsets(uint32_t* avail_in,
1116
                                         uint32_t* avail_out) const {
1117
1374
  *avail_in = avail_in_;
1118
1374
  *avail_out = avail_out_;
1119
1374
}
1120
1121
1122
349
void BrotliEncoderContext::DoThreadPoolWork() {
1123
349
  CHECK_EQ(mode_, BROTLI_ENCODE);
1124
349
  CHECK(state_);
1125
349
  const uint8_t* next_in = next_in_;
1126
698
  last_result_ = BrotliEncoderCompressStream(state_.get(),
1127
                                             flush_,
1128
                                             &avail_in_,
1129
                                             &next_in,
1130
                                             &avail_out_,
1131
                                             &next_out_,
1132
349
                                             nullptr);
1133
349
  next_in_ += next_in - next_in_;
1134
349
}
1135
1136
1137
230
void BrotliEncoderContext::Close() {
1138
230
  state_.reset();
1139
230
  mode_ = NONE;
1140
230
}
1141
1142
117
CompressionError BrotliEncoderContext::Init(brotli_alloc_func alloc,
1143
                                            brotli_free_func free,
1144
                                            void* opaque) {
1145
117
  alloc_ = alloc;
1146
117
  free_ = free;
1147
117
  alloc_opaque_ = opaque;
1148
117
  state_.reset(BrotliEncoderCreateInstance(alloc, free, opaque));
1149
117
  if (!state_) {
1150
    return CompressionError("Could not initialize Brotli instance",
1151
                            "ERR_ZLIB_INITIALIZATION_FAILED",
1152
                            -1);
1153
  } else {
1154
117
    return CompressionError {};
1155
  }
1156
}
1157
1158
CompressionError BrotliEncoderContext::ResetStream() {
1159
  return Init(alloc_, free_, alloc_opaque_);
1160
}
1161
1162
13
CompressionError BrotliEncoderContext::SetParams(int key, uint32_t value) {
1163
13
  if (!BrotliEncoderSetParameter(state_.get(),
1164
                                 static_cast<BrotliEncoderParameter>(key),
1165
                                 value)) {
1166
    return CompressionError("Setting parameter failed",
1167
                            "ERR_BROTLI_PARAM_SET_FAILED",
1168
1
                            -1);
1169
  } else {
1170
12
    return CompressionError {};
1171
  }
1172
}
1173
1174
349
CompressionError BrotliEncoderContext::GetErrorInfo() const {
1175
349
  if (!last_result_) {
1176
    return CompressionError("Compression failed",
1177
                            "ERR_BROTLI_COMPRESSION_FAILED",
1178
                            -1);
1179
  } else {
1180
349
    return CompressionError {};
1181
  }
1182
}
1183
1184
1185
226
void BrotliDecoderContext::Close() {
1186
226
  state_.reset();
1187
226
  mode_ = NONE;
1188
226
}
1189
1190
1026
void BrotliDecoderContext::DoThreadPoolWork() {
1191
1026
  CHECK_EQ(mode_, BROTLI_DECODE);
1192
1026
  CHECK(state_);
1193
1026
  const uint8_t* next_in = next_in_;
1194
1026
  last_result_ = BrotliDecoderDecompressStream(state_.get(),
1195
                                               &avail_in_,
1196
                                               &next_in,
1197
                                               &avail_out_,
1198
                                               &next_out_,
1199
                                               nullptr);
1200
1026
  next_in_ += next_in - next_in_;
1201
1026
  if (last_result_ == BROTLI_DECODER_RESULT_ERROR) {
1202
1
    error_ = BrotliDecoderGetErrorCode(state_.get());
1203
1
    error_string_ = std::string("ERR_") + BrotliDecoderErrorString(error_);
1204
  }
1205
1026
}
1206
1207
114
CompressionError BrotliDecoderContext::Init(brotli_alloc_func alloc,
1208
                                            brotli_free_func free,
1209
                                            void* opaque) {
1210
114
  alloc_ = alloc;
1211
114
  free_ = free;
1212
114
  alloc_opaque_ = opaque;
1213
114
  state_.reset(BrotliDecoderCreateInstance(alloc, free, opaque));
1214
114
  if (!state_) {
1215
    return CompressionError("Could not initialize Brotli instance",
1216
                            "ERR_ZLIB_INITIALIZATION_FAILED",
1217
                            -1);
1218
  } else {
1219
114
    return CompressionError {};
1220
  }
1221
}
1222
1223
CompressionError BrotliDecoderContext::ResetStream() {
1224
  return Init(alloc_, free_, alloc_opaque_);
1225
}
1226
1227
CompressionError BrotliDecoderContext::SetParams(int key, uint32_t value) {
1228
  if (!BrotliDecoderSetParameter(state_.get(),
1229
                                 static_cast<BrotliDecoderParameter>(key),
1230
                                 value)) {
1231
    return CompressionError("Setting parameter failed",
1232
                            "ERR_BROTLI_PARAM_SET_FAILED",
1233
                            -1);
1234
  } else {
1235
    return CompressionError {};
1236
  }
1237
}
1238
1239
1026
CompressionError BrotliDecoderContext::GetErrorInfo() const {
1240
1026
  if (error_ != BROTLI_DECODER_NO_ERROR) {
1241
    return CompressionError("Decompression failed",
1242
                            error_string_.c_str(),
1243
1
                            static_cast<int>(error_));
1244

1135
  } else if (flush_ == BROTLI_OPERATION_FINISH &&
1245
110
             last_result_ == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
1246
    // Match zlib's behaviour, as brotli doesn't have its own code for this.
1247
    return CompressionError("unexpected end of file",
1248
                            "Z_BUF_ERROR",
1249
                            Z_BUF_ERROR);
1250
  } else {
1251
1025
    return CompressionError {};
1252
  }
1253
}
1254
1255
1256
template <typename Stream>
1257
struct MakeClass {
1258
216
  static void Make(Environment* env, Local<Object> target, const char* name) {
1259
216
    Isolate* isolate = env->isolate();
1260
216
    Local<FunctionTemplate> z = NewFunctionTemplate(isolate, Stream::New);
1261
1262
432
    z->InstanceTemplate()->SetInternalFieldCount(
1263
        Stream::kInternalFieldCount);
1264
216
    z->Inherit(AsyncWrap::GetConstructorTemplate(env));
1265
1266
216
    SetProtoMethod(isolate, z, "write", Stream::template Write<true>);
1267
216
    SetProtoMethod(isolate, z, "writeSync", Stream::template Write<false>);
1268
216
    SetProtoMethod(isolate, z, "close", Stream::Close);
1269
1270
216
    SetProtoMethod(isolate, z, "init", Stream::Init);
1271
216
    SetProtoMethod(isolate, z, "params", Stream::Params);
1272
216
    SetProtoMethod(isolate, z, "reset", Stream::Reset);
1273
1274
216
    SetConstructorFunction(env->context(), target, name, z);
1275
216
  }
1276
1277
16656
  static void Make(ExternalReferenceRegistry* registry) {
1278
16656
    registry->Register(Stream::New);
1279
16656
    registry->Register(Stream::template Write<true>);
1280
16656
    registry->Register(Stream::template Write<false>);
1281
16656
    registry->Register(Stream::Close);
1282
16656
    registry->Register(Stream::Init);
1283
16656
    registry->Register(Stream::Params);
1284
16656
    registry->Register(Stream::Reset);
1285
16656
  }
1286
};
1287
1288
72
void Initialize(Local<Object> target,
1289
                Local<Value> unused,
1290
                Local<Context> context,
1291
                void* priv) {
1292
72
  Environment* env = Environment::GetCurrent(context);
1293
1294
72
  MakeClass<ZlibStream>::Make(env, target, "Zlib");
1295
72
  MakeClass<BrotliEncoderStream>::Make(env, target, "BrotliEncoder");
1296
72
  MakeClass<BrotliDecoderStream>::Make(env, target, "BrotliDecoder");
1297
1298
144
  target->Set(env->context(),
1299
              FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"),
1300
288
              FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION)).Check();
1301
72
}
1302
1303
5552
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
1304
5552
  MakeClass<ZlibStream>::Make(registry);
1305
5552
  MakeClass<BrotliEncoderStream>::Make(registry);
1306
5552
  MakeClass<BrotliDecoderStream>::Make(registry);
1307
5552
}
1308
1309
}  // anonymous namespace
1310
1311
786
void DefineZlibConstants(Local<Object> target) {
1312
3930
  NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
1313
3930
  NODE_DEFINE_CONSTANT(target, Z_PARTIAL_FLUSH);
1314
3930
  NODE_DEFINE_CONSTANT(target, Z_SYNC_FLUSH);
1315
3930
  NODE_DEFINE_CONSTANT(target, Z_FULL_FLUSH);
1316
3930
  NODE_DEFINE_CONSTANT(target, Z_FINISH);
1317
3930
  NODE_DEFINE_CONSTANT(target, Z_BLOCK);
1318
1319
  // return/error codes
1320
3930
  NODE_DEFINE_CONSTANT(target, Z_OK);
1321
3930
  NODE_DEFINE_CONSTANT(target, Z_STREAM_END);
1322
3930
  NODE_DEFINE_CONSTANT(target, Z_NEED_DICT);
1323
3930
  NODE_DEFINE_CONSTANT(target, Z_ERRNO);
1324
3930
  NODE_DEFINE_CONSTANT(target, Z_STREAM_ERROR);
1325
3930
  NODE_DEFINE_CONSTANT(target, Z_DATA_ERROR);
1326
3930
  NODE_DEFINE_CONSTANT(target, Z_MEM_ERROR);
1327
3930
  NODE_DEFINE_CONSTANT(target, Z_BUF_ERROR);
1328
3930
  NODE_DEFINE_CONSTANT(target, Z_VERSION_ERROR);
1329
1330
3930
  NODE_DEFINE_CONSTANT(target, Z_NO_COMPRESSION);
1331
3930
  NODE_DEFINE_CONSTANT(target, Z_BEST_SPEED);
1332
3930
  NODE_DEFINE_CONSTANT(target, Z_BEST_COMPRESSION);
1333
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_COMPRESSION);
1334
3930
  NODE_DEFINE_CONSTANT(target, Z_FILTERED);
1335
3930
  NODE_DEFINE_CONSTANT(target, Z_HUFFMAN_ONLY);
1336
3930
  NODE_DEFINE_CONSTANT(target, Z_RLE);
1337
3930
  NODE_DEFINE_CONSTANT(target, Z_FIXED);
1338
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_STRATEGY);
1339
3930
  NODE_DEFINE_CONSTANT(target, ZLIB_VERNUM);
1340
1341
3930
  NODE_DEFINE_CONSTANT(target, DEFLATE);
1342
3930
  NODE_DEFINE_CONSTANT(target, INFLATE);
1343
3930
  NODE_DEFINE_CONSTANT(target, GZIP);
1344
3930
  NODE_DEFINE_CONSTANT(target, GUNZIP);
1345
3930
  NODE_DEFINE_CONSTANT(target, DEFLATERAW);
1346
3930
  NODE_DEFINE_CONSTANT(target, INFLATERAW);
1347
3930
  NODE_DEFINE_CONSTANT(target, UNZIP);
1348
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODE);
1349
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_ENCODE);
1350
1351
3930
  NODE_DEFINE_CONSTANT(target, Z_MIN_WINDOWBITS);
1352
3930
  NODE_DEFINE_CONSTANT(target, Z_MAX_WINDOWBITS);
1353
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_WINDOWBITS);
1354
3930
  NODE_DEFINE_CONSTANT(target, Z_MIN_CHUNK);
1355
3930
  NODE_DEFINE_CONSTANT(target, Z_MAX_CHUNK);
1356
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_CHUNK);
1357
3930
  NODE_DEFINE_CONSTANT(target, Z_MIN_MEMLEVEL);
1358
3930
  NODE_DEFINE_CONSTANT(target, Z_MAX_MEMLEVEL);
1359
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_MEMLEVEL);
1360
3930
  NODE_DEFINE_CONSTANT(target, Z_MIN_LEVEL);
1361
3930
  NODE_DEFINE_CONSTANT(target, Z_MAX_LEVEL);
1362
3930
  NODE_DEFINE_CONSTANT(target, Z_DEFAULT_LEVEL);
1363
1364
  // Brotli constants
1365
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_OPERATION_PROCESS);
1366
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_OPERATION_FLUSH);
1367
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_OPERATION_FINISH);
1368
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_OPERATION_EMIT_METADATA);
1369
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_MODE);
1370
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MODE_GENERIC);
1371
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MODE_TEXT);
1372
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MODE_FONT);
1373
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DEFAULT_MODE);
1374
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_QUALITY);
1375
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MIN_QUALITY);
1376
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MAX_QUALITY);
1377
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DEFAULT_QUALITY);
1378
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_LGWIN);
1379
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MIN_WINDOW_BITS);
1380
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MAX_WINDOW_BITS);
1381
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_LARGE_MAX_WINDOW_BITS);
1382
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DEFAULT_WINDOW);
1383
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_LGBLOCK);
1384
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MIN_INPUT_BLOCK_BITS);
1385
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_MAX_INPUT_BLOCK_BITS);
1386
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING);
1387
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_SIZE_HINT);
1388
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_LARGE_WINDOW);
1389
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_NPOSTFIX);
1390
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_PARAM_NDIRECT);
1391
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_RESULT_ERROR);
1392
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_RESULT_SUCCESS);
1393
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT);
1394
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
1395
3930
  NODE_DEFINE_CONSTANT(target,
1396
      BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION);
1397
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_PARAM_LARGE_WINDOW);
1398
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NO_ERROR);
1399
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_SUCCESS);
1400
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NEEDS_MORE_INPUT);
1401
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_NEEDS_MORE_OUTPUT);
1402
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE);
1403
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_RESERVED);
1404
3930
  NODE_DEFINE_CONSTANT(target,
1405
      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE);
1406
3930
  NODE_DEFINE_CONSTANT(target,
1407
      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET);
1408
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME);
1409
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_CL_SPACE);
1410
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE);
1411
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT);
1412
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1);
1413
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2);
1414
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_TRANSFORM);
1415
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_DICTIONARY);
1416
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS);
1417
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_PADDING_1);
1418
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_PADDING_2);
1419
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_FORMAT_DISTANCE);
1420
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET);
1421
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_INVALID_ARGUMENTS);
1422
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES);
1423
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS);
1424
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP);
1425
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1);
1426
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2);
1427
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES);
1428
3930
  NODE_DEFINE_CONSTANT(target, BROTLI_DECODER_ERROR_UNREACHABLE);
1429
786
}
1430
1431
}  // namespace node
1432
1433
5623
NODE_MODULE_CONTEXT_AWARE_INTERNAL(zlib, node::Initialize)
1434

22421
NODE_MODULE_EXTERNAL_REFERENCE(zlib, node::RegisterExternalReferences)