diff --git a/include/hamlib/rig.h b/include/hamlib/rig.h
index 86f2cbdbc..fe9f12fa1 100644
--- a/include/hamlib/rig.h
+++ b/include/hamlib/rig.h
@@ -1898,9 +1898,9 @@ typedef struct hamlib_port {
 typedef hamlib_port_t port_t;
 #endif
 
-#define ELAPSED_GET 0
-#define ELAPSED_SET 1
-#define ELAPSED_INVALIDATE 2
+#define HAMLIB_ELAPSED_GET 0
+#define HAMLIB_ELAPSED_SET 1
+#define HAMLIB_ELAPSED_INVALIDATE 2
 
 typedef enum {
     CACHE_ALL, // to set all cache timeouts at once
@@ -1909,7 +1909,7 @@ typedef enum {
     CACHE_MODE,
     CACHE_PTT,
     CACHE_SPLIT
-} cache_t;
+} hamlib_cache_t;
 
 /**
  * \brief Rig cache data
@@ -2739,8 +2739,8 @@ extern HAMLIB_EXPORT(const char *) rig_copyright HAMLIB_PARAMS(());
 
 extern HAMLIB_EXPORT(void) rig_no_restore_ai();
 
-extern HAMLIB_EXPORT(int) rig_get_cache_timeout_ms(RIG *rig, cache_t selection);
-extern HAMLIB_EXPORT(int) rig_set_cache_timeout_ms(RIG *rig, cache_t selection, int ms);
+extern HAMLIB_EXPORT(int) rig_get_cache_timeout_ms(RIG *rig, hamlib_cache_t selection);
+extern HAMLIB_EXPORT(int) rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection, int ms);
 
 extern HAMLIB_EXPORT(int) rig_set_vfo_opt(RIG *rig, int status);
 
diff --git a/src/misc.c b/src/misc.c
index 9c0ffdeb4..b715a998d 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -1262,7 +1262,7 @@ double HAMLIB_API elapsed_ms(struct timespec *start, int option)
     struct timespec stop;
     double elapsed_msec;
 
-    if (option == ELAPSED_SET)
+    if (option == HAMLIB_ELAPSED_SET)
     {
         start->tv_sec = start->tv_nsec = 0;
     }
@@ -1273,7 +1273,7 @@ double HAMLIB_API elapsed_ms(struct timespec *start, int option)
 
     switch (option)
     {
-    case ELAPSED_GET:
+    case HAMLIB_ELAPSED_GET:
         if (start->tv_nsec == 0)   // if we haven't done SET yet
         {
             clock_gettime(CLOCK_REALTIME, start);
@@ -1283,14 +1283,14 @@ double HAMLIB_API elapsed_ms(struct timespec *start, int option)
         clock_gettime(CLOCK_REALTIME, &stop);
         break;
 
-    case ELAPSED_SET:
+    case HAMLIB_ELAPSED_SET:
         clock_gettime(CLOCK_REALTIME, start);
         rig_debug(RIG_DEBUG_TRACE, "%s: after gettime, start = %ld,%ld\n", __func__,
                   (long)start->tv_sec, (long)start->tv_nsec);
         return 999 * 1000; // so we can tell the difference in debug where we came from
         break;
 
-    case ELAPSED_INVALIDATE:
+    case HAMLIB_ELAPSED_INVALIDATE:
         clock_gettime(CLOCK_REALTIME, start);
         start->tv_sec -= 3600;
         break;
@@ -1301,18 +1301,18 @@ double HAMLIB_API elapsed_ms(struct timespec *start, int option)
 
     rig_debug(RIG_DEBUG_TRACE, "%s: elapsed_msecs=%g\n", __func__, elapsed_msec);
 
-    if (elapsed_msec < 0 || option == ELAPSED_INVALIDATE) { return 1000000; }
+    if (elapsed_msec < 0 || option == HAMLIB_ELAPSED_INVALIDATE) { return 1000000; }
 
     return elapsed_msec;
 }
 
-int HAMLIB_API rig_get_cache_timeout_ms(RIG *rig, cache_t selection)
+int HAMLIB_API rig_get_cache_timeout_ms(RIG *rig, hamlib_cache_t selection)
 {
     rig_debug(RIG_DEBUG_TRACE, "%s: called selection=%d\n", __func__, selection);
     return rig->state.cache.timeout_ms;
 }
 
-int HAMLIB_API rig_set_cache_timeout_ms(RIG *rig, cache_t selection, int ms)
+int HAMLIB_API rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection, int ms)
 {
     rig_debug(RIG_DEBUG_TRACE, "%s: called selection=%d, ms=%d\n", __func__,
               selection, ms);
diff --git a/src/rig.c b/src/rig.c
index 91526c1b6..e781aa614 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -1361,7 +1361,7 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 
     if (retcode == RIG_OK)
     {
-        elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
         rig->state.cache.freq = freq;
         rig->state.cache.vfo_freq = vfo;
     }
@@ -1432,7 +1432,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
     }
 
 
-    cache_ms = elapsed_ms(&rig->state.cache.time_freq, ELAPSED_GET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_freq, HAMLIB_ELAPSED_GET);
     rig_debug(RIG_DEBUG_TRACE, "%s: cache check age=%dms\n", __func__, cache_ms);
 
     if (cache_ms < rig->state.cache.timeout_ms && rig->state.cache.vfo_freq == vfo)
@@ -1481,7 +1481,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
             case RIG_VFO_MAIN:
             case RIG_VFO_MAIN_A:
                 rig->state.cache.freqMainA = *freq;
-                elapsed_ms(&rig->state.cache.time_freqMainA, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_freqMainA, HAMLIB_ELAPSED_SET);
                 rig->state.cache.freqMainA = *freq;
                 break;
 
@@ -1489,17 +1489,17 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
             case RIG_VFO_SUB:
             case RIG_VFO_MAIN_B:
                 rig->state.cache.freqMainB = *freq;
-                elapsed_ms(&rig->state.cache.time_freqMainB, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_freqMainB, HAMLIB_ELAPSED_SET);
                 break;
 
             case RIG_VFO_SUB_A:
                 rig->state.cache.freqSubA = *freq;
-                elapsed_ms(&rig->state.cache.time_freqSubA, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_freqSubA, HAMLIB_ELAPSED_SET);
                 break;
 
             case RIG_VFO_SUB_B:
                 rig->state.cache.freqSubB = *freq;
-                elapsed_ms(&rig->state.cache.time_freqSubB, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_freqSubB, HAMLIB_ELAPSED_SET);
                 break;
             }
 
@@ -1528,7 +1528,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
 
         if (RIG_OK == retcode)
         {
-            cache_ms = elapsed_ms(&(rig->state.cache.time_freq), ELAPSED_SET);
+            cache_ms = elapsed_ms(&(rig->state.cache.time_freq), HAMLIB_ELAPSED_SET);
             rig_debug(RIG_DEBUG_TRACE, "%s: cache reset age=%dms, vfo=%s, freq=%.0f\n",
                       __func__, cache_ms, rig_strvfo(vfo), *freq);
             rig->state.cache.freq = *freq;
@@ -1556,7 +1556,7 @@ if (rig->state.lo_freq != 0.0)
 }
 
 
-cache_ms = elapsed_ms(&(rig->state.cache.time_freq), ELAPSED_SET);
+cache_ms = elapsed_ms(&(rig->state.cache.time_freq), HAMLIB_ELAPSED_SET);
            rig_debug(RIG_DEBUG_TRACE, "%s: cache reset age=%dms, vfo=%s, freq=%.0f\n",
                      __func__, cache_ms, rig_strvfo(vfo), *freq);
            rig->state.cache.freq = *freq;
@@ -1648,7 +1648,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
     rig->state.cache.mode = mode;
     rig->state.cache.vfo_mode = vfo;
-    elapsed_ms(&rig->state.cache.time_mode, ELAPSED_SET);
+    elapsed_ms(&rig->state.cache.time_mode, HAMLIB_ELAPSED_SET);
 
     return retcode;
 }
@@ -1696,7 +1696,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
         return -RIG_ENAVAIL;
     }
 
-    cache_ms = elapsed_ms(&rig->state.cache.time_mode, ELAPSED_GET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_mode, HAMLIB_ELAPSED_GET);
     rig_debug(RIG_DEBUG_TRACE, "%s: cache check age=%dms\n", __func__, cache_ms);
 
     if (cache_ms < rig->state.cache.timeout_ms && rig->state.cache.vfo_mode == vfo)
@@ -1761,7 +1761,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
     rig->state.cache.mode = *mode;
     rig->state.cache.width = *width;
     rig->state.cache.vfo_mode = vfo;
-    cache_ms = elapsed_ms(&rig->state.cache.time_mode, ELAPSED_SET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_mode, HAMLIB_ELAPSED_SET);
 
     return retcode;
 }
@@ -1995,9 +1995,9 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
     }
 
     // expire several cached items when we switch VFOs
-    elapsed_ms(&rig->state.cache.time_vfo, ELAPSED_INVALIDATE);
-    elapsed_ms(&rig->state.cache.time_freq, ELAPSED_INVALIDATE);
-    elapsed_ms(&rig->state.cache.time_mode, ELAPSED_INVALIDATE);
+    elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_INVALIDATE);
+    elapsed_ms(&rig->state.cache.time_freq, HAMLIB_ELAPSED_INVALIDATE);
+    elapsed_ms(&rig->state.cache.time_mode, HAMLIB_ELAPSED_INVALIDATE);
 
     rig_debug(RIG_DEBUG_TRACE, "%s: return %d, vfo=%s\n", __func__, retcode,
               rig_strvfo(vfo));
@@ -2042,7 +2042,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
         return -RIG_ENAVAIL;
     }
 
-    cache_ms = elapsed_ms(&rig->state.cache.time_vfo, ELAPSED_GET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_GET);
     rig_debug(RIG_DEBUG_TRACE, "%s: cache check age=%dms\n", __func__, cache_ms);
 
     if (cache_ms < rig->state.cache.timeout_ms)
@@ -2062,11 +2062,11 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
     {
         rig->state.current_vfo = *vfo;
         rig->state.cache.vfo = *vfo;
-        cache_ms = elapsed_ms(&rig->state.cache.time_vfo, ELAPSED_SET);
+        cache_ms = elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_SET);
     }
     else
     {
-        cache_ms = elapsed_ms(&rig->state.cache.time_vfo, ELAPSED_INVALIDATE);
+        cache_ms = elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_INVALIDATE);
     }
 
     if (retcode != RIG_OK)
@@ -2273,7 +2273,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     }
 
     rig->state.cache.ptt = ptt;
-    elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+    elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
 
     if (retcode != RIG_OK) { rig_debug(RIG_DEBUG_ERR, "%s: return code=%d\n", __func__, retcode); }
 
@@ -2311,7 +2311,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
         return -RIG_EINVAL;
     }
 
-    cache_ms = elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_GET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_GET);
     rig_debug(RIG_DEBUG_TRACE, "%s: cache check age=%dms\n", __func__, cache_ms);
 
     if (cache_ms < rig->state.cache.timeout_ms)
@@ -2346,7 +2346,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
             if (retcode == RIG_OK)
             {
                 rig->state.cache.ptt = *ptt;
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
             }
 
             return retcode;
@@ -2374,7 +2374,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
             /* return the first error code */
             retcode = rc2;
             rig->state.cache.ptt = *ptt;
-            elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+            elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
         }
 
         return retcode;
@@ -2386,7 +2386,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
             if (retcode == RIG_OK)
             {
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
                 rig->state.cache.ptt = *ptt;
             }
 
@@ -2407,7 +2407,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
         }
 
         rig->state.cache.ptt = *ptt;
-        elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
         return retcode;
 
     case RIG_PTT_SERIAL_DTR:
@@ -2417,7 +2417,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
             if (retcode == RIG_OK)
             {
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
                 rig->state.cache.ptt = *ptt;
             }
 
@@ -2438,7 +2438,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
         }
 
         rig->state.cache.ptt = *ptt;
-        elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
         return retcode;
 
     case RIG_PTT_PARALLEL:
@@ -2448,7 +2448,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
             if (retcode == RIG_OK)
             {
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
                 rig->state.cache.ptt = *ptt;
             }
 
@@ -2459,7 +2459,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
         if (retcode == RIG_OK)
         {
-            elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+            elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
             rig->state.cache.ptt = *ptt;
         }
 
@@ -2472,7 +2472,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
             if (retcode == RIG_OK)
             {
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
                 rig->state.cache.ptt = *ptt;
             }
 
@@ -2483,7 +2483,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
         if (retcode == RIG_OK)
         {
-            elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+            elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
             rig->state.cache.ptt = *ptt;
         }
 
@@ -2497,14 +2497,14 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 
             if (retcode == RIG_OK)
             {
-                elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+                elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
                 rig->state.cache.ptt = *ptt;
             }
 
             return retcode;
         }
 
-        elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
         return gpio_ptt_get(&rig->state.pttport, ptt);
 
     case RIG_PTT_NONE:
@@ -2514,7 +2514,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
         return -RIG_EINVAL;
     }
 
-    elapsed_ms(&rig->state.cache.time_ptt, ELAPSED_SET);
+    elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
     return RIG_OK;
 }
 
@@ -3523,7 +3523,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
         rig->state.cache.split = split;
         rig->state.cache.split_vfo = tx_vfo;
-        elapsed_ms(&rig->state.cache.time_split, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
         return retcode;
     }
 
@@ -3558,7 +3558,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
 
     rig->state.cache.split = split;
     rig->state.cache.split_vfo = tx_vfo;
-    elapsed_ms(&rig->state.cache.time_split, ELAPSED_SET);
+    elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
     return retcode;
 }
 
@@ -3608,7 +3608,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
         return -RIG_ENAVAIL;
     }
 
-    cache_ms = elapsed_ms(&rig->state.cache.time_split, ELAPSED_GET);
+    cache_ms = elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_GET);
     rig_debug(RIG_DEBUG_TRACE, "%s: cache check age=%dms\n", __func__, cache_ms);
 
     if (cache_ms < rig->state.cache.timeout_ms)
@@ -3633,7 +3633,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
         retcode = caps->get_split_vfo(rig, vfo, split, tx_vfo);
         rig->state.cache.split = *split;
         rig->state.cache.split_vfo = *tx_vfo;
-        elapsed_ms(&rig->state.cache.time_split, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
         return retcode;
     }
 
@@ -3670,7 +3670,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
     {
         rig->state.cache.split = *split;
         rig->state.cache.split_vfo = *tx_vfo;
-        elapsed_ms(&rig->state.cache.time_split, ELAPSED_SET);
+        elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
     }
 
     return retcode;
diff --git a/tests/ampctl.c b/tests/ampctl.c
index 1fc31f271..1e7e93817 100644
--- a/tests/ampctl.c
+++ b/tests/ampctl.c
@@ -142,6 +142,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc,
                         argv,
@@ -191,7 +192,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/ampctld.c b/tests/ampctld.c
index dde43452d..e5244eaed 100644
--- a/tests/ampctld.c
+++ b/tests/ampctld.c
@@ -185,6 +185,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc, argv, SHORT_OPTIONS, long_options, &option_index);
 
@@ -230,7 +231,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/cachetest.c b/tests/cachetest.c
index f92758f48..54342fd56 100644
--- a/tests/cachetest.c
+++ b/tests/cachetest.c
@@ -101,7 +101,7 @@ int main(int argc, char *argv[])
         printf("Rig_info: '%s'\n", info_buf);
     }
 
-    elapsed_ms(&startall, ELAPSED_SET);
+    elapsed_ms(&startall, HAMLIB_ELAPSED_SET);
 
     for (i = 0; i < loops; ++i)
     {
@@ -111,51 +111,54 @@ int main(int argc, char *argv[])
         ptt_t ptt;
         split_t split;
 
-        elapsed_ms(&start, ELAPSED_SET);
+        elapsed_ms(&start, HAMLIB_ELAPSED_SET);
 
         retcode = rig_get_vfo(my_rig, &vfo);
 
         if (retcode != RIG_OK) { printf("Get vfo failed?? Err=%s\n", rigerror(retcode)); }
 
-        printf("%4dms: VFO = %s\n", (int)elapsed_ms(&start, ELAPSED_GET),
+        printf("%4dms: VFO = %s\n", (int)elapsed_ms(&start, HAMLIB_ELAPSED_GET),
                rig_strvfo(vfo));
 
-        elapsed_ms(&start, ELAPSED_SET);
+        elapsed_ms(&start, HAMLIB_ELAPSED_SET);
         retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
 
         if (retcode != RIG_OK) { printf("Get freq failed?? Err=%s\n", rigerror(retcode)); }
 
-        printf("%4dms: VFO freq. = %.1f Hz\n", (int)elapsed_ms(&start, ELAPSED_GET),
+        printf("%4dms: VFO freq. = %.1f Hz\n", (int)elapsed_ms(&start,
+                HAMLIB_ELAPSED_GET),
                freq);
-        elapsed_ms(&start, ELAPSED_SET);
+        elapsed_ms(&start, HAMLIB_ELAPSED_SET);
         retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &mode, &width);
 
         if (retcode != RIG_OK) { printf("Get mode failed?? Err=%s\n", rigerror(retcode)); }
 
         printf("%4dms: Current mode = %s, width = %ld\n", (int)elapsed_ms(&start,
-                ELAPSED_GET),
+                HAMLIB_ELAPSED_GET),
                rig_strrmode(mode), width);
 
-        elapsed_ms(&start, ELAPSED_SET);
+        elapsed_ms(&start, HAMLIB_ELAPSED_SET);
         retcode = rig_get_ptt(my_rig, RIG_VFO_A, &ptt);
 
         if (retcode != RIG_OK) { printf("Get ptt failed?? Err=%s\n", rigerror(retcode)); }
 
-        printf("%4dms: ptt=%d\n", (int)elapsed_ms(&start, ELAPSED_GET), ptt);
+        printf("%4dms: ptt=%d\n", (int)elapsed_ms(&start, HAMLIB_ELAPSED_GET), ptt);
 
 #if 1
-        elapsed_ms(&start, ELAPSED_SET);
+        elapsed_ms(&start, HAMLIB_ELAPSED_SET);
         retcode = rig_get_split_vfo(my_rig, RIG_VFO_A, &split, &vfo);
 
         if (retcode != RIG_OK) { printf("Get split_vfo failed?? Err=%s\n", rigerror(retcode)); }
 
-        printf("%4dms: split=%d, tx_vfo=%s\n", (int)elapsed_ms(&start, ELAPSED_GET),
+        printf("%4dms: split=%d, tx_vfo=%s\n", (int)elapsed_ms(&start,
+                HAMLIB_ELAPSED_GET),
                split,
                rig_strvfo(vfo));
 #endif
     }
 
-    printf("Elapsed %gsec\n", (int)elapsed_ms(&startall, ELAPSED_GET) / 1000.0);
+    printf("Elapsed %gsec\n", (int)elapsed_ms(&startall,
+            HAMLIB_ELAPSED_GET) / 1000.0);
 
     rig_close(my_rig);
     return 0;
diff --git a/tests/rigctl.c b/tests/rigctl.c
index 901a7e817..2c9d7800f 100644
--- a/tests/rigctl.c
+++ b/tests/rigctl.c
@@ -158,6 +158,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc,
                         argv,
@@ -353,7 +354,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rigctl_parse.c b/tests/rigctl_parse.c
index a4e9d084d..31c1d28c5 100644
--- a/tests/rigctl_parse.c
+++ b/tests/rigctl_parse.c
@@ -4085,9 +4085,9 @@ declare_proto_rig(dump_state)
     // backward compatible as new values will just generate warnings
     if (chk_vfo_executed) // for 3.3 compatiblility
     {
-       fprintf(fout, "vfo_ops=0x%x\n", rig->caps->vfo_ops);
-       fprintf(fout, "ptt_type=0x%x\n", rig->state.pttport.type.ptt);
-       fprintf(fout, "done\n");
+        fprintf(fout, "vfo_ops=0x%x\n", rig->caps->vfo_ops);
+        fprintf(fout, "ptt_type=0x%x\n", rig->state.pttport.type.ptt);
+        fprintf(fout, "done\n");
     }
 
 #if 0 // why isn't this implemented?  Does anybody care?
diff --git a/tests/rigctlcom.c b/tests/rigctlcom.c
index 118d11f3c..eda52b98a 100644
--- a/tests/rigctlcom.c
+++ b/tests/rigctlcom.c
@@ -227,6 +227,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc,
                         argv,
@@ -393,7 +394,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'S':
diff --git a/tests/rigctld.c b/tests/rigctld.c
index cc00e516c..2b0baea76 100644
--- a/tests/rigctld.c
+++ b/tests/rigctld.c
@@ -265,6 +265,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc,
                         argv,
@@ -442,7 +443,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rigmem.c b/tests/rigmem.c
index 029f77e45..ca0796638 100644
--- a/tests/rigmem.c
+++ b/tests/rigmem.c
@@ -115,6 +115,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc, argv, SHORT_OPTIONS, long_options, &option_index);
 
@@ -170,7 +171,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rigsmtr.c b/tests/rigsmtr.c
index 071814e20..c27cb7c81 100644
--- a/tests/rigsmtr.c
+++ b/tests/rigsmtr.c
@@ -99,6 +99,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc, argv, SHORT_OPTIONS, long_options, &option_index);
 
@@ -154,7 +155,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rigswr.c b/tests/rigswr.c
index 2901fe421..62bb949e5 100644
--- a/tests/rigswr.c
+++ b/tests/rigswr.c
@@ -89,6 +89,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc, argv, SHORT_OPTIONS, long_options, &option_index);
 
@@ -144,7 +145,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rotctl.c b/tests/rotctl.c
index f90fade14..dbcae7486 100644
--- a/tests/rotctl.c
+++ b/tests/rotctl.c
@@ -147,6 +147,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc,
                         argv,
@@ -196,7 +197,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':
diff --git a/tests/rotctld.c b/tests/rotctld.c
index 7c51f9bb3..ffc33bbcd 100644
--- a/tests/rotctld.c
+++ b/tests/rotctld.c
@@ -179,6 +179,7 @@ int main(int argc, char *argv[])
     {
         int c;
         int option_index = 0;
+        char dummy[2];
 
         c = getopt_long(argc, argv, SHORT_OPTIONS, long_options, &option_index);
 
@@ -224,7 +225,12 @@ int main(int argc, char *argv[])
                 exit(1);
             }
 
-            serial_rate = atoi(optarg);
+            if (sscanf(optarg, "%d%1s", &serial_rate, dummy) != 1)
+            {
+                fprintf(stderr, "Invalid baud rate of %s\n", optarg);
+                exit(1);
+            }
+
             break;
 
         case 'C':