Improve robustness of rigctld

Now retries opening indefinitely
Improved client side too
Error message should now show timeout if rig disappears

rigs/dummy/flrig.c

@@ -541,6 +541,11 @@ static int flrig_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
         if (retval != RIG_OK)
         {
             rig_debug(RIG_DEBUG_ERR, "%s: write_transaction error=%d\n", __func__, retval);
+
+            // if we get RIG_EIO the socket has probably disappeared
+            // so bubble up the error so port can re re-opened
+            if (retval == -RIG_EIO) { return retval; }
+
             hl_usleep(50 * 1000); // 50ms sleep if error
         }
 

rigs/dummy/flrig.h

@@ -28,7 +28,7 @@
 #include <sys/time.h>
 #endif
 
-#define BACKEND_VER "20210117"
+#define BACKEND_VER "20210123"
 
 #define EOM "\r"
 #define TRUE 1

src/rig.c

@@ -1653,12 +1653,16 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s\n", __func__, rig_strvfo(vfo));
 
+#if 0 // don't think we really need this check
+
     if (CHECK_RIG_ARG(rig) || !freq)
     {
         rig_debug(RIG_DEBUG_TRACE, "%s: rig or freq ptr invalid\n", __func__);
         RETURNFUNC(-RIG_EINVAL);
     }
 
+#endif
+
     curr_vfo = rig->state.current_vfo; // save vfo for restore later
 
     vfo = vfo_fixup(rig, vfo);

tests/rigctl.c

@@ -615,6 +615,23 @@ int main(int argc, char *argv[])
         {
             exitcode = 2;
         }
+
+        rig_debug(RIG_DEBUG_ERR, "%s: XXXXXXXXX#1 retcode=%d\n", __func__, retcode); 
+        if (retcode == -RIG_EIO || retcode == 2)
+        {
+            rig_debug(RIG_DEBUG_ERR, "%s: i/o error\n", __func__)
+
+            do
+            {
+                retcode = rig_close(my_rig);
+                hl_usleep(1000 * 1000);
+                rig_debug(RIG_DEBUG_ERR, "%s: rig_close retcode=%d\n", __func__, retcode);
+                retcode = rig_open(my_rig);
+                rig_debug(RIG_DEBUG_ERR, "%s: rig_open retcode=%d\n", __func__, retcode);
+            }
+            while (retcode != RIG_OK);
+
+        }
     }
     while (retcode == 0 || retcode == 2 || retcode == -RIG_ENAVAIL);
 

tests/rigctld.c

@@ -969,6 +969,31 @@ int main(int argc, char *argv[])
     return 0;
 }
 
+static FILE*get_fsockout(struct handle_data *handle_data_arg)
+{
+#ifdef __MINGW32__
+    return _fdopen(sock_osfhandle, "wb");
+#else
+    return fdopen(handle_data_arg->sock, "wb");
+#endif
+}
+
+static FILE* get_fsockin(struct handle_data *handle_data_arg)
+{
+#ifdef __MINGW32__
+    int sock_osfhandle = _open_osfhandle(handle_data_arg->sock, _O_RDONLY);
+
+    if (sock_osfhandle == -1)
+    {
+        rig_debug(RIG_DEBUG_ERR, "_open_osfhandle error: %s\n", strerror(errno));
+        goto handle_exit;
+    }
+
+    return _fdopen(sock_osfhandle,  "rb");
+#else
+    return fdopen(handle_data_arg->sock, "rb");
+#endif
+}
 
 /*
  * This is the function run by the threads
@@ -985,19 +1010,7 @@ void *handle_socket(void *arg)
     int ext_resp = 0;
     char resp_sep = '\n';
 
-#ifdef __MINGW32__
-    int sock_osfhandle = _open_osfhandle(handle_data_arg->sock, _O_RDONLY);
-
-    if (sock_osfhandle == -1)
-    {
-        rig_debug(RIG_DEBUG_ERR, "_open_osfhandle error: %s\n", strerror(errno));
-        goto handle_exit;
-    }
-
-    fsockin = _fdopen(sock_osfhandle,  "rb");
-#else
-    fsockin = fdopen(handle_data_arg->sock, "rb");
-#endif
+    fsockin = get_fsockin(handle_data_arg);
 
     if (!fsockin)
     {
@@ -1006,11 +1019,7 @@ void *handle_socket(void *arg)
         goto handle_exit;
     }
 
-#ifdef __MINGW32__
-    fsockout = _fdopen(sock_osfhandle, "wb");
-#else
-    fsockout = fdopen(handle_data_arg->sock, "wb");
-#endif
+    fsockout = get_fsockout(handle_data_arg);
 
     if (!fsockout)
     {
@@ -1055,7 +1064,7 @@ void *handle_socket(void *arg)
 
     do
     {
-        rig_debug(RIG_DEBUG_TRACE, "%s: vfo_mode=%d\n", __func__,
+        rig_debug(RIG_DEBUG_TRACE, "%s: doing rigctl_parse vfo_mode=%d\n", __func__,
                   handle_data_arg->vfo_mode);
         retcode = rigctl_parse(handle_data_arg->rig, fsockin, fsockout, NULL, 0,
                                sync_callback,
@@ -1063,24 +1072,42 @@ void *handle_socket(void *arg)
 
         if (retcode != 0) { rig_debug(RIG_DEBUG_ERR, "%s: rigctl_parse retcode=%d\n", __func__, retcode); }
 
+
+#if 0 // disabled -- don't think we need this
+
+        // see https://github.com/Hamlib/Hamlib/issues/516
         if (retcode == -1)
         {
             //sleep(1); // probably don't need this delay
-            continue;
+            //continue;
         }
 
-        if (ferror(fsockin) || ferror(fsockout))
+#endif
+
+        // if socket error or rigctld gets RIG_EIO we'll try to reopen
+        if (ferror(fsockin))
         {
+            rig_debug(RIG_DEBUG_ERR, "%s: sockin err=%s\n", __func__, strerror(errno));
+            RETURNFUNC(NULL);
+        }
+
+        if (ferror(fsockin) || ferror(fsockout) || retcode == 2)
+        {
+            if (ferror(fsockout)) fsockout = get_fsockout(handle_data_arg);
             rig_debug(RIG_DEBUG_ERR, "%s: socket error in=%d, out=%d\n", __func__,
                       ferror(fsockin), ferror(fsockout));
 
-            retcode = rig_close(my_rig);
-            rig_debug(RIG_DEBUG_ERR, "%s: rig_close retcode=%d\n", __func__, retcode);
-            retcode = rig_open(my_rig);
-            rig_debug(RIG_DEBUG_ERR, "%s: rig_open retcode=%d\n", __func__, retcode);
+            do
+            {
+                retcode = rig_close(my_rig);
+                hl_usleep(1000 * 1000);
+                rig_debug(RIG_DEBUG_ERR, "%s: rig_close retcode=%d\n", __func__, retcode);
+                retcode = rig_open(my_rig);
+                rig_debug(RIG_DEBUG_ERR, "%s: rig_open retcode=%d\n", __func__, retcode);
+            }
+            while (retcode != RIG_OK);
         }
     }
-
     while (retcode == 0 || retcode == 2 || retcode == -RIG_ENAVAIL);
 
 #ifdef HAVE_PTHREAD