hamlib 0.1.9 → 0.1.11

package/src/hamlib.cpp

@@ -15,6 +15,16 @@
 #endif
 #endif
 
+// 安全宏 - 检查RIG指针有效性，防止空指针解引用和已销毁对象访问
+#define CHECK_RIG_VALID() \
+  do { \
+    if (!hamlib_instance_ || !hamlib_instance_->my_rig) { \
+      result_code_ = -RIG_EINVAL; \
+      error_message_ = "RIG is not initialized or has been destroyed"; \
+      return; \
+    } \
+  } while(0)
+
 // Structure to hold rig information for the callback
 struct RigListData {
   std::vector<Napi::Object> rigList;
@@ -37,6 +47,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_open(hamlib_instance_->my_rig);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -54,7 +66,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -69,6 +85,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), freq_(freq), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_freq(hamlib_instance_->my_rig, vfo_, freq_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -77,7 +95,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -96,6 +118,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), freq_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_freq(hamlib_instance_->my_rig, vfo_, &freq_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -104,7 +128,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, freq_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, freq_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -123,6 +151,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), mode_(mode), width_(width), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_mode(hamlib_instance_->my_rig, vfo_, mode_, width_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -131,7 +161,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -151,6 +185,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), mode_(0), width_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_mode(hamlib_instance_->my_rig, RIG_VFO_CURR, &mode_, &width_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -159,12 +195,16 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        // Convert mode to string using rig_strrmode
-        const char* mode_str = rig_strrmode(mode_);
-        obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
-        obj.Set(Napi::String::New(env, "bandwidth"), width_);
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            // Convert mode to string using rig_strrmode
+            const char* mode_str = rig_strrmode(mode_);
+            obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
+            obj.Set(Napi::String::New(env, "bandwidth"), width_);
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -183,6 +223,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), ptt_(ptt) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_ptt(hamlib_instance_->my_rig, RIG_VFO_CURR, ptt_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -191,7 +233,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -209,6 +255,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), strength_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_strength(hamlib_instance_->my_rig, vfo_, &strength_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -217,7 +265,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, strength_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, strength_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -236,6 +288,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), value_(value) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_level(hamlib_instance_->my_rig, RIG_VFO_CURR, level_type_, value_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -244,7 +298,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -265,6 +323,8 @@ public:
     }
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_level(hamlib_instance_->my_rig, RIG_VFO_CURR, level_type_, &value_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -273,7 +333,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, value_.f));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, value_.f));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -292,6 +356,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), func_type_(func_type), enable_(enable) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_func(hamlib_instance_->my_rig, RIG_VFO_CURR, func_type_, enable_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -300,7 +366,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -319,6 +389,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), func_type_(func_type), state_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_func(hamlib_instance_->my_rig, RIG_VFO_CURR, func_type_, &state_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -327,7 +399,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -346,6 +422,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), chan_(chan) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_channel(hamlib_instance_->my_rig, RIG_VFO_MEM, &chan_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -354,7 +432,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -374,6 +456,8 @@ public:
     }
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         chan_.channel_num = channel_num_;
         chan_.vfo = RIG_VFO_MEM;
         result_code_ = rig_get_channel(hamlib_instance_->my_rig, RIG_VFO_MEM, &chan_, read_only_);
@@ -428,6 +512,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), channel_num_(channel_num) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_mem(hamlib_instance_->my_rig, RIG_VFO_CURR, channel_num_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -436,7 +522,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -454,6 +544,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), rit_offset_(rit_offset) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_rit(hamlib_instance_->my_rig, RIG_VFO_CURR, rit_offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -462,7 +554,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -480,6 +576,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), rit_offset_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_rit(hamlib_instance_->my_rig, RIG_VFO_CURR, &rit_offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -488,7 +586,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, rit_offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, rit_offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -506,6 +608,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), xit_offset_(xit_offset) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_xit(hamlib_instance_->my_rig, RIG_VFO_CURR, xit_offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -514,7 +618,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -532,6 +640,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), xit_offset_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_xit(hamlib_instance_->my_rig, RIG_VFO_CURR, &xit_offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -540,7 +650,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, xit_offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, xit_offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -558,6 +672,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         int ritCode = rig_set_rit(hamlib_instance_->my_rig, RIG_VFO_CURR, 0);
         int xitCode = rig_set_xit(hamlib_instance_->my_rig, RIG_VFO_CURR, 0);
         
@@ -574,7 +690,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -589,6 +709,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), tx_freq_(tx_freq), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_split_freq(hamlib_instance_->my_rig, vfo_, tx_freq_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -597,7 +719,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -616,6 +742,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), tx_freq_(0), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_split_freq(hamlib_instance_->my_rig, vfo_, &tx_freq_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -624,7 +752,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tx_freq_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tx_freq_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -643,6 +775,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), rx_vfo_(rx_vfo), split_(split), tx_vfo_(tx_vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_split_vfo(hamlib_instance_->my_rig, rx_vfo_, split_, tx_vfo_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -651,7 +785,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -671,6 +809,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), split_(RIG_SPLIT_OFF), tx_vfo_(RIG_VFO_B), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_split_vfo(hamlib_instance_->my_rig, vfo_, &split_, &tx_vfo_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -679,16 +819,20 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
-        
-        const char* vfo_str = "VFO-B";
-        if (tx_vfo_ == RIG_VFO_A) {
-            vfo_str = "VFO-A";
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
+            
+            const char* vfo_str = "VFO-B";
+            if (tx_vfo_ == RIG_VFO_A) {
+                vfo_str = "VFO-A";
+            }
+            obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
+            
+            deferred_.Resolve(obj);
         }
-        obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
-        
-        deferred_.Resolve(obj);
     }
     
     void OnError(const Napi::Error& e) override {
@@ -708,6 +852,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_vfo(hamlib_instance_->my_rig, vfo_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -716,7 +862,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -734,6 +884,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_vfo(hamlib_instance_->my_rig, &vfo_);
         if (result_code_ != RIG_OK) {
             // 提供更清晰的错误信息
@@ -795,6 +947,14 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
+        // 检查rig是否已经关闭
+        if (!hamlib_instance_->rig_is_open) {
+            result_code_ = RIG_OK;  // 已经关闭，返回成功
+            return;
+        }
+        
         result_code_ = rig_close(hamlib_instance_->my_rig);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -805,7 +965,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -820,20 +984,25 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
-        if (hamlib_instance_->rig_is_open) {
-            rig_close(hamlib_instance_->my_rig);
-        }
+        CHECK_RIG_VALID();
+        
+        // rig_cleanup会自动调用rig_close，所以我们不需要重复调用
         result_code_ = rig_cleanup(hamlib_instance_->my_rig);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
         } else {
             hamlib_instance_->rig_is_open = false;
+            hamlib_instance_->my_rig = nullptr;  // 重要：清空指针防止重复释放
         }
     }
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -849,6 +1018,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), scan_type_(scan_type), channel_(channel) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_scan(hamlib_instance_->my_rig, RIG_VFO_CURR, scan_type_, channel_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -857,7 +1028,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -877,6 +1052,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_scan(hamlib_instance_->my_rig, RIG_VFO_CURR, RIG_SCAN_STOP, 0);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -885,7 +1062,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -901,6 +1082,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_op_(vfo_op) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_vfo_op(hamlib_instance_->my_rig, RIG_VFO_CURR, vfo_op_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -909,7 +1092,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -928,6 +1115,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), antenna_(antenna), vfo_(vfo), option_(option) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_ant(hamlib_instance_->my_rig, vfo_, antenna_, option_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -936,7 +1125,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -957,6 +1150,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), antenna_(antenna), antenna_curr_(0), antenna_tx_(0), antenna_rx_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         option_ = {0};
         
         result_code_ = rig_get_ant(hamlib_instance_->my_rig, vfo_, antenna_, &option_, &antenna_curr_, &antenna_tx_, &antenna_rx_);
@@ -967,14 +1162,18 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object result = Napi::Object::New(env);
-        
-        result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
-        result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
-        result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
-        result.Set("option", Napi::Number::New(env, option_.f));
-        
-        deferred_.Resolve(result);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object result = Napi::Object::New(env);
+            
+            result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
+            result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
+            result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
+            result.Set("option", Napi::Number::New(env, option_.f));
+            
+            deferred_.Resolve(result);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -998,6 +1197,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), power_(power), freq_(freq), mode_(mode), mwpower_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_power2mW(hamlib_instance_->my_rig, &mwpower_, power_, freq_, mode_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1006,7 +1207,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, mwpower_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, mwpower_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1028,6 +1233,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), mwpower_(mwpower), freq_(freq), mode_(mode), power_(0.0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_mW2power(hamlib_instance_->my_rig, &power_, mwpower_, freq_, mode_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1036,7 +1243,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, power_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, power_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1058,6 +1269,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), tx_mode_(tx_mode), tx_width_(tx_width), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_split_mode(hamlib_instance_->my_rig, vfo_, tx_mode_, tx_width_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1066,7 +1279,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1087,6 +1304,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), tx_mode_(0), tx_width_(0), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_split_mode(hamlib_instance_->my_rig, vfo_, &tx_mode_, &tx_width_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1095,12 +1314,16 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        // Convert mode to string using rig_strrmode
-        const char* mode_str = rig_strrmode(tx_mode_);
-        obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
-        obj.Set(Napi::String::New(env, "width"), tx_width_);
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            // Convert mode to string using rig_strrmode
+            const char* mode_str = rig_strrmode(tx_mode_);
+            obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
+            obj.Set(Napi::String::New(env, "width"), tx_width_);
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1121,6 +1344,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), param_name_(param_name), param_value_(param_value) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         // Apply serial configuration parameter
         if (param_name_ == "data_bits") {
             int data_bits = std::stoi(param_value_);
@@ -1254,7 +1479,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1274,6 +1503,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), param_name_(param_name) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         // Get serial configuration parameter
         if (param_name_ == "data_bits") {
             param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.parm.serial.data_bits);
@@ -1365,7 +1596,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, param_value_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, param_value_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1385,6 +1620,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), ptt_type_(ptt_type) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         ptt_type_t ptt_type;
         if (ptt_type_ == "RIG") {
             ptt_type = RIG_PTT_RIG;
@@ -1414,7 +1651,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1433,6 +1674,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         ptt_type_t ptt_type = hamlib_instance_->my_rig->state.pttport.type.ptt;
         
         switch (ptt_type) {
@@ -1469,7 +1712,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1488,6 +1735,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), dcd_type_(dcd_type) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         dcd_type_t dcd_type;
         if (dcd_type_ == "RIG") {
             dcd_type = RIG_DCD_RIG;
@@ -1519,7 +1768,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1538,6 +1791,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         dcd_type_t dcd_type = hamlib_instance_->my_rig->state.dcdport.type.dcd;
         
         switch (dcd_type) {
@@ -1577,7 +1832,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1596,6 +1855,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), status_(status) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_powerstat(hamlib_instance_->my_rig, status_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1604,7 +1865,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1622,6 +1887,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), status_(RIG_POWER_UNKNOWN) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_powerstat(hamlib_instance_->my_rig, &status_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1630,7 +1897,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1649,6 +1920,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), ptt_(RIG_PTT_OFF) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_ptt(hamlib_instance_->my_rig, vfo_, &ptt_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1657,7 +1930,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1677,6 +1954,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), dcd_(RIG_DCD_OFF) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_dcd(hamlib_instance_->my_rig, vfo_, &dcd_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1685,7 +1964,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1705,6 +1988,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), ts_(ts) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_ts(hamlib_instance_->my_rig, vfo_, ts_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1713,7 +1998,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1732,6 +2021,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), ts_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_ts(hamlib_instance_->my_rig, vfo_, &ts_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1740,7 +2031,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, ts_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, ts_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1760,6 +2055,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), shift_(shift) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_rptr_shift(hamlib_instance_->my_rig, vfo_, shift_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1768,7 +2065,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1787,6 +2088,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), shift_(RIG_RPT_SHIFT_NONE) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_rptr_shift(hamlib_instance_->my_rig, vfo_, &shift_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1815,6 +2118,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), offset_(offset) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_rptr_offs(hamlib_instance_->my_rig, vfo_, offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1823,7 +2128,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1842,6 +2151,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), offset_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_rptr_offs(hamlib_instance_->my_rig, vfo_, &offset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -1850,7 +2161,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1961,6 +2276,21 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
   rig_is_open = false;
 }
 
+// 析构函数 - 确保资源正确清理
+NodeHamLib::~NodeHamLib() {
+  // 如果rig指针存在，执行清理
+  if (my_rig) {
+    // 如果rig是打开状态，先关闭
+    if (rig_is_open) {
+      rig_close(my_rig);
+      rig_is_open = false;
+    }
+    // 清理rig资源
+    rig_cleanup(my_rig);
+    my_rig = nullptr;
+  }
+}
+
 int NodeHamLib::freq_change_cb(RIG *rig, vfo_t vfo, freq_t freq, void* arg) {
       auto instance = static_cast<NodeHamLib*>(arg);
       printf("Rig changed freq to %0.7f Hz\n", freq);
@@ -3780,6 +4110,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), tone_(tone) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_ctcss_tone(hamlib_instance_->my_rig, vfo_, tone_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3788,7 +4120,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3807,6 +4143,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), tone_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_ctcss_tone(hamlib_instance_->my_rig, vfo_, &tone_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3815,7 +4153,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tone_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tone_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3834,6 +4176,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), code_(code) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_dcs_code(hamlib_instance_->my_rig, vfo_, code_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3842,7 +4186,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3861,6 +4209,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), code_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_dcs_code(hamlib_instance_->my_rig, vfo_, &code_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3869,7 +4219,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3888,6 +4242,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), tone_(tone) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_ctcss_sql(hamlib_instance_->my_rig, vfo_, tone_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3896,7 +4252,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3915,6 +4275,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), tone_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_ctcss_sql(hamlib_instance_->my_rig, vfo_, &tone_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3923,7 +4285,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tone_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tone_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3942,6 +4308,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), code_(code) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_dcs_sql(hamlib_instance_->my_rig, vfo_, code_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3950,7 +4318,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3969,6 +4341,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), code_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_dcs_sql(hamlib_instance_->my_rig, vfo_, &code_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -3977,7 +4351,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3997,6 +4375,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), parm_(parm), value_(value) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_parm(hamlib_instance_->my_rig, parm_, value_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4005,7 +4385,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4026,6 +4410,8 @@ public:
     }
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_parm(hamlib_instance_->my_rig, parm_, &value_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4034,7 +4420,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, value_.f));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, value_.f));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4054,6 +4444,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), digits_(digits) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_send_dtmf(hamlib_instance_->my_rig, vfo_, digits_.c_str());
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4062,7 +4454,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4083,6 +4479,8 @@ public:
     }
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         length_ = max_length_;
         result_code_ = rig_recv_dtmf(hamlib_instance_->my_rig, vfo_, digits_.data(), &length_);
         if (result_code_ != RIG_OK) {
@@ -4092,10 +4490,14 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
-        obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
+            obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4117,6 +4519,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), ch_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_get_mem(hamlib_instance_->my_rig, vfo_, &ch_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4125,7 +4529,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, ch_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, ch_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4144,6 +4552,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), bank_(bank) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_set_bank(hamlib_instance_->my_rig, vfo_, bank_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4152,7 +4562,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4171,6 +4585,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), count_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         count_ = rig_mem_count(hamlib_instance_->my_rig);
         if (count_ < 0) {
             result_code_ = count_;
@@ -4182,7 +4598,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, count_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, count_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4201,6 +4621,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), msg_(msg) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_send_morse(hamlib_instance_->my_rig, vfo_, msg_.c_str());
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4209,7 +4631,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4228,6 +4654,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_stop_morse(hamlib_instance_->my_rig, vfo_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4236,7 +4664,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4254,6 +4686,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_wait_morse(hamlib_instance_->my_rig, vfo_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4262,7 +4696,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4281,6 +4719,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), ch_(ch) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_send_voice_mem(hamlib_instance_->my_rig, vfo_, ch_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4289,7 +4729,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4308,6 +4752,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         #if HAVE_RIG_STOP_VOICE_MEM
         result_code_ = rig_stop_voice_mem(hamlib_instance_->my_rig, vfo_);
         if (result_code_ != RIG_OK) {
@@ -4323,7 +4769,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4344,6 +4794,8 @@ public:
           tx_mode_(tx_mode), tx_width_(tx_width) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         #if HAVE_RIG_SPLIT_FREQ_MODE
         result_code_ = rig_set_split_freq_mode(hamlib_instance_->my_rig, vfo_, tx_freq_, tx_mode_, tx_width_);
         if (result_code_ != RIG_OK) {
@@ -4359,7 +4811,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4380,6 +4836,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), vfo_(vfo), tx_freq_(0), tx_mode_(RIG_MODE_NONE), tx_width_(0) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         #if HAVE_RIG_SPLIT_FREQ_MODE
         result_code_ = rig_get_split_freq_mode(hamlib_instance_->my_rig, vfo_, &tx_freq_, &tx_mode_, &tx_width_);
         if (result_code_ != RIG_OK) {
@@ -4395,11 +4853,15 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
-        obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
-        obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
+            obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
+            obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4421,6 +4883,8 @@ public:
         : HamLibAsyncWorker(env, hamlib_instance), reset_(reset) {}
     
     void Execute() override {
+        CHECK_RIG_VALID();
+        
         result_code_ = rig_reset(hamlib_instance_->my_rig, reset_);
         if (result_code_ != RIG_OK) {
             error_message_ = rigerror(result_code_);
@@ -4429,7 +4893,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {