cdb naming clean up

git-svn-id: https://svn.bingwo.ca/repos/sg3_utils/trunk@709 6180dd3e-e324-4e3e-922d-17de1ae2f315

21 files changed, 296 insertions, 295 deletions

diff --git a/src/sg_format.c b/src/sg_format.c
index 10b1f618..c38bbe90 100644
--- a/src/sg_format.c
+++ b/src/sg_format.c
@@ -36,7 +36,7 @@
 #include "sg_pr2serr.h"
 #include "sg_pt.h"
 
-static const char * version_str = "1.36 20160423";
+static const char * version_str = "1.37 20160528";
 
 
 #define RW_ERROR_RECOVERY_PAGE 1  /* can give alternate with --mode=MP */
@@ -223,23 +223,23 @@ sg_ll_format_medium(int sg_fd, int verify, int immed, int format,
                     int verbose)
 {
         int k, ret, res, sense_cat;
-        unsigned char fmCmdBlk[SG_FORMAT_MEDIUM_CMDLEN] =
+        unsigned char fm_cdb[SG_FORMAT_MEDIUM_CMDLEN] =
                                   {SG_FORMAT_MEDIUM_CMD, 0, 0, 0, 0, 0};
         unsigned char sense_b[SENSE_BUFF_LEN];
         struct sg_pt_base * ptvp;
 
         if (verify)
-                fmCmdBlk[1] |= 0x2;
+                fm_cdb[1] |= 0x2;
         if (immed)
-                fmCmdBlk[1] |= 0x1;
+                fm_cdb[1] |= 0x1;
         if (format)
-                fmCmdBlk[2] |= (0xf & format);
+                fm_cdb[2] |= (0xf & format);
         if (transfer_len > 0)
-                sg_put_unaligned_be16(transfer_len, fmCmdBlk + 3);
+                sg_put_unaligned_be16(transfer_len, fm_cdb + 3);
         if (verbose) {
                 pr2serr("    Format medium cdb: ");
                 for (k = 0; k < SG_FORMAT_MEDIUM_CMDLEN; ++k)
-                        pr2serr("%02x ", fmCmdBlk[k]);
+                        pr2serr("%02x ", fm_cdb[k]);
                 pr2serr("\n");
         }
 
@@ -248,7 +248,7 @@ sg_ll_format_medium(int sg_fd, int verify, int immed, int format,
                 pr2serr("%s: out of memory\n", __func__);
                 return -1;
         }
-        set_scsi_pt_cdb(ptvp, fmCmdBlk, sizeof(fmCmdBlk));
+        set_scsi_pt_cdb(ptvp, fm_cdb, sizeof(fm_cdb));
         set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
         set_scsi_pt_data_out(ptvp, (unsigned char *)paramp, transfer_len);
         res = do_scsi_pt(ptvp, sg_fd, timeout, verbose);
diff --git a/src/sg_inq.c b/src/sg_inq.c
index 99e21953..8944d456 100644
--- a/src/sg_inq.c
+++ b/src/sg_inq.c
@@ -926,20 +926,20 @@ pt_inquiry(int sg_fd, int evpd, int pg_op, void * resp, int mx_resp_len,
            int * residp, int noisy, int verbose)
 {
     int res, ret, k, sense_cat, resid;
-    unsigned char inqCmdBlk[INQUIRY_CMDLEN] = {INQUIRY_CMD, 0, 0, 0, 0, 0};
+    unsigned char inq_cdb[INQUIRY_CMDLEN] = {INQUIRY_CMD, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     unsigned char * up;
     struct sg_pt_base * ptvp;
 
     if (evpd)
-        inqCmdBlk[1] |= 1;
-    inqCmdBlk[2] = (unsigned char)pg_op;
+        inq_cdb[1] |= 1;
+    inq_cdb[2] = (unsigned char)pg_op;
     /* 16 bit allocation length (was 8) is a recent SPC-3 addition */
-    sg_put_unaligned_be16((uint16_t)mx_resp_len, inqCmdBlk + 3);
+    sg_put_unaligned_be16((uint16_t)mx_resp_len, inq_cdb + 3);
     if (verbose) {
         pr2serr("    inquiry cdb: ");
         for (k = 0; k < INQUIRY_CMDLEN; ++k)
-            pr2serr("%02x ", inqCmdBlk[k]);
+            pr2serr("%02x ", inq_cdb[k]);
         pr2serr("\n");
     }
     if (resp && (mx_resp_len > 0)) {
@@ -953,7 +953,7 @@ pt_inquiry(int sg_fd, int evpd, int pg_op, void * resp, int mx_resp_len,
         pr2serr("inquiry: out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, inqCmdBlk, sizeof(inqCmdBlk));
+    set_scsi_pt_cdb(ptvp, inq_cdb, sizeof(inq_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
diff --git a/src/sg_opcodes.c b/src/sg_opcodes.c
index e3c25c65..929bffd3 100644
--- a/src/sg_opcodes.c
+++ b/src/sg_opcodes.c
@@ -29,7 +29,7 @@
 
 #include "sg_pt.h"
 
-static const char * version_str = "0.47 20160423";    /* spc5r08 */
+static const char * version_str = "0.48 20160528";    /* spc5r10 */
 
 
 #define SENSE_BUFF_LEN 64       /* Arbitrary, could be larger */
@@ -983,25 +983,25 @@ do_rsoc(int sg_fd, int rctd, int rep_opts, int rq_opcode, int rq_servact,
         void * resp, int mx_resp_len, int noisy, int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char rsocCmdBlk[RSOC_CMD_LEN] = {SG_MAINTENANCE_IN, RSOC_SA, 0,
+    unsigned char rsoc_cdb[RSOC_CMD_LEN] = {SG_MAINTENANCE_IN, RSOC_SA, 0,
                                               0, 0, 0, 0, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
     if (rctd)
-        rsocCmdBlk[2] |= 0x80;
+        rsoc_cdb[2] |= 0x80;
     if (rep_opts)
-        rsocCmdBlk[2] |= (rep_opts & 0x7);
+        rsoc_cdb[2] |= (rep_opts & 0x7);
     if (rq_opcode > 0)
-        rsocCmdBlk[3] = (rq_opcode & 0xff);
+        rsoc_cdb[3] = (rq_opcode & 0xff);
     if (rq_servact > 0)
-        sg_put_unaligned_be16((uint16_t)rq_servact, rsocCmdBlk + 4);
-    sg_put_unaligned_be32((uint32_t)mx_resp_len, rsocCmdBlk + 6);
+        sg_put_unaligned_be16((uint16_t)rq_servact, rsoc_cdb + 4);
+    sg_put_unaligned_be32((uint32_t)mx_resp_len, rsoc_cdb + 6);
 
     if (verbose) {
         pr2serr("    Report Supported Operation Codes cmd: ");
         for (k = 0; k < RSOC_CMD_LEN; ++k)
-            pr2serr("%02x ", rsocCmdBlk[k]);
+            pr2serr("%02x ", rsoc_cdb[k]);
         pr2serr("\n");
     }
     ptvp = construct_scsi_pt_obj();
@@ -1009,7 +1009,7 @@ do_rsoc(int sg_fd, int rctd, int rep_opts, int rq_opcode, int rq_servact,
         pr2serr("Report Supported Operation Codes: out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, rsocCmdBlk, sizeof(rsocCmdBlk));
+    set_scsi_pt_cdb(ptvp, rsoc_cdb, sizeof(rsoc_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_TIMEOUT_SECS, verbose);
@@ -1040,19 +1040,19 @@ do_rstmf(int sg_fd, int repd, void * resp, int mx_resp_len, int noisy,
          int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char rstmfCmdBlk[RSTMF_CMD_LEN] = {SG_MAINTENANCE_IN, RSTMF_SA,
+    unsigned char rstmf_cdb[RSTMF_CMD_LEN] = {SG_MAINTENANCE_IN, RSTMF_SA,
                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
     if (repd)
-        rstmfCmdBlk[2] = 0x80;
-    sg_put_unaligned_be32((uint32_t)mx_resp_len, rstmfCmdBlk + 6);
+        rstmf_cdb[2] = 0x80;
+    sg_put_unaligned_be32((uint32_t)mx_resp_len, rstmf_cdb + 6);
 
     if (verbose) {
         pr2serr("    Report Supported Task Management Functions cmd: ");
         for (k = 0; k < RSTMF_CMD_LEN; ++k)
-            pr2serr("%02x ", rstmfCmdBlk[k]);
+            pr2serr("%02x ", rstmf_cdb[k]);
         pr2serr("\n");
     }
     ptvp = construct_scsi_pt_obj();
@@ -1060,7 +1060,7 @@ do_rstmf(int sg_fd, int repd, void * resp, int mx_resp_len, int noisy,
         pr2serr("Report Supported Task Management Functions: out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, rstmfCmdBlk, sizeof(rstmfCmdBlk));
+    set_scsi_pt_cdb(ptvp, rstmf_cdb, sizeof(rstmf_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_TIMEOUT_SECS, verbose);
diff --git a/src/sg_rbuf.c b/src/sg_rbuf.c
index 5354b2f4..bd7f77ca 100644
--- a/src/sg_rbuf.c
+++ b/src/sg_rbuf.c
@@ -55,7 +55,7 @@
 #endif
 
 
-static const char * version_str = "4.96 20160222";
+static const char * version_str = "4.97 20160528";
 
 static struct option long_options[] = {
         {"buffer", required_argument, 0, 'b'},
@@ -349,7 +349,7 @@ main(int argc, char * argv[])
 {
     int sg_fd, res, j;
     unsigned int k, num;
-    unsigned char rbCmdBlk [RB_CMD_LEN];
+    unsigned char rb_cdb [RB_CMD_LEN];
     unsigned char * rbBuff = NULL;
     void * rawp = NULL;
     unsigned char sense_buffer[32];
@@ -411,25 +411,25 @@ main(int argc, char * argv[])
     }
     rbBuff = (unsigned char *)rawp;
 
-    memset(rbCmdBlk, 0, RB_CMD_LEN);
-    rbCmdBlk[0] = RB_OPCODE;
-    rbCmdBlk[1] = op->do_echo ? RB_MODE_ECHO_DESC : RB_MODE_DESC;
-    rbCmdBlk[8] = RB_DESC_LEN;
+    memset(rb_cdb, 0, RB_CMD_LEN);
+    rb_cdb[0] = RB_OPCODE;
+    rb_cdb[1] = op->do_echo ? RB_MODE_ECHO_DESC : RB_MODE_DESC;
+    rb_cdb[8] = RB_DESC_LEN;
     memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
     io_hdr.interface_id = 'S';
-    io_hdr.cmd_len = sizeof(rbCmdBlk);
+    io_hdr.cmd_len = sizeof(rb_cdb);
     io_hdr.mx_sb_len = sizeof(sense_buffer);
     io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
     io_hdr.dxfer_len = RB_DESC_LEN;
     io_hdr.dxferp = rbBuff;
-    io_hdr.cmdp = rbCmdBlk;
+    io_hdr.cmdp = rb_cdb;
     io_hdr.sbp = sense_buffer;
     io_hdr.timeout = 60000;     /* 60000 millisecs == 60 seconds */
     if (op->do_verbose) {
         pr2serr("    Read buffer (%sdescriptor) cdb: ",
                 (op->do_echo ? "echo " : ""));
         for (k = 0; k < RB_CMD_LEN; ++k)
-            pr2serr("%02x ", rbCmdBlk[k]);
+            pr2serr("%02x ", rb_cdb[k]);
         pr2serr("\n");
     }
 
@@ -530,23 +530,23 @@ main(int argc, char * argv[])
     }
     /* main data reading loop */
     for (k = 0; k < num; ++k) {
-        memset(rbCmdBlk, 0, RB_CMD_LEN);
-        rbCmdBlk[0] = RB_OPCODE;
-        rbCmdBlk[1] = op->do_echo ? RB_MODE_ECHO_DATA : RB_MODE_DATA;
-        sg_put_unaligned_be24((uint32_t)buf_size, rbCmdBlk + 6);
+        memset(rb_cdb, 0, RB_CMD_LEN);
+        rb_cdb[0] = RB_OPCODE;
+        rb_cdb[1] = op->do_echo ? RB_MODE_ECHO_DATA : RB_MODE_DATA;
+        sg_put_unaligned_be24((uint32_t)buf_size, rb_cdb + 6);
 #ifdef SG_DEBUG
         memset(rbBuff, 0, buf_size);
 #endif
 
         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
         io_hdr.interface_id = 'S';
-        io_hdr.cmd_len = sizeof(rbCmdBlk);
+        io_hdr.cmd_len = sizeof(rb_cdb);
         io_hdr.mx_sb_len = sizeof(sense_buffer);
         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
         io_hdr.dxfer_len = buf_size;
         if (! op->do_mmap)
             io_hdr.dxferp = rbBuff;
-        io_hdr.cmdp = rbCmdBlk;
+        io_hdr.cmdp = rb_cdb;
         io_hdr.sbp = sense_buffer;
         io_hdr.timeout = 20000;     /* 20000 millisecs == 20 seconds */
         io_hdr.pack_id = k;
@@ -560,7 +560,7 @@ main(int argc, char * argv[])
             pr2serr("    Read buffer (%sdata) cdb: ",
                     (op->do_echo ? "echo " : ""));
             for (j = 0; j < RB_CMD_LEN; ++j)
-                pr2serr("%02x ", rbCmdBlk[j]);
+                pr2serr("%02x ", rb_cdb[j]);
             pr2serr("\n");
         }
 
diff --git a/src/sg_read_attr.c b/src/sg_read_attr.c
index d874908f..a1436c49 100644
--- a/src/sg_read_attr.c
+++ b/src/sg_read_attr.c
@@ -34,7 +34,7 @@
  * and decodes the response. Based on spc5r08.pdf
  */
 
-static const char * version_str = "1.02 20160423";
+static const char * version_str = "1.02 20160528";
 
 #define MAX_RATTR_BUFF_LEN (1024 * 1024)
 #define DEF_RATTR_BUFF_LEN (1024 * 8)
@@ -239,28 +239,28 @@ sg_ll_read_attr(int sg_fd, void * resp, int * residp,
 {
     int k, ret, res, sense_cat;
     int noisy = 1;
-    unsigned char raCmdBlk[SG_READ_ATTRIBUTE_CMDLEN] =
+    unsigned char ra_cdb[SG_READ_ATTRIBUTE_CMDLEN] =
           {SG_READ_ATTRIBUTE_CMD, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,
            0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    raCmdBlk[1] = 0x1f & op->sa;
+    ra_cdb[1] = 0x1f & op->sa;
     if (op->ea)
-        sg_put_unaligned_be16(op->ea, raCmdBlk + 2);
+        sg_put_unaligned_be16(op->ea, ra_cdb + 2);
     if (op->lvn)
-        raCmdBlk[5] = 0xff & op->lvn;
+        ra_cdb[5] = 0xff & op->lvn;
     if (op->pn)
-        raCmdBlk[7] = 0xff & op->pn;
+        ra_cdb[7] = 0xff & op->pn;
     if (op->fai)
-        sg_put_unaligned_be16(op->fai, raCmdBlk + 8);
-    sg_put_unaligned_be32((uint32_t)op->maxlen, raCmdBlk + 10);
+        sg_put_unaligned_be16(op->fai, ra_cdb + 8);
+    sg_put_unaligned_be32((uint32_t)op->maxlen, ra_cdb + 10);
     if (op->cache)
-        raCmdBlk[14] |= 0x1;
+        ra_cdb[14] |= 0x1;
     if (op->verbose) {
         pr2serr("    Read attribute cdb: ");
         for (k = 0; k < SG_READ_ATTRIBUTE_CMDLEN; ++k)
-            pr2serr("%02x ", raCmdBlk[k]);
+            pr2serr("%02x ", ra_cdb[k]);
         pr2serr("\n");
     }
 
@@ -269,7 +269,7 @@ sg_ll_read_attr(int sg_fd, void * resp, int * residp,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, raCmdBlk, sizeof(raCmdBlk));
+    set_scsi_pt_cdb(ptvp, ra_cdb, sizeof(ra_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, op->maxlen);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, op->verbose);
diff --git a/src/sg_rep_zones.c b/src/sg_rep_zones.c
index 31fb88d0..0dd75d17 100644
--- a/src/sg_rep_zones.c
+++ b/src/sg_rep_zones.c
@@ -32,7 +32,7 @@
  * and decodes the response. Based on zbc-r02.pdf
  */
 
-static const char * version_str = "1.09 20160423";
+static const char * version_str = "1.09 20160528";
 
 #define MAX_RZONES_BUFF_LEN (1024 * 1024)
 #define DEF_RZONES_BUFF_LEN (1024 * 8)
@@ -96,21 +96,21 @@ sg_ll_report_zones(int sg_fd, uint64_t zs_lba, int partial, int report_opts,
                    int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char rzCmdBlk[SG_ZONING_IN_CMDLEN] =
+    unsigned char rz_cdb[SG_ZONING_IN_CMDLEN] =
           {SG_ZONING_IN, REPORT_ZONES_SA, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    sg_put_unaligned_be64(zs_lba, rzCmdBlk + 2);
-    sg_put_unaligned_be32((uint32_t)mx_resp_len, rzCmdBlk + 10);
-    rzCmdBlk[14] = report_opts & 0x3f;
+    sg_put_unaligned_be64(zs_lba, rz_cdb + 2);
+    sg_put_unaligned_be32((uint32_t)mx_resp_len, rz_cdb + 10);
+    rz_cdb[14] = report_opts & 0x3f;
     if (partial)
-        rzCmdBlk[14] |= 0x80;
+        rz_cdb[14] |= 0x80;
     if (verbose) {
         pr2serr("    Report zones cdb: ");
         for (k = 0; k < SG_ZONING_IN_CMDLEN; ++k)
-            pr2serr("%02x ", rzCmdBlk[k]);
+            pr2serr("%02x ", rz_cdb[k]);
         pr2serr("\n");
     }
 
@@ -119,7 +119,7 @@ sg_ll_report_zones(int sg_fd, uint64_t zs_lba, int partial, int report_opts,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, rzCmdBlk, sizeof(rzCmdBlk));
+    set_scsi_pt_cdb(ptvp, rz_cdb, sizeof(rz_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
diff --git a/src/sg_reset_wp.c b/src/sg_reset_wp.c
index 93613e8b..fc8c4a40 100644
--- a/src/sg_reset_wp.c
+++ b/src/sg_reset_wp.c
@@ -32,7 +32,7 @@
  * device. Based on zbc-r04c.pdf .
  */
 
-static const char * version_str = "1.05 20160519";
+static const char * version_str = "1.05 20160528";
 
 #define SG_ZONING_OUT_CMDLEN 16
 #define RESET_WRITE_POINTER_SA 0x4
@@ -79,19 +79,19 @@ sg_ll_reset_write_pointer(int sg_fd, uint64_t zid, int all, int noisy,
                           int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char rwpCmdBlk[SG_ZONING_OUT_CMDLEN] =
+    unsigned char rwp_cdb[SG_ZONING_OUT_CMDLEN] =
           {SG_ZONING_OUT, RESET_WRITE_POINTER_SA, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0,  0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    sg_put_unaligned_be64(zid, rwpCmdBlk + 2);
+    sg_put_unaligned_be64(zid, rwp_cdb + 2);
     if (all)
-        rwpCmdBlk[14] = 0x1;
+        rwp_cdb[14] = 0x1;
     if (verbose) {
         pr2serr("    Reset write pointer cdb: ");
         for (k = 0; k < SG_ZONING_OUT_CMDLEN; ++k)
-            pr2serr("%02x ", rwpCmdBlk[k]);
+            pr2serr("%02x ", rwp_cdb[k]);
         pr2serr("\n");
     }
 
@@ -100,7 +100,7 @@ sg_ll_reset_write_pointer(int sg_fd, uint64_t zid, int all, int noisy,
         pr2serr("Reset write pointer: out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, rwpCmdBlk, sizeof(rwpCmdBlk));
+    set_scsi_pt_cdb(ptvp, rwp_cdb, sizeof(rwp_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
     ret = sg_cmds_process_resp(ptvp, "reset write pointer", res, 0, sense_b,
diff --git a/src/sg_sanitize.c b/src/sg_sanitize.c
index af4481a3..8e1aa4d9 100644
--- a/src/sg_sanitize.c
+++ b/src/sg_sanitize.c
@@ -28,7 +28,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.02 20160423";
+static const char * version_str = "1.02 20160528";
 
 /* Not all environments support the Unix sleep() */
 #if defined(MSC_VER) || defined(__MINGW32__)
@@ -169,7 +169,7 @@ do_sanitize(int sg_fd, const struct opts_t * op, const void * param_lstp,
             int param_lst_len)
 {
     int k, ret, res, sense_cat, immed, timeout;
-    unsigned char sanCmdBlk[SANITIZE_OP_LEN];
+    unsigned char san_cdb[SANITIZE_OP_LEN];
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
@@ -181,30 +181,30 @@ do_sanitize(int sg_fd, const struct opts_t * op, const void * param_lstp,
     /* only use command line timeout if it exceeds previous defaults */
     if (op->timeout > timeout)
         timeout = op->timeout;
-    memset(sanCmdBlk, 0, sizeof(sanCmdBlk));
-    sanCmdBlk[0] = SANITIZE_OP;
+    memset(san_cdb, 0, sizeof(san_cdb));
+    san_cdb[0] = SANITIZE_OP;
     if (op->overwrite)
-        sanCmdBlk[1] = SANITIZE_SA_OVERWRITE;
+        san_cdb[1] = SANITIZE_SA_OVERWRITE;
     else if (op->block)
-        sanCmdBlk[1] = SANITIZE_SA_BLOCK_ERASE;
+        san_cdb[1] = SANITIZE_SA_BLOCK_ERASE;
     else if (op->crypto)
-        sanCmdBlk[1] = SANITIZE_SA_CRYPTO_ERASE;
+        san_cdb[1] = SANITIZE_SA_CRYPTO_ERASE;
     else if (op->fail)
-        sanCmdBlk[1] = SANITIZE_SA_EXIT_FAIL_MODE;
+        san_cdb[1] = SANITIZE_SA_EXIT_FAIL_MODE;
     else
         return SG_LIB_SYNTAX_ERROR;
     if (immed)
-        sanCmdBlk[1] |= 0x80;
+        san_cdb[1] |= 0x80;
     if (op->znr)        /* added sbc4r07 */
-        sanCmdBlk[1] |= 0x40;
+        san_cdb[1] |= 0x40;
     if (op->ause)
-        sanCmdBlk[1] |= 0x20;
-    sg_put_unaligned_be16((uint16_t)param_lst_len, sanCmdBlk + 7);
+        san_cdb[1] |= 0x20;
+    sg_put_unaligned_be16((uint16_t)param_lst_len, san_cdb + 7);
 
     if (op->verbose > 1) {
         pr2serr("    Sanitize cmd: ");
         for (k = 0; k < SANITIZE_OP_LEN; ++k)
-            pr2serr("%02x ", sanCmdBlk[k]);
+            pr2serr("%02x ", san_cdb[k]);
         pr2serr("\n");
         if (op->verbose > 2) {
             if (param_lst_len > 0) {
@@ -219,7 +219,7 @@ do_sanitize(int sg_fd, const struct opts_t * op, const void * param_lstp,
         pr2serr("Sanitize: out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, sanCmdBlk, sizeof(sanCmdBlk));
+    set_scsi_pt_cdb(ptvp, san_cdb, sizeof(san_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_out(ptvp, (unsigned char *)param_lstp, param_lst_len);
     res = do_scsi_pt(ptvp, sg_fd, timeout, op->verbose);
diff --git a/src/sg_sat_identify.c b/src/sg_sat_identify.c
index f74059fb..fd6ead83 100644
--- a/src/sg_sat_identify.c
+++ b/src/sg_sat_identify.c
@@ -50,7 +50,7 @@
 
 #define EBUFF_SZ 256
 
-static const char * version_str = "1.14 20160525";
+static const char * version_str = "1.14 20160528";
 
 static struct option long_options[] = {
         {"ck_cond", no_argument, 0, 'c'},
@@ -126,58 +126,58 @@ static int do_identify_dev(int sg_fd, int do_packet, int cdb_len,
     unsigned char inBuff[ID_RESPONSE_LEN];
     unsigned char sense_buffer[64];
     unsigned char ata_return_desc[16];
-    unsigned char aptCmdBlk[SAT_ATA_PASS_THROUGH16_LEN] =
+    unsigned char apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
                 {SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0, 0, 0};
-    unsigned char apt12CmdBlk[SAT_ATA_PASS_THROUGH12_LEN] =
+    unsigned char apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
                 {SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0};
-    unsigned char apt32CmdBlk[SAT_ATA_PASS_THROUGH32_LEN];
+    unsigned char apt32_cdb[SAT_ATA_PASS_THROUGH32_LEN];
     const unsigned short * usp;
     uint64_t ull;
 
     sb_sz = sizeof(sense_buffer);
     memset(sense_buffer, 0, sb_sz);
-    memset(apt32CmdBlk, 0, sizeof(apt32CmdBlk));
+    memset(apt32_cdb, 0, sizeof(apt32_cdb));
     memset(ata_return_desc, 0, sizeof(ata_return_desc));
     ok = 0;
     switch (cdb_len) {
     case SAT_ATA_PASS_THROUGH32_LEN:    /* SAT-4 revision 5 or later */
         /* Prepare SCSI ATA PASS-THROUGH COMMAND(32) command */
-        sg_put_unaligned_be16(1, apt32CmdBlk + 22);     /* count=1 */
-        apt32CmdBlk[25] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
+        sg_put_unaligned_be16(1, apt32_cdb + 22);     /* count=1 */
+        apt32_cdb[25] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
                                        ATA_IDENTIFY_DEVICE);
-        apt32CmdBlk[10] = (multiple_count << 5) | (protocol << 1) | extend;
-        apt32CmdBlk[11] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt32_cdb[10] = (multiple_count << 5) | (protocol << 1) | extend;
+        apt32_cdb[11] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                           (byte_block << 2) | t_length;
         /* following call takes care of all bytes below offset 10 in cdb */
-        res = sg_ll_ata_pt(sg_fd, apt32CmdBlk, cdb_len, DEF_TIMEOUT, inBuff,
+        res = sg_ll_ata_pt(sg_fd, apt32_cdb, cdb_len, DEF_TIMEOUT, inBuff,
                            NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
         break;
     case SAT_ATA_PASS_THROUGH16_LEN:
         /* Prepare SCSI ATA PASS-THROUGH COMMAND(16) command */
-        aptCmdBlk[6] = 1;   /* sector count */
-        aptCmdBlk[14] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
+        apt_cdb[6] = 1;   /* sector count */
+        apt_cdb[14] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
                                      ATA_IDENTIFY_DEVICE);
-        aptCmdBlk[1] = (multiple_count << 5) | (protocol << 1) | extend;
-        aptCmdBlk[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt_cdb[1] = (multiple_count << 5) | (protocol << 1) | extend;
+        apt_cdb[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                        (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, aptCmdBlk, cdb_len, DEF_TIMEOUT, inBuff,
+        res = sg_ll_ata_pt(sg_fd, apt_cdb, cdb_len, DEF_TIMEOUT, inBuff,
                            NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
         break;
     case SAT_ATA_PASS_THROUGH12_LEN:
         /* Prepare SCSI ATA PASS-THROUGH COMMAND(12) command */
-        apt12CmdBlk[4] = 1;   /* sector count */
-        apt12CmdBlk[9] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
+        apt12_cdb[4] = 1;   /* sector count */
+        apt12_cdb[9] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
                                       ATA_IDENTIFY_DEVICE);
-        apt12CmdBlk[1] = (multiple_count << 5) | (protocol << 1);
-        apt12CmdBlk[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt12_cdb[1] = (multiple_count << 5) | (protocol << 1);
+        apt12_cdb[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                          (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, apt12CmdBlk, cdb_len, DEF_TIMEOUT, inBuff,
+        res = sg_ll_ata_pt(sg_fd, apt12_cdb, cdb_len, DEF_TIMEOUT, inBuff,
                            NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
diff --git a/src/sg_sat_phy_event.c b/src/sg_sat_phy_event.c
index fcece2d0..c83762bb 100644
--- a/src/sg_sat_phy_event.c
+++ b/src/sg_sat_phy_event.c
@@ -22,7 +22,7 @@
 #include "sg_cmds_extra.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.07 20160126";
+static const char * version_str = "1.07 20160528";
 
 /* This program uses a ATA PASS-THROUGH SCSI command. This usage is
  * defined in the SCSI to ATA Translation (SAT) drafts and standards.
@@ -166,10 +166,10 @@ do_read_log_ext(int sg_fd, int log_addr, int page_in_log, int feature,
     struct sg_scsi_sense_hdr ssh;
     unsigned char sense_buffer[64];
     unsigned char ata_return_desc[16];
-    unsigned char aptCmdBlk[SAT_ATA_PASS_THROUGH16_LEN] =
+    unsigned char apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
                 {SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0, 0, 0};
-    unsigned char apt12CmdBlk[SAT_ATA_PASS_THROUGH12_LEN] =
+    unsigned char apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
                 {SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0};
 
@@ -179,33 +179,33 @@ do_read_log_ext(int sg_fd, int log_addr, int page_in_log, int feature,
     ok = 0;
     if (SAT_ATA_PASS_THROUGH16_LEN == cdb_len) {
         /* Prepare ATA PASS-THROUGH COMMAND (16) command */
-        aptCmdBlk[3] = (feature >> 8) & 0xff;   /* feature(15:8) */
-        aptCmdBlk[4] = feature & 0xff;          /* feature(7:0) */
-        aptCmdBlk[5] = (blk_count >> 8) & 0xff; /* sector_count(15:8) */
-        aptCmdBlk[6] = blk_count & 0xff;        /* sector_count(7:0) */
-        aptCmdBlk[8] = log_addr & 0xff;  /* lba_low(7:0) == LBA(7:0) */
-        aptCmdBlk[9] = (page_in_log >> 8) & 0xff;
+        apt_cdb[3] = (feature >> 8) & 0xff;   /* feature(15:8) */
+        apt_cdb[4] = feature & 0xff;          /* feature(7:0) */
+        apt_cdb[5] = (blk_count >> 8) & 0xff; /* sector_count(15:8) */
+        apt_cdb[6] = blk_count & 0xff;        /* sector_count(7:0) */
+        apt_cdb[8] = log_addr & 0xff;  /* lba_low(7:0) == LBA(7:0) */
+        apt_cdb[9] = (page_in_log >> 8) & 0xff;
                 /* lba_mid(15:8) == LBA(39:32) */
-        aptCmdBlk[10] = page_in_log & 0xff; /* lba_mid(7:0) == LBA(15:8) */
-        aptCmdBlk[14] = ATA_READ_LOG_EXT;
-        aptCmdBlk[1] = (multiple_count << 5) | (protocol << 1) | extend;
-        aptCmdBlk[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt_cdb[10] = page_in_log & 0xff; /* lba_mid(7:0) == LBA(15:8) */
+        apt_cdb[14] = ATA_READ_LOG_EXT;
+        apt_cdb[1] = (multiple_count << 5) | (protocol << 1) | extend;
+        apt_cdb[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                        (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, aptCmdBlk, cdb_len, DEF_TIMEOUT, resp,
+        res = sg_ll_ata_pt(sg_fd, apt_cdb, cdb_len, DEF_TIMEOUT, resp,
                            NULL /* doutp */, mx_resp_len, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
     } else {
         /* Prepare ATA PASS-THROUGH COMMAND (12) command */
-        apt12CmdBlk[3] = feature & 0xff;        /* feature(7:0) */
-        apt12CmdBlk[4] = blk_count & 0xff;        /* sector_count(7:0) */
-        apt12CmdBlk[5] = log_addr & 0xff;  /* lba_low(7:0) == LBA(7:0) */
-        apt12CmdBlk[6] = page_in_log & 0xff; /* lba_mid(7:0) == LBA(15:8) */
-        apt12CmdBlk[9] = ATA_READ_LOG_EXT;
-        apt12CmdBlk[1] = (multiple_count << 5) | (protocol << 1);
-        apt12CmdBlk[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt12_cdb[3] = feature & 0xff;        /* feature(7:0) */
+        apt12_cdb[4] = blk_count & 0xff;        /* sector_count(7:0) */
+        apt12_cdb[5] = log_addr & 0xff;  /* lba_low(7:0) == LBA(7:0) */
+        apt12_cdb[6] = page_in_log & 0xff; /* lba_mid(7:0) == LBA(15:8) */
+        apt12_cdb[9] = ATA_READ_LOG_EXT;
+        apt12_cdb[1] = (multiple_count << 5) | (protocol << 1);
+        apt12_cdb[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                          (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, apt12CmdBlk, cdb_len, DEF_TIMEOUT, resp,
+        res = sg_ll_ata_pt(sg_fd, apt12_cdb, cdb_len, DEF_TIMEOUT, resp,
                            NULL /* doutp */, mx_resp_len, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
diff --git a/src/sg_sat_read_gplog.c b/src/sg_sat_read_gplog.c
index df34de28..ad80d3e7 100644
--- a/src/sg_sat_read_gplog.c
+++ b/src/sg_sat_read_gplog.c
@@ -49,7 +49,7 @@
 
 #define DEF_TIMEOUT 20
 
-static const char * version_str = "1.13 20160126";
+static const char * version_str = "1.13 20160528";
 
 struct opts_t {
     int cdb_len;
@@ -134,10 +134,10 @@ do_read_gplog(int sg_fd, int ata_cmd, unsigned char *inbuff,
     struct sg_scsi_sense_hdr ssh;
     unsigned char sense_buffer[64];
     unsigned char ata_return_desc[16];
-    unsigned char aptCmdBlk[SAT_ATA_PASS_THROUGH16_LEN] =
+    unsigned char apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
                 {SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0, 0, 0};
-    unsigned char apt12CmdBlk[SAT_ATA_PASS_THROUGH12_LEN] =
+    unsigned char apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
                 {SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0};
     char cmd_name[32];
@@ -159,29 +159,29 @@ do_read_gplog(int sg_fd, int ata_cmd, unsigned char *inbuff,
                 op->pn);
     if (op->cdb_len == 16) {
         /* Prepare ATA PASS-THROUGH COMMAND (16) command */
-        aptCmdBlk[14] = ata_cmd;
-        sg_put_unaligned_be16((uint16_t)op->count, aptCmdBlk + 5);
-        aptCmdBlk[8] = op->la;
-        sg_put_unaligned_be16((uint16_t)op->pn, aptCmdBlk + 9);
-        aptCmdBlk[1] = (protocol << 1) | extend;
-        aptCmdBlk[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt_cdb[14] = ata_cmd;
+        sg_put_unaligned_be16((uint16_t)op->count, apt_cdb + 5);
+        apt_cdb[8] = op->la;
+        sg_put_unaligned_be16((uint16_t)op->pn, apt_cdb + 9);
+        apt_cdb[1] = (protocol << 1) | extend;
+        apt_cdb[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                        (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, aptCmdBlk, op->cdb_len, DEF_TIMEOUT, inbuff,
+        res = sg_ll_ata_pt(sg_fd, apt_cdb, op->cdb_len, DEF_TIMEOUT, inbuff,
                            NULL, op->count * 512, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, op->verbose);
     } else {
         /* Prepare ATA PASS-THROUGH COMMAND (12) command */
         /* Cannot map upper 8 bits of the pn since no LBA (39:32) field */
-        apt12CmdBlk[9] = ata_cmd;
-        apt12CmdBlk[4] = op->count;
-        apt12CmdBlk[5] = op->la;
-        apt12CmdBlk[6] = op->pn & 0xff;
-        /* apt12CmdBlk[7] = (op->pn >> 8) & 0xff; */
-        apt12CmdBlk[1] = (protocol << 1);
-        apt12CmdBlk[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt12_cdb[9] = ata_cmd;
+        apt12_cdb[4] = op->count;
+        apt12_cdb[5] = op->la;
+        apt12_cdb[6] = op->pn & 0xff;
+        /* apt12_cdb[7] = (op->pn >> 8) & 0xff; */
+        apt12_cdb[1] = (protocol << 1);
+        apt12_cdb[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                          (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, apt12CmdBlk, op->cdb_len, DEF_TIMEOUT,
+        res = sg_ll_ata_pt(sg_fd, apt12_cdb, op->cdb_len, DEF_TIMEOUT,
                            inbuff, NULL, op->count * 512, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, op->verbose);
diff --git a/src/sg_sat_set_features.c b/src/sg_sat_set_features.c
index 9f315039..278cf211 100644
--- a/src/sg_sat_set_features.c
+++ b/src/sg_sat_set_features.c
@@ -47,7 +47,7 @@
 
 #define DEF_TIMEOUT 20
 
-static const char * version_str = "1.12 20160126";
+static const char * version_str = "1.12 20160528";
 
 static struct option long_options[] = {
     {"count", required_argument, 0, 'c'},
@@ -119,10 +119,10 @@ do_set_features(int sg_fd, int feature, int count, uint64_t lba,
     struct sg_scsi_sense_hdr ssh;
     unsigned char sense_buffer[64];
     unsigned char ata_return_desc[16];
-    unsigned char aptCmdBlk[SAT_ATA_PASS_THROUGH16_LEN] =
+    unsigned char apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
                 {SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0, 0, 0};
-    unsigned char apt12CmdBlk[SAT_ATA_PASS_THROUGH12_LEN] =
+    unsigned char apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
                 {SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0};
 
@@ -131,34 +131,34 @@ do_set_features(int sg_fd, int feature, int count, uint64_t lba,
     memset(ata_return_desc, 0, sizeof(ata_return_desc));
     if (16 == cdb_len) {
         /* Prepare ATA PASS-THROUGH COMMAND (16) command */
-        aptCmdBlk[14] = ATA_SET_FEATURES;
-        aptCmdBlk[4] = feature;
-        aptCmdBlk[6] = count;
-        aptCmdBlk[8] = lba & 0xff;
-        aptCmdBlk[10] = (lba >> 8) & 0xff;
-        aptCmdBlk[12] = (lba >> 16) & 0xff;
-        aptCmdBlk[7] = (lba >> 24) & 0xff;
-        aptCmdBlk[9] = (lba >> 32) & 0xff;
-        aptCmdBlk[11] = (lba >> 40) & 0xff;
-        aptCmdBlk[1] = (multiple_count << 5) | (protocol << 1) | extend;
-        aptCmdBlk[2] = (ck_cond << 5) | (t_type << 4)| (t_dir << 3) |
+        apt_cdb[14] = ATA_SET_FEATURES;
+        apt_cdb[4] = feature;
+        apt_cdb[6] = count;
+        apt_cdb[8] = lba & 0xff;
+        apt_cdb[10] = (lba >> 8) & 0xff;
+        apt_cdb[12] = (lba >> 16) & 0xff;
+        apt_cdb[7] = (lba >> 24) & 0xff;
+        apt_cdb[9] = (lba >> 32) & 0xff;
+        apt_cdb[11] = (lba >> 40) & 0xff;
+        apt_cdb[1] = (multiple_count << 5) | (protocol << 1) | extend;
+        apt_cdb[2] = (ck_cond << 5) | (t_type << 4)| (t_dir << 3) |
                        (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, aptCmdBlk, cdb_len, DEF_TIMEOUT, NULL,
+        res = sg_ll_ata_pt(sg_fd, apt_cdb, cdb_len, DEF_TIMEOUT, NULL,
                            NULL /* doutp */, 0, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
     } else {
         /* Prepare ATA PASS-THROUGH COMMAND (12) command */
-        apt12CmdBlk[9] = ATA_SET_FEATURES;
-        apt12CmdBlk[3] = feature;
-        apt12CmdBlk[4] = count;
-        apt12CmdBlk[5] = lba & 0xff;
-        apt12CmdBlk[6] = (lba >> 8) & 0xff;
-        apt12CmdBlk[7] = (lba >> 16) & 0xff;
-        apt12CmdBlk[1] = (multiple_count << 5) | (protocol << 1);
-        apt12CmdBlk[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
+        apt12_cdb[9] = ATA_SET_FEATURES;
+        apt12_cdb[3] = feature;
+        apt12_cdb[4] = count;
+        apt12_cdb[5] = lba & 0xff;
+        apt12_cdb[6] = (lba >> 8) & 0xff;
+        apt12_cdb[7] = (lba >> 16) & 0xff;
+        apt12_cdb[1] = (multiple_count << 5) | (protocol << 1);
+        apt12_cdb[2] = (ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
                          (byte_block << 2) | t_length;
-        res = sg_ll_ata_pt(sg_fd, apt12CmdBlk, cdb_len, DEF_TIMEOUT, NULL,
+        res = sg_ll_ata_pt(sg_fd, apt12_cdb, cdb_len, DEF_TIMEOUT, NULL,
                            NULL /* doutp */, 0, sense_buffer,
                            sb_sz, ata_return_desc,
                            sizeof(ata_return_desc), &resid, verbose);
diff --git a/src/sg_scan_linux.c b/src/sg_scan_linux.c
index 667c6941..f9dd38c8 100644
--- a/src/sg_scan_linux.c
+++ b/src/sg_scan_linux.c
@@ -51,7 +51,7 @@
 #include "sg_pr2serr.h"
 
 
-static const char * version_str = "4.12 20160121";
+static const char * version_str = "4.12 20160528";
 
 #define ME "sg_scan: "
 
@@ -90,7 +90,7 @@ int sg3_inq(int sg_fd, unsigned char * inqBuff, int do_extra);
 int scsi_inq(int sg_fd, unsigned char * inqBuff);
 int try_ata_identity(const char * file_namep, int ata_fd, int do_inq);
 
-static unsigned char inqCmdBlk[INQ_CMD_LEN] =
+static unsigned char inq_cdb[INQ_CMD_LEN] =
                                 {0x12, 0, 0, 0, INQ_REPLY_LEN, 0};
 
 
@@ -399,12 +399,12 @@ int sg3_inq(int sg_fd, unsigned char * inqBuff, int do_extra)
     memset(inqBuff, 0, INQ_REPLY_LEN);
     inqBuff[0] = 0x7f;
     io_hdr.interface_id = 'S';
-    io_hdr.cmd_len = sizeof(inqCmdBlk);
+    io_hdr.cmd_len = sizeof(inq_cdb);
     io_hdr.mx_sb_len = sizeof(sense_buffer);
     io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
     io_hdr.dxfer_len = INQ_REPLY_LEN;
     io_hdr.dxferp = inqBuff;
-    io_hdr.cmdp = inqCmdBlk;
+    io_hdr.cmdp = inq_cdb;
     io_hdr.sbp = sense_buffer;
     io_hdr.timeout = 20000;     /* 20000 millisecs == 20 seconds */
 
@@ -466,7 +466,7 @@ int scsi_inq(int sg_fd, unsigned char * inqBuff)
     memset(buff, 0, sizeof(buff));
     sicp->inlen = 0;
     sicp->outlen = INQ_REPLY_LEN;
-    memcpy(sicp->data, inqCmdBlk, INQ_CMD_LEN);
+    memcpy(sicp->data, inq_cdb, INQ_CMD_LEN);
     res = ioctl(sg_fd, SCSI_IOCTL_SEND_COMMAND, sicp);
     if (0 == res)
         memcpy(inqBuff, sicp->data, INQ_REPLY_LEN);
diff --git a/src/sg_sync.c b/src/sg_sync.c
index c847f62f..96aa15a8 100644
--- a/src/sg_sync.c
+++ b/src/sg_sync.c
@@ -27,7 +27,7 @@
  * (e.g. disks).
  */
 
-static const char * version_str = "1.15 20160227";
+static const char * version_str = "1.15 20160528";
 
 #define SYNCHRONIZE_CACHE16_CMD     0x91
 #define SYNCHRONIZE_CACHE16_CMDLEN  16
@@ -88,24 +88,24 @@ ll_sync_cache_16(int sg_fd, int sync_nv, int immed, int group,
                  int noisy, int verbose)
 {
     int res, ret, k, sense_cat;
-    unsigned char scCmdBlk[SYNCHRONIZE_CACHE16_CMDLEN] =
+    unsigned char sc_cdb[SYNCHRONIZE_CACHE16_CMDLEN] =
                 {SYNCHRONIZE_CACHE16_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
     if (sync_nv)
-        scCmdBlk[1] |= 4;       /* obsolete in sbc3r35d */
+        sc_cdb[1] |= 4;       /* obsolete in sbc3r35d */
     if (immed)
-        scCmdBlk[1] |= 2;
-    sg_put_unaligned_be64(lba, scCmdBlk + 2);
-    scCmdBlk[14] = group & 0x1f;
-    sg_put_unaligned_be32((uint32_t)num_lb, scCmdBlk + 10);
+        sc_cdb[1] |= 2;
+    sg_put_unaligned_be64(lba, sc_cdb + 2);
+    sc_cdb[14] = group & 0x1f;
+    sg_put_unaligned_be32((uint32_t)num_lb, sc_cdb + 10);
 
     if (verbose) {
         pr2serr("    synchronize cache(16) cdb: ");
         for (k = 0; k < SYNCHRONIZE_CACHE16_CMDLEN; ++k)
-            pr2serr("%02x ", scCmdBlk[k]);
+            pr2serr("%02x ", sc_cdb[k]);
         pr2serr("\n");
     }
     ptvp = construct_scsi_pt_obj();
@@ -113,7 +113,7 @@ ll_sync_cache_16(int sg_fd, int sync_nv, int immed, int group,
         pr2serr("synchronize cache(16): out of memory\n");
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, scCmdBlk, sizeof(scCmdBlk));
+    set_scsi_pt_cdb(ptvp, sc_cdb, sizeof(sc_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     res = do_scsi_pt(ptvp, sg_fd, to_secs, verbose);
     ret = sg_cmds_process_resp(ptvp, "synchronize cache(16)", res, 0,
diff --git a/src/sg_test_rwbuf.c b/src/sg_test_rwbuf.c
index 13d98e38..db3ac5b4 100644
--- a/src/sg_test_rwbuf.c
+++ b/src/sg_test_rwbuf.c
@@ -1,7 +1,7 @@
 /*
  * (c) 2000 Kurt Garloff <garloff at suse dot de>
  * heavily based on Douglas Gilbert's sg_rbuf program.
- * (c) 1999-2015 Douglas Gilbert
+ * (c) 1999-2016 Douglas Gilbert
  *
  * Program to test the SCSI host adapter by issueing
  * write and read operations on a device's buffer
@@ -41,7 +41,7 @@
 #include "sg_pr2serr.h"
 
 
-static const char * version_str = "1.09 20151220";
+static const char * version_str = "1.09 20160528";
 
 #define BPI (signed)(sizeof(int))
 
@@ -84,29 +84,29 @@ static struct option long_options[] = {
 
 int find_out_about_buffer (int sg_fd)
 {
-        unsigned char rbCmdBlk[] = {READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        unsigned char rb_cdb[] = {READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         unsigned char rbBuff[RB_DESC_LEN];
         unsigned char sense_buffer[32];
         struct sg_io_hdr io_hdr;
         int k, res;
 
-        rbCmdBlk[1] = RB_MODE_DESC;
-        rbCmdBlk[8] = RB_DESC_LEN;
+        rb_cdb[1] = RB_MODE_DESC;
+        rb_cdb[8] = RB_DESC_LEN;
         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
         io_hdr.interface_id = 'S';
-        io_hdr.cmd_len = sizeof(rbCmdBlk);
+        io_hdr.cmd_len = sizeof(rb_cdb);
         io_hdr.mx_sb_len = sizeof(sense_buffer);
         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
         io_hdr.dxfer_len = RB_DESC_LEN;
         io_hdr.dxferp = rbBuff;
-        io_hdr.cmdp = rbCmdBlk;
+        io_hdr.cmdp = rb_cdb;
         io_hdr.sbp = sense_buffer;
         io_hdr.timeout = 60000;     /* 60000 millisecs == 60 seconds */
 
         if (verbose) {
                 pr2serr("    read buffer [mode desc] cdb: ");
-                for (k = 0; k < (int)sizeof(rbCmdBlk); ++k)
-                        pr2serr("%02x ", rbCmdBlk[k]);
+                for (k = 0; k < (int)sizeof(rb_cdb); ++k)
+                        pr2serr("%02x ", rb_cdb[k]);
                 pr2serr("\n");
         }
         if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
@@ -215,7 +215,7 @@ void do_fill_buffer (int *buf, int len)
 int read_buffer (int sg_fd, unsigned size)
 {
         int res, k;
-        unsigned char rbCmdBlk[] = {READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        unsigned char rb_cdb[] = {READ_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         int bufSize = size + addread;
         unsigned char * rbBuff = (unsigned char *)malloc(bufSize);
         unsigned char sense_buffer[32];
@@ -223,23 +223,23 @@ int read_buffer (int sg_fd, unsigned size)
 
         if (NULL == rbBuff)
                 return -1;
-        rbCmdBlk[1] = RWB_MODE_DATA;
-        sg_put_unaligned_be24((uint32_t)bufSize, rbCmdBlk + 6);
+        rb_cdb[1] = RWB_MODE_DATA;
+        sg_put_unaligned_be24((uint32_t)bufSize, rb_cdb + 6);
         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
         io_hdr.interface_id = 'S';
-        io_hdr.cmd_len = sizeof(rbCmdBlk);
+        io_hdr.cmd_len = sizeof(rb_cdb);
         io_hdr.mx_sb_len = sizeof(sense_buffer);
         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
         io_hdr.dxfer_len = bufSize;
         io_hdr.dxferp = rbBuff;
-        io_hdr.cmdp = rbCmdBlk;
+        io_hdr.cmdp = rb_cdb;
         io_hdr.sbp = sense_buffer;
         io_hdr.pack_id = 2;
         io_hdr.timeout = 60000;     /* 60000 millisecs == 60 seconds */
         if (verbose) {
                 pr2serr("    read buffer [mode data] cdb: ");
-                for (k = 0; k < (int)sizeof(rbCmdBlk); ++k)
-                        pr2serr("%02x ", rbCmdBlk[k]);
+                for (k = 0; k < (int)sizeof(rb_cdb); ++k)
+                        pr2serr("%02x ", rb_cdb[k]);
                 pr2serr("\n");
         }
 
@@ -269,7 +269,7 @@ int read_buffer (int sg_fd, unsigned size)
 
 int write_buffer (int sg_fd, unsigned size)
 {
-        unsigned char wbCmdBlk[] = {WRITE_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        unsigned char wb_cdb[] = {WRITE_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         int bufSize = size + addwrite;
         unsigned char * wbBuff = (unsigned char *)malloc(bufSize);
         unsigned char sense_buffer[32];
@@ -280,23 +280,23 @@ int write_buffer (int sg_fd, unsigned size)
                 return -1;
         memset(wbBuff, 0, bufSize);
         do_fill_buffer ((int*)wbBuff, size);
-        wbCmdBlk[1] = RWB_MODE_DATA;
-        sg_put_unaligned_be24((uint32_t)bufSize, wbCmdBlk + 6);
+        wb_cdb[1] = RWB_MODE_DATA;
+        sg_put_unaligned_be24((uint32_t)bufSize, wb_cdb + 6);
         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
         io_hdr.interface_id = 'S';
-        io_hdr.cmd_len = sizeof(wbCmdBlk);
+        io_hdr.cmd_len = sizeof(wb_cdb);
         io_hdr.mx_sb_len = sizeof(sense_buffer);
         io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
         io_hdr.dxfer_len = bufSize;
         io_hdr.dxferp = wbBuff;
-        io_hdr.cmdp = wbCmdBlk;
+        io_hdr.cmdp = wb_cdb;
         io_hdr.sbp = sense_buffer;
         io_hdr.pack_id = 1;
         io_hdr.timeout = 60000;     /* 60000 millisecs == 60 seconds */
         if (verbose) {
                 pr2serr("    write buffer [mode data] cdb: ");
-                for (k = 0; k < (int)sizeof(wbCmdBlk); ++k)
-                        pr2serr("%02x ", wbCmdBlk[k]);
+                for (k = 0; k < (int)sizeof(wb_cdb); ++k)
+                        pr2serr("%02x ", wb_cdb[k]);
                 pr2serr("\n");
         }
 
diff --git a/src/sg_timestamp.c b/src/sg_timestamp.c
index 78f1bbdc..12f95ed7 100644
--- a/src/sg_timestamp.c
+++ b/src/sg_timestamp.c
@@ -33,7 +33,7 @@
  * to the given SCSI device. Based on spc5r07.pdf .
  */
 
-static const char * version_str = "1.02 20160126";
+static const char * version_str = "1.02 20160528";
 
 #define REP_TIMESTAMP_CMDLEN 12
 #define SET_TIMESTAMP_CMDLEN 12
@@ -124,16 +124,16 @@ sg_ll_rep_timestamp(int sg_fd, void * resp, int mx_resp_len, int * residp,
                     int noisy, int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char rtCmdBlk[REP_TIMESTAMP_CMDLEN] =
+    unsigned char rt_cdb[REP_TIMESTAMP_CMDLEN] =
           {SG_MAINTENANCE_IN, REP_TIMESTAMP_SA, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    sg_put_unaligned_be32((uint32_t)mx_resp_len, rtCmdBlk + 6);
+    sg_put_unaligned_be32((uint32_t)mx_resp_len, rt_cdb + 6);
     if (verbose) {
         pr2serr("    Report timestamp cdb: ");
         for (k = 0; k < REP_TIMESTAMP_CMDLEN; ++k)
-            pr2serr("%02x ", rtCmdBlk[k]);
+            pr2serr("%02x ", rt_cdb[k]);
         pr2serr("\n");
     }
 
@@ -142,7 +142,7 @@ sg_ll_rep_timestamp(int sg_fd, void * resp, int mx_resp_len, int * residp,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, rtCmdBlk, sizeof(rtCmdBlk));
+    set_scsi_pt_cdb(ptvp, rt_cdb, sizeof(rt_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
@@ -182,17 +182,17 @@ sg_ll_set_timestamp(int sg_fd, void * paramp, int param_len, int noisy,
                     int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char stCmdBlk[SET_TIMESTAMP_CMDLEN] =
+    unsigned char st_cdb[SET_TIMESTAMP_CMDLEN] =
           {SG_MAINTENANCE_OUT, SET_TIMESTAMP_SA, 0, 0,  0, 0, 0, 0,
            0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    sg_put_unaligned_be32(param_len, stCmdBlk + 6);
+    sg_put_unaligned_be32(param_len, st_cdb + 6);
     if (verbose) {
         pr2serr("    Set timestamp cdb: ");
         for (k = 0; k < SET_TIMESTAMP_CMDLEN; ++k)
-            pr2serr("%02x ", stCmdBlk[k]);
+            pr2serr("%02x ", st_cdb[k]);
         pr2serr("\n");
         if ((verbose > 1) && paramp && param_len) {
             pr2serr("    set timestamp parameter list:\n");
@@ -205,7 +205,7 @@ sg_ll_set_timestamp(int sg_fd, void * paramp, int param_len, int noisy,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, stCmdBlk, sizeof(stCmdBlk));
+    set_scsi_pt_cdb(ptvp, st_cdb, sizeof(st_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_out(ptvp, (unsigned char *)paramp, param_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
diff --git a/src/sg_turs.c b/src/sg_turs.c
index 64c151dc..7c19c1b1 100644
--- a/src/sg_turs.c
+++ b/src/sg_turs.c
@@ -15,6 +15,7 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <getopt.h>
 
@@ -31,7 +32,7 @@
 #include "sg_pr2serr.h"
 
 
-static const char * version_str = "3.32 20160226";
+static const char * version_str = "3.33 20160525";
 
 #if defined(MSC_VER) || defined(__MINGW32__)
 #define HAVE_MS_SLEEP
@@ -61,12 +62,12 @@ static struct option long_options[] = {
 struct opts_t {
     int do_help;
     int do_number;
-    int do_progress;
-    int do_time;
+    bool do_progress;
+    bool do_time;
     int do_verbose;
-    int do_version;
+    bool do_version;
     const char * device_name;
-    int opt_new;
+    bool opts_new;
 };
 
 
@@ -107,7 +108,7 @@ static void usage_old()
 
 static void usage_for(const struct opts_t * op)
 {
-    if (op->opt_new)
+    if (op->opts_new)
         usage();
     else
         usage_old();
@@ -142,19 +143,19 @@ static int process_cl_new(struct opts_t * op, int argc, char * argv[])
         case 'N':
             break;      /* ignore */
         case 'O':
-            op->opt_new = 0;
+            op->opts_new = false;
             return 0;
         case 'p':
-            ++op->do_progress;
+            op->do_progress = true;
             break;
         case 't':
-            ++op->do_time;
+            op->do_time = true;
             break;
         case 'v':
             ++op->do_verbose;
             break;
         case 'V':
-            ++op->do_version;
+            op->do_version = true;
             break;
         default:
             pr2serr("unrecognised option code %c [0x%x]\n", c, c);
@@ -193,21 +194,21 @@ static int process_cl_old(struct opts_t * op, int argc, char * argv[])
             for (--plen, ++cp, jmp_out = 0; plen > 0; --plen, ++cp) {
                 switch (*cp) {
                 case 'N':
-                    op->opt_new = 1;
+                    op->opts_new = true;
                     return 0;
                 case 'O':
                     break;
                 case 'p':
-                    ++op->do_progress;
+                    op->do_progress = true;
                     break;
                 case 't':
-                    ++op->do_time;
+                    op->do_time = true;
                     break;
                 case 'v':
                     ++op->do_verbose;
                     break;
                 case 'V':
-                    ++op->do_verbose;
+                    op->do_version = true;
                     break;
                 case '?':
                     usage_old();
@@ -254,14 +255,14 @@ static int process_cl(struct opts_t * op, int argc, char * argv[])
 
     cp = getenv("SG3_UTILS_OLD_OPTS");
     if (cp) {
-        op->opt_new = 0;
+        op->opts_new = false;
         res = process_cl_old(op, argc, argv);
-        if ((0 == res) && op->opt_new)
+        if ((0 == res) && op->opts_new)
             res = process_cl_new(op, argc, argv);
     } else {
-        op->opt_new = 1;
+        op->opts_new = true;
         res = process_cl_new(op, argc, argv);
-        if ((0 == res) && (0 == op->opt_new))
+        if ((0 == res) && (0 == op->opts_new))
             res = process_cl_old(op, argc, argv);
     }
     return res;
@@ -271,7 +272,7 @@ int main(int argc, char * argv[])
 {
     int sg_fd, k, res, progress, pr, rem;
     int num_errs = 0;
-    int reported = 0;
+    bool reported = false;
     int ret = 0;
 #ifndef SG_LIB_MINGW
     struct timeval start_tm, end_tm;
@@ -326,7 +327,7 @@ int main(int argc, char * argv[])
         if (op->do_number > 1)
             printf("Completed %d Test Unit Ready commands\n",
                    ((k < op->do_number) ? k + 1 : k));
-    } else {
+    } else {            /* --progress not given */
 #ifndef SG_LIB_MINGW
         if (op->do_time) {
             start_tm.tv_sec = 0;
@@ -348,7 +349,7 @@ int main(int argc, char * argv[])
                                                   op->do_verbose);
                         printf("%s\n", b);
                     }
-                    reported = 1;
+                    reported = true;
                     break;
                 }
             }
diff --git a/src/sg_vpd.c b/src/sg_vpd.c
index 3c4afb00..19473bb0 100644
--- a/src/sg_vpd.c
+++ b/src/sg_vpd.c
@@ -37,7 +37,7 @@
 
 */
 
-static const char * version_str = "1.23 20160521";  /* spc5r10 + sbc4r10 */
+static const char * version_str = "1.23 20160528";  /* spc5r10 + sbc4r10 */
 
 
 /* These structures are duplicates of those of the same name in
@@ -481,20 +481,20 @@ pt_inquiry(int sg_fd, int evpd, int pg_op, void * resp, int mx_resp_len,
            int * residp, int noisy, int verbose)
 {
     int res, ret, k, sense_cat, resid;
-    unsigned char inqCmdBlk[INQUIRY_CMDLEN] = {INQUIRY_CMD, 0, 0, 0, 0, 0};
+    unsigned char inq_cdb[INQUIRY_CMDLEN] = {INQUIRY_CMD, 0, 0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     unsigned char * up;
     struct sg_pt_base * ptvp;
 
     if (evpd)
-        inqCmdBlk[1] |= 1;
-    inqCmdBlk[2] = (unsigned char)pg_op;
+        inq_cdb[1] |= 1;
+    inq_cdb[2] = (unsigned char)pg_op;
     /* 16 bit allocation length (was 8) is a recent SPC-3 addition */
-    sg_put_unaligned_be16((uint16_t)mx_resp_len, inqCmdBlk + 3);
+    sg_put_unaligned_be16((uint16_t)mx_resp_len, inq_cdb + 3);
     if (verbose) {
         pr2serr("    inquiry cdb: ");
         for (k = 0; k < INQUIRY_CMDLEN; ++k)
-            pr2serr("%02x ", inqCmdBlk[k]);
+            pr2serr("%02x ", inq_cdb[k]);
         pr2serr("\n");
     }
     if (resp && (mx_resp_len > 0)) {
@@ -508,7 +508,7 @@ pt_inquiry(int sg_fd, int evpd, int pg_op, void * resp, int mx_resp_len,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, inqCmdBlk, sizeof(inqCmdBlk));
+    set_scsi_pt_cdb(ptvp, inq_cdb, sizeof(inq_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
diff --git a/src/sg_write_buffer.c b/src/sg_write_buffer.c
index 0e2f1bc1..184bc484 100644
--- a/src/sg_write_buffer.c
+++ b/src/sg_write_buffer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2015 Luben Tuikov and Douglas Gilbert.
+ * Copyright (c) 2006-2016 Luben Tuikov and Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -29,7 +29,7 @@
  * This utility issues the SCSI WRITE BUFFER command to the given device.
  */
 
-static const char * version_str = "1.21 20151219";    /* spc5r02 */
+static const char * version_str = "1.21 20160528";    /* spc5r10 */
 
 #define ME "sg_write_buffer: "
 #define DEF_XFER_LEN (8 * 1024 * 1024)
@@ -181,7 +181,7 @@ sg_ll_write_buffer_v2(int sg_fd, int mode, int m_specific, int buffer_id,
                       uint32_t param_len, int to_secs, int noisy, int verbose)
 {
     int k, res, ret, sense_cat;
-    uint8_t wbufCmdBlk[WRITE_BUFFER_CMDLEN] =
+    uint8_t wbuf_cdb[WRITE_BUFFER_CMDLEN] =
         {WRITE_BUFFER_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     uint8_t sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
@@ -194,15 +194,15 @@ sg_ll_write_buffer_v2(int sg_fd, int mode, int m_specific, int buffer_id,
         pr2serr("%s: param_len value too large for 24 bits\n", __func__);
         return -1;
     }
-    wbufCmdBlk[1] = (uint8_t)(mode & 0x1f);
-    wbufCmdBlk[1] |= (uint8_t)((m_specific & 0x7) << 5);
-    wbufCmdBlk[2] = (uint8_t)(buffer_id & 0xff);
-    sg_put_unaligned_be24(buffer_offset, wbufCmdBlk + 3);
-    sg_put_unaligned_be24(param_len, wbufCmdBlk + 6);
+    wbuf_cdb[1] = (uint8_t)(mode & 0x1f);
+    wbuf_cdb[1] |= (uint8_t)((m_specific & 0x7) << 5);
+    wbuf_cdb[2] = (uint8_t)(buffer_id & 0xff);
+    sg_put_unaligned_be24(buffer_offset, wbuf_cdb + 3);
+    sg_put_unaligned_be24(param_len, wbuf_cdb + 6);
     if (verbose) {
         pr2serr("    Write buffer cmd: ");
         for (k = 0; k < WRITE_BUFFER_CMDLEN; ++k)
-            pr2serr("%02x ", wbufCmdBlk[k]);
+            pr2serr("%02x ", wbuf_cdb[k]);
         pr2serr("\n");
         if ((verbose > 1) && paramp && param_len) {
             pr2serr("    Write buffer parameter list%s:\n",
@@ -217,7 +217,7 @@ sg_ll_write_buffer_v2(int sg_fd, int mode, int m_specific, int buffer_id,
         pr2serr("%s: out of memory\n", __func__);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, wbufCmdBlk, sizeof(wbufCmdBlk));
+    set_scsi_pt_cdb(ptvp, wbuf_cdb, sizeof(wbuf_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_out(ptvp, (uint8_t *)paramp, param_len);
     res = do_scsi_pt(ptvp, sg_fd, to_secs, verbose);
diff --git a/src/sg_write_same.c b/src/sg_write_same.c
index b9d33b18..7c9078ac 100644
--- a/src/sg_write_same.c
+++ b/src/sg_write_same.c
@@ -29,7 +29,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.14 20160521";
+static const char * version_str = "1.14 20160528";
 
 
 #define ME "sg_write_same: "
@@ -159,7 +159,7 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
 {
     int k, ret, res, sense_cat, cdb_len;
     uint64_t llba;
-    unsigned char wsCmdBlk[WRITE_SAME32_LEN];
+    unsigned char ws_cdb[WRITE_SAME32_LEN];
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
@@ -184,62 +184,62 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
     }
     if (act_cdb_lenp)
         *act_cdb_lenp = cdb_len;
-    memset(wsCmdBlk, 0, sizeof(wsCmdBlk));
+    memset(ws_cdb, 0, sizeof(ws_cdb));
     switch (cdb_len) {
     case WRITE_SAME10_LEN:
-        wsCmdBlk[0] = WRITE_SAME10_OP;
-        wsCmdBlk[1] = ((op->wrprotect & 0x7) << 5);
+        ws_cdb[0] = WRITE_SAME10_OP;
+        ws_cdb[1] = ((op->wrprotect & 0x7) << 5);
         /* ANCHOR + UNMAP not allowed for WRITE_SAME10 in sbc3r24+r25 but
          * a proposal has been made to allow it. Anticipate approval. */
         if (op->anchor)
-            wsCmdBlk[1] |= 0x10;
+            ws_cdb[1] |= 0x10;
         if (op->unmap)
-            wsCmdBlk[1] |= 0x8;
+            ws_cdb[1] |= 0x8;
         if (op->pbdata)
-            wsCmdBlk[1] |= 0x4;
+            ws_cdb[1] |= 0x4;
         if (op->lbdata)
-            wsCmdBlk[1] |= 0x2;
-        sg_put_unaligned_be32((uint32_t)op->lba, wsCmdBlk + 2);
-        wsCmdBlk[6] = (op->grpnum & 0x1f);
-        sg_put_unaligned_be16((uint16_t)op->numblocks, wsCmdBlk + 7);
+            ws_cdb[1] |= 0x2;
+        sg_put_unaligned_be32((uint32_t)op->lba, ws_cdb + 2);
+        ws_cdb[6] = (op->grpnum & 0x1f);
+        sg_put_unaligned_be16((uint16_t)op->numblocks, ws_cdb + 7);
         break;
     case WRITE_SAME16_LEN:
-        wsCmdBlk[0] = WRITE_SAME16_OP;
-        wsCmdBlk[1] = ((op->wrprotect & 0x7) << 5);
+        ws_cdb[0] = WRITE_SAME16_OP;
+        ws_cdb[1] = ((op->wrprotect & 0x7) << 5);
         if (op->anchor)
-            wsCmdBlk[1] |= 0x10;
+            ws_cdb[1] |= 0x10;
         if (op->unmap)
-            wsCmdBlk[1] |= 0x8;
+            ws_cdb[1] |= 0x8;
         if (op->pbdata)
-            wsCmdBlk[1] |= 0x4;
+            ws_cdb[1] |= 0x4;
         if (op->lbdata)
-            wsCmdBlk[1] |= 0x2;
+            ws_cdb[1] |= 0x2;
         if (op->ndob)
-            wsCmdBlk[1] |= 0x1;
-        sg_put_unaligned_be64(op->lba, wsCmdBlk + 2);
-        sg_put_unaligned_be32((uint32_t)op->numblocks, wsCmdBlk + 10);
-        wsCmdBlk[14] = (op->grpnum & 0x1f);
+            ws_cdb[1] |= 0x1;
+        sg_put_unaligned_be64(op->lba, ws_cdb + 2);
+        sg_put_unaligned_be32((uint32_t)op->numblocks, ws_cdb + 10);
+        ws_cdb[14] = (op->grpnum & 0x1f);
         break;
     case WRITE_SAME32_LEN:
         /* Note: In Linux at this time the sg driver does not support
          * cdb_s > 16 bytes long, but the bsg driver does. */
-        wsCmdBlk[0] = VARIABLE_LEN_OP;
-        wsCmdBlk[6] = (op->grpnum & 0x1f);
-        wsCmdBlk[7] = WRITE_SAME32_ADD;
-        sg_put_unaligned_be16((uint16_t)WRITE_SAME32_SA, wsCmdBlk + 8);
-        wsCmdBlk[10] = ((op->wrprotect & 0x7) << 5);
+        ws_cdb[0] = VARIABLE_LEN_OP;
+        ws_cdb[6] = (op->grpnum & 0x1f);
+        ws_cdb[7] = WRITE_SAME32_ADD;
+        sg_put_unaligned_be16((uint16_t)WRITE_SAME32_SA, ws_cdb + 8);
+        ws_cdb[10] = ((op->wrprotect & 0x7) << 5);
         if (op->anchor)
-            wsCmdBlk[10] |= 0x10;
+            ws_cdb[10] |= 0x10;
         if (op->unmap)
-            wsCmdBlk[10] |= 0x8;
+            ws_cdb[10] |= 0x8;
         if (op->pbdata)
-            wsCmdBlk[10] |= 0x4;
+            ws_cdb[10] |= 0x4;
         if (op->lbdata)
-            wsCmdBlk[10] |= 0x2;
+            ws_cdb[10] |= 0x2;
         if (op->ndob)
-            wsCmdBlk[10] |= 0x1;
-        sg_put_unaligned_be64(op->lba, wsCmdBlk + 12);
-        sg_put_unaligned_be32((uint32_t)op->numblocks, wsCmdBlk + 28);
+            ws_cdb[10] |= 0x1;
+        sg_put_unaligned_be64(op->lba, ws_cdb + 12);
+        sg_put_unaligned_be32((uint32_t)op->numblocks, ws_cdb + 28);
         break;
     default:
         pr2serr("do_write_same: bad cdb length %d\n", cdb_len);
@@ -249,7 +249,7 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
     if (op->verbose > 1) {
         pr2serr("    Write same(%d) cmd: ", cdb_len);
         for (k = 0; k < cdb_len; ++k)
-            pr2serr("%02x ", wsCmdBlk[k]);
+            pr2serr("%02x ", ws_cdb[k]);
         pr2serr("\n    Data-out buffer length=%d\n",
                 op->xfer_len);
     }
@@ -262,7 +262,7 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
         pr2serr("Write same(%d): out of memory\n", cdb_len);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, wsCmdBlk, cdb_len);
+    set_scsi_pt_cdb(ptvp, ws_cdb, cdb_len);
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     set_scsi_pt_data_out(ptvp, (unsigned char *)dataoutp, op->xfer_len);
     res = do_scsi_pt(ptvp, sg_fd, op->timeout, op->verbose);
diff --git a/src/sg_zone.c b/src/sg_zone.c
index 36f3834b..cbf3e778 100644
--- a/src/sg_zone.c
+++ b/src/sg_zone.c
@@ -32,7 +32,7 @@
  * to the given SCSI device. Based on zbc-r04c.pdf .
  */
 
-static const char * version_str = "1.03 20160324";
+static const char * version_str = "1.03 20160528";
 
 #define SG_ZONING_OUT_CMDLEN 16
 #define CLOSE_ZONE_SA 0x1
@@ -94,21 +94,21 @@ sg_ll_zone_out(int sg_fd, int sa, uint64_t zid, int all, int noisy,
                int verbose)
 {
     int k, ret, res, sense_cat;
-    unsigned char zoCmdBlk[SG_ZONING_OUT_CMDLEN] =
+    unsigned char zo_cdb[SG_ZONING_OUT_CMDLEN] =
           {SG_ZONING_OUT, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0};
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
     char b[64];
 
-    zoCmdBlk[1] = 0x1f & sa;
-    sg_put_unaligned_be64(zid, zoCmdBlk + 2);
+    zo_cdb[1] = 0x1f & sa;
+    sg_put_unaligned_be64(zid, zo_cdb + 2);
     if (all)
-        zoCmdBlk[14] = 0x1;
-    sg_get_opcode_sa_name(zoCmdBlk[0], sa, -1, sizeof(b), b);
+        zo_cdb[14] = 0x1;
+    sg_get_opcode_sa_name(zo_cdb[0], sa, -1, sizeof(b), b);
     if (verbose) {
         pr2serr("    %s cdb: ", b);
         for (k = 0; k < SG_ZONING_OUT_CMDLEN; ++k)
-            pr2serr("%02x ", zoCmdBlk[k]);
+            pr2serr("%02x ", zo_cdb[k]);
         pr2serr("\n");
     }
 
@@ -117,7 +117,7 @@ sg_ll_zone_out(int sg_fd, int sa, uint64_t zid, int all, int noisy,
         pr2serr("%s: out of memory\n", b);
         return -1;
     }
-    set_scsi_pt_cdb(ptvp, zoCmdBlk, sizeof(zoCmdBlk));
+    set_scsi_pt_cdb(ptvp, zo_cdb, sizeof(zo_cdb));
     set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
     res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
     ret = sg_cmds_process_resp(ptvp, "reset write pointer", res, 0, sense_b,