node-liblzma 1.1.9 → 2.0.0

package/src/bindings/node-liblzma.hpp

@@ -1,20 +1,20 @@
 /**
-	* node-liblzma - Node.js bindings for liblzma
-	* Copyright (C) 2014-2015 Olivier Orabona <olivier.orabona@gmail.com>
-	*
-	* This program is free software: you can redistribute it and/or modify
-	* it under the terms of the GNU Lesser General Public License as published by
-	* the Free Software Foundation, either version 3 of the License, or
-	* (at your option) any later version.
-	*
-	* This program is distributed in the hope that it will be useful,
-	* but WITHOUT ANY WARRANTY; without even the implied warranty of
-	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-	* GNU General Public License for more details.
-	*
-	* You should have received a copy of the GNU Lesser General Public License
-	* along with this program. If not, see <https://www.gnu.org/licenses/>.
-	**/
+ * node-liblzma - Node.js bindings for liblzma
+ * Copyright (C) 2014-2015 Olivier Orabona <olivier.orabona@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ **/
 
 #ifndef BUILDING_NODE_EXTENSION
 #define BUILDING_NODE_EXTENSION
@@ -27,9 +27,14 @@
 #include <napi.h>
 
 #include <sstream>
+#include <memory>
+#include <functional>
 
 constexpr unsigned int STREAM_ENCODE = 0;
 constexpr unsigned int STREAM_DECODE = 1;
+constexpr int SYNC_PARAM_COUNT = 6;
+constexpr int ASYNC_PARAM_COUNT = 7;
+
 #ifdef ENABLE_THREAD_SUPPORT
 constexpr bool HAS_THREADS_SUPPORT = true;
 #else
@@ -37,55 +42,103 @@ constexpr bool HAS_THREADS_SUPPORT = false;
 #endif
 
 class LZMAWorker;
-class LZMA : public Napi::ObjectWrap<LZMA> {
+class LZMA : public Napi::ObjectWrap<LZMA>
+{
 public:
 	static void Init(Napi::Env env, Napi::Object exports);
 
-	explicit LZMA(const Napi::CallbackInfo& info);
-	~LZMA() = default;
+	explicit LZMA(const Napi::CallbackInfo &info);
+	~LZMA();
+
+	Napi::Value Close(const Napi::CallbackInfo &info);
+	Napi::Value Close(const Napi::Env &env);
 
-  Napi::Value Close(const Napi::CallbackInfo &info);
-  Napi::Value Close(const Napi::Env &env);
+	template <bool async>
+	Napi::Value Code(const Napi::CallbackInfo &info);
 
-	template<bool async>
-  Napi::Value Code(const Napi::CallbackInfo &info);
+	static void Process(LZMA *obj);
+	static Napi::Value AfterSync(const Napi::CallbackInfo &info, LZMA *obj);
 
-	static void Process(LZMA* obj);
-	static void After(Napi::Env env, LZMA* obj /*, int status */);
-	static Napi::Value AfterSync(const Napi::CallbackInfo &info, LZMA* obj);
+	// Allow LZMAWorker access to private members
+	friend class LZMAWorker;
 
 private:
+	// Buffer preparation and validation
+	struct BufferContext
+	{
+		const uint8_t *in;
+		uint8_t *out;
+		size_t in_len, out_len, in_off, out_off;
+	};
+
+	template <bool async>
+	bool ValidateAndPrepareBuffers(const Napi::CallbackInfo &info, BufferContext &ctx);
+
+	Napi::Value StartAsyncWork(const Napi::CallbackInfo &info);
+	Napi::Value ExecuteSyncWork(const Napi::CallbackInfo &info);
+
+	// Constructor helpers
+	bool ValidateConstructorArgs(const Napi::CallbackInfo &info, uint32_t &mode, Napi::Object &opts);
+	bool InitializeFilters(const Napi::Object &opts, uint32_t preset);
+	bool InitializeEncoder(const Napi::Object &opts, uint32_t preset, lzma_check check);
+	bool InitializeDecoder();
+
+	// Common cleanup operations for both sync and async completion
+	void AfterCommon(const Napi::Env &env);
+
+	// Unified completion helpers (overloaded):
+	// - After(env): builds result array, marks done, cleans up, returns array (sync path)
+	// - After(env, cb): builds result array, marks done, calls cb, then cleans up (async path)
+	Napi::Array After(const Napi::Env &env);
+	void After(const Napi::Env &env, const Napi::Function &cb);
+
 	lzma_stream _stream;
 	bool _wip;
 	bool _pending_close;
 
-  LZMAWorker* _worker;
+	LZMAWorker *_worker;
 
 	lzma_action _action;
-	Napi::FunctionReference _callback;
 	lzma_ret _ret;
-  lzma_filter *filters;
+	std::unique_ptr<lzma_filter[]> filters;
+	// Persist LZMA2 options referenced by filters to avoid dangling pointer
+	lzma_options_lzma _opt_lzma2;
+
+	// Keep input/output Buffers alive while async work runs
+	Napi::Reference<Napi::Buffer<uint8_t>> _in_buf_ref;
+	Napi::Reference<Napi::Buffer<uint8_t>> _out_buf_ref;
 };
 
-class LZMAWorker : public Napi::AsyncWorker {
-	public:
-		LZMAWorker(Napi::Env env, LZMA* instance) : AsyncWorker(env), lzma(instance) { }
-		~LZMAWorker() = default;
-
-		void Execute() {
-			LZMA::Process(this->lzma);
-		}
-		void OnOK() {
-			Napi::HandleScope scope(Env());
-			LZMA::After(Env(), this->lzma);
-		}
-		void OnError(const Napi::Error& e) {
-			Napi::HandleScope scope(Env());
-			LZMA::After(Env(), this->lzma);
-		}
-
-	private:
-		LZMA *lzma;
+class LZMAWorker : public Napi::AsyncWorker
+{
+public:
+	LZMAWorker(Napi::Env env, LZMA *instance, Napi::Function cb)
+		: AsyncWorker(cb, "LZMAWorker"), lzma(instance)
+	{
+		// Set work in progress flag when worker is created
+		lzma->_wip = true;
+	}
+	~LZMAWorker() = default;
+
+	void Execute() override
+	{
+		// Perform the compression/decompression step
+		LZMA::Process(this->lzma);
+	}
+	void OnOK() override
+	{
+		lzma->After(Env(), Callback().Value());
+	}
+	void OnError(const Napi::Error & /*e*/) override
+	{
+		// Fallback to a generic programming error code
+		// Set a generic error code so BuildResult exposes it
+		lzma->_ret = LZMA_PROG_ERROR;
+		lzma->After(Env(), Callback().Value());
+	}
+
+private:
+	LZMA *lzma;
 };
 
 #endif // NODE_LIBLZMA_H

package/src/errors.ts

@@ -0,0 +1,167 @@
+/**
+ * node-liblzma - Node.js bindings for liblzma
+ * Copyright (C) Olivier Orabona <olivier.orabona@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Base class for all LZMA-related errors
+ */
+export class LZMAError extends Error {
+  public readonly errno: number;
+  public readonly code: number;
+
+  constructor(message: string, errno: number) {
+    super(message);
+    this.name = 'LZMAError';
+    this.errno = errno;
+    this.code = errno;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Memory allocation error - thrown when LZMA cannot allocate required memory
+ */
+export class LZMAMemoryError extends LZMAError {
+  constructor(errno: number) {
+    super('Cannot allocate memory', errno);
+    this.name = 'LZMAMemoryError';
+  }
+}
+
+/**
+ * Memory limit error - thrown when operation would exceed memory usage limit
+ */
+export class LZMAMemoryLimitError extends LZMAError {
+  constructor(errno: number) {
+    super('Memory usage limit was reached', errno);
+    this.name = 'LZMAMemoryLimitError';
+  }
+}
+
+/**
+ * Format error - thrown when file format is not recognized
+ */
+export class LZMAFormatError extends LZMAError {
+  constructor(errno: number) {
+    super('File format not recognized', errno);
+    this.name = 'LZMAFormatError';
+  }
+}
+
+/**
+ * Options error - thrown when invalid or unsupported options are provided
+ */
+export class LZMAOptionsError extends LZMAError {
+  constructor(errno: number) {
+    super('Invalid or unsupported options', errno);
+    this.name = 'LZMAOptionsError';
+  }
+}
+
+/**
+ * Data error - thrown when compressed data is corrupt
+ */
+export class LZMADataError extends LZMAError {
+  constructor(errno: number) {
+    super('Data is corrupt', errno);
+    this.name = 'LZMADataError';
+  }
+}
+
+/**
+ * Buffer error - thrown when no progress is possible (e.g., buffer too small)
+ */
+export class LZMABufferError extends LZMAError {
+  constructor(errno: number) {
+    super('No progress is possible', errno);
+    this.name = 'LZMABufferError';
+  }
+}
+
+/**
+ * Programming error - thrown when there's an internal programming error
+ */
+export class LZMAProgrammingError extends LZMAError {
+  constructor(errno: number) {
+    super('Programming error', errno);
+    this.name = 'LZMAProgrammingError';
+  }
+}
+
+/**
+ * Factory function to create appropriate error instance based on errno
+ */
+export function createLZMAError(errno: number, message?: string): LZMAError {
+  // LZMA error codes mapping
+  const LZMA_OK = 0;
+  const LZMA_STREAM_END = 1;
+  const LZMA_NO_CHECK = 2;
+  const LZMA_UNSUPPORTED_CHECK = 3;
+  const LZMA_GET_CHECK = 4;
+  const LZMA_MEM_ERROR = 5;
+  const LZMA_MEMLIMIT_ERROR = 6;
+  const LZMA_FORMAT_ERROR = 7;
+  const LZMA_OPTIONS_ERROR = 8;
+  const LZMA_DATA_ERROR = 9;
+  const LZMA_BUF_ERROR = 10;
+  const LZMA_PROG_ERROR = 11;
+
+  switch (errno) {
+    case LZMA_MEM_ERROR:
+      return new LZMAMemoryError(errno);
+    case LZMA_MEMLIMIT_ERROR:
+      return new LZMAMemoryLimitError(errno);
+    case LZMA_FORMAT_ERROR:
+      return new LZMAFormatError(errno);
+    case LZMA_OPTIONS_ERROR:
+      return new LZMAOptionsError(errno);
+    case LZMA_DATA_ERROR:
+      return new LZMADataError(errno);
+    case LZMA_BUF_ERROR:
+      return new LZMABufferError(errno);
+    case LZMA_PROG_ERROR:
+      return new LZMAProgrammingError(errno);
+    default: {
+      // For success codes and unknown errors, use base LZMAError
+      const errorMessage = message || getErrorMessage(errno);
+      return new LZMAError(errorMessage, errno);
+    }
+  }
+}
+
+/**
+ * Get error message for a given errno
+ */
+function getErrorMessage(errno: number): string {
+  const messages = [
+    'Operation completed successfully',
+    'End of stream was reached',
+    'Input stream has no integrity check',
+    'Cannot calculate the integrity check',
+    'Integrity check type is not available',
+    'Cannot allocate memory',
+    'Memory usage limit was reached',
+    'File format not recognized',
+    'Invalid or unsupported options',
+    'Data is corrupt',
+    'No progress is possible',
+    'Programming error',
+  ];
+
+  const messageIndex = Math.max(0, Math.min(errno, messages.length - 1));
+  return messages[messageIndex];
+}