sg_lib: Linux: ENXIO errno --> SG_LIB_CAT_NOT_READY; asc/ascq codes --> T10 20150423

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

1 files changed, 196 insertions, 247 deletions

diff --git a/lib/sg_cmds_extra.c b/lib/sg_cmds_extra.c
index 6afea698..606ae1b6 100644
--- a/lib/sg_cmds_extra.c
+++ b/lib/sg_cmds_extra.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999-2014 Douglas Gilbert.
+ * Copyright (c) 1999-2015 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.
@@ -7,6 +7,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdarg.h>
 #include <string.h>
 #include <unistd.h>
 #define __STDC_FORMAT_MACROS 1
@@ -89,6 +90,26 @@
 #define REPORT_REFERRALS_SA 0x13
 #define EXTENDED_COPY_LID1_SA 0x0
 
+#ifdef __GNUC__
+static int pr2ws(const char * fmt, ...)
+        __attribute__ ((format (printf, 1, 2)));
+#else
+static int pr2ws(const char * fmt, ...);
+#endif
+
+
+static int
+pr2ws(const char * fmt, ...)
+{
+    va_list args;
+    int n;
+
+    va_start(args, fmt);
+    n = vfprintf(sg_warnings_strm ? sg_warnings_strm : stderr, fmt, args);
+    va_end(args);
+    return n;
+}
+
 
 /* Invokes a SCSI GET LBA STATUS command (SBC). Returns 0 -> success,
  * various SG_LIB_CAT_* positive values or -1 -> other errors */
@@ -117,18 +138,16 @@ sg_ll_get_lba_status(int sg_fd, uint64_t start_llba, void * resp,
     getLbaStatCmd[11] = (alloc_len >> 16) & 0xff;
     getLbaStatCmd[12] = (alloc_len >> 8) & 0xff;
     getLbaStatCmd[13] = alloc_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Get LBA status cmd: ");
+        pr2ws("    Get LBA status cmd: ");
         for (k = 0; k < SERVICE_ACTION_IN_16_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", getLbaStatCmd[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", getLbaStatCmd[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "get LBA status: out of memory\n");
+        pr2ws("get LBA status: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, getLbaStatCmd, sizeof(getLbaStatCmd));
@@ -151,8 +170,8 @@ sg_ll_get_lba_status(int sg_fd, uint64_t start_llba, void * resp,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    get LBA status: response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    get LBA status: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -189,19 +208,16 @@ sg_ll_report_tgt_prt_grp2(int sg_fd, void * resp, int mx_resp_len,
     rtpgCmdBlk[7] = (mx_resp_len >> 16) & 0xff;
     rtpgCmdBlk[8] = (mx_resp_len >> 8) & 0xff;
     rtpgCmdBlk[9] = mx_resp_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    report target port groups cdb: ");
+        pr2ws("    report target port groups cdb: ");
         for (k = 0; k < MAINTENANCE_IN_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rtpgCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rtpgCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "report target port groups: out of "
-                "memory\n");
+        pr2ws("report target port groups: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rtpgCmdBlk, sizeof(rtpgCmdBlk));
@@ -225,8 +241,8 @@ sg_ll_report_tgt_prt_grp2(int sg_fd, void * resp, int mx_resp_len,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    report target port group: "
-                    "response%s\n", (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    report target port group: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -252,24 +268,20 @@ sg_ll_set_tgt_prt_grp(int sg_fd, void * paramp, int param_len, int noisy,
     stpgCmdBlk[7] = (param_len >> 16) & 0xff;
     stpgCmdBlk[8] = (param_len >> 8) & 0xff;
     stpgCmdBlk[9] = param_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    set target port groups cdb: ");
+        pr2ws("    set target port groups cdb: ");
         for (k = 0; k < MAINTENANCE_OUT_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", stpgCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", stpgCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    set target port groups "
-                    "parameter list:\n");
+            pr2ws("    set target port groups parameter list:\n");
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "set target port groups: out of "
-                "memory\n");
+        pr2ws("set target port groups: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, stpgCmdBlk, sizeof(stpgCmdBlk));
@@ -323,19 +335,16 @@ sg_ll_report_referrals(int sg_fd, uint64_t start_llba, int one_seg,
     repRefCmdBlk[12] = (mx_resp_len >> 8) & 0xff;
     repRefCmdBlk[13] = mx_resp_len & 0xff;
     repRefCmdBlk[14] = one_seg & 0x1;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    report referrals cdb: ");
+        pr2ws("    report referrals cdb: ");
         for (k = 0; k < SERVICE_ACTION_IN_16_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", repRefCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", repRefCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "report target port groups: out of "
-                "memory\n");
+        pr2ws("report target port groups: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, repRefCmdBlk, sizeof(repRefCmdBlk));
@@ -359,8 +368,8 @@ sg_ll_report_referrals(int sg_fd, uint64_t start_llba, int one_seg,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    report referrals: response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    report referrals: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -390,16 +399,13 @@ sg_ll_send_diag(int sg_fd, int sf_code, int pf_bit, int sf_bit, int devofl_bit,
     senddiagCmdBlk[3] = (unsigned char)((param_len >> 8) & 0xff);
     senddiagCmdBlk[4] = (unsigned char)(param_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Send diagnostic cmd: ");
+        pr2ws("    Send diagnostic cmd: ");
         for (k = 0; k < SEND_DIAGNOSTIC_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", senddiagCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", senddiagCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    Send diagnostic parameter "
-                    "list:\n");
+            pr2ws("    Send diagnostic parameter list:\n");
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
@@ -410,7 +416,7 @@ sg_ll_send_diag(int sg_fd, int sf_code, int pf_bit, int sf_bit, int devofl_bit,
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "send diagnostic: out of memory\n");
+        pr2ws("send diagnostic: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, senddiagCmdBlk, sizeof(senddiagCmdBlk));
@@ -455,19 +461,16 @@ sg_ll_receive_diag(int sg_fd, int pcv, int pg_code, void * resp,
     rcvdiagCmdBlk[3] = (unsigned char)((mx_resp_len >> 8) & 0xff);
     rcvdiagCmdBlk[4] = (unsigned char)(mx_resp_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Receive diagnostic results cmd: ");
+        pr2ws("    Receive diagnostic results cmd: ");
         for (k = 0; k < RECEIVE_DIAGNOSTICS_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rcvdiagCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rcvdiagCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "receive diagnostic results: out of "
-                "memory\n");
+        pr2ws("receive diagnostic results: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rcvdiagCmdBlk, sizeof(rcvdiagCmdBlk));
@@ -491,8 +494,8 @@ sg_ll_receive_diag(int sg_fd, int pcv, int pg_code, void * resp,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    receive diagnostic results: "
-                    "response%s\n", (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    receive diagnostic results: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -517,22 +520,20 @@ sg_ll_read_defect10(int sg_fd, int req_plist, int req_glist, int dl_format,
                          ((req_glist << 3) & 0x8) | (dl_format & 0x7));
     rdefCmdBlk[7] = (unsigned char)((mx_resp_len >> 8) & 0xff);
     rdefCmdBlk[8] = (unsigned char)(mx_resp_len & 0xff);
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (mx_resp_len > 0xffff) {
-        fprintf(sg_warnings_strm, "mx_resp_len too big\n");
+        pr2ws("mx_resp_len too big\n");
         return -1;
     }
     if (verbose) {
-        fprintf(sg_warnings_strm, "    read defect (10) cdb: ");
+        pr2ws("    read defect (10) cdb: ");
         for (k = 0; k < READ_DEFECT10_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rdefCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rdefCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read defect (10): out of memory\n");
+        pr2ws("read defect (10): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rdefCmdBlk, sizeof(rdefCmdBlk));
@@ -555,8 +556,8 @@ sg_ll_read_defect10(int sg_fd, int req_plist, int req_glist, int dl_format,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read defect (10): response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read defect (10): response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -582,19 +583,16 @@ sg_ll_read_media_serial_num(int sg_fd, void * resp, int mx_resp_len,
     rmsnCmdBlk[7] = (mx_resp_len >> 16) & 0xff;
     rmsnCmdBlk[8] = (mx_resp_len >> 8) & 0xff;
     rmsnCmdBlk[9] = mx_resp_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    read media serial number cdb: ");
+        pr2ws("    read media serial number cdb: ");
         for (k = 0; k < SERVICE_ACTION_IN_12_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rmsnCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rmsnCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read media serial number: out of "
-                "memory\n");
+        pr2ws("read media serial number: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rmsnCmdBlk, sizeof(rmsnCmdBlk));
@@ -618,8 +616,8 @@ sg_ll_read_media_serial_num(int sg_fd, void * resp, int mx_resp_len,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read media serial number: respon"
-                    "se%s\n", (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read media serial number: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -648,19 +646,16 @@ sg_ll_report_id_info(int sg_fd, int itype, void * resp, int max_resp_len,
     riiCmdBlk[9] = max_resp_len & 0xff;
     riiCmdBlk[10] |= (itype << 1) & 0xfe;
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Report identifying information cdb: ");
+        pr2ws("    Report identifying information cdb: ");
         for (k = 0; k < MAINTENANCE_IN_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", riiCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", riiCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "report identifying information: out of "
-                "memory\n");
+        pr2ws("report identifying information: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, riiCmdBlk, sizeof(riiCmdBlk));
@@ -684,8 +679,8 @@ sg_ll_report_id_info(int sg_fd, int itype, void * resp, int max_resp_len,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    report identifying information: "
-                    "response%s\n", (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    report identifying information: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -713,24 +708,20 @@ sg_ll_set_id_info(int sg_fd, int itype, void * paramp, int param_len,
     siiCmdBlk[8] = (param_len >> 8) & 0xff;
     siiCmdBlk[9] = param_len & 0xff;
     siiCmdBlk[10] |= (itype << 1) & 0xfe;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Set identifying information cdb: ");
+        pr2ws("    Set identifying information cdb: ");
         for (k = 0; k < MAINTENANCE_OUT_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", siiCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", siiCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    Set identifying information "
-                    "parameter list:\n");
+            pr2ws("    Set identifying information parameter list:\n");
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "Set identifying information: out of "
-                "memory\n");
+        pr2ws("Set identifying information: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, siiCmdBlk, sizeof(siiCmdBlk));
@@ -781,23 +772,21 @@ sg_ll_format_unit(int sg_fd, int fmtpinfo, int longlist, int fmtdata,
         fuCmdBlk[1] |= 0x8;
     if (dlist_format)
         fuCmdBlk[1] |= (dlist_format & 0x7);
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     tmout = (timeout_secs > 0) ? timeout_secs : DEF_PT_TIMEOUT;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    format cdb: ");
+        pr2ws("    format cdb: ");
         for (k = 0; k < 6; ++k)
-            fprintf(sg_warnings_strm, "%02x ", fuCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", fuCmdBlk[k]);
+        pr2ws("\n");
     }
     if ((verbose > 1) && (param_len > 0)) {
-        fprintf(sg_warnings_strm, "    format parameter list:\n");
+        pr2ws("    format parameter list:\n");
         dStrHexErr((const char *)paramp, param_len, -1);
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "format unit: out of memory\n");
+        pr2ws("format unit: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, fuCmdBlk, sizeof(fuCmdBlk));
@@ -839,22 +828,20 @@ sg_ll_reassign_blocks(int sg_fd, int longlba, int longlist, void * paramp,
 
     reassCmdBlk[1] = (unsigned char)(((longlba << 1) & 0x2) |
                      (longlist & 0x1));
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    reassign blocks cdb: ");
+        pr2ws("    reassign blocks cdb: ");
         for (k = 0; k < REASSIGN_BLKS_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", reassCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", reassCmdBlk[k]);
+        pr2ws("\n");
     }
     if (verbose > 1) {
-        fprintf(sg_warnings_strm, "    reassign blocks parameter list\n");
+        pr2ws("    reassign blocks parameter list\n");
         dStrHexErr((const char *)paramp, param_len, -1);
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "reassign blocks: out of memory\n");
+        pr2ws("reassign blocks: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, reassCmdBlk, sizeof(reassCmdBlk));
@@ -900,19 +887,16 @@ sg_ll_persistent_reserve_in(int sg_fd, int rq_servact, void * resp,
     prinCmdBlk[7] = (unsigned char)((mx_resp_len >> 8) & 0xff);
     prinCmdBlk[8] = (unsigned char)(mx_resp_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Persistent Reservation In cmd: ");
+        pr2ws("    Persistent Reservation In cmd: ");
         for (k = 0; k < PERSISTENT_RESERVE_IN_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", prinCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", prinCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "persistent reservation in: out of "
-                "memory\n");
+        pr2ws("persistent reservation in: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, prinCmdBlk, sizeof(prinCmdBlk));
@@ -936,8 +920,8 @@ sg_ll_persistent_reserve_in(int sg_fd, int rq_servact, void * resp,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    persistent reserve in: "
-                    "response%s\n", (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    persistent reserve in: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -966,23 +950,20 @@ sg_ll_persistent_reserve_out(int sg_fd, int rq_servact, int rq_scope,
     proutCmdBlk[7] = (unsigned char)((param_len >> 8) & 0xff);
     proutCmdBlk[8] = (unsigned char)(param_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Persistent Reservation Out cmd: ");
+        pr2ws("    Persistent Reservation Out cmd: ");
         for (k = 0; k < PERSISTENT_RESERVE_OUT_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", proutCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", proutCmdBlk[k]);
+        pr2ws("\n");
         if (verbose > 1) {
-            fprintf(sg_warnings_strm, "    Persistent Reservation Out "
-                    "parameters:\n");
+            pr2ws("    Persistent Reservation Out parameters:\n");
             dStrHexErr((const char *)paramp, param_len, 0);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "persistent reserve out: out of memory\n");
+        pr2ws("persistent reserve out: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, proutCmdBlk, sizeof(proutCmdBlk));
@@ -1054,18 +1035,16 @@ sg_ll_read_long10(int sg_fd, int pblock, int correct, unsigned int lba,
     readLongCmdBlk[5] = lba & 0xff;
     readLongCmdBlk[7] = (xfer_len >> 8) & 0xff;
     readLongCmdBlk[8] = xfer_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Read Long (10) cmd: ");
+        pr2ws("    Read Long (10) cmd: ");
         for (k = 0; k < READ_LONG10_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", readLongCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", readLongCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read long (10): out of memory\n");
+        pr2ws("read long (10): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, readLongCmdBlk, sizeof(readLongCmdBlk));
@@ -1096,8 +1075,8 @@ sg_ll_read_long10(int sg_fd, int pblock, int correct, unsigned int lba,
                     ret = SG_LIB_CAT_ILLEGAL_REQ_WITH_INFO;
                 } else {
                     if (verbose > 1)
-                        fprintf(sg_warnings_strm, "  info field: 0x%" PRIx64
-                                ",  valid: %d, ili: %d\n", ull, valid, ili);
+                        pr2ws("  info field: 0x%" PRIx64 ",  valid: %d, "
+                              "ili: %d\n", ull, valid, ili);
                     ret = SG_LIB_CAT_ILLEGAL_REQ;
                 }
             }
@@ -1108,8 +1087,8 @@ sg_ll_read_long10(int sg_fd, int pblock, int correct, unsigned int lba,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read long(10): response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read long(10): response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -1149,18 +1128,16 @@ sg_ll_read_long16(int sg_fd, int pblock, int correct, uint64_t llba,
     readLongCmdBlk[9] = llba & 0xff;
     readLongCmdBlk[12] = (xfer_len >> 8) & 0xff;
     readLongCmdBlk[13] = xfer_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Read Long (16) cmd: ");
+        pr2ws("    Read Long (16) cmd: ");
         for (k = 0; k < SERVICE_ACTION_IN_16_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", readLongCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", readLongCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read long (16): out of memory\n");
+        pr2ws("read long (16): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, readLongCmdBlk, sizeof(readLongCmdBlk));
@@ -1191,8 +1168,8 @@ sg_ll_read_long16(int sg_fd, int pblock, int correct, uint64_t llba,
                     ret = SG_LIB_CAT_ILLEGAL_REQ_WITH_INFO;
                 } else {
                     if (verbose > 1)
-                        fprintf(sg_warnings_strm, "  info field: 0x%" PRIx64
-                                ",  valid: %d, ili: %d\n", ull, valid, ili);
+                        pr2ws("  info field: 0x%" PRIx64 ",  valid: %d, "
+                              "ili: %d\n", ull, valid, ili);
                     ret = SG_LIB_CAT_ILLEGAL_REQ;
                 }
             }
@@ -1203,8 +1180,8 @@ sg_ll_read_long16(int sg_fd, int pblock, int correct, uint64_t llba,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read long(16): response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read long(16): response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -1241,18 +1218,16 @@ sg_ll_write_long10(int sg_fd, int cor_dis, int wr_uncor, int pblock,
     writeLongCmdBlk[5] = lba & 0xff;
     writeLongCmdBlk[7] = (xfer_len >> 8) & 0xff;
     writeLongCmdBlk[8] = xfer_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Write Long (10) cmd: ");
+        pr2ws("    Write Long (10) cmd: ");
         for (k = 0; k < (int)sizeof(writeLongCmdBlk); ++k)
-            fprintf(sg_warnings_strm, "%02x ", writeLongCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", writeLongCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "write long(10): out of memory\n");
+        pr2ws("write long(10): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, writeLongCmdBlk, sizeof(writeLongCmdBlk));
@@ -1283,8 +1258,8 @@ sg_ll_write_long10(int sg_fd, int cor_dis, int wr_uncor, int pblock,
                     ret = SG_LIB_CAT_ILLEGAL_REQ_WITH_INFO;
                 } else {
                     if (verbose > 1)
-                        fprintf(sg_warnings_strm, "  info field: 0x%" PRIx64
-                                ",  valid: %d, ili: %d\n", ull, valid, ili);
+                        pr2ws("  info field: 0x%" PRIx64 ",  valid: %d, "
+                              "ili: %d\n", ull, valid, ili);
                     ret = SG_LIB_CAT_ILLEGAL_REQ;
                 }
             }
@@ -1333,18 +1308,16 @@ sg_ll_write_long16(int sg_fd, int cor_dis, int wr_uncor, int pblock,
     writeLongCmdBlk[9] = llba & 0xff;
     writeLongCmdBlk[12] = (xfer_len >> 8) & 0xff;
     writeLongCmdBlk[13] = xfer_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Write Long (16) cmd: ");
+        pr2ws("    Write Long (16) cmd: ");
         for (k = 0; k < SERVICE_ACTION_OUT_16_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", writeLongCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", writeLongCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "write long(16): out of memory\n");
+        pr2ws("write long(16): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, writeLongCmdBlk, sizeof(writeLongCmdBlk));
@@ -1375,8 +1348,8 @@ sg_ll_write_long16(int sg_fd, int cor_dis, int wr_uncor, int pblock,
                     ret = SG_LIB_CAT_ILLEGAL_REQ_WITH_INFO;
                 } else {
                     if (verbose > 1)
-                        fprintf(sg_warnings_strm, "  info field: 0x%" PRIx64
-                                ",  valid: %d, ili: %d\n", ull, valid, ili);
+                        pr2ws("  info field: 0x%" PRIx64 ",  valid: %d, "
+                              "ili: %d\n", ull, valid, ili);
                     ret = SG_LIB_CAT_ILLEGAL_REQ;
                 }
             }
@@ -1417,23 +1390,21 @@ sg_ll_verify10(int sg_fd, int vrprotect, int dpo, int bytchk,
     vCmdBlk[5] = (unsigned char)(lba & 0xff);
     vCmdBlk[7] = (unsigned char)((veri_len >> 8) & 0xff);
     vCmdBlk[8] = (unsigned char)(veri_len & 0xff);
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose > 1) {
-        fprintf(sg_warnings_strm, "    Verify(10) cdb: ");
+        pr2ws("    Verify(10) cdb: ");
         for (k = 0; k < VERIFY10_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", vCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", vCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 3) && bytchk && data_out && (data_out_len > 0)) {
             k = data_out_len > 4104 ? 4104 : data_out_len;
-            fprintf(sg_warnings_strm, "    data_out buffer%s\n",
-                    (data_out_len > 4104 ? ", first 4104 bytes" : ""));
+            pr2ws("    data_out buffer%s\n",
+                  (data_out_len > 4104 ? ", first 4104 bytes" : ""));
             dStrHexErr((const char *)data_out, k, verbose < 5);
         }
     }
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "verify (10): out of memory\n");
+        pr2ws("verify (10): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, vCmdBlk, sizeof(vCmdBlk));
@@ -1508,23 +1479,21 @@ sg_ll_verify16(int sg_fd, int vrprotect, int dpo, int bytchk, uint64_t llba,
     vCmdBlk[12] = (veri_len >> 8) & 0xff;
     vCmdBlk[13] = veri_len & 0xff;
     vCmdBlk[14] = group_num & 0x1f;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose > 1) {
-        fprintf(sg_warnings_strm, "    Verify(16) cdb: ");
+        pr2ws("    Verify(16) cdb: ");
         for (k = 0; k < VERIFY16_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", vCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", vCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 3) && bytchk && data_out && (data_out_len > 0)) {
             k = data_out_len > 4104 ? 4104 : data_out_len;
-            fprintf(sg_warnings_strm, "    data_out buffer%s\n",
-                    (data_out_len > 4104 ? ", first 4104 bytes" : ""));
+            pr2ws("    data_out buffer%s\n",
+                  (data_out_len > 4104 ? ", first 4104 bytes" : ""));
             dStrHexErr((const char *)data_out, k, verbose < 5);
         }
     }
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "verify (16): out of memory\n");
+        pr2ws("verify (16): out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, vCmdBlk, sizeof(vCmdBlk));
@@ -1605,16 +1574,14 @@ sg_ll_ata_pt(int sg_fd, const unsigned char * cdbp, int cdb_len,
     int ret = -1;
 
     b[0] = '\0';
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     cnamep = (12 == cdb_len) ?
              "ATA pass through (12)" : "ATA pass through (16)";
     if ((NULL == cdbp) || ((12 != cdb_len) && (16 != cdb_len))) {
         if (verbose) {
             if (NULL == cdbp)
-                fprintf(sg_warnings_strm, "%s NULL cdb pointer\n", cnamep);
+                pr2ws("%s NULL cdb pointer\n", cnamep);
             else
-                fprintf(sg_warnings_strm, "cdb_len must be 12 or 16\n");
+                pr2ws("cdb_len must be 12 or 16\n");
         }
         return -1;
     }
@@ -1631,14 +1598,14 @@ sg_ll_ata_pt(int sg_fd, const unsigned char * cdbp, int cdb_len,
     else
         memcpy(aptCmdBlk + 1, cdbp + 1, ((cdb_len > 15) ? 14 : (cdb_len - 1)));
     if (verbose) {
-        fprintf(sg_warnings_strm, "    %s cdb: ", cnamep);
+        pr2ws("    %s cdb: ", cnamep);
         for (k = 0; k < cdb_len; ++k)
-            fprintf(sg_warnings_strm, "%02x ", aptCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", aptCmdBlk[k]);
+        pr2ws("\n");
     }
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "%s: out of memory\n", cnamep);
+        pr2ws("%s: out of memory\n", cnamep);
         return -1;
     }
     set_scsi_pt_cdb(ptvp, aptCmdBlk, cdb_len);
@@ -1654,20 +1621,19 @@ sg_ll_ata_pt(int sg_fd, const unsigned char * cdbp, int cdb_len,
                      verbose);
     if (SCSI_PT_DO_BAD_PARAMS == res) {
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: bad parameters\n", cnamep);
+            pr2ws("%s: bad parameters\n", cnamep);
         goto out;
     } else if (SCSI_PT_DO_TIMEOUT == res) {
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: timeout\n", cnamep);
+            pr2ws("%s: timeout\n", cnamep);
         goto out;
     } else if (res > 2) {
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: do_scsi_pt: errno=%d\n",
-                    cnamep, -res);
+            pr2ws("%s: do_scsi_pt: errno=%d\n", cnamep, -res);
     }
 
     if ((verbose > 2) && ((duration = get_scsi_pt_duration_ms(ptvp)) >= 0))
-        fprintf(sg_warnings_strm, "      duration=%d ms\n", duration);
+        pr2ws("      duration=%d ms\n", duration);
 
     switch (get_scsi_pt_result_category(ptvp)) {
     case SCSI_PT_RESULT_GOOD:
@@ -1708,19 +1674,18 @@ sg_ll_ata_pt(int sg_fd, const unsigned char * cdbp, int cdb_len,
         break;
     case SCSI_PT_RESULT_TRANSPORT_ERR:
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: transport error: %s\n",
-                    cnamep, get_scsi_pt_transport_err_str(ptvp, sizeof(b) ,
-                                                          b));
+            pr2ws("%s: transport error: %s\n", cnamep,
+                  get_scsi_pt_transport_err_str(ptvp, sizeof(b), b));
         break;
     case SCSI_PT_RESULT_OS_ERR:
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: os error: %s\n",
-                    cnamep, get_scsi_pt_os_err_str(ptvp, sizeof(b) , b));
+            pr2ws("%s: os error: %s\n", cnamep,
+                  get_scsi_pt_os_err_str(ptvp, sizeof(b) , b));
         break;
     default:
         if (verbose)
-            fprintf(sg_warnings_strm, "%s: unknown pt_result_category=%d\n",
-                    cnamep, get_scsi_pt_result_category(ptvp));
+            pr2ws("%s: unknown pt_result_category=%d\n", cnamep,
+                  get_scsi_pt_result_category(ptvp));
         break;
     }
 
@@ -1749,18 +1714,16 @@ sg_ll_read_buffer(int sg_fd, int mode, int buffer_id, int buffer_offset,
     rbufCmdBlk[6] = (unsigned char)((mx_resp_len >> 16) & 0xff);
     rbufCmdBlk[7] = (unsigned char)((mx_resp_len >> 8) & 0xff);
     rbufCmdBlk[8] = (unsigned char)(mx_resp_len & 0xff);
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    read buffer cdb: ");
+        pr2ws("    read buffer cdb: ");
         for (k = 0; k < READ_BUFFER_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rbufCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rbufCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read buffer: out of memory\n");
+        pr2ws("read buffer: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rbufCmdBlk, sizeof(rbufCmdBlk));
@@ -1783,8 +1746,8 @@ sg_ll_read_buffer(int sg_fd, int mode, int buffer_id, int buffer_offset,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read buffer: response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read buffer: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -1813,24 +1776,22 @@ sg_ll_write_buffer(int sg_fd, int mode, int buffer_id, int buffer_offset,
     wbufCmdBlk[6] = (unsigned char)((param_len >> 16) & 0xff);
     wbufCmdBlk[7] = (unsigned char)((param_len >> 8) & 0xff);
     wbufCmdBlk[8] = (unsigned char)(param_len & 0xff);
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    Write buffer cmd: ");
+        pr2ws("    Write buffer cmd: ");
         for (k = 0; k < WRITE_BUFFER_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", wbufCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", wbufCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    Write buffer parameter list%s:\n",
-                    ((param_len > 256) ? " (first 256 bytes)" : ""));
+            pr2ws("    Write buffer parameter list%s:\n",
+                  ((param_len > 256) ? " (first 256 bytes)" : ""));
             dStrHexErr((const char *)paramp,
-                    ((param_len > 256) ? 256 : param_len), -1);
+                       ((param_len > 256) ? 256 : param_len), -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "write buffer: out of memory\n");
+        pr2ws("write buffer: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, wbufCmdBlk, sizeof(wbufCmdBlk));
@@ -1886,22 +1847,20 @@ sg_ll_unmap_v2(int sg_fd, int anchor, int group_num, int timeout_secs,
     uCmdBlk[6] = group_num & 0x1f;
     uCmdBlk[7] = (param_len >> 8) & 0xff;
     uCmdBlk[8] = param_len & 0xff;
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    unmap cdb: ");
+        pr2ws("    unmap cdb: ");
         for (k = 0; k < UNMAP_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", uCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", uCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    unmap parameter list:\n");
+            pr2ws("    unmap parameter list:\n");
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "unmap: out of memory\n");
+        pr2ws("unmap: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, uCmdBlk, sizeof(uCmdBlk));
@@ -1940,18 +1899,16 @@ sg_ll_read_block_limits(int sg_fd, void * resp, int mx_resp_len,
     unsigned char sense_b[SENSE_BUFF_LEN];
     struct sg_pt_base * ptvp;
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    read block limits cdb: ");
+        pr2ws("    read block limits cdb: ");
         for (k = 0; k < READ_BLOCK_LIMITS_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rlCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rlCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "read block limits: out of memory\n");
+        pr2ws("read block limits: out of memory\n");
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rlCmdBlk, sizeof(rlCmdBlk));
@@ -1974,8 +1931,8 @@ sg_ll_read_block_limits(int sg_fd, void * resp, int mx_resp_len,
         }
     } else {
         if ((verbose > 2) && (ret > 0)) {
-            fprintf(sg_warnings_strm, "    read block limits: response%s\n",
-                    (ret > 256 ? ", first 256 bytes" : ""));
+            pr2ws("    read block limits: response%s\n",
+                  (ret > 256 ? ", first 256 bytes" : ""));
             dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
         }
         ret = 0;
@@ -2013,18 +1970,16 @@ sg_ll_receive_copy_results(int sg_fd, int sa, int list_id, void * resp,
     rcvcopyresCmdBlk[12] = (unsigned char)((mx_resp_len >> 8) & 0xff);
     rcvcopyresCmdBlk[13] = (unsigned char)(mx_resp_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    %s cmd: ", b);
+        pr2ws("    %s cmd: ", b);
         for (k = 0; k < THIRD_PARTY_COPY_IN_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", rcvcopyresCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", rcvcopyresCmdBlk[k]);
+        pr2ws("\n");
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "%s: out of memory\n", b);
+        pr2ws("%s: out of memory\n", b);
         return -1;
     }
     set_scsi_pt_cdb(ptvp, rcvcopyresCmdBlk, sizeof(rcvcopyresCmdBlk));
@@ -2076,23 +2031,20 @@ sg_ll_extended_copy(int sg_fd, void * paramp, int param_len, int noisy,
     xcopyCmdBlk[12] = (unsigned char)((param_len >> 8) & 0xff);
     xcopyCmdBlk[13] = (unsigned char)(param_len & 0xff);
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     if (verbose) {
-        fprintf(sg_warnings_strm, "    %s cmd: ", opcode_name);
+        pr2ws("    %s cmd: ", opcode_name);
         for (k = 0; k < THIRD_PARTY_COPY_OUT_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", xcopyCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", xcopyCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    %s parameter list:\n",
-                    opcode_name);
+            pr2ws("    %s parameter list:\n", opcode_name);
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "%s: out of memory\n", opcode_name);
+        pr2ws("%s: out of memory\n", opcode_name);
         return -1;
     }
     set_scsi_pt_cdb(ptvp, xcopyCmdBlk, sizeof(xcopyCmdBlk));
@@ -2136,8 +2088,6 @@ sg_ll_3party_copy_out(int sg_fd, int sa, unsigned int list_id, int group_num,
     struct sg_pt_base * ptvp;
     char cname[80];
 
-    if (NULL == sg_warnings_strm)
-        sg_warnings_strm = stderr;
     sg_get_opcode_sa_name(THIRD_PARTY_COPY_OUT_CMD, sa, 0, sizeof(cname),
                           cname);
     xcopyCmdBlk[1] = (unsigned char)(sa & 0x1f);
@@ -2168,26 +2118,25 @@ sg_ll_3party_copy_out(int sg_fd, int sa, unsigned int list_id, int group_num,
         xcopyCmdBlk[5] = (unsigned char)(list_id & 0xff);
         break;
     default:
-        fprintf(sg_warnings_strm, "sg_ll_3party_copy_out: unknown service "
-                "action 0x%x\n", sa);
+        pr2ws("sg_ll_3party_copy_out: unknown service action 0x%x\n", sa);
         return -1;
     }
     tmout = (timeout_secs > 0) ? timeout_secs : DEF_PT_TIMEOUT;
 
     if (verbose) {
-        fprintf(sg_warnings_strm, "    %s cmd: ", cname);
+        pr2ws("    %s cmd: ", cname);
         for (k = 0; k < THIRD_PARTY_COPY_OUT_CMDLEN; ++k)
-            fprintf(sg_warnings_strm, "%02x ", xcopyCmdBlk[k]);
-        fprintf(sg_warnings_strm, "\n");
+            pr2ws("%02x ", xcopyCmdBlk[k]);
+        pr2ws("\n");
         if ((verbose > 1) && paramp && param_len) {
-            fprintf(sg_warnings_strm, "    %s parameter list:\n", cname);
+            pr2ws("    %s parameter list:\n", cname);
             dStrHexErr((const char *)paramp, param_len, -1);
         }
     }
 
     ptvp = construct_scsi_pt_obj();
     if (NULL == ptvp) {
-        fprintf(sg_warnings_strm, "%s: out of memory\n", cname);
+        pr2ws("%s: out of memory\n", cname);
         return -1;
     }
     set_scsi_pt_cdb(ptvp, xcopyCmdBlk, sizeof(xcopyCmdBlk));