diff --git a/src/amplifier.c b/src/amplifier.c
index f25ab87cc..995c8f302 100644
--- a/src/amplifier.c
+++ b/src/amplifier.c
@@ -469,7 +469,7 @@ int HAMLIB_API amp_close(AMP *amp)
     if (amp == NULL || amp->caps == NULL)
     {
         amp_debug(RIG_DEBUG_ERR, "%s: NULL ptr? amp=%p, amp->caps=%p\n", __func__, amp,
-                  amp->caps);
+                  amp->caps==NULL?NULL:amp->caps);
         return -RIG_EINVAL;
     }
 
diff --git a/src/multicast.c b/src/multicast.c
index ed241dd33..bae4274db 100644
--- a/src/multicast.c
+++ b/src/multicast.c
@@ -641,7 +641,8 @@ int main(int argc, char *argv[])
 
     if (rig == NULL)
     {
-
+        fprintf(stderr, "rig==NULL?\n");
+        return 1;
     }
 
     strncpy(rig->state.rigport.pathname, "/dev/ttyUSB0", HAMLIB_FILPATHLEN - 1);
diff --git a/src/rig.c b/src/rig.c
index 697502b18..89587070f 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -1509,13 +1509,15 @@ int HAMLIB_API rig_close(RIG *rig)
     const struct rig_caps *caps;
     struct rig_state *rs;
 
-    ENTERFUNC;
-
     if (!rig || !rig->caps)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
+
     caps = rig->caps;
     rs = &rig->state;
 
@@ -1711,13 +1713,14 @@ int HAMLIB_API rig_cleanup(RIG *rig)
  */
 int HAMLIB_API rig_set_twiddle(RIG *rig, int seconds)
 {
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     rig->state.twiddle_timeout = seconds;
 
     RETURNFUNC(RIG_OK);
@@ -1734,13 +1737,14 @@ int HAMLIB_API rig_set_twiddle(RIG *rig, int seconds)
  */
 int HAMLIB_API rig_set_uplink(RIG *rig, int val)
 {
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     rig->state.uplink = val;
 
     RETURNFUNC(RIG_OK);
@@ -1760,13 +1764,14 @@ int HAMLIB_API rig_set_uplink(RIG *rig, int val)
  */
 int HAMLIB_API rig_get_twiddle(RIG *rig, int *seconds)
 {
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig) || !seconds)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps or seconds is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     *seconds = rig->state.twiddle_timeout;
     RETURNFUNC(RIG_OK);
 }
@@ -1849,6 +1854,12 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     freq_t freq_new = freq;
     vfo_t vfo_save;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ELAPSED1;
     ENTERFUNC;
     LOCK(1);
@@ -1864,13 +1875,6 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
     if (vfo == RIG_VFO_A || vfo == RIG_VFO_MAIN) { freq += rig->state.offset_vfoa; }
     else if (vfo == RIG_VFO_B || vfo == RIG_VFO_SUB) { freq += rig->state.offset_vfob; }
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        ELAPSED2;
-        LOCK(0);
-        RETURNFUNC(-RIG_EINVAL);
-    }
-
     if (rig->state.twiddle_state == TWIDDLE_ON)
     {
         // we keep skipping set_freq while the vfo knob is in motion
@@ -2135,6 +2139,12 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
     rmode_t mode;
     pbwidth_t width;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ENTERFUNC;
 #if BUILTINFUNC
     rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, called from %s\n",
@@ -2145,11 +2155,6 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
               rig_strvfo(vfo));
 #endif
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        RETURNFUNC(-RIG_EINVAL);
-    }
-
     ELAPSED1;
 
     if (!freq)
@@ -2443,6 +2448,12 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     int retcode;
     int locked_mode;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ENTERFUNC;
     ELAPSED1;
     LOCK(1);
@@ -2452,12 +2463,6 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
               rig_strvfo(vfo), rig_strrmode(mode), (int)width,
               rig_strvfo(rig->state.current_vfo));
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
-    }
-
     rig_get_lock_mode(rig, &locked_mode);
 
     if (locked_mode)
@@ -2617,15 +2622,15 @@ int HAMLIB_API rig_get_mode(RIG *rig,
     int retcode;
     freq_t freq;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!mode || !width)
     {
         ELAPSED2;
@@ -2776,13 +2781,14 @@ pbwidth_t HAMLIB_API rig_passband_normal(RIG *rig, rmode_t mode)
     const struct rig_state *rs;
     int i;
 
-    ENTERFUNC;
-
     if (!rig)
     {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
         RETURNFUNC(RIG_PASSBAND_NORMAL);    /* huhu! */
     }
 
+    ENTERFUNC;
+
     rs = &rig->state;
 
     // return CW for CWR and RTTY for RTTYR
@@ -2828,13 +2834,14 @@ pbwidth_t HAMLIB_API rig_passband_narrow(RIG *rig, rmode_t mode)
     pbwidth_t normal;
     int i;
 
-    ENTERFUNC;
-
     if (!rig)
     {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
         RETURNFUNC(0);   /* huhu! */
     }
 
+    ENTERFUNC;
+
     rs = &rig->state;
 
     for (i = 0; i < HAMLIB_FLTLSTSIZ - 1 && rs->filters[i].modes; i++)
@@ -2880,13 +2887,14 @@ pbwidth_t HAMLIB_API rig_passband_wide(RIG *rig, rmode_t mode)
     pbwidth_t normal;
     int i;
 
-    ENTERFUNC;
-
     if (!rig)
     {
-        RETURNFUNC(0);   /* huhu! */
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return 0 ;   /* huhu! */
     }
 
+    ENTERFUNC;
+
     rs = &rig->state;
 
     for (i = 0; i < HAMLIB_FLTLSTSIZ - 1 && rs->filters[i].modes; i++)
@@ -2940,6 +2948,12 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
     freq_t curr_freq;
     vfo_t curr_vfo = RIG_VFO_CURR, tmp_vfo;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ELAPSED1;
     ENTERFUNC;
 #if BUILTINFUNC
@@ -2955,12 +2969,6 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
                   __func__, rig_strvfo(vfo));
     }
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
-    }
-
     vfo = vfo_fixup(rig, vfo, rig->state.cache.split);
 
     if (vfo == RIG_VFO_CURR)
@@ -3101,15 +3109,15 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
     int retcode;
     int cache_ms;
 
-    ENTERFUNC;
-    ELAPSED1;
-
     if (CHECK_RIG_ARG(rig) || !vfo)
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+    ELAPSED1;
+
     if (!vfo)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: no vfo?  rig=%p, vfo=%p\n", __func__,
@@ -3190,15 +3198,15 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     struct rig_state *rs = &rig->state;
     int retcode = RIG_OK;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     caps = rig->caps;
 
     LOCK(1);
@@ -3516,15 +3524,15 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
     int targetable_ptt = 0;
     int backend_num;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!ptt)
     {
         ELAPSED2;
@@ -3829,15 +3837,15 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
     int retcode, rc2, status;
     vfo_t curr_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!dcd)
     {
         ELAPSED2;
@@ -3970,15 +3978,15 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_rptr_shift == NULL)
@@ -4048,15 +4056,15 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!rptr_shift)
     {
         ELAPSED2;
@@ -4132,15 +4140,15 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_rptr_offs == NULL)
@@ -4210,15 +4218,15 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!rptr_offs)
     {
         ELAPSED2;
@@ -4294,14 +4302,13 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
     vfo_t curr_vfo, tx_vfo;
     freq_t tfreq = 0;
 
-    ELAPSED1;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC2(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, curr_vfo=%s, tx_freq=%.0f\n",
               __func__,
@@ -4462,15 +4469,15 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
     int retcode = -RIG_EPROTO, rc2;
     vfo_t save_vfo, tx_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!tx_freq)
     {
         ELAPSED2;
@@ -4622,15 +4629,15 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
     int retcode, rc2;
     vfo_t curr_vfo, tx_vfo, rx_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     // we check both VFOs are in the same tx mode -- then we can ignore
     // this could be make more intelligent but this should cover all cases where we can skip this
     if (tx_mode == rig->state.cache.modeMainA
@@ -4845,15 +4852,15 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
     int retcode, rc2;
     vfo_t curr_vfo, tx_vfo;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!tx_mode || !tx_width)
     {
         ELAPSED2;
@@ -4989,15 +4996,15 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig,
     const struct rig_caps *caps;
     int retcode;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     caps = rig->caps;
 
     // if split is off we'll turn it on
@@ -5110,15 +5117,15 @@ int HAMLIB_API rig_get_split_freq_mode(RIG *rig,
     const struct rig_caps *caps;
     int retcode;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!tx_freq || !tx_mode || !tx_width)
     {
         ELAPSED2;
@@ -5172,18 +5179,18 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ELAPSED1;
     ENTERFUNC;
     rig_debug(RIG_DEBUG_VERBOSE,
               "%s: rx_vfo=%s, split=%d, tx_vfo=%s, cache.split=%d\n", __func__,
               rig_strvfo(rx_vfo), split, rig_strvfo(tx_vfo), rig->state.cache.split);
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
-    }
-
     caps = rig->caps;
 
     if (caps->set_split_vfo == NULL)
@@ -5341,15 +5348,15 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
 #endif
     int cache_ms;
 
-    ELAPSED1;
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ELAPSED1;
+    ENTERFUNC;
+
     if (!split || !tx_vfo)
     {
         rig_debug(RIG_DEBUG_ERR, "%s: split or tx_vfo is null, split=%p, tx_vfo=%p\n",
@@ -5476,13 +5483,14 @@ int HAMLIB_API rig_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_rit == NULL)
@@ -5547,13 +5555,14 @@ int HAMLIB_API rig_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!rit)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -5624,13 +5633,14 @@ int HAMLIB_API rig_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_xit == NULL)
@@ -5695,13 +5705,14 @@ int HAMLIB_API rig_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!xit)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -5772,13 +5783,14 @@ int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_ts == NULL)
@@ -5843,13 +5855,14 @@ int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!ts)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -5924,13 +5937,14 @@ int HAMLIB_API rig_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->set_ant == NULL)
@@ -6004,13 +6018,14 @@ int HAMLIB_API rig_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (ant_curr == NULL || ant_tx == NULL || ant_rx == NULL)
     {
         rig_debug(RIG_DEBUG_ERR,
@@ -6098,13 +6113,14 @@ int HAMLIB_API rig_power2mW(RIG *rig,
     const freq_range_t *txrange;
     char buf[32];
 
-    ENTERFUNC;
-
     if (!rig || !rig->caps || !mwpower || power < 0.0 || power > 1.0)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps or mwpower or power is funky\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (rig->caps->power2mW != NULL)
     {
         RETURNFUNC(rig->caps->power2mW(rig, mwpower, power, freq, mode));
@@ -6229,13 +6245,14 @@ shortfreq_t HAMLIB_API rig_get_resolution(RIG *rig, rmode_t mode)
     const struct rig_state *rs;
     int i;
 
-    ENTERFUNC;
-
     if (!rig || !rig->caps || !mode)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps or mode is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     rs = &rig->state;
 
     for (i = 0; i < HAMLIB_TSLSTSIZ && rs->tuning_steps[i].ts; i++)
@@ -6269,14 +6286,15 @@ int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status)
 {
     int retcode;
 
-    ENTERFUNC;
     rig_debug(RIG_DEBUG_VERBOSE, "%s called status=%d\n", __func__, status);
-    ELAPSED1;
 
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
+    ENTERFUNC;
+    ELAPSED1;
 
     if (rig->caps->set_powerstat == NULL)
     {
@@ -6318,14 +6336,14 @@ int HAMLIB_API rig_get_powerstat(RIG *rig, powerstat_t *status)
 {
     int retcode;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
         *status = RIG_POWER_ON; // default to power on if not available
-        RETURNFUNC(-RIG_EINVAL);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!status)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -6373,13 +6391,14 @@ int HAMLIB_API rig_reset(RIG *rig, reset_t reset)
 {
     int retcode;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (rig->caps->reset == NULL)
     {
         RETURNFUNC(-RIG_ENAVAIL);
@@ -6474,13 +6493,13 @@ vfo_op_t HAMLIB_API rig_has_vfo_op(RIG *rig, vfo_op_t op)
 {
     int retcode;
 
-    ENTERFUNC;
-
     if (!rig || !rig->caps)
     {
         RETURNFUNC(0);
     }
 
+    ENTERFUNC;
+
     retcode = rig->caps->vfo_ops & op;
     RETURNFUNC(retcode);
 }
@@ -6507,14 +6526,15 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
     int retcode, rc2;
     vfo_t curr_vfo;
 
+    if (CHECK_RIG_ARG(rig))
+    {
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
+    }
+
     ENTERFUNC;
     ELAPSED1;
 
-    if (CHECK_RIG_ARG(rig))
-    {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
-    }
 
     caps = rig->caps;
 
@@ -6621,13 +6641,14 @@ int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->scan == NULL
@@ -6692,13 +6713,14 @@ int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!digits)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -6768,13 +6790,14 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!digits || !length)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -6843,13 +6866,14 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg)
     int retcode=RIG_EINTERNAL, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     if (!msg)
     {
         RETURNFUNC(-RIG_EINVAL);
@@ -6933,13 +6957,14 @@ int HAMLIB_API rig_stop_morse(RIG *rig, vfo_t vfo)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->stop_morse == NULL)
@@ -7038,13 +7063,14 @@ int HAMLIB_API rig_wait_morse(RIG *rig, vfo_t vfo)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if (CHECK_RIG_ARG(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (vfo == RIG_VFO_CURR
@@ -7102,13 +7128,14 @@ int HAMLIB_API rig_send_voice_mem(RIG *rig, vfo_t vfo, int ch)
     int retcode, rc2;
     vfo_t curr_vfo;
 
-    ENTERFUNC;
-
     if CHECK_RIG_ARG(rig)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->send_voice_mem == NULL)
@@ -7169,13 +7196,14 @@ int HAMLIB_API rig_stop_voice_mem(RIG *rig, vfo_t vfo)
     const struct rig_caps *caps;
     int retcode;
 
-    ENTERFUNC;
-
     if CHECK_RIG_ARG(rig)
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+
     caps = rig->caps;
 
     if (caps->stop_voice_mem == NULL)
@@ -7240,15 +7268,15 @@ int HAMLIB_API rig_set_vfo_opt(RIG *rig, int status)
 {
     int retcode;
 
-    ENTERFUNC;
-    ELAPSED1;
-
     if CHECK_RIG_ARG(rig)
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
+    ENTERFUNC;
+    ELAPSED1;
+
     // Only netrigctl has this function
     // We allow the status to be set for rigctl use
     if (rig->caps->set_vfo_opt == NULL)
@@ -7359,7 +7387,8 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
 
     if (CHECK_RIG_ARG(rig) || !response)
     {
-        RETURNFUNC2(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
 
     ELAPSED1;
@@ -7450,15 +7479,15 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
 {
     int retval;
 
-    ELAPSED1;
-    ENTERFUNC;
     rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s\n", __func__, rig_strvfo(vfo));
 
     if (CHECK_RIG_ARG(rig))
     {
-        ELAPSED2;
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
+    ELAPSED1;
+    ENTERFUNC;
 
     //if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
 
@@ -7524,12 +7553,12 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
  */
 int HAMLIB_API rig_get_vfo_list(RIG *rig, char *buf, int buflen)
 {
-    ENTERFUNC;
-
     if (CHECK_RIG_CAPS(rig))
     {
-        RETURNFUNC(-RIG_EINVAL);
+        rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n",__func__);
+        return -RIG_EINVAL;
     }
+    ENTERFUNC;
 
     rig_sprintf_vfo(buf, buflen - 1, rig->state.vfo_list);