diff --git a/kenwood/elecraft.c b/kenwood/elecraft.c
index 6884bc1f4..d1d6eacd9 100644
--- a/kenwood/elecraft.c
+++ b/kenwood/elecraft.c
@@ -289,10 +289,9 @@ int elecraft_get_firmware_revision_level(RIG *rig, const char *cmd,
 	int err;
 	char *bufptr;
 	char buf[KENWOOD_MAX_BUF_LEN];
-	size_t size = KENWOOD_MAX_BUF_LEN;
 
 	/* Get the actual firmware revision number. */
-	err = kenwood_transaction(rig, cmd, buf, &size);
+	err = kenwood_transaction(rig, cmd, buf, sizeof (buf));
 
 	if (err != RIG_OK) {
 		rig_debug(RIG_DEBUG_VERBOSE, "%s: Cannot get firmware revision level\n", __func__);
diff --git a/kenwood/flex6xxx.c b/kenwood/flex6xxx.c
index 53c348430..5b843f75e 100644
--- a/kenwood/flex6xxx.c
+++ b/kenwood/flex6xxx.c
@@ -224,7 +224,7 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
   }
 
   sprintf(buf, "MD%c", '0' + kmode);
-  err = kenwood_simple_cmd(rig, buf);
+  err = kenwood_transaction(rig, buf, NULL, 0);
   if (err != RIG_OK)
     return err;
 
@@ -252,7 +252,7 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     return -RIG_EINVAL;
   }
 
-  err = kenwood_simple_cmd(rig, buf);
+  err = kenwood_transaction(rig, buf, NULL, 0);
   if (err != RIG_OK)
     return err;
   return RIG_OK;
diff --git a/kenwood/k2.c b/kenwood/k2.c
index aa712486d..50731c095 100644
--- a/kenwood/k2.c
+++ b/kenwood/k2.c
@@ -347,16 +347,16 @@ int k2_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, "K22");
+	err = kenwood_transaction(rig, "K22", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
 	/* Set the filter slot */
-	err = kenwood_simple_cmd(rig, fcmd);
+	err = kenwood_transaction(rig, fcmd, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, "K20");
+	err = kenwood_transaction(rig, "K20", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -387,7 +387,7 @@ int k2_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, "K22");
+	err = kenwood_transaction(rig, "K22", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -395,7 +395,7 @@ int k2_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, "K20");
+	err = kenwood_transaction(rig, "K20", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -478,7 +478,7 @@ int k2_probe_mdfw(RIG *rig, struct kenwood_priv_data *priv)
 	/* The K2 extension level has been stored by elecraft_open().  Now set rig
 	 * to K22 for detailed query of mode and filter width values...
 	 */
-	err = kenwood_simple_cmd(rig, "K22");
+	err = kenwood_transaction(rig, "K22", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -503,7 +503,7 @@ int k2_probe_mdfw(RIG *rig, struct kenwood_priv_data *priv)
 
 	/* First try to put the K2 into RTTY mode and check if it's available. */
 	priv->k2_md_rtty = 0;		/* Assume RTTY module not installed */
-	err = kenwood_simple_cmd(rig, "MD6");
+	err = kenwood_transaction(rig, "MD6", NULL, 0);
 	if (err != RIG_OK && err != -RIG_ERJCTED)
 		return err;
 	if (RIG_OK == err)
@@ -565,15 +565,15 @@ int k2_mdfw_rest(RIG *rig, const char *mode, const char *fw)
 	if (strlen(mode) != 3 || strlen(fw) != 7)
 		return -RIG_EINVAL;
 
-	err = kenwood_simple_cmd(rig, mode);
+	err = kenwood_transaction(rig, mode, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, fw);
+	err = kenwood_transaction(rig, fw, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
-	err = kenwood_simple_cmd(rig, "K20");
+	err = kenwood_transaction(rig, "K20", NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -607,14 +607,14 @@ int k2_pop_fw_lst(RIG *rig, const char *cmd)
 		return -RIG_EINVAL;
 
 	/* Set the mode */
-	err = kenwood_simple_cmd(rig, cmd);
+	err = kenwood_transaction(rig, cmd, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
 	for (f = 1; f < 5; f++) {
 		snprintf(fcmd, 8, "FW0000%d", f);
 
-		err = kenwood_simple_cmd(rig, fcmd);
+		err = kenwood_transaction(rig, fcmd, NULL, 0);
 		if (err != RIG_OK)
 			return err;
 
diff --git a/kenwood/k3.c b/kenwood/k3.c
index f9ff0e62c..e3fae6468 100644
--- a/kenwood/k3.c
+++ b/kenwood/k3.c
@@ -401,7 +401,7 @@ int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 		width = pb_wid;
 
 	sprintf(cmd_s, "BW%04ld", width / 10);
-	err = kenwood_simple_cmd(rig, cmd_s);
+	err = kenwood_transaction(rig, cmd_s, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 
@@ -411,7 +411,7 @@ int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 	if (mode == RIG_MODE_PKTLSB || mode == RIG_MODE_PKTUSB
 	    || mode == RIG_MODE_RTTY || mode == RIG_MODE_RTTYR)
 	  {
-	    err = kenwood_simple_cmd(rig, cmd_m);
+	    err = kenwood_transaction(rig, cmd_m, NULL, 0);
 	    if (err != RIG_OK)
 	      return err;
 	  }
@@ -437,7 +437,7 @@ int k3_set_vfo(RIG *rig, vfo_t vfo)
 
 	switch (vfo) {
 	case RIG_VFO_B:
-		err = kenwood_simple_cmd(rig, "SWT11");
+		err = kenwood_transaction(rig, "SWT11", NULL, 0);
 		if (err != RIG_OK)
 			return err;
 		break;
@@ -473,7 +473,7 @@ int k3_set_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t val)
 	switch(token) {
 	case TOK_RIT_CLR:
 		/* Clear offset */
-		err = kenwood_simple_cmd(rig, "RC");
+		err = kenwood_transaction(rig, "RC", NULL, 0);
 		if (err != RIG_OK)
 			return err;
 
@@ -634,7 +634,7 @@ int k3_set_split_mode(RIG * rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
   }
 
   sprintf(buf, "MD$%c", '0' + kmode);
-  err = kenwood_simple_cmd(rig, buf);
+  err = kenwood_transaction(rig, buf, NULL, 0);
   if (err != RIG_OK)
     return err;
 
@@ -663,7 +663,7 @@ int k3_set_split_mode(RIG * rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
     tx_width = pb_wid;
 
   sprintf(cmd_s, "BW$%04ld", tx_width / 10);
-  err = kenwood_simple_cmd(rig, cmd_s);
+  err = kenwood_transaction(rig, cmd_s, NULL, 0);
   if (err != RIG_OK)
     return err;
 
@@ -672,7 +672,7 @@ int k3_set_split_mode(RIG * rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
    */
   if (tx_mode == RIG_MODE_PKTLSB || tx_mode == RIG_MODE_PKTUSB
       || tx_mode == RIG_MODE_RTTY || tx_mode == RIG_MODE_RTTYR) {
-    err = kenwood_simple_cmd(rig, cmd_m);
+    err = kenwood_transaction(rig, cmd_m, NULL, 0);
     if (err != RIG_OK)
       return err;
   }
@@ -869,7 +869,7 @@ int set_rit_xit(RIG *rig, shortfreq_t rit)
 
 	if (rit == 0) {
 		/* Clear offset and return */
-		err = kenwood_simple_cmd(rig, "RC");
+		err = kenwood_transaction(rig, "RC", NULL, 0);
 		if (err != RIG_OK)
 			return err;
 
@@ -881,7 +881,7 @@ int set_rit_xit(RIG *rig, shortfreq_t rit)
 		offs = (rit < 0) ? '-' : '+';
 		snprintf(cmd, 8, "RO%c%04d", offs, abs((int)rit));
 
-		err = kenwood_simple_cmd(rig, cmd);
+		err = kenwood_transaction(rig, cmd, NULL, 0);
 		if (err != RIG_OK)
 			return err;
 
diff --git a/kenwood/kenwood.c b/kenwood/kenwood.c
index 22f5d0d07..702f473bc 100644
--- a/kenwood/kenwood.c
+++ b/kenwood/kenwood.c
@@ -183,16 +183,15 @@ const struct confparams kenwood_cfg_params[] = {
  *        is needed and will return with RIG_OK after command was sent.
  * datasize: in: Size of buffer. It is the caller's responsibily to provide
  *         a large enough buffer for all possible replies for a command.
- *      out: Location where to store number of bytes read.
  *
  * returns:
- *   RIG_OK -   if no error occured.
+ *   RIG_OK -   if no error occurred.
  *   RIG_EIO -    if an I/O error occured while sending/receiving data.
  *   RIG_ETIMEOUT - if timeout expires without any characters received.
  *   RIG_REJECTED - if a negative acknowledge was received or command not
  *          recognized by rig.
  */
-int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasize)
+int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t datasize)
 {
   char buffer[KENWOOD_MAX_BUF_LEN]; /* use our own buffer since
                                        verification may need a longer
@@ -200,7 +199,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
 
   rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
-  if (!rig || !datasize || !cmdstr)
+  if (!rig || (!cmdstr && !datasize) || (datasize && !data))
     return -RIG_EINVAL;
 
   struct kenwood_priv_caps *caps = kenwood_caps(rig);
@@ -210,7 +209,6 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
   char *cmd;
   int len;
   int retry_read = 0;
-  int reply_expected = !cmdstr || (data && *datasize > 0);
   static char const std_verify[] = "ID;"; /* command we can always
                                              send to any rig even when
                                              the rig is busy */
@@ -255,7 +253,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
         goto transaction_quit;
     }
 
-  if (!reply_expected) {
+  if (!datasize) {
     rig->state.hold_decode = 0;
 
     /* no reply expected so we need to write a command that always
@@ -266,7 +264,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
     }
   }
 
-  len = min (reply_expected ? *datasize : strlen (verify) + 5, KENWOOD_MAX_BUF_LEN);
+  len = min (datasize ? datasize : strlen (verify) + 5, KENWOOD_MAX_BUF_LEN);
   retval = read_string(&rs->rigport, buffer, len, cmdtrm, strlen(cmdtrm));
   if (retval < 0) {
     if (retry_read++ < rig->caps->retry)
@@ -336,7 +334,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
    * single character commands we only check the first character in
    * that case.
    */
-  if (reply_expected)
+  if (datasize)
     {
       if (cmdstr && (buffer[0] != cmdstr[0] || (cmdstr[1] && buffer[1] != cmdstr[1])))
         {
@@ -359,9 +357,9 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data, size_t *datasi
         {
           /* move the result excluding the command terminator into the
              caller buffer */
-          *datasize = min (*datasize, retval) - 1;
-          strncpy (data, buffer, *datasize);
-          data[*datasize] = '\0';
+          len = min (datasize, retval) - 1;
+          strncpy (data, buffer, len);
+          data[len] = '\0';
         }
     }
   else
@@ -425,12 +423,12 @@ int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf,
 
   do
     {
-      size_t length = buf_size;
-      err = kenwood_transaction(rig, cmd, buf, &length);
+      err = kenwood_transaction(rig, cmd, buf, buf_size);
       if (err != RIG_OK)        /* return immediately on error as any
                                    retries handled at lower level */
         return err;
 
+      size_t length = strlen (buf);
       if (length != expected) /* worth retrying as some rigs
                                    occasionally send short results */
         {
@@ -530,31 +528,27 @@ int kenwood_open(RIG *rig)
   if (RIG_MODEL_TS590S == rig->caps->rig_model)
     {
       /* we need the firmware version for these rigs to deal with f/w defects */
-      char buffer[KENWOOD_MAX_BUF_LEN];
-      static char fw_version[5];
-      size_t size = KENWOOD_MAX_BUF_LEN;
+      static char fw_version[7];
       struct kenwood_priv_data * priv = rig->state.priv;
 
-      err = kenwood_transaction (rig, "FV", buffer, &size);
+      err = kenwood_transaction (rig, "FV", fw_version, sizeof (fw_version));
       if (RIG_OK != err)
         {
-    rig_debug (RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__);
-    return err;
+          rig_debug (RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__);
+          return err;
         }
-      /* store the data between "FV" and ";" which should be a
-         f/w version string of the form n.n e.g. 1.07 */
-      priv->fw_rev = strncpy (fw_version, &buffer[2], size - 3);
-      char * dot_pos = strchr (buffer, '.');
+      /* store the data  after the "FV" which should be  a f/w version
+         string of the form n.n e.g. 1.07 */
+      priv->fw_rev = &fw_version[2];
+      char * dot_pos = strchr (fw_version, '.');
       if (dot_pos)
         {
-    *dot_pos = '\0';
-    buffer[size - 1] = '\0';
-    priv->fw_rev_uint = atoi (&buffer[2]) * 100 + atoi (dot_pos + 1);
+          priv->fw_rev_uint = atoi (&fw_version[2]) * 100 + atoi (dot_pos + 1);
         }
       else
         {
-    rig_debug (RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__);
-    return -RIG_EPROTO;
+          rig_debug (RIG_DEBUG_ERR, "%s: cannot get f/w version\n", __func__);
+          return -RIG_EPROTO;
         }
       rig_debug (RIG_DEBUG_TRACE, "%s: found f/w version %s\n", __func__, priv->fw_rev);
     }
@@ -625,9 +619,7 @@ int kenwood_get_id(RIG *rig, char *buf)
   if (!rig)
     return -RIG_EINVAL;
 
-  size_t size = KENWOOD_MAX_BUF_LEN;
-
-  return kenwood_transaction(rig, "ID", buf, &size);
+  return kenwood_transaction(rig, "ID", buf, KENWOOD_MAX_BUF_LEN);
 }
 
 
@@ -698,7 +690,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
     }
 
   /* set RX VFO */
-  retval = kenwood_simple_cmd(rig, cmdbuf);
+  retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
   if (retval != RIG_OK)
     return retval;
 
@@ -709,7 +701,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
 
   /* set TX VFO */
   cmdbuf[1] = 'T';
-  return kenwood_simple_cmd(rig, cmdbuf);
+  return kenwood_transaction(rig, cmdbuf, NULL, 0);
 }
 
 
@@ -742,7 +734,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 
     /* set RX VFO */
     sprintf(cmdbuf, "FR%c", vfo_function);
-    retval = kenwood_simple_cmd(rig, cmdbuf);
+    retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
     if (retval != RIG_OK)
       return retval;
   }
@@ -768,7 +760,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
   }
   /* set TX VFO */
   sprintf(cmdbuf, "FT%c", vfo_function);
-  retval = kenwood_simple_cmd(rig, cmdbuf);
+  retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
   if (retval != RIG_OK)
     return retval;
 
@@ -795,7 +787,7 @@ int kenwood_set_split(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
   int retval;
 
   sprintf(cmdbuf, "SP%c", RIG_SPLIT_ON == split ? '1' : '0');
-  retval = kenwood_simple_cmd(rig, cmdbuf);
+  retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
   if (retval != RIG_OK)
     return retval;
 
@@ -940,7 +932,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
   }
   sprintf(freqbuf, "F%c%011ld", vfo_letter, (long)freq);
 
-  int err = kenwood_simple_cmd(rig, freqbuf);
+  int err = kenwood_transaction(rig, freqbuf, NULL, 0);
 
   struct kenwood_priv_data * priv = rig->state.priv;
   if (RIG_OK == err && RIG_MODEL_TS590S == rig->caps->rig_model && priv->fw_rev_uint <= 107 && ('A' == vfo_letter || 'B' == vfo_letter))
@@ -974,7 +966,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
       {
         return err;
       }
-    err = kenwood_simple_cmd (rig, freqbuf);
+    err = kenwood_transaction (rig, freqbuf, NULL, 0);
         }
     }
 
@@ -1085,17 +1077,17 @@ int kenwood_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
   int retval, i;
 
   if (rit == 0)
-    return kenwood_simple_cmd(rig, "RC");
-
+    return kenwood_transaction(rig, "RC", NULL, 0);
+  
   sprintf(buf, "R%c", (rit > 0) ? 'U' : 'D');
 
-  retval = kenwood_simple_cmd(rig, "RC");
+  retval = kenwood_transaction(rig, "RC", NULL, 0);
   if (retval != RIG_OK)
     return retval;
 
   for (i = 0; i < abs(rint(rit/10)); i++)
-    retval = kenwood_simple_cmd(rig, buf);
-
+    retval = kenwood_transaction(rig, buf, NULL, 0);
+  
   return retval;
 }
 
@@ -1129,7 +1121,7 @@ int kenwood_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
   if (!rig)
     return -RIG_EINVAL;
 
-  return kenwood_simple_cmd(rig, scan == RIG_SCAN_STOP ? "SC0" : "SC1");
+  return kenwood_transaction(rig, scan == RIG_SCAN_STOP ? "SC0" : "SC1", NULL, 0);
 }
 
 /*
@@ -1163,7 +1155,7 @@ static int kenwood_set_filter(RIG *rig, pbwidth_t width)
   else
     cmd = "FL002002";
 
-  return kenwood_simple_cmd(rig, cmd);
+  return kenwood_transaction(rig, cmd, NULL, 0);
 }
 
 /*
@@ -1215,7 +1207,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
   }
 
   sprintf(buf, "MD%c", '0' + kmode);
-  err = kenwood_simple_cmd(rig, buf);
+  err = kenwood_transaction(rig, buf, NULL, 0);
   if (err != RIG_OK)
     return err;
 
@@ -1224,7 +1216,7 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     {
       /* supports DATA sub modes - see above */
       sprintf (buf, "DA%c", data_mode);
-      int retval = kenwood_simple_cmd (rig, buf);
+      int retval = kenwood_transaction (rig, buf, NULL, 0);
       if (RIG_OK != retval)
         {
     return retval;
@@ -1473,7 +1465,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
     return -RIG_EINVAL;
   }
 
-  return kenwood_simple_cmd(rig, levelbuf);
+  return kenwood_transaction(rig, levelbuf, NULL, 0);
 }
 
 int get_kenwood_level(RIG *rig, const char *cmd, int cmd_len, float *f)
@@ -1509,11 +1501,10 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
   if (!rig || !val)
     return -RIG_EINVAL;
 
-  char lvlbuf[50];
+  char lvlbuf[KENWOOD_MAX_BUF_LEN];
   int retval;
   int lvl;
   int i, ret, agclevel;
-  size_t lvl_len;
 
   switch (level) {
   case RIG_LEVEL_RAWSTR:
@@ -1614,16 +1605,14 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
     return ret;
 
   case RIG_LEVEL_SLOPE_LOW:
-    lvl_len = 50;
-    retval = kenwood_transaction (rig, "SL", lvlbuf, &lvl_len);
+    retval = kenwood_transaction (rig, "SL", lvlbuf, sizeof (lvlbuf));
     if (retval != RIG_OK)
       return retval;
     val->i=atoi(&lvlbuf[2]);
     break;
 
   case RIG_LEVEL_SLOPE_HIGH:
-    lvl_len = 50;
-    retval = kenwood_transaction (rig, "SH", lvlbuf, &lvl_len);
+    retval = kenwood_transaction (rig, "SH", lvlbuf, sizeof (lvlbuf));
     if (retval != RIG_OK)
       return retval;
     val->i=atoi(&lvlbuf[2]);
@@ -1677,59 +1666,59 @@ int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
   switch (func) {
   case RIG_FUNC_NB:
     sprintf(buf, "NB%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_ABM:
     sprintf(buf, "AM%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_COMP:
     sprintf(buf, "PR%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_TONE:
     sprintf(buf, "TO%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_TSQL:
     sprintf(buf, "CT%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_VOX:
     sprintf(buf, "VX%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_FAGC:
     sprintf(buf, "GT00%c", (status == 0) ? '4' : '2');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_NR:
     sprintf(buf, "NR%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_BC:
     sprintf(buf, "BC%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_ANF:
     sprintf(buf, "NT%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_LOCK:
     sprintf(buf, "LK%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_AIP:
     sprintf(buf, "MX%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_RIT:
     sprintf(buf, "RT%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case RIG_FUNC_XIT:
     sprintf(buf, "XT%c", (status == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   default:
     rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %#x", func);
@@ -1857,7 +1846,7 @@ int kenwood_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
 /* TODO: replace menu no 57 by a define */
   sprintf(tonebuf, "EX%03d%04d", 57, i+1);
 
-  return kenwood_simple_cmd(rig, tonebuf);
+  return kenwood_transaction(rig, tonebuf, NULL, 0);
 }
 
 int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone)
@@ -1882,7 +1871,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone)
 
   sprintf(buf, "TN%02d", i + 1);
 
-  return kenwood_simple_cmd(rig, buf);
+  return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 /*
@@ -1953,7 +1942,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
 
   sprintf(buf, "CN%02d", i + 1);
 
-  return kenwood_simple_cmd(rig, buf);
+  return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
@@ -2054,7 +2043,7 @@ int kenwood_set_ant_no_ack(RIG * rig, vfo_t vfo, ant_t ant)
     return -RIG_EINVAL;
   }
 
-  return kenwood_simple_cmd(rig, cmd);
+  return kenwood_transaction(rig, cmd, NULL, 0);
 }
 
 /*
@@ -2122,7 +2111,7 @@ int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     case RIG_PTT_OFF: ptt_cmd = "RX"; break;
     default: return -RIG_EINVAL;
   }
-  return kenwood_simple_cmd(rig, ptt_cmd);
+  return kenwood_transaction(rig, ptt_cmd, NULL, 0);
 }
 
 int kenwood_set_ptt_safe(RIG *rig, vfo_t vfo, ptt_t ptt)
@@ -2142,8 +2131,8 @@ int kenwood_set_ptt_safe(RIG *rig, vfo_t vfo, ptt_t ptt)
   if (current_ptt == ptt)
     return RIG_OK;
 
-  return kenwood_simple_cmd(rig,
-    (ptt == RIG_PTT_ON) ? "TX" : "RX");
+  return kenwood_transaction(rig,
+                             (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0);
 }
 
 
@@ -2272,7 +2261,7 @@ int kenwood_reset(RIG *rig, reset_t reset)
   sprintf(rstbuf, "SR%c", rst);
 
   /* this command has no answer */
-  return kenwood_simple_cmd(rig, rstbuf);
+  return kenwood_transaction(rig, rstbuf, NULL, 0);
 }
 
 /*
@@ -2308,7 +2297,7 @@ int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg)
 
     /* the command must consist of 28 bytes */
     sprintf(morsebuf, "KY %-24s", m2);
-    retval = kenwood_simple_cmd(rig, morsebuf);
+    retval = kenwood_transaction(rig, morsebuf, NULL, 0);
     if (retval != RIG_OK)
       return retval;
 
@@ -2331,16 +2320,16 @@ int kenwood_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
   switch(op) {
   case RIG_OP_UP:
-    return kenwood_simple_cmd(rig, "UP");
+    return kenwood_transaction(rig, "UP", NULL, 0);
 
   case RIG_OP_DOWN:
-    return kenwood_simple_cmd(rig, "DN");
+    return kenwood_transaction(rig, "DN", NULL, 0);
 
   case RIG_OP_BAND_UP:
-    return kenwood_simple_cmd(rig, "BU");
+    return kenwood_transaction(rig, "BU", NULL, 0);
 
   case RIG_OP_BAND_DOWN:
-    return kenwood_simple_cmd(rig, "BD");
+    return kenwood_transaction(rig, "BD", NULL, 0);
 
   default:
     rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n",
@@ -2367,7 +2356,7 @@ int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch)
    */
   sprintf(buf, "MC %02d", ch);
 
-  return kenwood_simple_cmd(rig, buf);
+  return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 /*
@@ -2568,7 +2557,7 @@ int kenwood_set_channel(RIG *rig, const channel_t *chan)
           chan->ctcss_tone ? '1' : '0',
           chan->ctcss_tone ? (tone + 1) : 0);
 
-  err = kenwood_simple_cmd(rig, buf);
+  err = kenwood_transaction(rig, buf, NULL, 0);
   if (err != RIG_OK)
     return err;
 
@@ -2581,7 +2570,7 @@ int kenwood_set_channel(RIG *rig, const channel_t *chan)
           chan->ctcss_tone ? '1' : '0',
           chan->ctcss_tone ? (tone + 1) : 0);
 
-  return kenwood_simple_cmd(rig, buf);
+  return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val)
@@ -2595,19 +2584,19 @@ int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val)
 
   switch (token) {
   case TOK_VOICE:
-    return kenwood_simple_cmd(rig, "VR");
+    return kenwood_transaction(rig, "VR", NULL, 0);
 
   case TOK_FINE:
     sprintf(buf, "FS%c", (val.i == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case TOK_XIT:
     sprintf(buf, "XT%c", (val.i == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
 
   case TOK_RIT:
     sprintf(buf, "RT%c", (val.i == 0) ? '0' : '1');
-    return kenwood_simple_cmd(rig, buf);
+    return kenwood_transaction(rig, buf, NULL, 0);
   }
 
   return -RIG_EINVAL;
diff --git a/kenwood/kenwood.h b/kenwood/kenwood.h
index 26b7f6b36..213a51f7f 100644
--- a/kenwood/kenwood.h
+++ b/kenwood/kenwood.h
@@ -88,8 +88,7 @@ extern rmode_t kenwood_mode_table[KENWOOD_MODE_TABLE_MAX];
 extern const tone_t kenwood38_ctcss_list[];
 extern const tone_t kenwood42_ctcss_list[];
 
-int kenwood_transaction(RIG *rig, const char *cmd, char *data,
-        size_t *data_len);
+int kenwood_transaction(RIG *rig, const char *cmd, char *data, size_t data_len);
 int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf,
         size_t buf_size, size_t expected);
 
@@ -204,10 +203,4 @@ static int inline kenwood_simple_transaction(RIG *rig, const char *cmd, size_t e
   return kenwood_safe_transaction(rig, cmd, priv->info, KENWOOD_MAX_BUF_LEN, expected);
 }
 
-/* no answer needed at all */
-static int inline kenwood_simple_cmd(RIG *rig, const char *cmd)
-{
-  return kenwood_safe_transaction(rig, cmd, NULL, 0, 0);
-}
-
 #endif /* _KENWOOD_H */
diff --git a/kenwood/th.c b/kenwood/th.c
index 9beb8aadd..7156e7891 100644
--- a/kenwood/th.c
+++ b/kenwood/th.c
@@ -52,16 +52,16 @@ th_decode_event (RIG *rig)
 {
 	char asyncbuf[128];
 	int retval;
-	size_t async_len=128;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-	retval = kenwood_transaction(rig, NULL, asyncbuf, &async_len);
+	retval = kenwood_transaction(rig, NULL, asyncbuf, sizeof (asyncbuf));
 	if (retval != RIG_OK)
 		return retval;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
 
+	size_t async_len = strlen (asyncbuf);
 	if (async_len> 3 && asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') {
 
 		vfo_t vfo;
@@ -197,7 +197,7 @@ th_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
 	freq_sent = freq_sent >= MHz(470) ? (round(freq_sent/10000)*10000) : freq_sent;
 	sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step);
 
-	return kenwood_simple_cmd(rig, buf);
+	return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 /*
@@ -270,7 +270,7 @@ th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 
 	sprintf(mdbuf, "MD %c", kmode);
 
-	retval = kenwood_simple_cmd(rig, mdbuf);
+	retval = kenwood_transaction(rig, mdbuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -403,24 +403,24 @@ th_set_vfo(RIG *rig, vfo_t vfo)
 		return kenwood_wrong_vfo(__func__, vfo);
 	}
 
-	return kenwood_simple_cmd(rig, cmd);
+	return kenwood_transaction(rig, cmd, NULL, 0);
 }
 
 int
 th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
 {
 	char cmdbuf[10], buf[10], vfoc;
-	size_t buf_size=10;
 	int retval;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
 	/* Get VFO band */
 
-	retval = kenwood_transaction(rig, "BC", buf, &buf_size);
+	retval = kenwood_transaction(rig, "BC", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
-	switch (buf_size) {
+	size_t length = strlen (buf);
+	switch (length) {
 	case 4: /*original case BC 0*/
 	  vfoc = buf[3];
 	  break;
@@ -433,7 +433,7 @@ th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
 	  }
 	  break;
 	default:
-	  rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, buf_size);
+	  rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, length);
 	  return -RIG_EPROTO;
 	  break;
 	}
@@ -512,8 +512,6 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo)
     char vfobuf[16], ackbuf[16];
     int vfonum, txvfonum, vfomode=0;
     int retval;
-    size_t ack_len;
-
 
     rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo));
 
@@ -534,8 +532,7 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo)
         case RIG_VFO_MEM:
             /* get current band */
             sprintf(vfobuf, "BC");
-            ack_len=16;
-            retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+            retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof (ackbuf));
             if (retval != RIG_OK)
                 return retval;
             txvfonum = vfonum = ackbuf[3]-'0';
@@ -548,7 +545,7 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo)
 	}
 
 	sprintf(vfobuf, "VMC %d,%d", vfonum, vfomode);
-	retval = kenwood_simple_cmd(rig, vfobuf);
+	retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
@@ -556,7 +553,7 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo)
         return RIG_OK;
 
     sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum);
-    retval = kenwood_simple_cmd(rig, vfobuf);
+    retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
@@ -599,12 +596,12 @@ int th_set_split_vfo (RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 
     /* Set VFO mode. To be done for TX vfo also? */
 	sprintf(vfobuf, "VMC %d,0", vfonum);
-	retval = kenwood_simple_cmd(rig, vfobuf);
+	retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
     sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum);
-    retval = kenwood_simple_cmd(rig, vfobuf);
+    retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
@@ -652,7 +649,7 @@ int th_get_split_vfo (RIG *rig, vfo_t vfo, split_t *split, vfo_t *txvfo)
 int
 th_set_trn(RIG *rig, int trn)
 {
-	return kenwood_simple_cmd(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0");
+	return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0", NULL, 0);
 }
 
 /*
@@ -664,20 +661,19 @@ th_get_trn(RIG *rig, int *trn)
 {
 	char buf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len=ACKBUF_LEN;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-	retval = kenwood_transaction(rig, "AI", buf, &ack_len);
+	retval = kenwood_transaction(rig, "AI", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
 
-	if (ack_len != 3 ) {
+	if (strlen (buf) != 3 ) {
 		rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf);
 		return -RIG_ERJCTED;
 	}
 
-	*trn = (buf[3] != '0') ? RIG_TRN_RIG : RIG_TRN_OFF;
+	*trn = (buf[2] != '0') ? RIG_TRN_RIG : RIG_TRN_OFF;
 
 	return RIG_OK;
 }
@@ -747,7 +743,7 @@ th_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
 
 static int th_tburst(RIG *rig, vfo_t vfo, int status)
 {
-	return kenwood_simple_cmd(rig, (status == 1) ? "TT" : "RX");
+	return kenwood_transaction(rig, (status == 1) ? "TT" : "RX", NULL, 0);
 }
 
 /*
@@ -766,7 +762,7 @@ static int th_set_kenwood_func(RIG *rig, const char *cmd, int status)
 	buf[BUFSZ-1] = '\0';
 	strncat(buf, status ? " 1" : " 0", BUFSZ-1);
 
-	return kenwood_simple_cmd(rig, buf);
+	return kenwood_transaction(rig, buf, NULL, 0);
 }
 
 
@@ -901,12 +897,12 @@ th_set_parm(RIG *rig, setting_t parm, value_t val)
 
 	case RIG_PARM_APO:
 		if (val.i > 30)
-			return kenwood_simple_cmd(rig, "APO 2");
+			return kenwood_transaction(rig, "APO 2", NULL, 0);
 		else if (val.i > 0)
-			return kenwood_simple_cmd(rig, "APO 1");
+			return kenwood_transaction(rig, "APO 1", NULL, 0);
 		else
-			return kenwood_simple_cmd(rig, "APO 0");
-
+			return kenwood_transaction(rig, "APO 0", NULL, 0);
+		
 	default:
 		rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm);
 		return -RIG_EINVAL;
@@ -926,7 +922,6 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 	char vch, buf[10], ackbuf[20];
 	int retval, v, l;
 
-	size_t ack_len = sizeof(ackbuf);
 	vfo_t tvfo;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
@@ -949,7 +944,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		sprintf(buf, "SM %c", vch);
 
 		// XXX use kenwood_safe_transaction
-		retval = kenwood_transaction(rig, buf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf));
 		if (retval != RIG_OK)
 			return retval;
 
@@ -981,7 +976,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 
 	case RIG_LEVEL_AF:
 		sprintf(buf, "AG %c", vch);
-		retval = kenwood_transaction(rig, buf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf));
 		if (retval != RIG_OK)
 			return retval;
 
@@ -998,7 +993,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 
 	case RIG_LEVEL_RFPOWER:
 		sprintf(buf, "PC %c",vch);
-		retval = kenwood_transaction(rig, buf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf));
 		if (retval != RIG_OK)
 			return retval;
 
@@ -1089,29 +1084,29 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val)
 			(int)(val.f*(rig->caps->level_gran[LVL_RFPOWER].max.i - rig->caps->level_gran[LVL_RFPOWER].min.i))
 			+ rig->caps->level_gran[LVL_RFPOWER].min.i);
 
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_SQL :
 		sprintf(buf, "SQ %c,%02x", vch,
 			(int)(val.f*(rig->caps->level_gran[LVL_SQL].max.i-rig->caps->level_gran[LVL_SQL].min.i))
 			+ rig->caps->level_gran[LVL_SQL].min.i);
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_AF :
 		sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0));
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_ATT :
 		sprintf(buf, "ATT %c", val.i ? '1' : '0');
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_BALANCE :
 		sprintf(buf, "BAL %c", '4' - (int) (val.f * ('4'-'0')));
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_VOXGAIN:
 		sprintf(buf, "VXG %d", (int) (val.f * 9));
-		return kenwood_simple_cmd(rig, buf);
+		return kenwood_transaction(rig, buf, NULL, 0);
 
 	case RIG_LEVEL_VOXDELAY: /* "VXD" */
 		return -RIG_ENIMPL;
@@ -1135,9 +1130,8 @@ int
 th_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
 {
 	const struct rig_caps *caps;
-	char tonebuf[16],ackbuf[ACKBUF_LEN];
+	char tonebuf[16];
 	int i, retval;
-	size_t ack_len;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
@@ -1153,8 +1147,7 @@ th_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
 
 	i += (i == 0) ? 1 : 2;  /* Correct for TH-D7A index anomally */
 	sprintf(tonebuf, "TN %02d", i);
-	ack_len = ACKBUF_LEN;
-	retval = kenwood_transaction(rig, tonebuf, ackbuf, &ack_len);
+	retval = kenwood_transaction(rig, tonebuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1171,14 +1164,13 @@ th_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
 	struct rig_caps *caps;
 	char buf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len=ACKBUF_LEN;
 	unsigned int tone_idx;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
 	caps = rig->caps;
 
-	retval = kenwood_transaction(rig, "TN", buf, &ack_len);
+	retval = kenwood_transaction(rig, "TN", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1209,9 +1201,8 @@ int
 th_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
 {
 	const struct rig_caps *caps;
-	char tonebuf[16],ackbuf[ACKBUF_LEN];
+	char tonebuf[16];
 	int i, retval;
-	size_t ack_len;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
@@ -1227,8 +1218,7 @@ th_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
 
 	i += (i == 0) ? 1 : 2;  /* Correct for TH-D7A index anomally */
 	sprintf(tonebuf, "CTN %02d", i);
-	ack_len = ACKBUF_LEN;
-	retval = kenwood_transaction(rig, tonebuf, ackbuf, &ack_len);
+	retval = kenwood_transaction(rig, tonebuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1245,14 +1235,13 @@ th_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
 	struct rig_caps *caps;
 	char buf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len=ACKBUF_LEN;
 	unsigned int tone_idx;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
 	caps = rig->caps;
 
-	retval = kenwood_transaction(rig, "CTN", buf, &ack_len);
+	retval = kenwood_transaction(rig, "CTN", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1295,7 +1284,7 @@ th_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
 	caps = rig->caps;
 
 	if (code == 0) {
-		return kenwood_simple_cmd(rig, "DCS 0");
+		return kenwood_transaction(rig, "DCS 0", NULL, 0);
 	}
 
 	for (i = 0; caps->dcs_list[i] != 0 && i < RIG_CODEMAX; i++) {
@@ -1306,12 +1295,12 @@ th_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
 	if (caps->dcs_list[i] != code)
 		return -RIG_EINVAL;
 
-	retval = kenwood_simple_cmd(rig, "DCS 1");
+	retval = kenwood_transaction(rig, "DCS 1", NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
 	sprintf(codebuf, "DCSN %04d", (i+1)*10);
-	retval = kenwood_simple_cmd(rig, codebuf);
+	retval = kenwood_transaction(rig, codebuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1328,14 +1317,13 @@ th_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
 	struct rig_caps *caps;
 	char buf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len=ACKBUF_LEN;
 	unsigned int code_idx;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
 	caps = rig->caps;
 
-	retval = kenwood_transaction(rig, "DCS", buf, &ack_len);
+	retval = kenwood_transaction(rig, "DCS", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1351,8 +1339,7 @@ th_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
 		return RIG_OK;
     }
 
-	ack_len=ACKBUF_LEN;
-	retval = kenwood_transaction(rig, "DCSN", buf, &ack_len);
+	retval = kenwood_transaction(rig, "DCSN", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1380,16 +1367,14 @@ th_get_info(RIG *rig)
 {
 	static char firmbuf[50];
 	int retval;
-	size_t firm_len=50;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-	memset(firmbuf, 0, sizeof(firmbuf));
-
-	retval = kenwood_transaction(rig, "ID", firmbuf, &firm_len);
+	retval = kenwood_transaction(rig, "ID", firmbuf, sizeof (firmbuf));
 	if (retval != RIG_OK)
 		return NULL;
 
+	size_t firm_len = strlen (firmbuf);
 	if (firm_len < 3) {
 		rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n",
 			   __func__, firmbuf, firm_len);
@@ -1500,7 +1485,7 @@ th_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
 {
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-	return kenwood_simple_cmd(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX");
+	return kenwood_transaction(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0);
 }
 
 int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
@@ -1557,13 +1542,13 @@ int th_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
 	switch (op) {
 	case RIG_OP_UP:
-		return kenwood_simple_cmd(rig, "UP");
+		return kenwood_transaction(rig, "UP", NULL, 0);
 
 	case RIG_OP_DOWN:
-		return kenwood_simple_cmd(rig, "DW");
+		return kenwood_transaction(rig, "DW", NULL, 0);
 
 	case RIG_OP_TO_VFO:
-		return kenwood_simple_cmd(rig, "MSH");
+		return kenwood_transaction(rig, "MSH", NULL, 0);
 
 	default:
 		return -RIG_EINVAL;
@@ -1577,7 +1562,6 @@ int th_get_channel(RIG *rig, channel_t *chan)
 {
 	char membuf[64],ackbuf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len;
 	freq_t freq,offset;
 	char req[16],scf[128];
 	int step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout;
@@ -1657,9 +1641,8 @@ int th_get_channel(RIG *rig, channel_t *chan)
 	}
 
 	sprintf(membuf, "%s",req);
-	ack_len=ACKBUF_LEN;
 
-	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+	retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1761,8 +1744,7 @@ int th_get_channel(RIG *rig, channel_t *chan)
 		/* split ? */
 		req[3+strlen(mr_extra)]='1';
 		sprintf(membuf, "%s",req);
-		ack_len=ACKBUF_LEN;
-		retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
 		if (retval == RIG_OK) {
 			strcpy(scf,req);
 			strcat(scf, ",%"SCNfreq",%x");
@@ -1778,13 +1760,13 @@ int th_get_channel(RIG *rig, channel_t *chan)
 			sprintf(membuf, "MNA %sI-%01d",mr_extra,channel_num);
 		else
 			sprintf(membuf, "MNA %s%03d",mr_extra,channel_num);
-		ack_len=ACKBUF_LEN;
 
 		/* Get memory name */
-		retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
 		if (retval != RIG_OK)
 			return retval;
 
+		size_t ack_len = strlen (ackbuf);
 		if (ack_len > rig->caps->chan_desc_sz)
 			ack_len = rig->caps->chan_desc_sz;
 
@@ -1810,9 +1792,8 @@ static int find_tone_index(const tone_t *tone_list, tone_t tone)
 /* --------------------------------------------------------------------- */
 int th_set_channel(RIG *rig, const channel_t *chan)
 {
-	char membuf[ACKBUF_LEN],ackbuf[ACKBUF_LEN];
+	char membuf[ACKBUF_LEN];
 	int retval;
-	size_t ack_len;
 	char req[64];
 	char lockoutstr[8];
 	int channel_num, step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout;
@@ -1972,9 +1953,7 @@ int th_set_channel(RIG *rig, const channel_t *chan)
 			);
 	}
 
-	ack_len = ACKBUF_LEN;
-
-	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+	retval = kenwood_transaction(rig, membuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -1986,23 +1965,20 @@ int th_set_channel(RIG *rig, const channel_t *chan)
 		req[3+strlen(mr_extra)]='1';
 
 		sprintf(membuf, "%s,%011"PRIll",%X", req,(int64_t)chan->tx_freq, step);
-		ack_len=ACKBUF_LEN;
-
-		retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, membuf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
 
 	if (channel_desc) {
 		/* Memory name */
-		ack_len=ACKBUF_LEN;
 		/* TODO: check strlen(channel_desc) < rig->caps->chan_desc_sz */
 		if (chan_caps[1].type == RIG_MTYPE_PRIO)
 			sprintf(membuf, "MNA %sI-%01d,%s",mr_extra,channel_num,channel_desc);
 		else
 			sprintf(membuf, "MNA %s%03d,%s",mr_extra,channel_num,channel_desc);
 
-		retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+		retval = kenwood_transaction(rig, membuf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -2036,7 +2012,7 @@ int th_set_ant(RIG * rig, vfo_t vfo, ant_t ant)
 		return -RIG_EINVAL;
 	}
 
-	return kenwood_simple_cmd(rig, cmd);
+	return kenwood_transaction(rig, cmd, NULL, 0);
 }
 
 
@@ -2070,10 +2046,10 @@ int th_reset(RIG *rig, reset_t reset)
 {
 	switch(reset) {
 	case RIG_RESET_VFO:
-		return kenwood_simple_cmd(rig, "SR 1");
+		return kenwood_transaction(rig, "SR 1", NULL, 0);
 
 	case RIG_RESET_MASTER:
-		return kenwood_simple_cmd(rig, "SR 3");
+		return kenwood_transaction(rig, "SR 3", NULL, 0);
 
 	default:
 		rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n",
diff --git a/kenwood/thd72.c b/kenwood/thd72.c
index 7003f05a9..e8e3ff5d5 100644
--- a/kenwood/thd72.c
+++ b/kenwood/thd72.c
@@ -183,9 +183,9 @@ int thd72_open(RIG *rig)
 {
     int ret;
 
-    kenwood_simple_cmd(rig, "");
+    kenwood_transaction(rig, "", NULL, 0);
 
-    ret = kenwood_simple_cmd(rig, "TC1");
+    ret = kenwood_transaction(rig, "TC1", NULL, 0);
     if (ret != RIG_OK)
         return ret;
 
@@ -247,7 +247,7 @@ int thd72_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg)
     char block[BLOCK_SZ];
     char resp[CMD_SZ];
 
-    ret = kenwood_simple_cmd(rig, "0M PROGRAM");
+    ret = kenwood_transaction(rig, "0M PROGRAM", NULL, 0);
     if (ret != RIG_OK)
         return ret;
 
diff --git a/kenwood/thf6a.c b/kenwood/thf6a.c
index d3bca9e0f..823f78740 100644
--- a/kenwood/thf6a.c
+++ b/kenwood/thf6a.c
@@ -337,16 +337,16 @@ int thf6a_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
 	switch(op) {
 	case RIG_OP_UP:
-		return kenwood_simple_cmd(rig, "UP");
+		return kenwood_transaction(rig, "UP", NULL, 0);
 
 	case RIG_OP_DOWN:
-		return kenwood_simple_cmd(rig, "DW");
+		return kenwood_transaction(rig, "DW", NULL, 0);
 /*	Not implemented!
 	case RIG_OP_BAND_UP:
-		return kenwood_simple_cmd(rig, "BU");
+		return kenwood_transaction(rig, "BU", NULL, 0);
 
 	case RIG_OP_BAND_DOWN:
-		return kenwood_simple_cmd(rig, "BD");
+		return kenwood_transaction(rig, "BD", NULL, 0);
 */
 	default:
 		rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n",
diff --git a/kenwood/thf7.c b/kenwood/thf7.c
index c5886b3be..fd2088eeb 100644
--- a/kenwood/thf7.c
+++ b/kenwood/thf7.c
@@ -331,16 +331,16 @@ int thf7e_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
 
 	switch(op) {
 	case RIG_OP_UP:
-		return kenwood_simple_cmd(rig, "UP");
+		return kenwood_transaction(rig, "UP", NULL, 0);
 
 	case RIG_OP_DOWN:
-		return kenwood_simple_cmd(rig, "DW");
+		return kenwood_transaction(rig, "DW", NULL, 0);
 /*	Not implemented!
 	case RIG_OP_BAND_UP:
-		return kenwood_simple_cmd(rig, "BU");
+		return kenwood_transaction(rig, "BU", NULL, 0);
 
 	case RIG_OP_BAND_DOWN:
-		return kenwood_simple_cmd(rig, "BD");
+		return kenwood_transaction(rig, "BD", NULL, 0);
 */
 	default:
 		rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n",
diff --git a/kenwood/thg71.c b/kenwood/thg71.c
index 177844f13..999f7f49e 100644
--- a/kenwood/thg71.c
+++ b/kenwood/thg71.c
@@ -194,10 +194,9 @@ int thg71_decode_event (RIG *rig)
 {
     char asyncbuf[ACKBUF_LEN];
     int retval;
-    size_t asyncbuf_len = ACKBUF_LEN;
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-    retval = kenwood_transaction(rig, NULL, asyncbuf, &asyncbuf_len);
+    retval = kenwood_transaction(rig, NULL, asyncbuf, sizeof (asyncbuf));
     if (retval != RIG_OK)
         return retval;
 
@@ -302,7 +301,6 @@ int thg71_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 {
     char ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len=ACKBUF_LEN;
     int step;
     freq_t freq;
 
@@ -317,7 +315,7 @@ int thg71_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 	}
 
 	/* try to guess from frequency */
-    retval = kenwood_transaction(rig, "FQ", ackbuf, &ack_len);
+  retval = kenwood_transaction(rig, "FQ", ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         return retval;
 
@@ -337,9 +335,8 @@ int thg71_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 /* --------------------------------------------------------------------- */
 int thg71_set_vfo (RIG *rig, vfo_t vfo)
 {
-    char vfobuf[16], ackbuf[ACKBUF_LEN];
+    char vfobuf[16];
     int retval;
-    size_t ack_len;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
@@ -356,8 +353,7 @@ int thg71_set_vfo (RIG *rig, vfo_t vfo)
             return -RIG_EVFO;
         }
 
-    ack_len = 0;
-    retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+        retval = kenwood_transaction(rig, vfobuf, NULL, 0);
         if (retval != RIG_OK)
         return retval;
 
@@ -369,10 +365,9 @@ int thg71_get_vfo (RIG *rig, vfo_t *vfo)
 {
     char ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len=ACKBUF_LEN;
     int vch;
 
-    retval = kenwood_transaction(rig, "VMC 0" , ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, "VMC 0" , ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         return retval;
 
@@ -395,16 +390,13 @@ int thg71_get_vfo (RIG *rig, vfo_t *vfo)
 /* --------------------------------------------------------------------- */
 int thg71_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 {
-    char ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len;
 
      if(func != RIG_FUNC_TBURST)
 		return -RIG_EINVAL;
 
-    ack_len = 0;
     if(status==1) {
-    retval = kenwood_transaction(rig, "TT", ackbuf, &ack_len);
+      retval = kenwood_transaction(rig, "TT", NULL, 0);
         if (retval != RIG_OK)
         	return retval;
 
@@ -421,7 +413,6 @@ int thg71_open(RIG *rig)
 {
     char ackbuf[ACKBUF_LEN],*strl,*stru;
     int retval,i;
-    size_t ack_len=ACKBUF_LEN;
     const freq_range_t frend=RIG_FRNG_END;
 
     /* this will check the model id */
@@ -430,8 +421,7 @@ int thg71_open(RIG *rig)
         return retval;
 
 	/* fill state.rx/tx range_list */
-    ack_len=ACKBUF_LEN;
-    retval = kenwood_transaction(rig, "FL", ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, "FL", ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         	return retval;
 
diff --git a/kenwood/tmd710.c b/kenwood/tmd710.c
index 86a05eb4f..47f7c115b 100644
--- a/kenwood/tmd710.c
+++ b/kenwood/tmd710.c
@@ -812,17 +812,17 @@ int
 tmd710_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
 {
 	char cmdbuf[10], buf[10], vfoc;
-	size_t buf_size=10;
 	int retval;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
 	/* Get VFO band */
 	
-	retval = kenwood_transaction(rig, "BC", buf, &buf_size);
+	retval = kenwood_transaction(rig, "BC", buf, sizeof (buf));
 	if (retval != RIG_OK)
 		return retval;
-	switch (buf_size) {
+  size_t length = strlen (buf);
+	switch (length) {
 	case 6: /*intended for D700 BC 0,0*/
 	  if ((buf[0]=='B') &&(buf[1]=='C') && (buf[2]==' ') && (buf[4]=',')){
 	    vfoc = buf[3];
@@ -832,7 +832,7 @@ tmd710_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
 	  }
 	  break;
 	default:
-	  rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, buf_size);
+	  rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, length);
 	  return -RIG_EPROTO;
 	  break;
 	}
@@ -907,8 +907,6 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo)
     char vfobuf[16], ackbuf[16];
     int vfonum, txvfonum, vfomode=0;
     int retval;
-    size_t ack_len;
-
 
     rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo));
 
@@ -928,9 +926,8 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo)
             break;
         case RIG_VFO_MEM:
             /* get current band */
-	  snprintf(vfobuf, 10, "BC");
-            ack_len=16;
-            retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+          snprintf(vfobuf, 10, "BC");
+          retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof (ackbuf));
             if (retval != RIG_OK)
                 return retval;
             txvfonum = vfonum = ackbuf[3]-'0';
@@ -943,7 +940,7 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo)
 	}
 
 	snprintf(vfobuf,9, "VM %d,%d", vfonum, vfomode);
-	retval = kenwood_simple_cmd(rig, vfobuf);
+	retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
@@ -951,7 +948,7 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo)
         return RIG_OK;
 
     snprintf(vfobuf, 15, "BC %d,%d", vfonum, txvfonum);
-    retval = kenwood_simple_cmd(rig, vfobuf);
+    retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
diff --git a/kenwood/tmv7.c b/kenwood/tmv7.c
index 10353fc24..690d6e3ea 100644
--- a/kenwood/tmv7.c
+++ b/kenwood/tmv7.c
@@ -223,10 +223,9 @@ int tmv7_decode_event (RIG *rig)
 {
     char asyncbuf[ACKBUF_LEN];
     int retval;
-    size_t asyncbuf_len = ACKBUF_LEN;
     rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
 
-    retval = kenwood_transaction(rig, NULL, asyncbuf, &asyncbuf_len);
+    retval = kenwood_transaction(rig, NULL, asyncbuf, sizeof (asyncbuf));
     if (retval != RIG_OK)
         return retval;
 
@@ -332,7 +331,6 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
 {
     char vfobuf[16], ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len;
 
     rig_debug(RIG_DEBUG_TRACE, "%s: called %d\n", __func__,vfo);
 
@@ -346,8 +344,7 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
             break;
         case RIG_VFO_MEM:
             sprintf(vfobuf, "BC");
-    	    ack_len=ACKBUF_LEN;
-	    retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+            retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof (ackbuf));
 	    if (retval != RIG_OK) return retval;
             sprintf(vfobuf, "VMC %c,2",ackbuf[3]);
             break;
@@ -356,8 +353,7 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
             return -RIG_EVFO;
 	}
 
-    ack_len=0;
-    retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK) {
             rig_debug(RIG_DEBUG_ERR, "%s: bad return \n", __func__);
         return retval;
@@ -379,8 +375,7 @@ int tmv7_set_vfo (RIG *rig, vfo_t vfo)
 	}
 
     rig_debug(RIG_DEBUG_TRACE, "%s: next2\n", __func__);
-    ack_len=0;
-    retval = kenwood_transaction(rig, vfobuf, ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, vfobuf, NULL, 0);
 	if (retval != RIG_OK)
         return retval;
 
@@ -392,7 +387,6 @@ int tmv7_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 {
     char ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len=ACKBUF_LEN;
     int step;
     freq_t freq;
 
@@ -407,7 +401,7 @@ int tmv7_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 	}
 
 	/* try to guess from frequency */
-    retval = kenwood_transaction(rig, "FQ", ackbuf, &ack_len);
+  retval = kenwood_transaction(rig, "FQ", ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         return retval;
 
@@ -438,7 +432,6 @@ int tmv7_get_channel(RIG *rig, channel_t *chan)
 {
     char membuf[64],ackbuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len;
     freq_t freq;
     char req[16],scf[128];
     int step, shift, rev, tone, ctcss, tonefq, ctcssfq;
@@ -478,8 +471,7 @@ int tmv7_get_channel(RIG *rig, channel_t *chan)
 	return -RIG_EINVAL;
 
     sprintf(membuf,"%s",req);
-    ack_len=ACKBUF_LEN;
-    retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         	return retval;
 
@@ -522,8 +514,7 @@ int tmv7_get_channel(RIG *rig, channel_t *chan)
     if(chan->channel_num<223 && shift==0) {
 	req[5]='1';
         sprintf(membuf,"%s",req);
-        ack_len=ACKBUF_LEN;
-    	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+        retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
         if (retval == RIG_OK) {
     		strcpy(scf,req);
     		strcat(scf,",%"SCNfreq",%d");
@@ -537,8 +528,7 @@ int tmv7_get_channel(RIG *rig, channel_t *chan)
 	    	sprintf(membuf,"MNA 0,%03d",chan->channel_num);
 	    else
 	    	sprintf(membuf,"MNA 1,%03d",chan->channel_num-100);
-        ack_len=ACKBUF_LEN;
-    	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+      retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf));
         if (retval != RIG_OK)
         	return retval;
         memcpy(chan->channel_desc,&ackbuf[10],7);
@@ -549,9 +539,8 @@ int tmv7_get_channel(RIG *rig, channel_t *chan)
 /* --------------------------------------------------------------------- */
 int tmv7_set_channel(RIG *rig, const channel_t *chan)
 {
-    char membuf[ACKBUF_LEN],ackbuf[ACKBUF_LEN];
+    char membuf[ACKBUF_LEN];
     int retval;
-    size_t ack_len;
     char req[64];
     long freq;
     int step, shift, tone, ctcss, tonefq, ctcssfq;
@@ -634,16 +623,14 @@ int tmv7_set_channel(RIG *rig, const channel_t *chan)
                     req, (long)freq, step, shift, tone,
                     ctcss, tonefq, ctcssfq);
 
-    ack_len=0;
-    retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+    retval = kenwood_transaction(rig, membuf, NULL, 0);
         if (retval != RIG_OK)
         	return retval;
 
     if(chan->tx_freq!=RIG_FREQ_NONE) {
     	req[5]='1';
     	sprintf(membuf, "%s,%011"PRIll",%01d", req, (int64_t)chan->tx_freq, step);
-        ack_len=0;
-    	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+      retval = kenwood_transaction(rig, membuf, NULL, 0);
         if (retval != RIG_OK)
         	return retval;
     }
@@ -653,8 +640,7 @@ int tmv7_set_channel(RIG *rig, const channel_t *chan)
 	    	sprintf(membuf,"MNA 0,%03d,%s",chan->channel_num,chan->channel_desc);
 	    else
 	    	sprintf(membuf,"MNA 1,%03d,%s",chan->channel_num-100,chan->channel_desc);
-    	ack_len=0;
-    	retval = kenwood_transaction(rig, membuf, ackbuf, &ack_len);
+      retval = kenwood_transaction(rig, membuf, NULL, 0);
         if (retval != RIG_OK)
         	return retval;
     }
diff --git a/kenwood/transfox.c b/kenwood/transfox.c
index 23247683a..9fc50d71c 100644
--- a/kenwood/transfox.c
+++ b/kenwood/transfox.c
@@ -196,14 +196,13 @@ int transfox_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
 const char* transfox_get_info(RIG *rig)
 {
 	static char firmbuf[32];
-    size_t firmlen = sizeof firmbuf;
 	int retval;
 
 	rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__);
 
     firmbuf[0] = '\0';
 
-	retval = kenwood_transaction(rig, "CS", firmbuf, &firmlen);
+		retval = kenwood_transaction(rig, "CS", firmbuf, sizeof (firmbuf));
 	if (retval != RIG_OK)
 		return NULL;
 
@@ -220,24 +219,24 @@ int transfox_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
 
 	case RIG_LEVEL_ATT:
 		if (val.i == 0) {
-			ret = kenwood_simple_cmd(rig, "C30");
+			ret = kenwood_transaction(rig, "C30", NULL, 0);
 			if (ret != RIG_OK)
 				return ret;
-			ret = kenwood_simple_cmd(rig, "C20");
+			ret = kenwood_transaction(rig, "C20", NULL, 0);
 			if (ret != RIG_OK)
 				return ret;
         } else if (val.i == 10) {
-				ret = kenwood_simple_cmd(rig, "C30");
+			ret = kenwood_transaction(rig, "C30", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
-				ret = kenwood_simple_cmd(rig, "C21");
+				ret = kenwood_transaction(rig, "C21", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
         } else if (val.i == 20) {
-				ret = kenwood_simple_cmd(rig, "C31");
+			ret = kenwood_transaction(rig, "C31", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
-				ret = kenwood_simple_cmd(rig, "C21");
+				ret = kenwood_transaction(rig, "C21", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
 		}
@@ -245,24 +244,24 @@ int transfox_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
 
 	case RIG_LEVEL_PREAMP:
 		if (val.i == 0) {
-			ret = kenwood_simple_cmd(rig, "C30");
+			ret = kenwood_transaction(rig, "C30", NULL, 0);
 			if (ret != RIG_OK)
 				return ret;
-			ret = kenwood_simple_cmd(rig, "C20");
+			ret = kenwood_transaction(rig, "C20", NULL, 0);
 			if (ret != RIG_OK)
 				return ret;
         } else if (val.i == 22) {
-				ret = kenwood_simple_cmd(rig, "C30");
+			ret = kenwood_transaction(rig, "C30", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
-				ret = kenwood_simple_cmd(rig, "C22");
+				ret = kenwood_transaction(rig, "C22", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
         } else if (val.i == 44) {
-				ret = kenwood_simple_cmd(rig, "C32");
+			ret = kenwood_transaction(rig, "C32", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
-				ret = kenwood_simple_cmd(rig, "C22");
+				ret = kenwood_transaction(rig, "C22", NULL, 0);
 				if (ret != RIG_OK)
 					return ret;
 		}
diff --git a/kenwood/ts140.c b/kenwood/ts140.c
index 9d8a51fbc..d8217f744 100644
--- a/kenwood/ts140.c
+++ b/kenwood/ts140.c
@@ -66,7 +66,7 @@ static int ts140_set_vfo(RIG *rig, vfo_t vfo)
                 }
 
                 sprintf(cmdbuf, "FN%c", vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
-                return kenwood_simple_cmd(rig, cmdbuf);
+                return kenwood_transaction(rig, cmdbuf, NULL, 0);
 }
 
 /*
diff --git a/kenwood/ts2000.c b/kenwood/ts2000.c
index b7e57d1ea..d0aa9a2e5 100644
--- a/kenwood/ts2000.c
+++ b/kenwood/ts2000.c
@@ -371,16 +371,16 @@ int ts2000_get_channel(RIG *rig, channel_t *chan)
 
 	int err;
 	char buf[52];
-	size_t buf_size = 52;
 	char cmd[8];
 	struct kenwood_priv_caps *caps = kenwood_caps(rig);
 
 	/* put channel num in the command string */
 	sprintf(cmd, "MR0%03d;", chan->channel_num);
 
-	err = kenwood_transaction(rig, cmd, buf, &buf_size );
+	err = kenwood_transaction(rig, cmd, buf, sizeof (buf));
 	if (err != RIG_OK)
 		return err;
+	size_t length = strlen (buf);
 	memset(chan, 0x00, sizeof(channel_t));
 
 	chan->vfo = RIG_VFO_MEM;
@@ -393,7 +393,7 @@ int ts2000_get_channel(RIG *rig, channel_t *chan)
 	 */
 	/* First check if a name is assigned.
 	   Name is returned at positions 41-48 (counting from 0) */
-	if( buf_size > 41 ){
+	if( length > 41 ){
 // 	  rig_debug(RIG_DEBUG_VERBOSE, "Copying channel description: %s\n", &buf[ 41 ] );
 	  strcpy( chan->channel_desc, &buf[ 41 ] );
 	}
@@ -505,8 +505,7 @@ int ts2000_get_channel(RIG *rig, channel_t *chan)
 
 	/* Check split freq */
 	cmd[2] = '1';
-	buf_size = 52;
-	err = kenwood_transaction(rig, cmd, buf, &buf_size );
+	err = kenwood_transaction(rig, cmd, buf, sizeof (buf));
 	if (err != RIG_OK)
 		return err;
 
@@ -642,8 +641,7 @@ int ts2000_set_channel(RIG *rig, const channel_t *chan)
 		);
 	rig_debug( RIG_DEBUG_VERBOSE, "The command will be: %s\n", buf );
 
-    size_t tmp=0;
-	err = kenwood_transaction(rig, buf, NULL, &tmp );
+	err = kenwood_transaction(rig, buf, NULL, 0);
 	if (err != RIG_OK)
 		return err;
 	
@@ -666,8 +664,7 @@ int ts2000_set_channel(RIG *rig, const channel_t *chan)
 		);
 	  rig_debug( RIG_DEBUG_VERBOSE, "Split, the command will be: %s\n", buf );
 	
-      tmp = 0;
-	  err = kenwood_transaction(rig, buf, NULL, &tmp );
+	  err = kenwood_transaction(rig, buf, NULL, 0);
 	}
 	return err;
 }
@@ -687,9 +684,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		switch (level) {
 
 		case RIG_LEVEL_PREAMP:
-			retval = kenwood_transaction (rig, "PA", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "PA", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if ((lvl_len != 4)){ /*TS-2000 returns 4 chars for PA; */
 				rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer len=%d\n",
 					       __func__, lvl_len);
@@ -704,10 +702,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_ATT:
-			retval = kenwood_transaction (rig, "RA", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RA", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			lvl_len = strlen (lvlbuf);
 			if ((lvl_len != 6)){ /* TS-2000 returns 6 chars for RA; */
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 								"unexpected answer len=%d\n", lvl_len);
@@ -723,9 +721,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_VOX:
-			retval = kenwood_transaction (rig, "VD", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "VD", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 6) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -736,9 +735,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 	        case RIG_LEVEL_AF:
-			retval = kenwood_transaction (rig, "AG0", lvlbuf, &lvl_len);
+						retval = kenwood_transaction (rig, "AG0", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 6) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -749,9 +749,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_RF:
-			retval = kenwood_transaction (rig, "RG", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RG", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -762,9 +763,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_SQL:
-			retval = kenwood_transaction (rig, "SQ0", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SQ0", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 6) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -775,9 +777,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_CWPITCH:
-			retval = kenwood_transaction (rig, "EX0310000", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "EX0310000", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 15) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d answer=%s\n", lvl_len, lvlbuf);
@@ -788,9 +791,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_RFPOWER:
-			retval = kenwood_transaction (rig, "PC", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "PC", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -801,9 +805,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
         	  	break;
 
 		case RIG_LEVEL_MICGAIN:
-			retval = kenwood_transaction (rig, "MG", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "MG", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -814,9 +819,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_KEYSPD:
-			retval = kenwood_transaction (rig, "KS", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "KS", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -831,9 +837,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_COMP:
-			retval = kenwood_transaction (rig, "PL", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "PL", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 8) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -856,9 +863,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_BKINDL:
-			retval = kenwood_transaction (rig, "SD", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SD", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 6) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -873,9 +881,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		    break;
 
 		case RIG_LEVEL_METER:
-			retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 7) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -886,9 +895,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_VOXGAIN:
-			retval = kenwood_transaction (rig, "VG", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "VG", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"ts2000_get_level: "
 					"unexpected answer len=%d\n", lvl_len);
@@ -904,10 +914,10 @@ int ts2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 
 		case RIG_LEVEL_RAWSTR:
 		case RIG_LEVEL_STRENGTH:
-			retval = kenwood_transaction (rig, "SM0", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SM0", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			lvl_len = strlen (lvlbuf);
 			if (( (lvl_len !=7)) || lvlbuf[1] != 'M') {
 				/* TS-2000 returns 8 bytes for S meter level */
 				rig_debug(RIG_DEBUG_ERR,"%s: wrong answer len=%d\n",
diff --git a/kenwood/ts480.c b/kenwood/ts480.c
index dd31e9956..11c413ca6 100644
--- a/kenwood/ts480.c
+++ b/kenwood/ts480.c
@@ -47,13 +47,12 @@ static const char *
 kenwood_ts480_get_info (RIG * rig)
 {
   char firmbuf[50];
-  size_t firm_len;
   int retval;
 
-  firm_len = 50;
-  retval = kenwood_transaction (rig, "TY", firmbuf, &firm_len);
+  retval = kenwood_transaction (rig, "TY", firmbuf, sizeof (firmbuf));
   if (retval != RIG_OK)
     return NULL;
+  size_t firm_len = strlen (firmbuf);
   if (firm_len != 5)
     {
       rig_debug (RIG_DEBUG_ERR, "kenwood_get_info: wrong answer len=%d\n", firm_len);
@@ -137,7 +136,7 @@ kenwood_ts480_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
       return -RIG_EINVAL;
     }
 
-  return kenwood_simple_cmd(rig, levelbuf);
+  return kenwood_transaction(rig, levelbuf, NULL, 0);
 }
 
 
@@ -149,16 +148,17 @@ int
 kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
 {
   char ackbuf[50];
-  size_t ack_len = 50;
+  size_t ack_len;
   int levelint;
   int retval;
 
   switch (level)
     {
     case RIG_LEVEL_RFPOWER:
-      retval = kenwood_transaction (rig, "PC", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "PC", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+      ack_len = strlen (ackbuf);
       if (5 != ack_len)
 	return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[2], "%d", &levelint))
@@ -167,9 +167,10 @@ kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
       return RIG_OK;
 
     case RIG_LEVEL_AF:
-      retval = kenwood_transaction (rig, "AG0", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "AG0", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+      ack_len = strlen (ackbuf);
       if (6 != ack_len)
 	return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[3], "%d", &levelint))
@@ -178,9 +179,10 @@ kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
       return RIG_OK;
 
     case RIG_LEVEL_RF:
-      retval = kenwood_transaction (rig, "RG", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "RG", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+      ack_len = strlen (ackbuf);
       if (5 != ack_len)
 	return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[2], "%d", &levelint))
@@ -189,9 +191,10 @@ kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
       return RIG_OK;
 
     case RIG_LEVEL_SQL:
-      retval = kenwood_transaction (rig, "SQ0", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "SQ0", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+      ack_len = strlen (ackbuf);
       if (6 != ack_len)
 	return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[3], "%d", &levelint))
@@ -200,9 +203,10 @@ kenwood_ts480_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
       return RIG_OK;
 
     case RIG_LEVEL_AGC:
-      retval = kenwood_transaction (rig, "GT", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "GT", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+      ack_len = strlen (ackbuf);
       if (5 != ack_len)
 	return -RIG_EPROTO;
       switch (ackbuf[4])
diff --git a/kenwood/ts570.c b/kenwood/ts570.c
index 113607aef..f854b34d4 100644
--- a/kenwood/ts570.c
+++ b/kenwood/ts570.c
@@ -51,19 +51,17 @@ static struct kenwood_priv_caps ts570_priv_caps  = {
 static int ts570_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 {
   char buf[50];
-  size_t buf_len;
+  size_t length;
   int retval;
 
-
-  buf_len = 50;
-  retval = kenwood_transaction (rig, "MD", buf, &buf_len);
+  retval = kenwood_transaction (rig, "MD", buf, sizeof (buf));
   if (retval != RIG_OK)
     return retval;
-
-  if (buf_len != 3 || buf[1] != 'D')
+	length = strlen (buf);
+  if (length != 3 || buf[1] != 'D')
   {
     rig_debug(RIG_DEBUG_ERR,"ts570_get_mode: unexpected MD answer, len=%d\n",
-      buf_len);
+      length);
     return -RIG_ERJCTED;
   }
 
@@ -96,13 +94,13 @@ static int ts570_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
     case RIG_MODE_CWR:
     case RIG_MODE_RTTY:
     case RIG_MODE_RTTYR:
-      buf_len = 50;
-      retval = kenwood_transaction (rig, "FW", buf, &buf_len);
+      retval = kenwood_transaction (rig, "FW", buf, sizeof (buf));
       if (retval != RIG_OK) return retval;
-      if (buf_len != 6 || buf[1] != 'W')
+			length = strlen (buf);
+      if (length != 6 || buf[1] != 'W')
       {
         rig_debug(RIG_DEBUG_ERR,
-          "ts570_get_mode: unexpected FW answer, len=%d\n", buf_len);
+          "ts570_get_mode: unexpected FW answer, len=%d\n", length);
         return -RIG_ERJCTED;
       }
       *width = atoi(&buf[2]);
@@ -111,13 +109,13 @@ static int ts570_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
     case RIG_MODE_LSB:
     case RIG_MODE_FM:
     case RIG_MODE_AM:
-      buf_len = 50;
-      retval = kenwood_transaction (rig, "SL", buf, &buf_len);
+      retval = kenwood_transaction (rig, "SL", buf, sizeof (buf));
       if (retval != RIG_OK) return retval;
-      if (buf_len != 4 || buf[1] != 'L')
+			length = strlen (buf);
+      if (length != 4 || buf[1] != 'L')
       {
         rig_debug(RIG_DEBUG_ERR,
-          "ts570_get_mode: unexpected SL answer, len=%d\n", buf_len);
+          "ts570_get_mode: unexpected SL answer, len=%d\n", length);
         return -RIG_ERJCTED;
       }
       *width = 50 * atoi(&buf[2]);
@@ -155,7 +153,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
      return -RIG_EINVAL;
 
   sprintf(buf, "MD%c", kmode);
-  retval = kenwood_simple_cmd(rig, buf);
+  retval = kenwood_transaction(rig, buf, NULL, 0);
   if (retval != RIG_OK) return retval;
 
   switch (mode)
@@ -165,7 +163,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     case RIG_MODE_RTTY:
     case RIG_MODE_RTTYR:
       sprintf(buf, "FW%04d", (int)width);
-      retval = kenwood_simple_cmd(rig, buf);
+      retval = kenwood_transaction(rig, buf, NULL, 0);
       if (retval != RIG_OK) return retval;
       break;
     case RIG_MODE_USB:
@@ -173,7 +171,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     case RIG_MODE_FM:
     case RIG_MODE_AM:
       sprintf(buf, "SL%02d", (int)width/50);
-      retval = kenwood_simple_cmd(rig, buf);
+      retval = kenwood_transaction(rig, buf, NULL, 0);
       if (retval != RIG_OK) return retval;
       break;
     default:
@@ -201,10 +199,10 @@ int ts570_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
 			if ((status < 0) || (status >2))
 				return -RIG_EINVAL;
 			sprintf(fctbuf,"NR%01d", status);
-			return kenwood_simple_cmd(rig, fctbuf);
+			return kenwood_transaction(rig, fctbuf, NULL, 0);
 		case RIG_FUNC_TUNER:
 			sprintf(fctbuf,"AC %c0", (0==status)?'0':'1');
- 			return kenwood_simple_cmd(rig, fctbuf);
+ 			return kenwood_transaction(rig, fctbuf, NULL, 0);
 
 		default:
 			return kenwood_set_func(rig, vfo, func, status);
@@ -230,10 +228,10 @@ int ts570_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
 		 */
 		switch (func) {
 		case RIG_FUNC_NR:
-			retval = kenwood_transaction (rig, "NR", fctbuf, &fct_len);
+			retval = kenwood_transaction (rig, "NR", fctbuf, sizeof (fctbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			fct_len = strlen (fctbuf);
 			if (fct_len != 3) {
 				rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: "
 					"wrong answer len=%d\n", fct_len);
@@ -244,10 +242,10 @@ int ts570_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
 			break;
 
 		case RIG_FUNC_TUNER:
-			retval = kenwood_transaction (rig, "AC", fctbuf, &fct_len);
+			retval = kenwood_transaction (rig, "AC", fctbuf, sizeof (fctbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			fct_len = strlen (fctbuf);
 			if (fct_len != 5) {
 				rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: "
 					"wrong answer len=%d\n", fct_len);
@@ -293,19 +291,19 @@ ts570_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
 	    }
 	    else
 	    	return -RIG_EINVAL;
-        return kenwood_simple_cmd(rig, levelbuf);
+	return kenwood_transaction(rig, levelbuf, NULL, 0);
 
     case RIG_LEVEL_RFPOWER:
       /* level for TS570D is from 0.. 100W in SSB and CW */
       kenwood_val = val.f * 100;
       sprintf (levelbuf, "PC%03d", kenwood_val);
-      return kenwood_simple_cmd(rig, levelbuf);
+      return kenwood_transaction(rig, levelbuf, NULL, 0);
 
     case RIG_LEVEL_MICGAIN:
       /* level is from 0..100 */
       kenwood_val = val.f * 100;
       sprintf (levelbuf, "MG%03d", kenwood_val);
-      return kenwood_simple_cmd(rig, levelbuf);
+      return kenwood_transaction(rig, levelbuf, NULL, 0);
 
     default:
       return kenwood_set_level (rig, vfo, level, val);
@@ -323,7 +321,7 @@ int
 ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
 {
   char ackbuf[50];
-  size_t ack_len = 50;
+  size_t ack_len;
   int levelint;
   int retval;
   int i;
@@ -332,9 +330,10 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
     {
     case RIG_LEVEL_RFPOWER:
       /* ts570d returns 5..100 measured in watt */
-      retval = kenwood_transaction (rig, "PC", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "PC", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
 	return retval;
+			ack_len = strlen (ackbuf);
       if (5 != ack_len)
 	return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[2], "%d", &levelint))
@@ -344,9 +343,10 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
 
     case RIG_LEVEL_MICGAIN:
       /* reads from 0..100 */
-      retval = kenwood_transaction (rig, "MG", ackbuf, &ack_len);
+      retval = kenwood_transaction (rig, "MG", ackbuf, sizeof (ackbuf));
       if (RIG_OK != retval)
         return retval;
+			ack_len = strlen (ackbuf);
       if (5 != ack_len)
         return -RIG_EPROTO;
       if (1 != sscanf (&ackbuf[2], "%d", &levelint))
@@ -355,10 +355,10 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
       return RIG_OK;
 
     case RIG_LEVEL_PREAMP:
-	retval = kenwood_transaction (rig, "PA", ackbuf, &ack_len);
+			retval = kenwood_transaction (rig, "PA", ackbuf, sizeof (ackbuf));
 	if (retval != RIG_OK)
 	    return retval;
-
+			ack_len = strlen (ackbuf);
 	if (3  != ack_len) {
 	    rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer len=%d\n",
 			__func__, ack_len);
@@ -394,17 +394,15 @@ ts570_get_level (RIG * rig, vfo_t vfo, setting_t level, value_t * val)
 int ts570_get_split_vfo(RIG * rig, vfo_t vfo, split_t * split, vfo_t * tx_vfo)
 {
 	char ack[10];
-	size_t acklen = 10;
 	char ack2[10];
-	size_t ack2len = 10;
 	int retval;
 
-	retval = kenwood_transaction(rig, "FR", ack, &acklen);
+	retval = kenwood_transaction(rig, "FR", ack, sizeof (ack));
 	if (retval != RIG_OK)
 		return retval;
 
 
-	retval = kenwood_transaction(rig, "FT", ack2, &ack2len);
+	retval = kenwood_transaction(rig, "FT", ack2, sizeof (ack2));
 	if (retval != RIG_OK)
 		return retval;
 
@@ -435,7 +433,6 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 {
 	char cmdbuf[16], ackbuf[20];
 	int cmd_len, retval;
-	size_t ack_len;
 	unsigned char vfo_function;
 
 	if(vfo !=RIG_VFO_CURR) {
@@ -454,7 +451,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 		if (cmd_len < 0)
 			return -RIG_ETRUNC;
 
-		retval = kenwood_simple_cmd(rig, cmdbuf);
+		retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -474,7 +471,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 		if (cmd_len < 0)
 			return -RIG_ETRUNC;
 
-		retval = kenwood_simple_cmd(rig, cmdbuf);
+		retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 
@@ -482,8 +479,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 		if(vfo==RIG_VFO_CURR) {
 	  		/* switch to current RX VFO */
 			/* first ask for it */
-			ack_len = 10;
-			retval = kenwood_transaction(rig, "FR", ackbuf, &ack_len);
+			retval = kenwood_transaction(rig, "FR", ackbuf, sizeof (ackbuf));
 			if (retval != RIG_OK)
 				return retval;
 			/* and then set it to both vfo's */
@@ -492,7 +488,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 			if (cmd_len < 0)
 				return -RIG_ETRUNC;
 
-			retval = kenwood_simple_cmd(rig, cmdbuf);
+			retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
 			if (retval != RIG_OK)
 				return retval;
 		}
@@ -514,9 +510,8 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
 
 int ts570_set_channel (RIG * rig, const channel_t * chan)
 {
-                char cmdbuf[30], membuf[30];
+                char cmdbuf[30];
                 int retval, cmd_len;
-		size_t mem_len;
 		int num,freq,tx_freq,tone;
 		char mode,tx_mode,tones;
 
@@ -547,8 +542,7 @@ int ts570_set_channel (RIG * rig, const channel_t * chan)
 		if (cmd_len < 0)
 			return -RIG_ETRUNC;
 
-                mem_len = 0;
-                retval = kenwood_transaction (rig, cmdbuf, membuf, &mem_len);
+                retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
                 if (retval != RIG_OK)
                                 return retval;
 
@@ -557,8 +551,7 @@ int ts570_set_channel (RIG * rig, const channel_t * chan)
 		if (cmd_len < 0)
 			return -RIG_ETRUNC;
 
-                mem_len = 0;
-                retval = kenwood_transaction (rig, cmdbuf, membuf, &mem_len);
+                retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
                 if (retval != RIG_OK)
                                 return retval;
 
@@ -569,13 +562,11 @@ int ts570_get_xit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
 {
 	char infobuf[50];
 	int retval;
-	size_t info_len;
 
-	info_len = 50;
-	retval = kenwood_transaction (rig, "IF", infobuf, &info_len);
+	retval = kenwood_transaction (rig, "IF", infobuf, sizeof (infobuf));
 	if (retval != RIG_OK)
 		return retval;
-
+	size_t info_len = strlen (infobuf);
 	if (info_len != 37 || infobuf[1] != 'F') {
 	rig_debug(RIG_DEBUG_ERR,"kenwood_get_rit: wrong answer len=%d\n",
 					info_len);
@@ -593,20 +584,18 @@ int ts570_get_xit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
 
 int ts570_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 {
-        char buf[50], infobuf[50];
+        char buf[50];
 	unsigned char c;
         int retval, len, i;
-	size_t info_len;
 
-        info_len = 0;
         if (rit == 0) {
-		retval = kenwood_transaction(rig, "RT0", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "RT0", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 		else
 			return RIG_OK;
 	} else {
-		retval = kenwood_transaction(rig, "RT1", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "RT1", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -619,15 +608,13 @@ int ts570_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 	if (len < 0)
 		return -RIG_ETRUNC;
 
-        info_len = 0;
-        retval = kenwood_transaction(rig, "RC", infobuf, &info_len);
+        retval = kenwood_transaction(rig, "RC", NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
         for (i = 0; i < abs(rint(rit/10)); i++)
         {
-                info_len = 0;
-                retval = kenwood_transaction(rig, buf, infobuf, &info_len);
+                retval = kenwood_transaction(rig, buf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
         }
@@ -637,20 +624,18 @@ int ts570_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 
 int ts570_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 {
-        char buf[50], infobuf[50];
+        char buf[50];
 	unsigned char c;
         int retval, len, i;
-	size_t info_len;
 
-        info_len = 0;
         if (rit == 0) {
-		retval = kenwood_transaction(rig, "XT0", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "XT0", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 		else
 			return RIG_OK;
 	} else {
-		retval = kenwood_transaction(rig, "XT1", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "XT1", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -663,15 +648,13 @@ int ts570_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 	if (len < 0)
 		return -RIG_ETRUNC;
 
-        info_len = 0;
-        retval = kenwood_transaction(rig, "RC", infobuf, &info_len);
+        retval = kenwood_transaction(rig, "RC", NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
         for (i = 0; i < abs(rint(rit/10)); i++)
         {
-                info_len = 0;
-                retval = kenwood_transaction(rig, buf, infobuf, &info_len);
+                retval = kenwood_transaction(rig, buf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
         }
diff --git a/kenwood/ts680.c b/kenwood/ts680.c
index fdf656c10..fcba72501 100644
--- a/kenwood/ts680.c
+++ b/kenwood/ts680.c
@@ -66,7 +66,7 @@ static int ts680_set_vfo(RIG *rig, vfo_t vfo)
                 }
 
                 sprintf(cmdbuf, "FN%c", vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
-                return kenwood_simple_cmd(rig, cmdbuf);
+                return kenwood_transaction(rig, cmdbuf, NULL, 0);
 }
 
 /*
diff --git a/kenwood/ts850.c b/kenwood/ts850.c
index 8609410c1..73b874226 100644
--- a/kenwood/ts850.c
+++ b/kenwood/ts850.c
@@ -242,18 +242,16 @@ const struct rig_caps ts850_caps = {
 
 int ts850_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 {
-	char buf[50], infobuf[50];
+	char buf[50];
 	unsigned char c;
 	int retval, i;
-	size_t info_len;
 
-	info_len = 0;
 	if (rit == 0) {
-		retval = kenwood_transaction(rig, "RT0", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "RT0", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	} else {
-		retval = kenwood_transaction(rig, "RT1", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "RT1", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -264,15 +262,13 @@ int ts850_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 		c = 'D';
 	sprintf(buf, "R%c", c);
 
-	info_len = 0;
-	retval = kenwood_transaction(rig, "RC", infobuf, &info_len);
+	retval = kenwood_transaction(rig, "RC", NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
 	for (i = 0; i < abs(rint(rit/20)); i++)
 	{
-		info_len = 0;
-		retval = kenwood_transaction(rig, buf, infobuf, &info_len);
+		retval = kenwood_transaction(rig, buf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -282,24 +278,21 @@ int ts850_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
 
 int ts850_set_xit(RIG * rig, vfo_t vfo, shortfreq_t xit)
 {
-	char buf[50], infobuf[50];
+	char buf[50];
 	unsigned char c;
 	int retval, i;
-	size_t info_len;
 
-	info_len = 0;
 	if (xit == 0) {
-		retval = kenwood_transaction(rig, "XT0", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "XT0", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	} else {
-		retval = kenwood_transaction(rig, "XT1", infobuf, &info_len);
+		retval = kenwood_transaction(rig, "XT1", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
 
-	info_len = 0;
-	retval = kenwood_transaction(rig, "RC", infobuf, &info_len);
+	retval = kenwood_transaction(rig, "RC", NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
@@ -311,8 +304,7 @@ int ts850_set_xit(RIG * rig, vfo_t vfo, shortfreq_t xit)
 
 	for (i = 0; i < abs(rint(xit/20)); i++)
 	{
-		info_len = 0;
-		retval = kenwood_transaction(rig, buf, infobuf, &info_len);
+		retval = kenwood_transaction(rig, buf, NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
 	}
@@ -341,23 +333,20 @@ int ts850_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 {
 	char lvlbuf[50];
 	int i, retval;
-	size_t lvl_len;
 
 	if(vfo!=RIG_VFO_CURR)
 		return -RIG_EINVAL;
 
 	switch (level) {
 		case RIG_LEVEL_RAWSTR:
-		lvl_len = 50;
-		retval = kenwood_transaction (rig, "SM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SM", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		val->i=atoi(&lvlbuf[2]);
 		break;
 
 		case RIG_LEVEL_STRENGTH:
-		lvl_len = 50;
-		retval = kenwood_transaction (rig, "SM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SM", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		val->i=atoi(&lvlbuf[2]);
@@ -366,12 +355,10 @@ int ts850_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		break;
 
 		case RIG_LEVEL_SWR:
-			lvl_len = 0;
-		retval = kenwood_transaction (rig, "RM1", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM1", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
-		lvl_len = 50;
-		retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		i=atoi(&lvlbuf[3]);
@@ -382,32 +369,27 @@ int ts850_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		break;
 
 		case RIG_LEVEL_COMP:
-			lvl_len = 0;
-		retval = kenwood_transaction (rig, "RM2", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM2", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
-		lvl_len = 50;
-		retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		val->f=(float)atoi(&lvlbuf[3])/30.0;
 		break;
 
 		case RIG_LEVEL_ALC:
-			lvl_len = 0;
-		retval = kenwood_transaction (rig, "RM3", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM3", NULL, 0);
 		if (retval != RIG_OK)
 			return retval;
-		lvl_len = 50;
-		retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+		retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		val->f=(float)atoi(&lvlbuf[3])/30.0;
 		break;
 
 		case RIG_LEVEL_CWPITCH:
-			lvl_len = 25;
-		retval = kenwood_transaction (rig, "PT", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "PT", lvlbuf, sizeof (lvlbuf));
 		if (retval != RIG_OK)
 			return retval;
 		val->i=atoi(&lvlbuf[2]);
@@ -423,9 +405,8 @@ int ts850_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 
 int ts850_set_channel (RIG * rig, const channel_t * chan)
 {
-	char cmdbuf[30], membuf[30];
+	char cmdbuf[30];
 	int retval;
-	size_t mem_len;
 	int num,freq,tx_freq,tone;
 	char mode,tx_mode,tones;
 
@@ -453,15 +434,13 @@ int ts850_set_channel (RIG * rig, const channel_t * chan)
 
 	sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ",
 					num,freq,mode,tones,tone);
-	mem_len = 0;
-	retval = kenwood_transaction (rig, cmdbuf, membuf, &mem_len);
+	retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
 	sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ",
 					num,tx_freq,tx_mode,tones,tone);
-	mem_len = 0;
-	retval = kenwood_transaction (rig, cmdbuf, membuf, &mem_len);
+	retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
 	if (retval != RIG_OK)
 		return retval;
 
diff --git a/kenwood/ts870s.c b/kenwood/ts870s.c
index b7645fac3..6b880dad4 100644
--- a/kenwood/ts870s.c
+++ b/kenwood/ts870s.c
@@ -67,11 +67,10 @@ static int ts870s_get_vfo(RIG *rig, vfo_t *vfo)
 
 
 		/* query RX VFO */
-		vfo_len = 50;
-		retval = kenwood_transaction (rig, "FR", vfobuf, &vfo_len);
+		retval = kenwood_transaction (rig, "FR", vfobuf, sizeof (vfobuf));
 		if (retval != RIG_OK)
 			return retval;
-
+		vfo_len = strlen (vfobuf);
 		if (vfo_len != 3 || vfobuf[1] != 'R') {
 			rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer %s, "
 						"len=%d\n",__func__,vfobuf, vfo_len);
@@ -98,10 +97,10 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
   int retval;
 
   buf_len = 50;
-  retval = kenwood_transaction (rig, "MD", buf, &buf_len);
+  retval = kenwood_transaction (rig, "MD", buf, sizeof (buf));
   if (retval != RIG_OK)
     return retval;
-
+	buf_len = strlen (buf);
   if (buf_len != 3 || buf[1] != 'D')
   {
     rig_debug(RIG_DEBUG_ERR,"%s: unexpected MD answer, len=%d\n",
@@ -126,11 +125,10 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
       return -RIG_EINVAL;
   }
 
-  buf_len = 50;
-  retval = kenwood_transaction (rig, "FW", buf, &buf_len);
+  retval = kenwood_transaction (rig, "FW", buf, sizeof (buf));
   if (retval != RIG_OK)
     return retval;
-
+	buf_len = strlen (buf);
   if (buf_len != 6 || buf[1] != 'W')
   {
     rig_debug(RIG_DEBUG_ERR,"%s: unexpected FW answer, len=%d\n",
@@ -144,11 +142,10 @@ static int ts870s_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
     {
       /* we only have HPF value and need LPF as well to calculate bandwidth */
 
-      buf_len = 50;
-      retval = kenwood_transaction (rig, "IS", buf, &buf_len);
+      retval = kenwood_transaction (rig, "IS", buf, sizeof (buf));
       if (retval != RIG_OK)
 	return retval;
-
+	buf_len = strlen (buf);
       if (buf_len != 7 || buf[1] != 'S')
 	{
 	  rig_debug(RIG_DEBUG_ERR,"%s: unexpected IS answer, len=%d\n",
@@ -185,7 +182,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
   }
 
   sprintf(buf, "MD%c", kmode);
-  retval = kenwood_simple_cmd(rig, buf);
+  retval = kenwood_transaction(rig, buf, NULL, 0);
   if (retval != RIG_OK) return retval;
 
   if (RIG_PASSBAND_NORMAL != width) /* leave well alone if default passband requested */
@@ -203,7 +200,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 	      mode_default_hpf = 100;
 	    }
 	  sprintf(buf, "IS %04d", (int)(width + mode_default_hpf));
-	  retval = kenwood_simple_cmd(rig, buf);
+	  retval = kenwood_transaction(rig, buf, NULL, 0);
 	}
       else
 	{
@@ -212,7 +209,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 	   * so we don't need to check the value...
 	   */
 	  sprintf(buf, "FW%04d", (int)width/10);
-	  retval = kenwood_simple_cmd(rig, buf);
+	  retval = kenwood_transaction(rig, buf, NULL, 0);
 	}
     }
 
@@ -228,7 +225,7 @@ int ts870s_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
 	case RIG_LEVEL_RFPOWER:
 		intval = val.f * 100;
 		sprintf(levelbuf, "PC%03d", intval);
-		return kenwood_simple_cmd(rig, levelbuf);
+		return kenwood_transaction(rig, levelbuf, NULL, 0);
 		break;
 
 	default:
@@ -244,13 +241,12 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 		int lvl, retval;
 		int i, ret, agclevel;
 
-		lvl_len = 50;
 		switch (level) {
 		case RIG_LEVEL_STRENGTH:
-			retval = kenwood_transaction (rig, "SM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "SM", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 6 || lvlbuf[1] != 'M') {
 				rig_debug(RIG_DEBUG_ERR,"ts870s_get_level: "
 								"wrong answer len=%d\n", lvl_len);
@@ -263,19 +259,16 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_SWR:
-			lvl_len = 50;
-			retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
 			/* set meter to SWR if needed */
 			if (lvlbuf[2] != '1')
 			{
-				lvl_len = 0;
-				retval = kenwood_transaction (rig, "RM1", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM1", NULL, 0);
 				if (retval != RIG_OK)
 					return retval;
-				lvl_len = 50;
-				retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 				if (retval != RIG_OK)
 					return retval;
 			}
@@ -288,19 +281,16 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_COMP:
-			lvl_len = 50;
-			retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
 			/* set meter to COMP if needed */
 			if (lvlbuf[2] != '2')
 			{
-				lvl_len = 0;
-				retval = kenwood_transaction (rig, "RM2", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM2", NULL, 0);
 				if (retval != RIG_OK)
 					return retval;
-				lvl_len = 50;
-				retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 				if (retval != RIG_OK)
 					return retval;
 			}
@@ -309,19 +299,16 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_ALC:
-			lvl_len = 50;
-			retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
 			/* set meter to ALC if needed */
 			if (lvlbuf[2] != '3')
 			{
-				lvl_len = 0;
-				retval = kenwood_transaction (rig, "RM3", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM3", NULL, 0);
 				if (retval != RIG_OK)
 					return retval;
-				lvl_len = 50;
-				retval = kenwood_transaction (rig, "RM", lvlbuf, &lvl_len);
+				retval = kenwood_transaction (rig, "RM", lvlbuf, sizeof (lvlbuf));
 				if (retval != RIG_OK)
 					return retval;
 			}
@@ -330,10 +317,10 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 
 		case RIG_LEVEL_ATT:
-			retval = kenwood_transaction (rig, "RA", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "RA", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
-
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 4) {
 				rig_debug(RIG_DEBUG_ERR,"ts870s_get_level: "
 								"unexpected answer len=%d\n", lvl_len);
@@ -357,9 +344,10 @@ static int ts870s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 			break;
 		case RIG_LEVEL_RFPOWER:
 			/* RFPOWER is 0..100 and not 0..255 like all the other levels*/
-			retval = kenwood_transaction (rig, "PC", lvlbuf, &lvl_len);
+			retval = kenwood_transaction (rig, "PC", lvlbuf, sizeof (lvlbuf));
 			if (retval != RIG_OK)
 				return retval;
+			lvl_len = strlen (lvlbuf);
 			if (lvl_len != 5 || lvlbuf[1] != 'C')
 			{
 				rig_debug(RIG_DEBUG_ERR,"ts870s_get_level: "
diff --git a/kenwood/xg3.c b/kenwood/xg3.c
index a790e62a0..6c6eb4d5f 100644
--- a/kenwood/xg3.c
+++ b/kenwood/xg3.c
@@ -247,7 +247,7 @@ int xg3_set_level(RIG * rig, vfo_t vfo, setting_t level, value_t val)
             return -RIG_EINVAL;
     }
 
-    return kenwood_simple_cmd(rig, levelbuf);
+    return kenwood_transaction(rig, levelbuf, NULL, 0);
 }
 
 /*
@@ -386,7 +386,7 @@ int xg3_set_freq(RIG * rig, vfo_t vfo, freq_t freq)
     {
         sprintf(cmdbuf, "F,%011ld", (long)freq);
     }
-    int err = kenwood_simple_cmd(rig, cmdbuf);
+    int err = kenwood_transaction(rig, cmdbuf, NULL, 0);
 
     return err;
 }
@@ -465,7 +465,7 @@ int xg3_set_powerstat(RIG * rig, powerstat_t status)
     if (status == RIG_POWER_OFF)
     {
         priv->powerstat = RIG_POWER_OFF;
-        return kenwood_simple_cmd(rig, cmd);
+        return kenwood_transaction(rig, cmd, NULL, 0);
     }
 
     rig_debug(RIG_DEBUG_VERBOSE, "%s invalid powerstat request status=%d\n",
@@ -481,7 +481,7 @@ int xg3_get_powerstat(RIG * rig, powerstat_t * status)
     rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
 
     const char *cmd = "G";      // any command to test will do
-    int retval = kenwood_simple_cmd(rig, cmd);
+    int retval = kenwood_transaction(rig, cmd, NULL, 0);
     if (retval != RIG_OK)
         return retval;
 
@@ -519,7 +519,7 @@ int xg3_set_mem(RIG * rig, vfo_t vfo, int ch)
         return -RIG_EINVAL;
     }
     sprintf(cmdbuf, "C,%02d;", ch);
-    retval = kenwood_simple_cmd(rig, cmdbuf);
+    retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
     if (retval != RIG_OK)
     {
         rig_debug(RIG_DEBUG_VERBOSE, "%s invalid set_mem cmd=%d\n", __func__,
@@ -542,7 +542,7 @@ int xg3_get_mem(RIG * rig, vfo_t vfo, int *ch)
 
     struct rig_state *rs = &rig->state;
     sprintf(cmdbuf, "C;");
-    retval = kenwood_simple_cmd(rig, cmdbuf);
+    retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
     if (retval != RIG_OK)
         return retval;
 
diff --git a/src/iofunc.c b/src/iofunc.c
index 5494182f3..2396bf523 100644
--- a/src/iofunc.c
+++ b/src/iofunc.c
@@ -487,6 +487,9 @@ int HAMLIB_API read_string(hamlib_port_t *p, char *rxbuffer, size_t rxmax, const
   int rd_count, total_count = 0;
   int retval;
 
+	if (!p || !rxbuffer) return -RIG_EINVAL;
+	if (rxmax < 1) return 0;
+
   /*
    * Wait up to timeout ms.
    */