diff options
Diffstat (limited to 'lib/sg_lib.c')
| -rw-r--r-- | lib/sg_lib.c | 4088 |
1 files changed, 4088 insertions, 0 deletions
diff --git a/lib/sg_lib.c b/lib/sg_lib.c new file mode 100644 index 00000000..36fcf5cd --- /dev/null +++ b/lib/sg_lib.c @@ -0,0 +1,4088 @@ +/* + * Copyright (c) 1999-2022 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. + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/* NOTICE: + * On 5th October 2004 (v1.00) this file name was changed from sg_err.c + * to sg_lib.c and the previous GPL was changed to a FreeBSD license. + * The intention is to maintain this file and the related sg_lib.h file + * as open source and encourage their unencumbered use. + * + * CONTRIBUTIONS: + * This file started out as a copy of SCSI opcodes, sense keys and + * additional sense codes (ASC/ASCQ) kept in the Linux SCSI subsystem + * in the kernel source file: drivers/scsi/constant.c . That file + * bore this notice: "Copyright (C) 1993, 1994, 1995 Eric Youngdale" + * and a GPL notice. + * + * Much of the data in this file is derived from SCSI draft standards + * found at https://www.t10.org with the "SCSI Primary Commands-4" (SPC-4) + * being the central point of reference. + * + * Contributions: + * sense key specific field decoding [Trent Piepho 20031116] + * + */ + +#define _POSIX_C_SOURCE 200809L /* for posix_memalign() */ +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdint.h> +#include <string.h> +#include <ctype.h> +#define __STDC_FORMAT_MACROS 1 +#include <inttypes.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "sg_lib.h" +#include "sg_lib_data.h" +#include "sg_unaligned.h" +#include "sg_pr2serr.h" + +/* sg_lib_version_str (and datestamp) defined in sg_lib_data.c file */ + +#define ASCQ_ATA_PT_INFO_AVAILABLE 0x1d /* corresponding ASC is 0 */ + +typedef unsigned int my_uint; /* convenience to save a few line wraps */ + +FILE * sg_warnings_strm = NULL; /* would like to default to stderr */ + + +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; +} + +/* Want safe, 'n += snprintf(b + n, blen - n, ...)' style sequence of + * functions. Returns number of chars placed in cp excluding the + * trailing null char. So for cp_max_len > 0 the return value is always + * < cp_max_len; for cp_max_len <= 1 the return value is 0 and no chars are + * written to cp. Note this means that when cp_max_len = 1, this function + * assumes that cp[0] is the null character and does nothing (and returns + * 0). Linux kernel has a similar function called scnprintf(). Public + * declaration in sg_pr2serr.h header */ +int +sg_scnpr(char * cp, int cp_max_len, const char * fmt, ...) +{ + va_list args; + int n; + + if (cp_max_len < 2) + return 0; + va_start(args, fmt); + n = vsnprintf(cp, cp_max_len, fmt, args); + va_end(args); + return (n < cp_max_len) ? n : (cp_max_len - 1); +} + +/* Simple ASCII printable (does not use locale), includes space and excludes + * DEL (0x7f). */ +static inline int +my_isprint(int ch) +{ + return ((ch >= ' ') && (ch < 0x7f)); +} + +/* DSENSE is 'descriptor sense' as opposed to the older 'fixed sense'. + * Only (currently) used in SNTL. */ +bool +sg_get_initial_dsense(void) +{ + int k; + const char * cp; + + cp = getenv("SG3_UTILS_DSENSE"); + if (cp) { + if (1 == sscanf(cp, "%d", &k)) + return k ? true : false; + } + return false; +} + +/* Searches 'arr' for match on 'value' then 'peri_type'. If matches + 'value' but not 'peri_type' then yields first 'value' match entry. + Last element of 'arr' has NULL 'name'. If no match returns NULL. */ +static const struct sg_lib_value_name_t * +get_value_name(const struct sg_lib_value_name_t * arr, int value, + int peri_type) +{ + const struct sg_lib_value_name_t * vp = arr; + const struct sg_lib_value_name_t * holdp; + + if (peri_type < 0) + peri_type = 0; + for (; vp->name; ++vp) { + if (value == vp->value) { + if (sg_pdt_s_eq(peri_type, vp->peri_dev_type)) + return vp; + holdp = vp; + while ((vp + 1)->name && (value == (vp + 1)->value)) { + ++vp; + if (sg_pdt_s_eq(peri_type, vp->peri_dev_type)) + return vp; + } + return holdp; + } + } + return NULL; +} + +/* If this function is not called, sg_warnings_strm will be NULL and all users + * (mainly fprintf() ) need to check and substitute stderr as required */ +void +sg_set_warnings_strm(FILE * warnings_strm) +{ + sg_warnings_strm = warnings_strm; +} + +/* Take care to minimize printf() parsing delays when printing commands */ +static char bin2hexascii[] = {'0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + + +/* Given a SCSI command pointed to by cdbp of sz bytes this function forms + * a SCSI command in ASCII surrounded by square brackets in 'b'. 'b' is at + * least blen bytes long. If cmd_name is true then the command is prefixed + * by its SCSI command name (e.g. "VERIFY(10) [2f ...]". The command is + * shown as spaced separated pairs of hexadecimal digits (i.e. 0-9, a-f). + * Each pair represents byte. The leftmost pair of digits is cdbp[0] . If + * sz <= 0 then this function tries to guess the length of the command. */ +char * +sg_get_command_str(const uint8_t * cdbp, int sz, bool cmd_name, int blen, + char * b) +{ + int k, j, jj; + + if ((cdbp == NULL) || (b == NULL) || (blen < 1)) + return b; + if (cmd_name && (blen > 16)) { + sg_get_command_name(cdbp, 0, blen, b); + j = (int)strlen(b); + if (j < (blen - 1)) + b[j++] = ' '; + } else + j = 0; + if (j >= blen) + goto fini; + b[j++] = '['; + if (j >= blen) + goto fini; + if (sz <= 0) { + if (SG_VARIABLE_LENGTH_CMD == cdbp[0]) + sz = cdbp[7] + 8; + else + sz = sg_get_command_size(cdbp[0]); + } + jj = j; + for (k = 0; (k < sz) && (j < (blen - 3)); ++k, j += 3, ++cdbp) { + b[j] = bin2hexascii[(*cdbp >> 4) & 0xf]; + b[j + 1] = bin2hexascii[*cdbp & 0xf]; + b[j + 2] = ' '; + } + if (j > jj) + --j; /* don't want trailing space before ']' */ + if (j >= blen) + goto fini; + b[j++] = ']'; +fini: + if (j >= blen) + b[blen - 1] = '\0'; /* truncated string */ + else + b[j] = '\0'; + return b; +} + +#define CMD_NAME_LEN 128 + +void +sg_print_command_len(const uint8_t * cdbp, int sz) +{ + char buff[CMD_NAME_LEN]; + + sg_get_command_str(cdbp, sz, true, sizeof(buff), buff); + pr2ws("%s\n", buff); +} + +void +sg_print_command(const uint8_t * cdbp) +{ + sg_print_command_len(cdbp, 0); +} + +bool +sg_scsi_status_is_good(int sstatus) +{ + sstatus &= 0xfe; + switch (sstatus) { + case SAM_STAT_GOOD: + case SAM_STAT_CONDITION_MET: + return true; + default: + return false; + } +} + +bool +sg_scsi_status_is_bad(int sstatus) +{ + sstatus &= 0xfe; + switch (sstatus) { + case SAM_STAT_GOOD: + case SAM_STAT_CONDITION_MET: + return false; + default: + return true; + } +} + +void +sg_get_scsi_status_str(int scsi_status, int buff_len, char * buff) +{ + const struct sg_lib_simple_value_name_t * sstatus_p; + + if ((NULL == buff) || (buff_len < 1)) + return; + else if (1 == buff_len) { + buff[0] = '\0'; + return; + } + scsi_status &= 0x7e; /* sanitize as much as possible */ + for (sstatus_p = sg_lib_sstatus_str_arr; sstatus_p->name; ++sstatus_p) { + if (scsi_status == sstatus_p->value) + break; + } + if (sstatus_p->name) + sg_scnpr(buff, buff_len, "%s", sstatus_p->name); + else + sg_scnpr(buff, buff_len, "Unknown status [0x%x]", scsi_status); +} + +void +sg_print_scsi_status(int scsi_status) +{ + char buff[128]; + + sg_get_scsi_status_str(scsi_status, sizeof(buff) - 1, buff); + buff[sizeof(buff) - 1] = '\0'; + pr2ws("%s ", buff); +} + +/* Get sense key from sense buffer. If successful returns a sense key value + * between 0 and 15. If sense buffer cannot be decode, returns -1 . */ +int +sg_get_sense_key(const uint8_t * sbp, int sb_len) +{ + if ((NULL == sbp) || (sb_len < 2)) + return -1; + switch (sbp[0] & 0x7f) { + case 0x70: + case 0x71: + return (sb_len < 3) ? -1 : (sbp[2] & 0xf); + case 0x72: + case 0x73: + return sbp[1] & 0xf; + default: + return -1; + } +} + +/* Yield string associated with sense_key value. Returns 'buff'. */ +char * +sg_get_sense_key_str(int sense_key, int buff_len, char * buff) +{ + if (1 == buff_len) { + buff[0] = '\0'; + return buff; + } + if ((sense_key >= 0) && (sense_key < 16)) + sg_scnpr(buff, buff_len, "%s", sg_lib_sense_key_desc[sense_key]); + else + sg_scnpr(buff, buff_len, "invalid value: 0x%x", sense_key); + return buff; +} + +/* Yield string associated with ASC/ASCQ values. Returns 'buff'. */ +char * +sg_get_additional_sense_str(int asc, int ascq, bool add_sense_leadin, + int buff_len, char * buff) +{ + int k, num, rlen; + bool found = false; + + if (1 == buff_len) { + buff[0] = '\0'; + return buff; + } + for (k = 0; sg_lib_asc_ascq_range[k].text; ++k) { + struct sg_lib_asc_ascq_range_t * ei2p = &sg_lib_asc_ascq_range[k]; + + if ((ei2p->asc == asc) && + (ascq >= ei2p->ascq_min) && + (ascq <= ei2p->ascq_max)) { + found = true; + if (add_sense_leadin) + num = sg_scnpr(buff, buff_len, "Additional sense: "); + else + num = 0; + rlen = buff_len - num; + sg_scnpr(buff + num, ((rlen > 0) ? rlen : 0), ei2p->text, ascq); + } + } + if (found) + return buff; + + for (k = 0; sg_lib_asc_ascq[k].text; ++k) { + struct sg_lib_asc_ascq_t * eip = &sg_lib_asc_ascq[k]; + + if (eip->asc == asc && + eip->ascq == ascq) { + found = true; + if (add_sense_leadin) + sg_scnpr(buff, buff_len, "Additional sense: %s", eip->text); + else + sg_scnpr(buff, buff_len, "%s", eip->text); + } + } + if (! found) { + if (asc >= 0x80) + sg_scnpr(buff, buff_len, "vendor specific ASC=%02x, ASCQ=%02x " + "(hex)", asc, ascq); + else if (ascq >= 0x80) + sg_scnpr(buff, buff_len, "ASC=%02x, vendor specific qualification " + "ASCQ=%02x (hex)", asc, ascq); + else + sg_scnpr(buff, buff_len, "ASC=%02x, ASCQ=%02x (hex)", asc, ascq); + } + return buff; +} + +/* Yield string associated with ASC/ASCQ values. Returns 'buff'. */ +char * +sg_get_asc_ascq_str(int asc, int ascq, int buff_len, char * buff) +{ + return sg_get_additional_sense_str(asc, ascq, true, buff_len, buff); +} + +/* Attempt to find the first SCSI sense data descriptor that matches the + * given 'desc_type'. If found return pointer to start of sense data + * descriptor; otherwise (including fixed format sense data) returns NULL. */ +const uint8_t * +sg_scsi_sense_desc_find(const uint8_t * sbp, int sb_len, + int desc_type) +{ + int add_sb_len, desc_len, k; + const uint8_t * descp; + + if ((sb_len < 8) || (0 == (add_sb_len = sbp[7]))) + return NULL; + if ((sbp[0] < 0x72) || (sbp[0] > 0x73)) + return NULL; + add_sb_len = (add_sb_len < (sb_len - 8)) ? add_sb_len : (sb_len - 8); + descp = &sbp[8]; + for (desc_len = 0, k = 0; k < add_sb_len; k += desc_len) { + int add_d_len; + + descp += desc_len; + add_d_len = (k < (add_sb_len - 1)) ? descp[1]: -1; + desc_len = add_d_len + 2; + if (descp[0] == desc_type) + return descp; + if (add_d_len < 0) /* short descriptor ?? */ + break; + } + return NULL; +} + +/* Returns true if valid bit set, false if valid bit clear. Irrespective the + * information field is written out via 'info_outp' (except when it is + * NULL). Handles both fixed and descriptor sense formats. */ +bool +sg_get_sense_info_fld(const uint8_t * sbp, int sb_len, + uint64_t * info_outp) +{ + const uint8_t * bp; + + if (info_outp) + *info_outp = 0; + if (sb_len < 7) + return false; + switch (sbp[0] & 0x7f) { + case 0x70: + case 0x71: + if (info_outp) + *info_outp = sg_get_unaligned_be32(sbp + 3); + return !!(sbp[0] & 0x80); + case 0x72: + case 0x73: + bp = sg_scsi_sense_desc_find(sbp, sb_len, 0 /* info desc */); + if (bp && (0xa == bp[1])) { + uint64_t ull = sg_get_unaligned_be64(bp + 4); + + if (info_outp) + *info_outp = ull; + return !!(bp[2] & 0x80); /* since spc3r23 should be set */ + } else + return false; + default: + return false; + } +} + +/* Returns true if fixed format or command specific information descriptor + * is found in the descriptor sense; else false. If available the command + * specific information field (4 byte integer in fixed format, 8 byte + * integer in descriptor format) is written out via 'cmd_spec_outp'. + * Handles both fixed and descriptor sense formats. */ +bool +sg_get_sense_cmd_spec_fld(const uint8_t * sbp, int sb_len, + uint64_t * cmd_spec_outp) +{ + const uint8_t * bp; + + if (cmd_spec_outp) + *cmd_spec_outp = 0; + if (sb_len < 7) + return false; + switch (sbp[0] & 0x7f) { + case 0x70: + case 0x71: + if (cmd_spec_outp) + *cmd_spec_outp = sg_get_unaligned_be32(sbp + 8); + return true; + case 0x72: + case 0x73: + bp = sg_scsi_sense_desc_find(sbp, sb_len, + 1 /* command specific info desc */); + if (bp && (0xa == bp[1])) { + if (cmd_spec_outp) + *cmd_spec_outp = sg_get_unaligned_be64(bp + 4); + return true; + } else + return false; + default: + return false; + } +} + +/* Returns true if any of the 3 bits (i.e. FILEMARK, EOM or ILI) are set. + * In descriptor format if the stream commands descriptor not found + * then returns false. Writes true or false corresponding to these bits to + * the last three arguments if they are non-NULL. */ +bool +sg_get_sense_filemark_eom_ili(const uint8_t * sbp, int sb_len, + bool * filemark_p, bool * eom_p, bool * ili_p) +{ + const uint8_t * bp; + + if (sb_len < 7) + return false; + switch (sbp[0] & 0x7f) { + case 0x70: + case 0x71: + if (sbp[2] & 0xe0) { + if (filemark_p) + *filemark_p = !!(sbp[2] & 0x80); + if (eom_p) + *eom_p = !!(sbp[2] & 0x40); + if (ili_p) + *ili_p = !!(sbp[2] & 0x20); + return true; + } else + return false; + case 0x72: + case 0x73: + /* Look for stream commands sense data descriptor */ + bp = sg_scsi_sense_desc_find(sbp, sb_len, 4); + if (bp && (bp[1] >= 2)) { + if (bp[3] & 0xe0) { + if (filemark_p) + *filemark_p = !!(bp[3] & 0x80); + if (eom_p) + *eom_p = !!(bp[3] & 0x40); + if (ili_p) + *ili_p = !!(bp[3] & 0x20); + return true; + } + } + return false; + default: + return false; + } +} + +/* Returns true if SKSV is set and sense key is NO_SENSE or NOT_READY. Also + * returns true if progress indication sense data descriptor found. Places + * progress field from sense data where progress_outp points. If progress + * field is not available returns false and *progress_outp is unaltered. + * Handles both fixed and descriptor sense formats. + * Hint: if true is returned *progress_outp may be multiplied by 100 then + * divided by 65536 to get the percentage completion. */ +bool +sg_get_sense_progress_fld(const uint8_t * sbp, int sb_len, + int * progress_outp) +{ + const uint8_t * bp; + int sk, sk_pr; + + if (sb_len < 7) + return false; + switch (sbp[0] & 0x7f) { + case 0x70: + case 0x71: + sk = (sbp[2] & 0xf); + if ((sb_len < 18) || + ((SPC_SK_NO_SENSE != sk) && (SPC_SK_NOT_READY != sk))) + return false; + if (sbp[15] & 0x80) { /* SKSV bit set */ + if (progress_outp) + *progress_outp = sg_get_unaligned_be16(sbp + 16); + return true; + } else + return false; + case 0x72: + case 0x73: + /* sense key specific progress (0x2) or progress descriptor (0xa) */ + sk = (sbp[1] & 0xf); + sk_pr = (SPC_SK_NO_SENSE == sk) || (SPC_SK_NOT_READY == sk); + if (sk_pr && ((bp = sg_scsi_sense_desc_find(sbp, sb_len, 2))) && + (0x6 == bp[1]) && (0x80 & bp[4])) { + if (progress_outp) + *progress_outp = sg_get_unaligned_be16(bp + 5); + return true; + } else if (((bp = sg_scsi_sense_desc_find(sbp, sb_len, 0xa))) && + ((0x6 == bp[1]))) { + if (progress_outp) + *progress_outp = sg_get_unaligned_be16(bp + 6); + return true; + } else + return false; + default: + return false; + } +} + +char * +sg_get_pdt_str(int pdt, int buff_len, char * buff) +{ + if ((pdt < 0) || (pdt > PDT_MAX)) + sg_scnpr(buff, buff_len, "bad pdt"); + else + sg_scnpr(buff, buff_len, "%s", sg_lib_pdt_strs[pdt]); + return buff; +} + +/* Returns true if left argument is "equal" to the right argument. l_pdt_s + * is a compound PDT (SCSI Peripheral Device Type) or a negative number + * which represents a wildcard (i.e. match anything). r_pdt_s has a similar + * form. PDT values are 5 bits long (0 to 31) and a compound pdt_s is + * formed by shifting the second (upper) PDT by eight bits to the left and + * OR-ing it with the first PDT. The pdt_s values must be defined so + * PDT_DISK (0) is _not_ the upper value in a compound pdt_s. */ +bool +sg_pdt_s_eq(int l_pdt_s, int r_pdt_s) +{ + bool upper_l = !!(l_pdt_s & PDT_UPPER_MASK); + bool upper_r = !!(r_pdt_s & PDT_UPPER_MASK); + + if ((l_pdt_s < 0) || (r_pdt_s < 0)) + return true; + if (!upper_l && !upper_r) + return l_pdt_s == r_pdt_s; + else if (upper_l && upper_r) + return (((PDT_UPPER_MASK & l_pdt_s) == (PDT_UPPER_MASK & r_pdt_s)) || + ((PDT_LOWER_MASK & l_pdt_s) == (PDT_LOWER_MASK & r_pdt_s))); + else if (upper_l) + return (((PDT_LOWER_MASK & l_pdt_s) == r_pdt_s) || + ((PDT_UPPER_MASK & l_pdt_s) >> 8) == r_pdt_s); + return (((PDT_LOWER_MASK & r_pdt_s) == l_pdt_s) || + ((PDT_UPPER_MASK & r_pdt_s) >> 8) == l_pdt_s); +} + +int +sg_lib_pdt_decay(int pdt) +{ + if ((pdt < 0) || (pdt > PDT_MAX)) + return 0; + return sg_lib_pdt_decay_arr[pdt]; +} + +char * +sg_get_trans_proto_str(int tpi, int buff_len, char * buff) +{ + if ((tpi < 0) || (tpi > 15)) + sg_scnpr(buff, buff_len, "bad tpi"); + else + sg_scnpr(buff, buff_len, "%s", sg_lib_transport_proto_strs[tpi]); + return buff; +} + +#define TRANSPORT_ID_MIN_LEN 24 + +char * +sg_decode_transportid_str(const char * lip, uint8_t * bp, int bplen, + bool only_one, int blen, char * b) +{ + int num, k, n; + uint64_t ull; + int bump; + + if ((NULL == b) || (blen < 1)) + return b; + else if (1 == blen) { + b[0] = '\0'; + return b; + } + if (NULL == lip) + lip = ""; + /* bump = TRANSPORT_ID_MIN_LEN; // some old compilers insisted on this */ + for (k = 0, n = 0; bplen > 0; ++k, bp += bump, bplen -= bump) { + int proto_id, normal_len, tpid_format; + + if ((k > 0) && only_one) + break; + if ((bplen < 24) || (0 != (bplen % 4))) + n += sg_scnpr(b + n, blen - n, "%sTransport Id short or not " + "multiple of 4 [length=%d]:\n", lip, blen); + else + n += sg_scnpr(b + n, blen - n, "%sTransport Id of initiator:\n", + lip); + tpid_format = ((bp[0] >> 6) & 0x3); + proto_id = (bp[0] & 0xf); + normal_len = (bplen > TRANSPORT_ID_MIN_LEN) ? + TRANSPORT_ID_MIN_LEN : bplen; + switch (proto_id) { + case TPROTO_FCP: /* Fibre channel */ + n += sg_scnpr(b + n, blen - n, "%s FCP-2 World Wide Name:\n", + lip); + if (0 != tpid_format) + n += sg_scnpr(b + n, blen - n, "%s [Unexpected TPID format: " + "%d]\n", lip, tpid_format); + n += hex2str(bp + 8, 8, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_SPI: /* Scsi Parallel Interface, obsolete */ + n += sg_scnpr(b + n, blen - n, "%s Parallel SCSI initiator SCSI " + "address: 0x%x\n", lip, + sg_get_unaligned_be16(bp + 2)); + if (0 != tpid_format) + n += sg_scnpr(b + n, blen - n, "%s [Unexpected TPID format: " + "%d]\n", lip, tpid_format); + n += sg_scnpr(b + n, blen - n, "%s relative port number (of " + "corresponding target): 0x%x\n", lip, + sg_get_unaligned_be16(bp + 6)); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_SSA: + n += sg_scnpr(b + n, blen - n, "%s SSA (transport id not " + "defined):\n", lip); + n += sg_scnpr(b + n, blen - n, "%s TPID format: %d\n", lip, + tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_1394: /* IEEE 1394 */ + n += sg_scnpr(b + n, blen - n, "%s IEEE 1394 EUI-64 name:\n", + lip); + if (0 != tpid_format) + n += sg_scnpr(b + n, blen - n, "%s [Unexpected TPID format: " + "%d]\n", lip, tpid_format); + n += hex2str(&bp[8], 8, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_SRP: /* SCSI over RDMA */ + n += sg_scnpr(b + n, blen - n, "%s RDMA initiator port " + "identifier:\n", lip); + if (0 != tpid_format) + n += sg_scnpr(b + n, blen - n, "%s [Unexpected TPID format: " + "%d]\n", lip, tpid_format); + n += hex2str(bp + 8, 16, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_ISCSI: + n += sg_scnpr(b + n, blen - n, "%s iSCSI ", lip); + num = sg_get_unaligned_be16(bp + 2); + if (0 == tpid_format) + n += sg_scnpr(b + n, blen - n, "name: %.*s\n", num, &bp[4]); + else if (1 == tpid_format) + n += sg_scnpr(b + n, blen - n, "world wide unique port id: " + "%.*s\n", num, &bp[4]); + else { + n += sg_scnpr(b + n, blen - n, " [Unexpected TPID format: " + "%d]\n", tpid_format); + n += hex2str(bp, num + 4, lip, 0, blen - n, b + n); + } + bump = (((num + 4) < TRANSPORT_ID_MIN_LEN) ? + TRANSPORT_ID_MIN_LEN : num + 4); + break; + case TPROTO_SAS: + ull = sg_get_unaligned_be64(bp + 4); + n += sg_scnpr(b + n, blen - n, "%s SAS address: 0x%" PRIx64 "\n", + lip, ull); + if (0 != tpid_format) + n += sg_scnpr(b + n, blen - n, "%s [Unexpected TPID format: " + "%d]\n", lip, tpid_format); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_ADT: /* no TransportID defined by T10 yet */ + n += sg_scnpr(b + n, blen - n, "%s ADT:\n", lip); + n += sg_scnpr(b + n, blen - n, "%s TPID format: %d\n", lip, + tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_ATA: /* no TransportID defined by T10 yet */ + n += sg_scnpr(b + n, blen - n, "%s ATAPI:\n", lip); + n += sg_scnpr(b + n, blen - n, "%s TPID format: %d\n", lip, + tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_UAS: /* no TransportID defined by T10 yet */ + n += sg_scnpr(b + n, blen - n, "%s UAS:\n", lip); + n += sg_scnpr(b + n, blen - n, "%s TPID format: %d\n", lip, + tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_SOP: + n += sg_scnpr(b + n, blen - n, "%s SOP ", lip); + num = sg_get_unaligned_be16(bp + 2); + if (0 == tpid_format) + n += sg_scnpr(b + n, blen - n, "Routing ID: 0x%x\n", num); + else { + n += sg_scnpr(b + n, blen - n, " [Unexpected TPID format: " + "%d]\n", tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + } + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_PCIE: /* no TransportID defined by T10 yet */ + n += sg_scnpr(b + n, blen - n, "%s PCIE:\n", lip); + n += sg_scnpr(b + n, blen - n, "%s TPID format: %d\n", lip, + tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + case TPROTO_NONE: /* no TransportID defined by T10 */ + n += sg_scnpr(b + n, blen - n, "%s No specified protocol\n", + lip); + /* n += hex2str(bp, ((bplen > 24) ? 24 : bplen), + * lip, 0, blen - n, b + n); */ + bump = TRANSPORT_ID_MIN_LEN; + break; + default: + n += sg_scnpr(b + n, blen - n, "%s unknown protocol id=0x%x " + "TPID format=%d\n", lip, proto_id, tpid_format); + n += hex2str(bp, normal_len, lip, 1, blen - n, b + n); + bump = TRANSPORT_ID_MIN_LEN; + break; + } + } + return b; +} + + +static const char * desig_code_set_str_arr[] = +{ + "Reserved [0x0]", + "Binary", + "ASCII", + "UTF-8", + "Reserved [0x4]", "Reserved [0x5]", "Reserved [0x6]", "Reserved [0x7]", + "Reserved [0x8]", "Reserved [0x9]", "Reserved [0xa]", "Reserved [0xb]", + "Reserved [0xc]", "Reserved [0xd]", "Reserved [0xe]", "Reserved [0xf]", +}; + +const char * +sg_get_desig_code_set_str(int val) +{ + if ((val >= 0) && (val < (int)SG_ARRAY_SIZE(desig_code_set_str_arr))) + return desig_code_set_str_arr[val]; + else + return NULL; +} + +static const char * desig_assoc_str_arr[] = +{ + "Addressed logical unit", + "Target port", /* that received request; unless SCSI ports VPD */ + "Target device that contains addressed lu", + "Reserved [0x3]", +}; + +const char * +sg_get_desig_assoc_str(int val) +{ + if ((val >= 0) && (val < (int)SG_ARRAY_SIZE(desig_assoc_str_arr))) + return desig_assoc_str_arr[val]; + else + return NULL; +} + +static const char * desig_type_str_arr[] = +{ + "Vendor specific [0x0]", + "T10 vendor identification", + "EUI-64 based", + "NAA", + "Relative target port", + "Target port group", /* spc4r09: _primary_ target port group */ + "Logical unit group", + "MD5 logical unit identifier", + "SCSI name string", + "Protocol specific port identifier", /* spc4r36 */ + "UUID identifier", /* spc5r08 */ + "Reserved [0xb]", + "Reserved [0xc]", "Reserved [0xd]", "Reserved [0xe]", "Reserved [0xf]", +}; + +const char * +sg_get_desig_type_str(int val) +{ + if ((val >= 0) && (val < (int)SG_ARRAY_SIZE(desig_type_str_arr))) + return desig_type_str_arr[val]; + else + return NULL; +} + +char * +sg_get_zone_type_str(uint8_t zt, int buff_len, char * buff) +{ + if ((NULL == buff) || (buff_len < 1)) + return NULL; + switch (zt) { + case 1: + sg_scnpr(buff, buff_len, "conventional"); + break; + case 2: + sg_scnpr(buff, buff_len, "sequential write required"); + break; + case 3: + sg_scnpr(buff, buff_len, "sequential write preferred"); + break; + case 4: + sg_scnpr(buff, buff_len, "sequential or before required"); + break; + case 5: + sg_scnpr(buff, buff_len, "gap"); + break; + default: + sg_scnpr(buff, buff_len, "unknown [0x%x]", zt); + break; + } + return buff; +} + + +/* Expects a T10 UUID designator (as found in the Device Identification VPD + * page) pointed to by 'dp'. To not produce an error string in 'b', c_set + * should be 1 (binary) and dlen should be 18. Currently T10 only supports + * locally assigned UUIDs. Writes output to string 'b' of no more than blen + * bytes and returns the number of bytes actually written to 'b' but doesn't + * count the trailing null character it always appends (if blen > 0). 'lip' + * is lead-in string (on each line) than may be NULL. skip_prefix avoids + * outputting: ' Locally assigned UUID: ' before the UUID. */ +int +sg_t10_uuid_desig2str(const uint8_t *dp, int dlen, int c_set, bool do_long, + bool skip_prefix, const char * lip /* lead-in */, + int blen, char * b) +{ + int m; + int n = 0; + + if (NULL == lip) + lip = ""; + if (1 != c_set) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set >>\n", lip); + n += hex2str(dp, dlen, lip, 0, blen - n, b + n); + return n; + } + if ((1 != ((dp[0] >> 4) & 0xf)) || (18 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << expected locally " + "assigned UUID, 16 bytes long >>\n", lip); + n += hex2str(dp, dlen, lip, 0, blen - n, b + n); + return n; + } + if (skip_prefix) { + if (strlen(lip) > 0) + n += sg_scnpr(b + n, blen - n, "%s", lip); + } else + n += sg_scnpr(b + n, blen - n, "%s Locally assigned UUID: ", + lip); + for (m = 0; m < 16; ++m) { + if ((4 == m) || (6 == m) || (8 == m) || (10 == m)) + n += sg_scnpr(b + n, blen - n, "-"); + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)dp[2 + m]); + } + n += sg_scnpr(b + n, blen - n, "\n"); + if (do_long) { + n += sg_scnpr(b + n, blen - n, "%s [0x", lip); + for (m = 0; m < 16; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)dp[2 + m]); + n += sg_scnpr(b + n, blen - n, "]\n"); + } + return n; +} + +int +sg_get_designation_descriptor_str(const char * lip, const uint8_t * ddp, + int dd_len, bool print_assoc, bool do_long, + int blen, char * b) +{ + int m, p_id, piv, c_set, assoc, desig_type, ci_off, c_id, d_id, naa; + int vsi, k, n, dlen; + uint64_t ccc_id, vsei; + const uint8_t * ip; + char e[64]; + const char * cp; + + n = 0; + if (NULL == lip) + lip = ""; + if (dd_len < 4) { + n += sg_scnpr(b + n, blen - n, "%sdesignator desc too short: got " + "length of %d want 4 or more\n", lip, dd_len); + return n; + } + dlen = ddp[3]; + if (dlen > (dd_len - 4)) { + n += sg_scnpr(b + n, blen - n, "%sdesignator too long: says it is %d " + "bytes, but given %d bytes\n", lip, dlen, dd_len - 4); + return n; + } + ip = ddp + 4; + p_id = ((ddp[0] >> 4) & 0xf); + c_set = (ddp[0] & 0xf); + piv = ((ddp[1] & 0x80) ? 1 : 0); + assoc = ((ddp[1] >> 4) & 0x3); + desig_type = (ddp[1] & 0xf); + if (print_assoc && ((cp = sg_get_desig_assoc_str(assoc)))) + n += sg_scnpr(b + n, blen - n, "%s %s:\n", lip, cp); + n += sg_scnpr(b + n, blen - n, "%s designator type: ", lip); + cp = sg_get_desig_type_str(desig_type); + if (cp) + n += sg_scnpr(b + n, blen - n, "%s", cp); + n += sg_scnpr(b + n, blen - n, ", code set: "); + cp = sg_get_desig_code_set_str(c_set); + if (cp) + n += sg_scnpr(b + n, blen - n, "%s", cp); + n += sg_scnpr(b + n, blen - n, "\n"); + if (piv && ((1 == assoc) || (2 == assoc))) + n += sg_scnpr(b + n, blen - n, "%s transport: %s\n", lip, + sg_get_trans_proto_str(p_id, sizeof(e), e)); + switch (desig_type) { + case 0: /* vendor specific */ + k = 0; + if ((1 == c_set) || (2 == c_set)) { /* ASCII or UTF-8 */ + for (k = 0; (k < dlen) && my_isprint(ip[k]); ++k) + ; + if (k >= dlen) + k = 1; + } + if (k) + n += sg_scnpr(b + n, blen - n, "%s vendor specific: %.*s\n", + lip, dlen, ip); + else { + n += sg_scnpr(b + n, blen - n, "%s vendor specific:\n", lip); + n += hex2str(ip, dlen, lip, 0, blen - n, b + n); + } + break; + case 1: /* T10 vendor identification */ + n += sg_scnpr(b + n, blen - n, "%s vendor id: %.8s\n", lip, ip); + if (dlen > 8) { + if ((2 == c_set) || (3 == c_set)) { /* ASCII or UTF-8 */ + n += sg_scnpr(b + n, blen - n, "%s vendor specific: " + "%.*s\n", lip, dlen - 8, ip + 8); + } else { + n += sg_scnpr(b + n, blen - n, "%s vendor specific: 0x", + lip); + for (m = 8; m < dlen; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + } + } + break; + case 2: /* EUI-64 based */ + if (! do_long) { + if ((8 != dlen) && (12 != dlen) && (16 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << expect 8, 12 and " + "16 byte EUI, got %d >>\n", lip, dlen); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + n += sg_scnpr(b + n, blen - n, "%s 0x", lip); + for (m = 0; m < dlen; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + break; + } + n += sg_scnpr(b + n, blen - n, "%s EUI-64 based %d byte " + "identifier\n", lip, dlen); + if (1 != c_set) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set (1) >>\n", lip); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + ci_off = 0; + if (16 == dlen) { /* first 8 bytes are 'Identifier Extension' */ + uint64_t id_ext = sg_get_unaligned_be64(ip); + + ci_off = 8; + n += sg_scnpr(b + n, blen - n, "%s Identifier extension: 0x%" + PRIx64 "\n", lip, id_ext); + } else if ((8 != dlen) && (12 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << can only decode 8, 12 " + "and 16 byte ids >>\n", lip); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + ccc_id = sg_get_unaligned_be64(ip + ci_off); + n += sg_scnpr(b + n, blen - n, "%s IEEE identifier: 0x%" + PRIx64 "\n", lip, ccc_id); + if (12 == dlen) { + d_id = sg_get_unaligned_be32(ip + 8); + n += sg_scnpr(b + n, blen - n, "%s Directory ID: 0x%x\n", + lip, d_id); + } + break; + case 3: /* NAA <n> */ + if (1 != c_set) { + n += sg_scnpr(b + n, blen - n, "%s << unexpected code set " + "%d for NAA >>\n", lip, c_set); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + naa = (ip[0] >> 4) & 0xff; + switch (naa) { + case 2: /* NAA 2: IEEE Extended */ + if (8 != dlen) { + n += sg_scnpr(b + n, blen - n, "%s << unexpected NAA 2 " + "identifier length: 0x%x >>\n", lip, dlen); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + d_id = (((ip[0] & 0xf) << 8) | ip[1]); + c_id = sg_get_unaligned_be24(ip + 2); + vsi = sg_get_unaligned_be24(ip + 5); + if (do_long) { + n += sg_scnpr(b + n, blen - n, "%s NAA 2, vendor " + "specific identifier A: 0x%x\n", lip, d_id); + n += sg_scnpr(b + n, blen - n, "%s AOI: 0x%x\n", lip, + c_id); + n += sg_scnpr(b + n, blen - n, "%s vendor specific " + "identifier B: 0x%x\n", lip, vsi); + n += sg_scnpr(b + n, blen - n, "%s [0x", lip); + for (m = 0; m < 8; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "]\n"); + } + n += sg_scnpr(b + n, blen - n, "%s 0x", lip); + for (m = 0; m < 8; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + break; + case 3: /* NAA 3: Locally assigned */ + if (8 != dlen) { + n += sg_scnpr(b + n, blen - n, "%s << unexpected NAA 3 " + "identifier length: 0x%x >>\n", lip, dlen); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + if (do_long) + n += sg_scnpr(b + n, blen - n, "%s NAA 3, Locally " + "assigned:\n", lip); + n += sg_scnpr(b + n, blen - n, "%s 0x", lip); + for (m = 0; m < 8; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + break; + case 5: /* NAA 5: IEEE Registered */ + if (8 != dlen) { + n += sg_scnpr(b + n, blen - n, "%s << unexpected NAA 5 " + "identifier length: 0x%x >>\n", lip, dlen); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + c_id = (((ip[0] & 0xf) << 20) | (ip[1] << 12) | + (ip[2] << 4) | ((ip[3] & 0xf0) >> 4)); + vsei = ip[3] & 0xf; + for (m = 1; m < 5; ++m) { + vsei <<= 8; + vsei |= ip[3 + m]; + } + if (do_long) { + n += sg_scnpr(b + n, blen - n, "%s NAA 5, AOI: 0x%x\n", + lip, c_id); + n += sg_scnpr(b + n, blen - n, "%s Vendor Specific " + "Identifier: 0x%" PRIx64 "\n", lip, vsei); + n += sg_scnpr(b + n, blen - n, "%s [0x", lip); + for (m = 0; m < 8; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "]\n"); + } else { + n += sg_scnpr(b + n, blen - n, "%s 0x", lip); + for (m = 0; m < 8; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + } + break; + case 6: /* NAA 6: IEEE Registered extended */ + if (16 != dlen) { + n += sg_scnpr(b + n, blen - n, "%s << unexpected NAA 6 " + "identifier length: 0x%x >>\n", lip, dlen); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + c_id = (((ip[0] & 0xf) << 20) | (ip[1] << 12) | + (ip[2] << 4) | ((ip[3] & 0xf0) >> 4)); + vsei = ip[3] & 0xf; + for (m = 1; m < 5; ++m) { + vsei <<= 8; + vsei |= ip[3 + m]; + } + if (do_long) { + n += sg_scnpr(b + n, blen - n, "%s NAA 6, AOI: 0x%x\n", + lip, c_id); + n += sg_scnpr(b + n, blen - n, "%s Vendor Specific " + "Identifier: 0x%" PRIx64 "\n", lip, vsei); + vsei = sg_get_unaligned_be64(ip + 8); + n += sg_scnpr(b + n, blen - n, "%s Vendor Specific " + "Identifier Extension: 0x%" PRIx64 "\n", lip, + vsei); + n += sg_scnpr(b + n, blen - n, "%s [0x", lip); + for (m = 0; m < 16; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "]\n"); + } else { + n += sg_scnpr(b + n, blen - n, "%s 0x", lip); + for (m = 0; m < 16; ++m) + n += sg_scnpr(b + n, blen - n, "%02x", (my_uint)ip[m]); + n += sg_scnpr(b + n, blen - n, "\n"); + } + break; + default: + n += sg_scnpr(b + n, blen - n, "%s << unexpected NAA [0x%x] " + ">>\n", lip, naa); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + break; + case 4: /* Relative target port */ + if ((1 != c_set) || (1 != assoc) || (4 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set, target port association, length 4 >>\n", + lip); + n += hex2str(ip, dlen, "", 1, blen - n, b + n); + break; + } + d_id = sg_get_unaligned_be16(ip + 2); + n += sg_scnpr(b + n, blen - n, "%s Relative target port: 0x%x\n", + lip, d_id); + break; + case 5: /* (primary) Target port group */ + if ((1 != c_set) || (1 != assoc) || (4 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set, target port association, length 4 >>\n", + lip); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + d_id = sg_get_unaligned_be16(ip + 2); + n += sg_scnpr(b + n, blen - n, "%s Target port group: 0x%x\n", + lip, d_id); + break; + case 6: /* Logical unit group */ + if ((1 != c_set) || (0 != assoc) || (4 != dlen)) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set, logical unit association, length 4 >>\n", + lip); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + d_id = sg_get_unaligned_be16(ip + 2); + n += sg_scnpr(b + n, blen - n, "%s Logical unit group: 0x%x\n", + lip, d_id); + break; + case 7: /* MD5 logical unit identifier */ + if ((1 != c_set) || (0 != assoc)) { + n += sg_scnpr(b + n, blen - n, "%s << expected binary " + "code_set, logical unit association >>\n", lip); + n += hex2str(ip, dlen, "", 1, blen - n, b + n); + break; + } + n += sg_scnpr(b + n, blen - n, "%s MD5 logical unit " + "identifier:\n", lip); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + case 8: /* SCSI name string */ + if (3 != c_set) { /* accept ASCII as subset of UTF-8 */ + if (2 == c_set) { + if (do_long) + n += sg_scnpr(b + n, blen - n, "%s << expected " + "UTF-8, use ASCII >>\n", lip); + } else { + n += sg_scnpr(b + n, blen - n, "%s << expected UTF-8 " + "code_set >>\n", lip); + n += hex2str(ip, dlen, lip, 0, blen - n, b + n); + break; + } + } + n += sg_scnpr(b + n, blen - n, "%s SCSI name string:\n", lip); + /* does %s print out UTF-8 ok?? + * Seems to depend on the locale. Looks ok here with my + * locale setting: en_AU.UTF-8 + */ + n += sg_scnpr(b + n, blen - n, "%s %.*s\n", lip, dlen, + (const char *)ip); + break; + case 9: /* Protocol specific port identifier */ + /* added in spc4r36, PIV must be set, proto_id indicates */ + /* whether UAS (USB) or SOP (PCIe) or ... */ + if (! piv) + n += sg_scnpr(b + n, blen - n, " %s >>>> Protocol specific " + "port identifier expects protocol\n%s " + "identifier to be valid and it is not\n", lip, lip); + if (TPROTO_UAS == p_id) { + n += sg_scnpr(b + n, blen - n, "%s USB device address: " + "0x%x\n", lip, 0x7f & ip[0]); + n += sg_scnpr(b + n, blen - n, "%s USB interface number: " + "0x%x\n", lip, ip[2]); + } else if (TPROTO_SOP == p_id) { + n += sg_scnpr(b + n, blen - n, "%s PCIe routing ID, bus " + "number: 0x%x\n", lip, ip[0]); + n += sg_scnpr(b + n, blen - n, "%s function number: " + "0x%x\n", lip, ip[1]); + n += sg_scnpr(b + n, blen - n, "%s [or device number: " + "0x%x, function number: 0x%x]\n", lip, + (0x1f & (ip[1] >> 3)), 0x7 & ip[1]); + } else + n += sg_scnpr(b + n, blen - n, "%s >>>> unexpected protocol " + "identifier: %s\n%s with Protocol " + "specific port identifier\n", lip, + sg_get_trans_proto_str(p_id, sizeof(e), e), lip); + break; + case 0xa: /* UUID identifier */ + n += sg_t10_uuid_desig2str(ip, dlen, c_set, do_long, false, lip, + blen - n, b + n); + break; + default: /* reserved */ + n += sg_scnpr(b + n, blen - n, "%s reserved designator=0x%x\n", + lip, desig_type); + n += hex2str(ip, dlen, lip, 1, blen - n, b + n); + break; + } + return n; +} + +static int +decode_sks(const char * lip, const uint8_t * descp, int add_d_len, + int sense_key, bool * processedp, int blen, char * b) +{ + int progress, pr, rem, n; + + n = 0; + if (NULL == lip) + lip = ""; + switch (sense_key) { + case SPC_SK_ILLEGAL_REQUEST: + if (add_d_len < 6) { + n += sg_scnpr(b + n, blen - n, "Field pointer: "); + goto too_short; + } + /* abbreviate to fit on one line */ + n += sg_scnpr(b + n, blen - n, "Field pointer:\n"); + n += sg_scnpr(b + n, blen - n, "%s Error in %s: byte %d", lip, + (descp[4] & 0x40) ? "Command" : "Data parameters", + sg_get_unaligned_be16(descp + 5)); + if (descp[4] & 0x08) { + n += sg_scnpr(b + n, blen - n, " bit %d\n", descp[4] & 0x07); + } else + n += sg_scnpr(b + n, blen - n, "\n"); + break; + case SPC_SK_HARDWARE_ERROR: + case SPC_SK_MEDIUM_ERROR: + case SPC_SK_RECOVERED_ERROR: + n += sg_scnpr(b + n, blen - n, "Actual retry count: "); + if (add_d_len < 6) + goto too_short; + n += sg_scnpr(b + n, blen - n,"%u\n", + sg_get_unaligned_be16(descp + 5)); + break; + case SPC_SK_NO_SENSE: + case SPC_SK_NOT_READY: + n += sg_scnpr(b + n, blen - n, "Progress indication: "); + if (add_d_len < 6) + goto too_short; + progress = sg_get_unaligned_be16(descp + 5); + pr = (progress * 100) / 65536; + rem = ((progress * 100) % 65536) / 656; + n += sg_scnpr(b + n, blen - n, "%d.%02d%%\n", pr, rem); + break; + case SPC_SK_COPY_ABORTED: + n += sg_scnpr(b + n, blen - n, "Segment pointer:\n"); + if (add_d_len < 6) + goto too_short; + n += sg_scnpr(b + n, blen - n, "%s Relative to start of %s, " + "byte %d", lip, (descp[4] & 0x20) ? + "segment descriptor" : "parameter list", + sg_get_unaligned_be16(descp + 5)); + if (descp[4] & 0x08) + n += sg_scnpr(b + n, blen - n, " bit %d\n", descp[4] & 0x07); + else + n += sg_scnpr(b + n, blen - n, "\n"); + break; + case SPC_SK_UNIT_ATTENTION: + n += sg_scnpr(b + n, blen - n, "Unit attention condition queue:\n"); + n += sg_scnpr(b + n, blen - n, "%s overflow flag is %d\n", lip, + !!(descp[4] & 0x1)); + break; + default: + n += sg_scnpr(b + n, blen - n, "Sense_key: 0x%x unexpected\n", + sense_key); + *processedp = false; + break; + } + return n; + +too_short: + n += sg_scnpr(b + n, blen - n, "%s\n", " >> descriptor too short"); + *processedp = false; + return n; +} + +#define TPGS_STATE_OPTIMIZED 0x0 +#define TPGS_STATE_NONOPTIMIZED 0x1 +#define TPGS_STATE_STANDBY 0x2 +#define TPGS_STATE_UNAVAILABLE 0x3 +#define TPGS_STATE_OFFLINE 0xe +#define TPGS_STATE_TRANSITIONING 0xf + +static int +decode_tpgs_state(int st, char * b, int blen) +{ + switch (st) { + case TPGS_STATE_OPTIMIZED: + return sg_scnpr(b, blen, "active/optimized"); + case TPGS_STATE_NONOPTIMIZED: + return sg_scnpr(b, blen, "active/non optimized"); + case TPGS_STATE_STANDBY: + return sg_scnpr(b, blen, "standby"); + case TPGS_STATE_UNAVAILABLE: + return sg_scnpr(b, blen, "unavailable"); + case TPGS_STATE_OFFLINE: + return sg_scnpr(b, blen, "offline"); + case TPGS_STATE_TRANSITIONING: + return sg_scnpr(b, blen, "transitioning between states"); + default: + return sg_scnpr(b, blen, "unknown: 0x%x", st); + } +} + +static int +uds_referral_descriptor_str(char * b, int blen, const uint8_t * dp, + int alen, const char * lip) +{ + int n = 0; + int dlen = alen - 2; + int k, j, g, f; + const uint8_t * tp; + char c[40]; + + if (NULL == lip) + lip = ""; + n += sg_scnpr(b + n, blen - n, "%s Not all referrals: %d\n", lip, + !!(dp[2] & 0x1)); + dp += 4; + for (k = 0, f = 1; (k + 4) < dlen; k += g, dp += g, ++f) { + int ntpgd = dp[3]; + uint64_t ull; + + g = (ntpgd * 4) + 20; + n += sg_scnpr(b + n, blen - n, "%s Descriptor %d\n", lip, f); + if ((k + g) > dlen) { + n += sg_scnpr(b + n, blen - n, "%s truncated descriptor, " + "stop\n", lip); + return n; + } + ull = sg_get_unaligned_be64(dp + 4); + n += sg_scnpr(b + n, blen - n, "%s first uds LBA: 0x%" PRIx64 + "\n", lip, ull); + ull = sg_get_unaligned_be64(dp + 12); + n += sg_scnpr(b + n, blen - n, "%s last uds LBA: 0x%" PRIx64 + "\n", lip, ull); + for (j = 0; j < ntpgd; ++j) { + tp = dp + 20 + (j * 4); + decode_tpgs_state(tp[0] & 0xf, c, sizeof(c)); + n += sg_scnpr(b + n, blen - n, "%s tpg: %d state: %s\n", + lip, sg_get_unaligned_be16(tp + 2), c); + } + } + return n; +} + +static const char * dd_usage_reason_str_arr[] = { + "Unknown", + "resend this and further commands to:", + "resend this command to:", + "new subsidiary lu added to this administrative lu:", + "administrative lu associated with a preferred binding:", + }; + + +/* Decode descriptor format sense descriptors (assumes sense buffer is + * in descriptor format). 'leadin' is string prepended to each line written + * to 'b', NULL treated as "". Returns the number of bytes written to 'b' + * excluding the trailing '\0'. If problem, returns 0. */ +int +sg_get_sense_descriptors_str(const char * lip, const uint8_t * sbp, + int sb_len, int blen, char * b) +{ + int add_sb_len, desc_len, k, j, sense_key; + int n, progress, pr, rem; + uint16_t sct_sc; + bool processed; + const uint8_t * descp; + char z[64]; + static const char * dtsp = " >> descriptor too short"; + static const char * eccp = "Extended copy command"; + static const char * ddp = "destination device"; + + if ((NULL == b) || (blen <= 0)) + return 0; + b[0] = '\0'; + if (lip) + sg_scnpr(z, sizeof(z), "%.60s ", lip); + else + sg_scnpr(z, sizeof(z), " "); + if ((sb_len < 8) || (0 == (add_sb_len = sbp[7]))) + return 0; + add_sb_len = (add_sb_len < (sb_len - 8)) ? add_sb_len : (sb_len - 8); + sense_key = (sbp[1] & 0xf); + + for (descp = (sbp + 8), k = 0, n = 0; + (k < add_sb_len) && (n < blen); + k += desc_len, descp += desc_len) { + int add_d_len = (k < (add_sb_len - 1)) ? descp[1] : -1; + + if ((k + add_d_len + 2) > add_sb_len) + add_d_len = add_sb_len - k - 2; + desc_len = add_d_len + 2; + n += sg_scnpr(b + n, blen - n, "%s Descriptor type: ", lip); + processed = true; + switch (descp[0]) { + case 0: + n += sg_scnpr(b + n, blen - n, "Information: "); + if (add_d_len >= 10) { + if (! (0x80 & descp[2])) + n += sg_scnpr(b + n, blen - n, "Valid=0 (-> vendor " + "specific) "); + n += sg_scnpr(b + n, blen - n, "0x"); + for (j = 0; j < 8; ++j) + n += sg_scnpr(b + n, blen - n, "%02x", descp[4 + j]); + n += sg_scnpr(b + n, blen - n, "\n"); + } else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 1: + n += sg_scnpr(b + n, blen - n, "Command specific: "); + if (add_d_len >= 10) { + n += sg_scnpr(b + n, blen - n, "0x"); + for (j = 0; j < 8; ++j) + n += sg_scnpr(b + n, blen - n, "%02x", descp[4 + j]); + n += sg_scnpr(b + n, blen - n, "\n"); + } else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 2: /* Sense Key Specific */ + n += sg_scnpr(b + n, blen - n, "Sense key specific: "); + n += decode_sks(lip, descp, add_d_len, sense_key, &processed, + blen - n, b + n); + break; + case 3: + n += sg_scnpr(b + n, blen - n, "Field replaceable unit code: "); + if (add_d_len >= 2) + n += sg_scnpr(b + n, blen - n, "0x%x\n", descp[3]); + else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 4: + n += sg_scnpr(b + n, blen - n, "Stream commands: "); + if (add_d_len >= 2) { + if (descp[3] & 0x80) + n += sg_scnpr(b + n, blen - n, "FILEMARK"); + if (descp[3] & 0x40) + n += sg_scnpr(b + n, blen - n, "End Of Medium (EOM)"); + if (descp[3] & 0x20) + n += sg_scnpr(b + n, blen - n, "Incorrect Length " + "Indicator (ILI)"); + n += sg_scnpr(b + n, blen - n, "\n"); + } else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 5: + n += sg_scnpr(b + n, blen - n, "Block commands: "); + if (add_d_len >= 2) + n += sg_scnpr(b + n, blen - n, "Incorrect Length Indicator " + "(ILI) %s\n", + (descp[3] & 0x20) ? "set" : "clear"); + else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 6: + n += sg_scnpr(b + n, blen - n, "OSD object identification\n"); + processed = false; + break; + case 7: + n += sg_scnpr(b + n, blen - n, "OSD response integrity check " + "value\n"); + processed = false; + break; + case 8: + n += sg_scnpr(b + n, blen - n, "OSD attribute identification\n"); + processed = false; + break; + case 9: /* this is defined in SAT (SAT-2) */ + n += sg_scnpr(b + n, blen - n, "ATA Status Return: "); + if (add_d_len >= 12) { + int extend, count; + + extend = descp[2] & 1; + count = descp[5] + (extend ? (descp[4] << 8) : 0); + n += sg_scnpr(b + n, blen - n, "extend=%d error=0x%x \n%s" + " count=0x%x ", extend, descp[3], lip, + count); + if (extend) + n += sg_scnpr(b + n, blen - n, + "lba=0x%02x%02x%02x%02x%02x%02x ", + descp[10], descp[8], descp[6], descp[11], + descp[9], descp[7]); + else + n += sg_scnpr(b + n, blen - n, "lba=0x%02x%02x%02x ", + descp[11], descp[9], descp[7]); + n += sg_scnpr(b + n, blen - n, "device=0x%x status=0x%x\n", + descp[12], descp[13]); + } else { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + } + break; + case 0xa: + /* Added in SPC-4 rev 17, became 'Another ...' in rev 34 */ + n += sg_scnpr(b + n, blen - n, "Another progress indication: "); + if (add_d_len < 6) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + progress = sg_get_unaligned_be16(descp + 6); + pr = (progress * 100) / 65536; + rem = ((progress * 100) % 65536) / 656; + n += sg_scnpr(b + n, blen - n, "%d.02%d%%\n", pr, rem); + n += sg_scnpr(b + n, blen - n, "%s [sense_key=0x%x " + "asc,ascq=0x%x,0x%x]\n", lip, descp[2], descp[3], + descp[4]); + break; + case 0xb: /* Added in SPC-4 rev 23, defined in SBC-3 rev 22 */ + n += sg_scnpr(b + n, blen - n, "User data segment referral: "); + if (add_d_len < 2) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + n += sg_scnpr(b + n, blen - n, "\n"); + n += uds_referral_descriptor_str(b + n, blen - n, descp, + add_d_len, lip); + break; + case 0xc: /* Added in SPC-4 rev 28 */ + n += sg_scnpr(b + n, blen - n, "Forwarded sense data\n"); + if (add_d_len < 2) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + n += sg_scnpr(b + n, blen - n, "%s FSDT: %s\n", lip, + (descp[2] & 0x80) ? "set" : "clear"); + j = descp[2] & 0xf; + n += sg_scnpr(b + n, blen - n, "%s Sense data source: ", lip); + switch (j) { + case 0: + n += sg_scnpr(b + n, blen - n, "%s source device\n", eccp); + break; + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + n += sg_scnpr(b + n, blen - n, "%s %s %d\n", eccp, ddp, j - 1); + break; + default: + n += sg_scnpr(b + n, blen - n, "unknown [%d]\n", j); + } + { + char c[480]; + + sg_get_scsi_status_str(descp[3], sizeof(c) - 1, c); + c[sizeof(c) - 1] = '\0'; + n += sg_scnpr(b + n, blen - n, "%s Forwarded status: %s\n", + lip, c); + if (add_d_len > 2) { + /* recursing; hope not to get carried away */ + n += sg_scnpr(b + n, blen - n, "%s vvvvvvvvvvvvvvvv\n", + lip); + sg_get_sense_str(lip, descp + 4, add_d_len - 2, false, + sizeof(c), c); + n += sg_scnpr(b + n, blen - n, "%s", c); + n += sg_scnpr(b + n, blen - n, "%s ^^^^^^^^^^^^^^^^\n", + lip); + } + } + break; + case 0xd: /* Added in SBC-3 rev 36d */ + /* this descriptor combines descriptors 0, 1, 2 and 3 */ + n += sg_scnpr(b + n, blen - n, "Direct-access block device\n"); + if (add_d_len < 28) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + if (0x20 & descp[2]) + n += sg_scnpr(b + n, blen - n, "%s ILI (incorrect length " + "indication) set\n", lip); + if (0x80 & descp[4]) { + n += sg_scnpr(b + n, blen - n, "%s Sense key specific: ", + lip); + n += decode_sks(lip, descp, add_d_len, sense_key, &processed, + blen - n, b + n); + } + n += sg_scnpr(b + n, blen - n, "%s Field replaceable unit " + "code: 0x%x\n", lip, descp[7]); + if (0x80 & descp[2]) { + n += sg_scnpr(b + n, blen - n, "%s Information: 0x", lip); + for (j = 0; j < 8; ++j) + n += sg_scnpr(b + n, blen - n, "%02x", descp[8 + j]); + n += sg_scnpr(b + n, blen - n, "\n"); + } + n += sg_scnpr(b + n, blen - n, "%s Command specific: 0x", lip); + for (j = 0; j < 8; ++j) + n += sg_scnpr(b + n, blen - n, "%02x", descp[16 + j]); + n += sg_scnpr(b + n, blen - n, "\n"); + break; + case 0xe: /* Added in SPC-5 rev 6 (for Bind/Unbind) */ + n += sg_scnpr(b + n, blen - n, "Device designation\n"); + j = (int)SG_ARRAY_SIZE(dd_usage_reason_str_arr); + if (descp[3] < j) + n += sg_scnpr(b + n, blen - n, "%s Usage reason: %s\n", + lip, dd_usage_reason_str_arr[descp[3]]); + else + n += sg_scnpr(b + n, blen - n, "%s Usage reason: " + "reserved[%d]\n", lip, descp[3]); + n += sg_get_designation_descriptor_str(z, descp + 4, descp[1] - 2, + true, false, blen - n, + b + n); + break; + case 0xf: /* Added in SPC-5 rev 10 (for Write buffer) */ + n += sg_scnpr(b + n, blen - n, "Microcode activation "); + if (add_d_len < 6) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + progress = sg_get_unaligned_be16(descp + 6); + n += sg_scnpr(b + n, blen - n, "time: "); + if (0 == progress) + n += sg_scnpr(b + n, blen - n, "unknown\n"); + else + n += sg_scnpr(b + n, blen - n, "%d seconds\n", progress); + break; + case 0xde: /* NVME Status Field; vendor (sg3_utils) specific */ + n += sg_scnpr(b + n, blen - n, "NVMe Status: "); + if (add_d_len < 6) { + n += sg_scnpr(b + n, blen - n, "%s\n", dtsp); + processed = false; + break; + } + n += sg_scnpr(b + n, blen - n, "DNR=%d, M=%d, ", + (int)!!(0x80 & descp[5]), (int)!!(0x40 & descp[5])); + sct_sc = sg_get_unaligned_be16(descp + 6); + n += sg_scnpr(b + n, blen - n, "SCT_SC=0x%x\n", sct_sc); + if (sct_sc > 0) { + char d[80]; + + n += sg_scnpr(b + n, blen - n, " %s\n", + sg_get_nvme_cmd_status_str(sct_sc, sizeof(d), d)); + } + break; + default: + if (descp[0] >= 0x80) + n += sg_scnpr(b + n, blen - n, "Vendor specific [0x%x]\n", + descp[0]); + else + n += sg_scnpr(b + n, blen - n, "Unknown [0x%x]\n", descp[0]); + processed = false; + break; + } + if (! processed) { + if (add_d_len > 0) { + n += sg_scnpr(b + n, blen - n, "%s ", lip); + for (j = 0; j < add_d_len; ++j) { + if ((j > 0) && (0 == (j % 24))) + n += sg_scnpr(b + n, blen - n, "\n%s ", lip); + n += sg_scnpr(b + n, blen - n, "%02x ", descp[j + 2]); + } + n += sg_scnpr(b + n, blen - n, "\n"); + } + } + if (add_d_len < 0) + n += sg_scnpr(b + n, blen - n, "%s short descriptor\n", lip); + } + return n; +} + +/* Decode SAT ATA PASS-THROUGH fixed format sense. Shows "+" after 'count' + * and/or 'lba' values to indicate that not all data in those fields is shown. + * That extra field information may be available in the ATA pass-through + * results log page parameter with the corresponding 'log_index'. */ +static int +sg_get_sense_sat_pt_fixed_str(const char * lip, const uint8_t * sp, + int slen, int blen, char * b) +{ + int n = 0; + bool extend, count_upper_nz, lba_upper_nz; + + if ((blen < 1) || (slen < 12)) + return n; + if (NULL == lip) + lip = ""; + if (SPC_SK_RECOVERED_ERROR != (0xf & sp[2])) + n += sg_scnpr(b + n, blen - n, "%s >> expected Sense key: Recovered " + "Error ??\n", lip); + /* Fixed sense command-specific information field starts at sp + 8 */ + extend = !!(0x80 & sp[8]); + count_upper_nz = !!(0x40 & sp[8]); + lba_upper_nz = !!(0x20 & sp[8]); + /* Fixed sense information field starts at sp + 3 */ + n += sg_scnpr(b + n, blen - n, "%s error=0x%x, status=0x%x, " + "device=0x%x, count(7:0)=0x%x%c\n", lip, sp[3], sp[4], + sp[5], sp[6], (count_upper_nz ? '+' : ' ')); + n += sg_scnpr(b + n, blen - n, "%s extend=%d, log_index=0x%x, " + "lba_high,mid,low(7:0)=0x%x,0x%x,0x%x%c\n", lip, + (int)extend, (0xf & sp[8]), sp[11], sp[10], sp[9], + (lba_upper_nz ? '+' : ' ')); + return n; +} + +/* Fetch sense information */ +int +sg_get_sense_str(const char * lip, const uint8_t * sbp, int sb_len, + bool raw_sinfo, int cblen, char * cbp) +{ + bool descriptor_format = false; + bool sdat_ovfl = false; + bool valid_info_fld; + int len, progress, n, r, pr, rem, blen; + unsigned int info; + uint8_t resp_code; + const char * ebp = NULL; + char ebuff[64]; + char b[256]; + struct sg_scsi_sense_hdr ssh; + + if ((NULL == cbp) || (cblen <= 0)) + return 0; + else if (1 == cblen) { + cbp[0] = '\0'; + return 0; + } + blen = sizeof(b); + n = 0; + if (NULL == lip) + lip = ""; + if ((NULL == sbp) || (sb_len < 1)) { + n += sg_scnpr(cbp, cblen, "%s >>> sense buffer empty\n", lip); + return n; + } + resp_code = 0x7f & sbp[0]; + valid_info_fld = !!(sbp[0] & 0x80); + len = sb_len; + if (sg_scsi_normalize_sense(sbp, sb_len, &ssh)) { + switch (ssh.response_code) { + case 0x70: /* fixed, current */ + ebp = "Fixed format, current"; + len = (sb_len > 7) ? (sbp[7] + 8) : sb_len; + len = (len > sb_len) ? sb_len : len; + sdat_ovfl = (len > 2) ? !!(sbp[2] & 0x10) : false; + break; + case 0x71: /* fixed, deferred */ + /* error related to a previous command */ + ebp = "Fixed format, <<<deferred>>>"; + len = (sb_len > 7) ? (sbp[7] + 8) : sb_len; + len = (len > sb_len) ? sb_len : len; + sdat_ovfl = (len > 2) ? !!(sbp[2] & 0x10) : false; + break; + case 0x72: /* descriptor, current */ + descriptor_format = true; + ebp = "Descriptor format, current"; + sdat_ovfl = (sb_len > 4) ? !!(sbp[4] & 0x80) : false; + break; + case 0x73: /* descriptor, deferred */ + descriptor_format = true; + ebp = "Descriptor format, <<<deferred>>>"; + sdat_ovfl = (sb_len > 4) ? !!(sbp[4] & 0x80) : false; + break; + case 0x0: + ebp = "Response code: 0x0 (?)"; + break; + default: + sg_scnpr(ebuff, sizeof(ebuff), "Unknown response code: 0x%x", + ssh.response_code); + ebp = ebuff; + break; + } + n += sg_scnpr(cbp + n, cblen - n, "%s%s; Sense key: %s\n", lip, ebp, + sg_lib_sense_key_desc[ssh.sense_key]); + if (sdat_ovfl) + n += sg_scnpr(cbp + n, cblen - n, "%s<<<Sense data overflow " + "(SDAT_OVFL)>>>\n", lip); + if (descriptor_format) { + n += sg_scnpr(cbp + n, cblen - n, "%s%s\n", lip, + sg_get_asc_ascq_str(ssh.asc, ssh.ascq, blen, b)); + n += sg_get_sense_descriptors_str(lip, sbp, len, + cblen - n, cbp + n); + } else if ((len > 12) && (0 == ssh.asc) && + (ASCQ_ATA_PT_INFO_AVAILABLE == ssh.ascq)) { + /* SAT ATA PASS-THROUGH fixed format */ + n += sg_scnpr(cbp + n, cblen - n, "%s%s\n", lip, + sg_get_asc_ascq_str(ssh.asc, ssh.ascq, blen, b)); + n += sg_get_sense_sat_pt_fixed_str(lip, sbp, len, + cblen - n, cbp + n); + } else if (len > 2) { /* fixed format */ + if (len > 12) + n += sg_scnpr(cbp + n, cblen - n, "%s%s\n", lip, + sg_get_asc_ascq_str(ssh.asc, ssh.ascq, blen, b)); + r = 0; + if (strlen(lip) > 0) + r += sg_scnpr(b + r, blen - r, "%s", lip); + if (len > 6) { + info = sg_get_unaligned_be32(sbp + 3); + if (valid_info_fld) + r += sg_scnpr(b + r, blen - r, " Info fld=0x%x [%u] ", + info, info); + else if (info > 0) + r += sg_scnpr(b + r, blen - r, " Valid=0, Info fld=0x%x " + "[%u] ", info, info); + } else + info = 0; + if (sbp[2] & 0xe0) { + if (sbp[2] & 0x80) + r += sg_scnpr(b + r, blen - r, " FMK"); + /* current command has read a filemark */ + if (sbp[2] & 0x40) + r += sg_scnpr(b + r, blen - r, " EOM"); + /* end-of-medium condition exists */ + if (sbp[2] & 0x20) + r += sg_scnpr(b + r, blen - r, " ILI"); + /* incorrect block length requested */ + r += sg_scnpr(b + r, blen - r, "\n"); + } else if (valid_info_fld || (info > 0)) + r += sg_scnpr(b + r, blen - r, "\n"); + if ((len >= 14) && sbp[14]) + r += sg_scnpr(b + r, blen - r, "%s Field replaceable unit " + "code: %d\n", lip, sbp[14]); + if ((len >= 18) && (sbp[15] & 0x80)) { + /* sense key specific decoding */ + switch (ssh.sense_key) { + case SPC_SK_ILLEGAL_REQUEST: + r += sg_scnpr(b + r, blen - r, "%s Sense Key Specific: " + "Error in %s: byte %d", lip, + ((sbp[15] & 0x40) ? + "Command" : "Data parameters"), + sg_get_unaligned_be16(sbp + 16)); + if (sbp[15] & 0x08) + r += sg_scnpr(b + r, blen - r, " bit %d\n", + sbp[15] & 0x07); + else + r += sg_scnpr(b + r, blen - r, "\n"); + break; + case SPC_SK_NO_SENSE: + case SPC_SK_NOT_READY: + progress = sg_get_unaligned_be16(sbp + 16); + pr = (progress * 100) / 65536; + rem = ((progress * 100) % 65536) / 656; + r += sg_scnpr(b + r, blen - r, "%s Progress indication: " + "%d.%02d%%\n", lip, pr, rem); + break; + case SPC_SK_HARDWARE_ERROR: + case SPC_SK_MEDIUM_ERROR: + case SPC_SK_RECOVERED_ERROR: + r += sg_scnpr(b + r, blen - r, "%s Actual retry count: " + "0x%02x%02x\n", lip, sbp[16], sbp[17]); + break; + case SPC_SK_COPY_ABORTED: + r += sg_scnpr(b + r, blen - r, "%s Segment pointer: ", + lip); + r += sg_scnpr(b + r, blen - r, "Relative to start of %s, " + "byte %d", ((sbp[15] & 0x20) ? + "segment descriptor" : "parameter list"), + sg_get_unaligned_be16(sbp + 16)); + if (sbp[15] & 0x08) + r += sg_scnpr(b + r, blen - r, " bit %d\n", + sbp[15] & 0x07); + else + r += sg_scnpr(b + r, blen - r, "\n"); + break; + case SPC_SK_UNIT_ATTENTION: + r += sg_scnpr(b + r, blen - r, "%s Unit attention " + "condition queue: ", lip); + r += sg_scnpr(b + r, blen - r, "overflow flag is %d\n", + !!(sbp[15] & 0x1)); + break; + default: + r += sg_scnpr(b + r, blen - r, "%s Sense_key: 0x%x " + "unexpected\n", lip, ssh.sense_key); + break; + } + } + if (r > 0) + n += sg_scnpr(cbp + n, cblen - n, "%s", b); + } else + n += sg_scnpr(cbp + n, cblen - n, "%s fixed descriptor length " + "too short, len=%d\n", lip, len); + } else { /* unable to normalise sense buffer, something irregular */ + if (sb_len < 4) { /* Too short */ + n += sg_scnpr(cbp + n, cblen - n, "%ssense buffer too short (4 " + "byte minimum)\n", lip); + goto check_raw; + } + if (0x7f == resp_code) { /* Vendor specific */ + n += sg_scnpr(cbp + n, cblen - n, "%sVendor specific sense " + "buffer, in hex:\n", lip); + n += hex2str(sbp, sb_len, lip, -1, cblen - n, cbp + n); + return n; /* no need to check raw, just output in hex */ + } + /* non-extended SCSI-1 sense data ?? */ + r = 0; + if (strlen(lip) > 0) + r += sg_scnpr(b + r, blen - r, "%s", lip); + r += sg_scnpr(b + r, blen - r, "Probably uninitialized data.\n%s " + "Try to view as SCSI-1 non-extended sense:\n", lip); + r += sg_scnpr(b + r, blen - r, " AdValid=%d Error class=%d Error " + "code=%d\n", valid_info_fld, ((sbp[0] >> 4) & 0x7), + (sbp[0] & 0xf)); + if (valid_info_fld) + sg_scnpr(b + r, blen - r, "%s lba=0x%x\n", lip, + sg_get_unaligned_be24(sbp + 1) & 0x1fffff); + n += sg_scnpr(cbp + n, cblen - n, "%s\n", b); + } +check_raw: + if (raw_sinfo) { + int calculated_len; + char z[64]; + + n += sg_scnpr(cbp + n, cblen - n, "%s Raw sense data (in hex), " + "sb_len=%d", lip, sb_len); + if (n >= (cblen - 1)) + return n; + if ((sb_len > 7) && (sbp[0] >= 0x70) && (sbp[0] < 0x74)) { + calculated_len = sbp[7] + 8; + n += sg_scnpr(cbp + n, cblen - n, ", calculated_len=%d\n", + calculated_len); + } else { + calculated_len = sb_len; + n += sg_scnpr(cbp + n, cblen - n, "\n"); + } + if (n >= (cblen - 1)) + return n; + + sg_scnpr(z, sizeof(z), "%.50s ", lip); + n += hex2str(sbp, calculated_len, z, -1, cblen - n, cbp + n); + } + return n; +} + +/* Print sense information */ +void +sg_print_sense(const char * leadin, const uint8_t * sbp, int sb_len, + bool raw_sinfo) +{ + uint32_t pg_sz = sg_get_page_size(); + char *cp; + uint8_t *free_cp; + + cp = (char *)sg_memalign(pg_sz, pg_sz, &free_cp, false); + if (NULL == cp) + return; + sg_get_sense_str(leadin, sbp, sb_len, raw_sinfo, pg_sz, cp); + pr2ws("%s", cp); + free(free_cp); +} + +/* This examines exit_status and if an error message is known it is output + * as a string to 'b' and true is returned. If 'longer' is true and extra + * information is available then it is added to the output. If no error + * message is available a null character is output and false is returned. + * If exit_status is zero (no error) and 'longer' is true then the string + * 'No errors' is output; if 'longer' is false then a null character is + * output; in both cases true is returned. If exit_status is negative then + * a null character is output and false is returned. All messages are a + * single line (less than 80 characters) with no trailing LF. The output + * string including the trailing null character is no longer than b_len. + * exit_status represents the Unix exit status available after a utility + * finishes executing (for whatever reason). */ +bool sg_exit2str(int exit_status, bool longer, int b_len, char *b) +{ + const struct sg_value_2names_t * ess = sg_exit_str_arr; + + if ((b_len < 1) || (NULL == b)) + return false; + /* if there is a valid buffer, initialize it to a valid empty string */ + b[0] = '\0'; + if (exit_status < 0) + return false; + else if ((0 == exit_status) || (SG_LIB_OK_FALSE == exit_status)) { + if (longer) + goto fini; + return true; + } + + if ((exit_status > SG_LIB_OS_BASE_ERR) && /* 51 to 96 inclusive */ + (exit_status < SG_LIB_CAT_MALFORMED)) { + snprintf(b, b_len, "%s%s", (longer ? "OS error: " : ""), + safe_strerror(exit_status - SG_LIB_OS_BASE_ERR)); + return true; + } else if ((exit_status > 128) && (exit_status < 255)) { + snprintf(b, b_len, "Utility stopped/aborted by signal number: %d", + exit_status - 128); + return true; + } +fini: + for ( ; ess->name; ++ess) { + if (exit_status == ess->value) + break; + } + if (ess->name) { + if (longer && ess->name2) + snprintf(b, b_len, "%s, %s", ess->name, ess->name2); + else + snprintf(b, b_len, "%s", ess->name); + return true; + } + return false; +} + +static bool +sg_if_can2fp(const char * leadin, int exit_status, FILE * fp) +{ + char b[256]; + const char * s = leadin ? leadin : ""; + + if ((0 == exit_status) || (SG_LIB_OK_FALSE == exit_status)) + return true; /* don't print anything */ + else if (sg_exit2str(exit_status, false, sizeof(b), b)) { + fprintf(fp, "%s%s\n", s, b); + return true; + } else + return false; +} + +/* This examines exit_status and if an error message is known it is output + * to stdout/stderr and true is returned. If no error message is + * available nothing is output and false is returned. If exit_status is + * zero (no error) nothing is output and true is returned. If exit_status + * is negative then nothing is output and false is returned. If leadin is + * non-NULL then it is printed before the error message. All messages are + * a single line with a trailing LF. */ +bool +sg_if_can2stdout(const char * leadin, int exit_status) +{ + return sg_if_can2fp(leadin, exit_status, stdout); +} + +/* See sg_if_can2stdout() comments */ +bool +sg_if_can2stderr(const char * leadin, int exit_status) +{ + return sg_if_can2fp(leadin, exit_status, + sg_warnings_strm ? sg_warnings_strm : stderr); +} + +/* If os_err_num is within bounds then the returned value is 'os_err_num + + * SG_LIB_OS_BASE_ERR' otherwise SG_LIB_OS_BASE_ERR is returned. If + * os_err_num is 0 then 0 is returned. */ +int +sg_convert_errno(int os_err_num) +{ + if (os_err_num <= 0) { + if (os_err_num < 0) + return SG_LIB_OS_BASE_ERR; + return os_err_num; /* os_err_num of 0 maps to 0 */ + } + if (os_err_num < (SG_LIB_CAT_MALFORMED - SG_LIB_OS_BASE_ERR)) + return SG_LIB_OS_BASE_ERR + os_err_num; + return SG_LIB_OS_BASE_ERR; +} + +static const char * const bad_sense_cat = "Bad sense category"; + +/* Yield string associated with sense category. Returns 'b' (or pointer + * to "Bad sense category" if 'b' is NULL). If sense_cat unknown then + * yield "Sense category: <sense_cat_val>" string. The original 'sense + * category' concept has been expanded to most detected errors and is + * returned by these utilities as their exit status value (an (unsigned) + * 8 bit value where 0 means good (i.e. no errors)). Uses sg_exit2str() + * function. */ +const char * +sg_get_category_sense_str(int sense_cat, int b_len, char * b, int verbose) +{ + if (NULL == b) + return bad_sense_cat; + if (b_len <= 0) + return b; + if (! sg_exit2str(sense_cat, (verbose > 0), b_len, b)) { + int n = sg_scnpr(b, b_len, "Sense category: %d", sense_cat); + + if ((0 == verbose) && (n < (b_len - 1))) + sg_scnpr(b + n, b_len - n, ", try '-v' option for more " + "information"); + } + return b; /* Note that a valid C string is returned in all cases */ +} + +/* See description in sg_lib.h header file */ +bool +sg_scsi_normalize_sense(const uint8_t * sbp, int sb_len, + struct sg_scsi_sense_hdr * sshp) +{ + uint8_t resp_code; + if (sshp) + memset(sshp, 0, sizeof(struct sg_scsi_sense_hdr)); + if ((NULL == sbp) || (sb_len < 1)) + return false; + resp_code = 0x7f & sbp[0]; + if ((resp_code < 0x70) || (resp_code > 0x73)) + return false; + if (sshp) { + sshp->response_code = resp_code; + if (sshp->response_code >= 0x72) { /* descriptor format */ + if (sb_len > 1) + sshp->sense_key = (0xf & sbp[1]); + if (sb_len > 2) + sshp->asc = sbp[2]; + if (sb_len > 3) + sshp->ascq = sbp[3]; + if (sb_len > 7) + sshp->additional_length = sbp[7]; + sshp->byte4 = sbp[4]; /* bit 7: SDAT_OVFL bit */ + /* sbp[5] and sbp[6] reserved for descriptor format */ + } else { /* fixed format */ + if (sb_len > 2) + sshp->sense_key = (0xf & sbp[2]); + if (sb_len > 7) { + sb_len = (sb_len < (sbp[7] + 8)) ? sb_len : (sbp[7] + 8); + if (sb_len > 12) + sshp->asc = sbp[12]; + if (sb_len > 13) + sshp->ascq = sbp[13]; + } + if (sb_len > 6) { /* lower 3 bytes of INFO field */ + sshp->byte4 = sbp[4]; + sshp->byte5 = sbp[5]; + sshp->byte6 = sbp[6]; + } + } + } + return true; +} + +/* Returns a SG_LIB_CAT_* value. If cannot decode sense buffer (sbp) or a + * less common sense key then return SG_LIB_CAT_SENSE .*/ +int +sg_err_category_sense(const uint8_t * sbp, int sb_len) +{ + struct sg_scsi_sense_hdr ssh; + + if ((sbp && (sb_len > 2)) && + (sg_scsi_normalize_sense(sbp, sb_len, &ssh))) { + switch (ssh.sense_key) { /* 0 to 0x1f */ + case SPC_SK_NO_SENSE: + return SG_LIB_CAT_NO_SENSE; + case SPC_SK_RECOVERED_ERROR: + return SG_LIB_CAT_RECOVERED; + case SPC_SK_NOT_READY: + if ((0x04 == ssh.asc) && (0x0b == ssh.ascq)) + return SG_LIB_CAT_STANDBY; + if ((0x04 == ssh.asc) && (0x0c == ssh.ascq)) + return SG_LIB_CAT_UNAVAILABLE; + return SG_LIB_CAT_NOT_READY; + case SPC_SK_MEDIUM_ERROR: + case SPC_SK_HARDWARE_ERROR: + case SPC_SK_BLANK_CHECK: + return SG_LIB_CAT_MEDIUM_HARD; + case SPC_SK_UNIT_ATTENTION: + return SG_LIB_CAT_UNIT_ATTENTION; + /* used to return SG_LIB_CAT_MEDIA_CHANGED when ssh.asc==0x28 */ + case SPC_SK_ILLEGAL_REQUEST: + if ((0x20 == ssh.asc) && (0x0 == ssh.ascq)) + return SG_LIB_CAT_INVALID_OP; + else if ((0x21 == ssh.asc) && (0x0 == ssh.ascq)) + return SG_LIB_LBA_OUT_OF_RANGE; + else + return SG_LIB_CAT_ILLEGAL_REQ; + break; + case SPC_SK_ABORTED_COMMAND: + if (0x10 == ssh.asc) + return SG_LIB_CAT_PROTECTION; + else + return SG_LIB_CAT_ABORTED_COMMAND; + case SPC_SK_MISCOMPARE: + return SG_LIB_CAT_MISCOMPARE; + case SPC_SK_DATA_PROTECT: + return SG_LIB_CAT_DATA_PROTECT; + case SPC_SK_COPY_ABORTED: + return SG_LIB_CAT_COPY_ABORTED; + case SPC_SK_COMPLETED: + case SPC_SK_VOLUME_OVERFLOW: + return SG_LIB_CAT_SENSE; + default: + ; /* reserved and vendor specific sense keys fall through */ + } + } + return SG_LIB_CAT_SENSE; +} + +/* Beware: gives wrong answer for variable length command (opcode=0x7f) */ +int +sg_get_command_size(uint8_t opcode) +{ + switch ((opcode >> 5) & 0x7) { + case 0: + return 6; + case 3: case 5: + return 12; + case 4: + return 16; + default: /* 1, 2, 6, 7 */ + return 10; + } +} + +void +sg_get_command_name(const uint8_t * cdbp, int peri_type, int buff_len, + char * buff) +{ + int service_action; + + if ((NULL == buff) || (buff_len < 1)) + return; + else if (1 == buff_len) { + buff[0] = '\0'; + return; + } + if (NULL == cdbp) { + sg_scnpr(buff, buff_len, "%s", "<null> command pointer"); + return; + } + service_action = (SG_VARIABLE_LENGTH_CMD == cdbp[0]) ? + sg_get_unaligned_be16(cdbp + 8) : (cdbp[1] & 0x1f); + sg_get_opcode_sa_name(cdbp[0], service_action, peri_type, buff_len, buff); +} + +struct op_code2sa_t { + int op_code; + int pdt_s; + struct sg_lib_value_name_t * arr; + const char * prefix; +}; + +static struct op_code2sa_t op_code2sa_arr[] = { + {SG_VARIABLE_LENGTH_CMD, PDT_ALL, sg_lib_variable_length_arr, NULL}, + {SG_MAINTENANCE_IN, PDT_ALL, sg_lib_maint_in_arr, NULL}, + {SG_MAINTENANCE_OUT, PDT_ALL, sg_lib_maint_out_arr, NULL}, + {SG_SERVICE_ACTION_IN_12, PDT_ALL, sg_lib_serv_in12_arr, NULL}, + {SG_SERVICE_ACTION_OUT_12, PDT_ALL, sg_lib_serv_out12_arr, NULL}, + {SG_SERVICE_ACTION_IN_16, PDT_ALL, sg_lib_serv_in16_arr, NULL}, + {SG_SERVICE_ACTION_OUT_16, PDT_ALL, sg_lib_serv_out16_arr, NULL}, + {SG_SERVICE_ACTION_BIDI, PDT_ALL, sg_lib_serv_bidi_arr, NULL}, + {SG_PERSISTENT_RESERVE_IN, PDT_ALL, sg_lib_pr_in_arr, + "Persistent reserve in"}, + {SG_PERSISTENT_RESERVE_OUT, PDT_ALL, sg_lib_pr_out_arr, + "Persistent reserve out"}, + {SG_3PARTY_COPY_OUT, PDT_ALL, sg_lib_xcopy_sa_arr, NULL}, + {SG_3PARTY_COPY_IN, PDT_ALL, sg_lib_rec_copy_sa_arr, NULL}, + {SG_READ_BUFFER, PDT_ALL, sg_lib_read_buff_arr, "Read buffer(10)"}, + {SG_READ_BUFFER_16, PDT_ALL, sg_lib_read_buff_arr, "Read buffer(16)"}, + {SG_READ_ATTRIBUTE, PDT_ALL, sg_lib_read_attr_arr, "Read attribute"}, + {SG_READ_POSITION, PDT_TAPE, sg_lib_read_pos_arr, "Read position"}, + {SG_SANITIZE, PDT_DISK_ZBC, sg_lib_sanitize_sa_arr, "Sanitize"}, + {SG_WRITE_BUFFER, PDT_ALL, sg_lib_write_buff_arr, "Write buffer"}, + {SG_ZONING_IN, PDT_DISK_ZBC, sg_lib_zoning_in_arr, NULL}, + {SG_ZONING_OUT, PDT_DISK_ZBC, sg_lib_zoning_out_arr, NULL}, + {0xffff, -1, NULL, NULL}, +}; + +void +sg_get_opcode_sa_name(uint8_t cmd_byte0, int service_action, + int peri_type, int buff_len, char * buff) +{ + int d_pdt; + const struct sg_lib_value_name_t * vnp; + const struct op_code2sa_t * osp; + char b[80]; + + if ((NULL == buff) || (buff_len < 1)) + return; + else if (1 == buff_len) { + buff[0] = '\0'; + return; + } + + if (peri_type < 0) + peri_type = 0; + d_pdt = sg_lib_pdt_decay(peri_type); + for (osp = op_code2sa_arr; osp->arr; ++osp) { + if ((int)cmd_byte0 == osp->op_code) { + if (sg_pdt_s_eq(osp->pdt_s, d_pdt)) { + vnp = get_value_name(osp->arr, service_action, peri_type); + if (vnp) { + if (osp->prefix) + sg_scnpr(buff, buff_len, "%s, %s", osp->prefix, + vnp->name); + else + sg_scnpr(buff, buff_len, "%s", vnp->name); + } else { + sg_get_opcode_name(cmd_byte0, peri_type, sizeof(b), b); + sg_scnpr(buff, buff_len, "%s service action=0x%x", b, + service_action); + } + } else + sg_get_opcode_name(cmd_byte0, peri_type, buff_len, buff); + return; + } + } + sg_get_opcode_name(cmd_byte0, peri_type, buff_len, buff); +} + +void +sg_get_opcode_name(uint8_t cmd_byte0, int peri_type, int buff_len, + char * buff) +{ + const struct sg_lib_value_name_t * vnp; + int grp; + + if ((NULL == buff) || (buff_len < 1)) + return; + else if (1 == buff_len) { + buff[0] = '\0'; + return; + } + if (SG_VARIABLE_LENGTH_CMD == cmd_byte0) { + sg_scnpr(buff, buff_len, "%s", "Variable length"); + return; + } + grp = (cmd_byte0 >> 5) & 0x7; + switch (grp) { + case 0: + case 1: + case 2: + case 4: + case 5: + vnp = get_value_name(sg_lib_normal_opcodes, cmd_byte0, peri_type); + if (vnp) + sg_scnpr(buff, buff_len, "%s", vnp->name); + else + sg_scnpr(buff, buff_len, "Opcode=0x%x", (int)cmd_byte0); + break; + case 3: + sg_scnpr(buff, buff_len, "Reserved [0x%x]", (int)cmd_byte0); + break; + case 6: + case 7: + sg_scnpr(buff, buff_len, "Vendor specific [0x%x]", (int)cmd_byte0); + break; + } +} + +/* Fetch NVMe command name given first byte (byte offset 0 in 64 byte + * command) of command. Gets Admin NVMe command name if 'admin' is true + * (e.g. opcode=0x6 -> Identify), otherwise gets NVM command set name + * (e.g. opcode=0 -> Flush). Returns 'buff'. */ +char * +sg_get_nvme_opcode_name(uint8_t cmd_byte0, bool admin, int buff_len, + char * buff) +{ + const struct sg_lib_simple_value_name_t * vnp = admin ? + sg_lib_nvme_admin_cmd_arr : sg_lib_nvme_nvm_cmd_arr; + + if ((NULL == buff) || (buff_len < 1)) + return buff; + else if (1 == buff_len) { + buff[0] = '\0'; + return buff; + } + for ( ; vnp->name; ++vnp) { + if (cmd_byte0 == (uint8_t)vnp->value) { + snprintf(buff, buff_len, "%s", vnp->name); + return buff; + } + } + if (admin) { + if (cmd_byte0 >= 0xc0) + snprintf(buff, buff_len, "Vendor specific opcode: 0x%x", + cmd_byte0); + else if (cmd_byte0 >= 0x80) + snprintf(buff, buff_len, "Command set specific opcode: 0x%x", + cmd_byte0); + else + snprintf(buff, buff_len, "Unknown opcode: 0x%x", cmd_byte0); + } else { /* NVM (non-Admin) command set */ + if (cmd_byte0 >= 0x80) + snprintf(buff, buff_len, "Vendor specific opcode: 0x%x", + cmd_byte0); + else + snprintf(buff, buff_len, "Unknown opcode: 0x%x", cmd_byte0); + } + return buff; +} + +/* Iterates to next designation descriptor in the device identification + * VPD page. The 'initial_desig_desc' should point to start of first + * descriptor with 'page_len' being the number of valid bytes in that + * and following descriptors. To start, 'off' should point to a negative + * value, thereafter it should point to the value yielded by the previous + * call. If 0 returned then 'initial_desig_desc + *off' should be a valid + * descriptor; returns -1 if normal end condition and -2 for an abnormal + * termination. Matches association, designator_type and/or code_set when + * any of those values are greater than or equal to zero. */ +int +sg_vpd_dev_id_iter(const uint8_t * initial_desig_desc, int page_len, + int * off, int m_assoc, int m_desig_type, int m_code_set) +{ + bool fltr = ((m_assoc >= 0) || (m_desig_type >= 0) || (m_code_set >= 0)); + int k = *off; + const uint8_t * bp = initial_desig_desc; + + while ((k + 3) < page_len) { + k = (k < 0) ? 0 : (k + bp[k + 3] + 4); + if ((k + 4) > page_len) + break; + if (fltr) { + if (m_code_set >= 0) { + if ((bp[k] & 0xf) != m_code_set) + continue; + } + if (m_assoc >= 0) { + if (((bp[k + 1] >> 4) & 0x3) != m_assoc) + continue; + } + if (m_desig_type >= 0) { + if ((bp[k + 1] & 0xf) != m_desig_type) + continue; + } + } + *off = k; + return 0; + } + return (k == page_len) ? -1 : -2; +} + +static const char * sg_sfs_spc_reserved = "SPC Reserved"; +static const char * sg_sfs_sbc_reserved = "SBC Reserved"; +static const char * sg_sfs_ssc_reserved = "SSC Reserved"; +static const char * sg_sfs_zbc_reserved = "ZBC Reserved"; +static const char * sg_sfs_reserved = "Reserved"; + +/* Yield SCSI Feature Set (sfs) string. When 'peri_type' is < -1 (or > 31) + * returns pointer to string (same as 'buff') associated with 'sfs_code'. + * When 'peri_type' is between -1 (for SPC) and 31 (inclusive) then a match + * on both 'sfs_code' and 'peri_type' is required. If 'foundp' is not NULL + * then where it points is set to true if a match is found else it is set to + * false. If 'buff' is not NULL then in the case of a match a descriptive + * string is written to 'buff' while if there is not a not then a string + * ending in "Reserved" is written (and may be prefixed with SPC, SBC, SSC + * or ZBC). Returns 'buff' (i.e. a pointer value) even if it is NULL. + * Example: + * char b[64]; + * ... + * printf("%s\n", sg_get_sfs_str(sfs_code, -2, sizeof(b), b, NULL, 0)); + */ +const char * +sg_get_sfs_str(uint16_t sfs_code, int peri_type, int buff_len, char * buff, + bool * foundp, int verbose) +{ + const struct sg_lib_value_name_t * vnp = NULL; + int n = 0; + int my_pdt; + + if ((NULL == buff) || (buff_len < 1)) { + if (foundp) + *foundp = false; + return NULL; + } else if (1 == buff_len) { + buff[0] = '\0'; + if (foundp) + *foundp = false; + return NULL; + } + my_pdt = ((peri_type < -1) || (peri_type > PDT_MAX)) ? -2 : peri_type; + vnp = get_value_name(sg_lib_scsi_feature_sets, sfs_code, my_pdt); + if (vnp && (-2 != my_pdt)) { + if (! sg_pdt_s_eq(my_pdt, vnp->peri_dev_type)) + vnp = NULL; /* shouldn't really happen */ + } + if (foundp) + *foundp = vnp ? true : false; + if (sfs_code < 0x100) { /* SPC Feature Sets */ + if (vnp) { + if (verbose) + n += sg_scnpr(buff, buff_len, "SPC %s", vnp->name); + else + n += sg_scnpr(buff, buff_len, "%s", vnp->name); + } else + n += sg_scnpr(buff, buff_len, "%s", sg_sfs_spc_reserved); + } else if (sfs_code < 0x200) { /* SBC Feature Sets */ + if (vnp) { + if (verbose) + n += sg_scnpr(buff, buff_len, "SBC %s", vnp->name); + else + n += sg_scnpr(buff, buff_len, "%s", vnp->name); + } else + n += sg_scnpr(buff, buff_len, "%s", sg_sfs_sbc_reserved); + } else if (sfs_code < 0x300) { /* SSC Feature Sets */ + if (vnp) { + if (verbose) + n += sg_scnpr(buff, buff_len, "SSC %s", vnp->name); + else + n += sg_scnpr(buff, buff_len, "%s", vnp->name); + } else + n += sg_scnpr(buff, buff_len, "%s", sg_sfs_ssc_reserved); + } else if (sfs_code < 0x400) { /* ZBC Feature Sets */ + if (vnp) { + if (verbose) + n += sg_scnpr(buff, buff_len, "ZBC %s", vnp->name); + else + n += sg_scnpr(buff, buff_len, "%s", vnp->name); + } else + n += sg_scnpr(buff, buff_len, "%s", sg_sfs_zbc_reserved); + } else { /* Other SCSI Feature Sets */ + if (vnp) { + if (verbose) + n += sg_scnpr(buff, buff_len, "[unrecognized PDT] %s", + vnp->name); + else + n += sg_scnpr(buff, buff_len, "%s", vnp->name); + } else + n += sg_scnpr(buff, buff_len, "%s", sg_sfs_reserved); + + } + if (verbose > 4) + pr2ws("%s: length of returned string (n) %d\n", __func__, n); + return buff; +} + +/* This is a heuristic that takes into account the command bytes and length + * to decide whether the presented unstructured sequence of bytes could be + * a SCSI command. If so it returns true otherwise false. Vendor specific + * SCSI commands (i.e. opcodes from 0xc0 to 0xff), if presented, are assumed + * to follow SCSI conventions (i.e. length of 6, 10, 12 or 16 bytes). The + * only SCSI commands considered above 16 bytes of length are the Variable + * Length Commands (opcode 0x7f) and the XCDB wrapped commands (opcode 0x7e). + * Both have an inbuilt length field which can be cross checked with clen. + * No NVMe commands (64 bytes long plus some extra added by some OSes) have + * opcodes 0x7e or 0x7f yet. ATA is register based but SATA has FIS + * structures that are sent across the wire. The FIS register structure is + * used to move a command from a SATA host to device, but the ATA 'command' + * is not the first byte. So it is harder to say what will happen if a + * FIS structure is presented as a SCSI command, hopefully there is a low + * probability this function will yield true in that case. */ +bool +sg_is_scsi_cdb(const uint8_t * cdbp, int clen) +{ + uint8_t opcode; + uint8_t top3bits; + + if (clen < 6) + return false; + opcode = cdbp[0]; + top3bits = opcode >> 5; + if (0x3 == top3bits) { + int ilen, sa; + + if ((clen < 12) || (clen % 4)) + return false; /* must be modulo 4 and 12 or more bytes */ + switch (opcode) { + case 0x7e: /* Extended cdb (XCDB) */ + ilen = 4 + sg_get_unaligned_be16(cdbp + 2); + return (ilen == clen); + case 0x7f: /* Variable Length cdb */ + ilen = 8 + cdbp[7]; + sa = sg_get_unaligned_be16(cdbp + 8); + /* service action (sa) 0x0 is reserved */ + return ((ilen == clen) && sa); + default: + return false; + } + } else if (clen <= 16) { + switch (clen) { + case 6: + if (top3bits > 0x5) /* vendor */ + return true; + return (0x0 == top3bits); /* 6 byte cdb */ + case 10: + if (top3bits > 0x5) /* vendor */ + return true; + return ((0x1 == top3bits) || (0x2 == top3bits)); /* 10 byte cdb */ + case 16: + if (top3bits > 0x5) /* vendor */ + return true; + return (0x4 == top3bits); /* 16 byte cdb */ + case 12: + if (top3bits > 0x5) /* vendor */ + return true; + return (0x5 == top3bits); /* 12 byte cdb */ + default: + return false; + } + } + /* NVMe probably falls out here, clen > 16 and (opcode < 0x60 or + * opcode > 0x7f). */ + return false; +} + +/* Yield string associated with NVMe command status value in sct_sc. It + * expects to decode DW3 bits 27:17 from the completion queue. Bits 27:25 + * are the Status Code Type (SCT) and bits 24:17 are the Status Code (SC). + * Bit 17 in DW3 should be bit 0 in sct_sc. If no status string is found + * a string of the form "Reserved [0x<sct_sc_in_hex>]" is generated. + * Returns 'buff'. Does nothing if buff_len<=0 or if buff is NULL.*/ +char * +sg_get_nvme_cmd_status_str(uint16_t sct_sc, int b_len, char * b) +{ + int k; + uint16_t s = 0x3ff & sct_sc; + const struct sg_lib_value_name_t * vp = sg_lib_nvme_cmd_status_arr; + + if ((b_len <= 0) || (NULL == b)) + return b; + else if (1 == b_len) { + b[0] = '\0'; + return b; + } + for (k = 0; (vp->name && (k < 1000)); ++k, ++vp) { + if (s == (uint16_t)vp->value) { + strncpy(b, vp->name, b_len); + b[b_len - 1] = '\0'; + return b; + } + } + if (k >= 1000) + pr2ws("%s: where is sentinel for sg_lib_nvme_cmd_status_arr ??\n", + __func__); + snprintf(b, b_len, "Reserved [0x%x]", sct_sc); + return b; +} + +/* Attempts to map NVMe status value ((SCT << 8) | SC) to SCSI status, + * sense_key, asc and ascq tuple. If successful returns true and writes to + * non-NULL pointer arguments; otherwise returns false. */ +bool +sg_nvme_status2scsi(uint16_t sct_sc, uint8_t * status_p, uint8_t * sk_p, + uint8_t * asc_p, uint8_t * ascq_p) +{ + int k, ind; + uint16_t s = 0x3ff & sct_sc; + struct sg_lib_value_name_t * vp = sg_lib_nvme_cmd_status_arr; + struct sg_lib_4tuple_u8 * mp = sg_lib_scsi_status_sense_arr; + + for (k = 0; (vp->name && (k < 1000)); ++k, ++vp) { + if (s == (uint16_t)vp->value) + break; + } + if (k >= 1000) { + pr2ws("%s: where is sentinel for sg_lib_nvme_cmd_status_arr ??\n", + __func__); + return false; + } + if (NULL == vp->name) + return false; + ind = vp->peri_dev_type; + + + for (k = 0; (0xff != mp->t2) && k < 1000; ++k, ++mp) + ; /* count entries for valid index range */ + if (k >= 1000) { + pr2ws("%s: where is sentinel for sg_lib_scsi_status_sense_arr ??\n", + __func__); + return false; + } else if (ind >= k) + return false; + + mp = sg_lib_scsi_status_sense_arr + ind; + if (status_p) + *status_p = mp->t1; + if (sk_p) + *sk_p = mp->t2; + if (asc_p) + *asc_p = mp->t3; + if (ascq_p) + *ascq_p = mp->t4; + return true; +} + +/* Add vendor (sg3_utils) specific sense descriptor for the NVMe Status + * field. Assumes descriptor (i.e. not fixed) sense. Assumes sbp has room. */ +void +sg_nvme_desc2sense(uint8_t * sbp, bool dnr, bool more, uint16_t sct_sc) +{ + int len = sbp[7] + 8; + + sbp[len] = 0xde; /* vendor specific descriptor type */ + sbp[len + 1] = 6; /* descriptor is 8 bytes long */ + memset(sbp + len + 2, 0, 6); + if (dnr) + sbp[len + 5] = 0x80; + if (more) + sbp[len + 5] |= 0x40; + sg_put_unaligned_be16(sct_sc, sbp + len + 6); + sbp[7] += 8; +} + +/* Build minimum sense buffer, either descriptor type (desc=true) or fixed + * type (desc=false). Assume sbp has enough room (8 or 14 bytes + * respectively). sbp should have room for 32 or 18 bytes respectively */ +void +sg_build_sense_buffer(bool desc, uint8_t *sbp, uint8_t skey, uint8_t asc, + uint8_t ascq) +{ + if (desc) { + sbp[0] = 0x72; /* descriptor, current */ + sbp[1] = skey; + sbp[2] = asc; + sbp[3] = ascq; + sbp[7] = 0; + } else { + sbp[0] = 0x70; /* fixed, current */ + sbp[2] = skey; + sbp[7] = 0xa; /* Assumes length is 18 bytes */ + sbp[12] = asc; + sbp[13] = ascq; + } +} + +/* safe_strerror() contributed by Clayton Weaver <cgweav at email dot com> + * Allows for situation in which strerror() is given a wild value (or the + * C library is incomplete) and returns NULL. Still not thread safe. + */ + +static char safe_errbuf[64] = {'u', 'n', 'k', 'n', 'o', 'w', 'n', ' ', + 'e', 'r', 'r', 'n', 'o', ':', ' ', 0}; + +char * +safe_strerror(int errnum) +{ + char * errstr; + + if (errnum < 0) + errnum = -errnum; + errstr = strerror(errnum); + if (NULL == errstr) { + size_t len = strlen(safe_errbuf); + + sg_scnpr(safe_errbuf + len, sizeof(safe_errbuf) - len, "%i", errnum); + return safe_errbuf; + } + return errstr; +} + +static int +trimTrailingSpaces(char * b) +{ + int n = strlen(b); + + while ((n > 0) && (' ' == b[n - 1])) + b[--n] = '\0'; + return n; +} + +/* Read binary starting at 'str' for 'len' bytes and output as ASCII + * hexadecinal into file pointer (fp). 16 bytes per line are output with an + * additional space between 8th and 9th byte on each line (for readability). + * 'no_ascii' selects one of 3 output format types: + * > 0 each line has address then up to 16 ASCII-hex bytes + * = 0 in addition, the bytes are listed in ASCII to the right + * < 0 only the ASCII-hex bytes are listed (i.e. without address) */ +void +dStrHexFp(const char* str, int len, int no_ascii, FILE * fp) +{ + const char * p = str; + const char * formatstr; + uint8_t c; + char buff[82]; + int a = 0; + int bpstart = 5; + const int cpstart = 60; + int cpos = cpstart; + int bpos = bpstart; + int i, k, blen; + + if (len <= 0) + return; + blen = (int)sizeof(buff); + if (0 == no_ascii) /* address at left and ASCII at right */ + formatstr = "%.76s\n"; + else /* previously when > 0 str was "%.58s\n" */ + formatstr = "%s\n"; /* when < 0 str was: "%.48s\n" */ + memset(buff, ' ', 80); + buff[80] = '\0'; + if (no_ascii < 0) { + bpstart = 0; + bpos = bpstart; + for (k = 0; k < len; k++) { + c = *p++; + if (bpos == (bpstart + (8 * 3))) + bpos++; + sg_scnpr(&buff[bpos], blen - bpos, "%.2x", (int)(uint8_t)c); + buff[bpos + 2] = ' '; + if ((k > 0) && (0 == ((k + 1) % 16))) { + trimTrailingSpaces(buff); + fprintf(fp, formatstr, buff); + bpos = bpstart; + memset(buff, ' ', 80); + } else + bpos += 3; + } + if (bpos > bpstart) { + buff[bpos + 2] = '\0'; + trimTrailingSpaces(buff); + fprintf(fp, "%s\n", buff); + } + return; + } + /* no_ascii>=0, start each line with address (offset) */ + k = sg_scnpr(buff + 1, blen - 1, "%.2x", a); + buff[k + 1] = ' '; + + for (i = 0; i < len; i++) { + c = *p++; + bpos += 3; + if (bpos == (bpstart + (9 * 3))) + bpos++; + sg_scnpr(&buff[bpos], blen - bpos, "%.2x", (int)(uint8_t)c); + buff[bpos + 2] = ' '; + if (no_ascii) + buff[cpos++] = ' '; + else { + if (! my_isprint(c)) + c = '.'; + buff[cpos++] = c; + } + if (cpos > (cpstart + 15)) { + if (no_ascii) + trimTrailingSpaces(buff); + fprintf(fp, formatstr, buff); + bpos = bpstart; + cpos = cpstart; + a += 16; + memset(buff, ' ', 80); + k = sg_scnpr(buff + 1, blen - 1, "%.2x", a); + buff[k + 1] = ' '; + } + } + if (cpos > cpstart) { + buff[cpos] = '\0'; + if (no_ascii) + trimTrailingSpaces(buff); + fprintf(fp, "%s\n", buff); + } +} + +void +dStrHex(const char* str, int len, int no_ascii) +{ + dStrHexFp(str, len, no_ascii, stdout); +} + +void +dStrHexErr(const char* str, int len, int no_ascii) +{ + dStrHexFp(str, len, no_ascii, + (sg_warnings_strm ? sg_warnings_strm : stderr)); +} + +#define DSHS_LINE_BLEN 160 /* maximum characters per line */ +#define DSHS_BPL 16 /* bytes per line */ + +/* Read 'len' bytes from 'str' and output as ASCII-Hex bytes (space separated) + * to 'b' not to exceed 'b_len' characters. Each line starts with 'leadin' + * (NULL for no leadin) and there are 16 bytes per line with an extra space + * between the 8th and 9th bytes. 'oformat' is 0 for repeat in printable ASCII + * ('.' for non printable chars) to right of each line; 1 don't (so just + * output ASCII hex). If 'oformat' is 2 output same as 1 but any LFs are + * replaced by space (and trailing spaces are trimmed). Note that an address + * is not printed on each line preceding the hex data. Returns number of bytes + * written to 'b' excluding the trailing '\0'. The only difference between + * dStrHexStr() and hex2str() is the type of the first argument. */ +int +dStrHexStr(const char * str, int len, const char * leadin, int oformat, + int b_len, char * b) +{ + bool want_ascii = (0 == oformat); + int bpstart, bpos, k, n, prior_ascii_len; + char buff[DSHS_LINE_BLEN + 2]; /* allow for trailing null */ + char a[DSHS_BPL + 1]; /* printable ASCII bytes or '.' */ + const char * p = str; + const char * lf_or = (oformat > 1) ? " " : "\n"; + + if (len <= 0) { + if (b_len > 0) + b[0] = '\0'; + return 0; + } + if (b_len <= 0) + return 0; + if (want_ascii) { + memset(a, ' ', DSHS_BPL); + a[DSHS_BPL] = '\0'; + } + n = 0; + bpstart = 0; + if (leadin) { + if (oformat > 1) + n += sg_scnpr(b + n, b_len - n, "%s", leadin); + else { + bpstart = strlen(leadin); + /* Cap leadin at (DSHS_LINE_BLEN - 70) characters */ + if (bpstart > (DSHS_LINE_BLEN - 70)) + bpstart = DSHS_LINE_BLEN - 70; + } + } + bpos = bpstart; + prior_ascii_len = bpstart + (DSHS_BPL * 3) + 1; + memset(buff, ' ', DSHS_LINE_BLEN); + buff[DSHS_LINE_BLEN] = '\0'; + if (bpstart > 0) + memcpy(buff, leadin, bpstart); + for (k = 0; k < len; k++) { + uint8_t c = *p++; + + if (bpos == (bpstart + ((DSHS_BPL / 2) * 3))) + bpos++; /* for extra space in middle of each line's hex */ + sg_scnpr(buff + bpos, (int)sizeof(buff) - bpos, "%.2x", + (int)(uint8_t)c); + buff[bpos + 2] = ' '; + if (want_ascii) + a[k % DSHS_BPL] = my_isprint(c) ? c : '.'; + if ((k > 0) && (0 == ((k + 1) % DSHS_BPL))) { + trimTrailingSpaces(buff); + if (want_ascii) { + n += sg_scnpr(b + n, b_len - n, "%-*s %s\n", + prior_ascii_len, buff, a); + memset(a, ' ', DSHS_BPL); + } else + n += sg_scnpr(b + n, b_len - n, "%s%s", buff, lf_or); + if (n >= (b_len - 1)) + goto fini; + memset(buff, ' ', DSHS_LINE_BLEN); + bpos = bpstart; + if (bpstart > 0) + memcpy(buff, leadin, bpstart); + } else + bpos += 3; + } + if (bpos > bpstart) { + trimTrailingSpaces(buff); + if (want_ascii) + n += sg_scnpr(b + n, b_len - n, "%-*s %s\n", prior_ascii_len, + buff, a); + else + n += sg_scnpr(b + n, b_len - n, "%s%s", buff, lf_or); + } +fini: + if (oformat > 1) + n = trimTrailingSpaces(b); + return n; +} + +void +hex2stdout(const uint8_t * b_str, int len, int no_ascii) +{ + dStrHex((const char *)b_str, len, no_ascii); +} + +void +hex2stderr(const uint8_t * b_str, int len, int no_ascii) +{ + dStrHexErr((const char *)b_str, len, no_ascii); +} + +int +hex2str(const uint8_t * b_str, int len, const char * leadin, int oformat, + int b_len, char * b) +{ + return dStrHexStr((const char *)b_str, len, leadin, oformat, b_len, b); +} + +void +hex2fp(const uint8_t * b_str, int len, const char * leadin, int oformat, + FILE * fp) +{ + int k, num; + char b[800]; /* allow for 4 lines of 16 bytes (in hex) each */ + + if (leadin && (strlen(leadin) > 118)) { + fprintf(fp, ">>> leadin parameter is too large\n"); + return; + } + for (k = 0; k < len; k += num) { + num = ((k + 64) < len) ? 64 : (len - k); + hex2str(b_str + k, num, leadin, oformat, sizeof(b), b); + fprintf(fp, "%s", b); + } +} + +/* Returns true when executed on big endian machine; else returns false. + * Useful for displaying ATA identify words (which need swapping on a + * big endian machine). */ +bool +sg_is_big_endian() +{ + union u_t { + uint16_t s; + uint8_t c[sizeof(uint16_t)]; + } u; + + u.s = 0x0102; + return (u.c[0] == 0x01); /* The lowest address contains + the most significant byte */ +} + +bool +sg_all_zeros(const uint8_t * bp, int b_len) +{ + if ((NULL == bp) || (b_len <= 0)) + return false; + for (--b_len; b_len >= 0; --b_len) { + if (0x0 != bp[b_len]) + return false; + } + return true; +} + +bool +sg_all_ffs(const uint8_t * bp, int b_len) +{ + if ((NULL == bp) || (b_len <= 0)) + return false; + for (--b_len; b_len >= 0; --b_len) { + if (0xff != bp[b_len]) + return false; + } + return true; +} + +static uint16_t +swapb_uint16(uint16_t u) +{ + uint16_t r; + + r = (u >> 8) & 0xff; + r |= ((u & 0xff) << 8); + return r; +} + +/* Note the ASCII-hex output goes to stdout. [Most other output from functions + * in this file go to sg_warnings_strm (default stderr).] + * 'no_ascii' allows for 3 output types: + * > 0 each line has address then up to 8 ASCII-hex 16 bit words + * = 0 in addition, the ASCI bytes pairs are listed to the right + * = -1 only the ASCII-hex words are listed (i.e. without address) + * = -2 only the ASCII-hex words, formatted for "hdparm --Istdin" + * < -2 same as -1 + * If 'swapb' is true then bytes in each word swapped. Needs to be set + * for ATA IDENTIFY DEVICE response on big-endian machines. */ +void +dWordHex(const uint16_t* words, int num, int no_ascii, bool swapb) +{ + const uint16_t * p = words; + uint16_t c; + char buff[82]; + uint8_t upp, low; + int a = 0; + const int bpstart = 3; + const int cpstart = 52; + int cpos = cpstart; + int bpos = bpstart; + int i, k, blen; + + if (num <= 0) + return; + blen = (int)sizeof(buff); + memset(buff, ' ', 80); + buff[80] = '\0'; + if (no_ascii < 0) { + for (k = 0; k < num; k++) { + c = *p++; + if (swapb) + c = swapb_uint16(c); + bpos += 5; + sg_scnpr(buff + bpos, blen - bpos, "%.4x", (my_uint)c); + buff[bpos + 4] = ' '; + if ((k > 0) && (0 == ((k + 1) % 8))) { + if (-2 == no_ascii) + printf("%.39s\n", buff +8); + else + printf("%.47s\n", buff); + bpos = bpstart; + memset(buff, ' ', 80); + } + } + if (bpos > bpstart) { + if (-2 == no_ascii) + printf("%.39s\n", buff +8); + else + printf("%.47s\n", buff); + } + return; + } + /* no_ascii>=0, start each line with address (offset) */ + k = sg_scnpr(buff + 1, blen - 1, "%.2x", a); + buff[k + 1] = ' '; + + for (i = 0; i < num; i++) { + c = *p++; + if (swapb) + c = swapb_uint16(c); + bpos += 5; + sg_scnpr(buff + bpos, blen - bpos, "%.4x", (my_uint)c); + buff[bpos + 4] = ' '; + if (no_ascii) { + buff[cpos++] = ' '; + buff[cpos++] = ' '; + buff[cpos++] = ' '; + } else { + upp = (c >> 8) & 0xff; + low = c & 0xff; + if (! my_isprint(upp)) + upp = '.'; + buff[cpos++] = upp; + if (! my_isprint(low)) + low = '.'; + buff[cpos++] = low; + buff[cpos++] = ' '; + } + if (cpos > (cpstart + 23)) { + printf("%.76s\n", buff); + bpos = bpstart; + cpos = cpstart; + a += 8; + memset(buff, ' ', 80); + k = sg_scnpr(buff + 1, blen - 1, "%.2x", a); + buff[k + 1] = ' '; + } + } + if (cpos > cpstart) + printf("%.76s\n", buff); +} + +/* If the number in 'buf' can not be decoded or the multiplier is unknown + * then -1 is returned. Accepts a hex prefix (0x or 0X) or a decimal + * multiplier suffix (as per GNU's dd (since 2002: SI and IEC 60027-2)). + * Main (SI) multipliers supported: K, M, G. Ignore leading spaces and + * tabs; accept comma, hyphen, space, tab and hash as terminator. + * Handles zero and positive values up to 2**31-1 . + * Experimental: left argument (must in with hexadecimal digit) added + * to, or multiplied, by right argument. No embedded spaces. + * Examples: '3+1k' (evaluates to 1027) and '0x34+1m'. */ +int +sg_get_num(const char * buf) +{ + bool is_hex = false; + int res, num, n, len; + unsigned int unum; + char * cp; + const char * b; + const char * b2p; + char c = 'c'; + char c2 = '\0'; /* keep static checker happy */ + char c3 = '\0'; /* keep static checker happy */ + char lb[16]; + + if ((NULL == buf) || ('\0' == buf[0])) + return -1; + len = strlen(buf); + n = strspn(buf, " \t"); + if (n > 0) { + if (n == len) + return -1; + buf += n; + len -= n; + } + /* following hack to keep C++ happy */ + cp = strpbrk((char *)buf, " \t,#-"); + if (cp) { + len = cp - buf; + n = (int)sizeof(lb) - 1; + len = (len < n) ? len : n; + memcpy(lb, buf, len); + lb[len] = '\0'; + b = lb; + } else + b = buf; + + b2p = b; + if (('0' == b[0]) && (('x' == b[1]) || ('X' == b[1]))) { + res = sscanf(b + 2, "%x%c", &unum, &c); + num = unum; + is_hex = true; + b2p = b + 2; + } else if ('H' == toupper((int)b[len - 1])) { + res = sscanf(b, "%x", &unum); + num = unum; + } else + res = sscanf(b, "%d%c%c%c", &num, &c, &c2, &c3); + + if (res < 1) + return -1; + else if (1 == res) + return num; + else { + c = toupper((int)c); + if (is_hex) { + if (! ((c == '+') || (c == 'X'))) + return -1; + } + if (res > 2) + c2 = toupper((int)c2); + if (res > 3) + c3 = toupper((int)c3); + + switch (c) { + case 'C': + return num; + case 'W': + return num * 2; + case 'B': + return num * 512; + case 'K': + if (2 == res) + return num * 1024; + if (('B' == c2) || ('D' == c2)) + return num * 1000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1024; + return -1; + case 'M': + if (2 == res) + return num * 1048576; + if (('B' == c2) || ('D' == c2)) + return num * 1000000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1048576; + return -1; + case 'G': + if (2 == res) + return num * 1073741824; + if (('B' == c2) || ('D' == c2)) + return num * 1000000000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1073741824; + return -1; + case 'X': /* experimental: multiplication */ + /* left argument must end with hexadecimal digit */ + cp = (char *)strchr(b2p, 'x'); + if (NULL == cp) + cp = (char *)strchr(b2p, 'X'); + if (cp) { + n = sg_get_num(cp + 1); + if (-1 != n) + return num * n; + } + return -1; + case '+': /* experimental: addition */ + /* left argument must end with hexadecimal digit */ + cp = (char *)strchr(b2p, '+'); + if (cp) { + n = sg_get_num(cp + 1); + if (-1 != n) + return num + n; + } + return -1; + default: + pr2ws("unrecognized multiplier\n"); + return -1; + } + } +} + +/* If the number in 'buf' can not be decoded then -1 is returned. Accepts a + * hex prefix (0x or 0X) or a 'h' (or 'H') suffix; otherwise decimal is + * assumed. Does not accept multipliers. Accept a comma (","), hyphen ("-"), + * a whitespace or newline as terminator. */ +int +sg_get_num_nomult(const char * buf) +{ + int res, len, num; + unsigned int unum; + char * commap; + + if ((NULL == buf) || ('\0' == buf[0])) + return -1; + len = strlen(buf); + commap = (char *)strchr(buf + 1, ','); + if (('0' == buf[0]) && (('x' == buf[1]) || ('X' == buf[1]))) { + res = sscanf(buf + 2, "%x", &unum); + num = unum; + } else if (commap && ('H' == toupper((int)*(commap - 1)))) { + res = sscanf(buf, "%x", &unum); + num = unum; + } else if ((NULL == commap) && ('H' == toupper((int)buf[len - 1]))) { + res = sscanf(buf, "%x", &unum); + num = unum; + } else + res = sscanf(buf, "%d", &num); + if (1 == res) + return num; + else + return -1; +} + +/* If the number in 'buf' can not be decoded or the multiplier is unknown + * then -1LL is returned. Accepts a hex prefix (0x or 0X), hex suffix + * (h or H), or a decimal multiplier suffix (as per GNU's dd (since 2002: + * SI and IEC 60027-2)). Main (SI) multipliers supported: K, M, G, T, P + * and E. Ignore leading spaces and tabs; accept comma, hyphen, space, tab + * and hash as terminator. Handles zero and positive values up to 2**63-1 . + * Experimental: left argument (must in with hexadecimal digit) added + * to, or multiplied by right argument. No embedded spaces. + * Examples: '3+1k' (evaluates to 1027) and '0x34+1m'. */ +int64_t +sg_get_llnum(const char * buf) +{ + bool is_hex = false; + int res, len, n; + int64_t num, ll; + uint64_t unum; + char * cp; + const char * b; + const char * b2p; + char c = 'c'; + char c2 = '\0'; /* keep static checker happy */ + char c3 = '\0'; /* keep static checker happy */ + char lb[32]; + + if ((NULL == buf) || ('\0' == buf[0])) + return -1LL; + len = strlen(buf); + n = strspn(buf, " \t"); + if (n > 0) { + if (n == len) + return -1LL; + buf += n; + len -= n; + } + /* following cast hack to keep C++ happy */ + cp = strpbrk((char *)buf, " \t,#-"); + if (cp) { + len = cp - buf; + n = (int)sizeof(lb) - 1; + len = (len < n) ? len : n; + memcpy(lb, buf, len); + lb[len] = '\0'; + b = lb; + } else + b = buf; + + b2p = b; + if (('0' == b[0]) && (('x' == b[1]) || ('X' == b[1]))) { + res = sscanf(b + 2, "%" SCNx64 "%c", &unum, &c); + num = unum; + is_hex = true; + b2p = b + 2; + } else if ('H' == toupper((int)b[len - 1])) { + res = sscanf(b, "%" SCNx64 , &unum); + num = unum; + } else + res = sscanf(b, "%" SCNd64 "%c%c%c", &num, &c, &c2, &c3); + + if (res < 1) + return -1LL; + else if (1 == res) + return num; + else { + c = toupper((int)c); + if (is_hex) { + if (! ((c == '+') || (c == 'X'))) + return -1; + } + if (res > 2) + c2 = toupper((int)c2); + if (res > 3) + c3 = toupper((int)c3); + + switch (c) { + case 'C': + return num; + case 'W': + return num * 2; + case 'B': + return num * 512; + case 'K': /* kilo or kibi */ + if (2 == res) + return num * 1024; + if (('B' == c2) || ('D' == c2)) + return num * 1000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1024; /* KiB */ + return -1LL; + case 'M': /* mega or mebi */ + if (2 == res) + return num * 1048576; /* M */ + if (('B' == c2) || ('D' == c2)) + return num * 1000000; /* MB */ + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1048576; /* MiB */ + return -1LL; + case 'G': /* giga or gibi */ + if (2 == res) + return num * 1073741824; /* G */ + if (('B' == c2) || ('D' == c2)) + return num * 1000000000; /* GB */ + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1073741824; /* GiB */ + return -1LL; + case 'T': /* tera or tebi */ + if (2 == res) + return num * 1099511627776LL; /* T */ + if (('B' == c2) || ('D' == c2)) + return num * 1000000000000LL; /* TB */ + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1099511627776LL; /* TiB */ + return -1LL; + case 'P': /* peta or pebi */ + if (2 == res) + return num * 1099511627776LL * 1024; + if (('B' == c2) || ('D' == c2)) + return num * 1000000000000LL * 1000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1099511627776LL * 1024; + return -1LL; + case 'E': /* exa or exbi */ + if (2 == res) + return num * 1099511627776LL * 1024 * 1024; + if (('B' == c2) || ('D' == c2)) + return num * 1000000000000LL * 1000 * 1000; + if (('I' == c2) && (4 == res) && ('B' == c3)) + return num * 1099511627776LL * 1024 * 1024; + return -1LL; + case 'X': /* experimental: decimal (left arg) multiplication */ + cp = (char *)strchr(b2p, 'x'); + if (NULL == cp) + cp = (char *)strchr(b2p, 'X'); + if (cp) { + ll = sg_get_llnum(cp + 1); + if (-1LL != ll) + return num * ll; + } + return -1LL; + case '+': /* experimental: decimal (left arg) addition */ + cp = (char *)strchr(b2p, '+'); + if (cp) { + ll = sg_get_llnum(cp + 1); + if (-1LL != ll) + return num + ll; + } + return -1LL; + default: + pr2ws("unrecognized multiplier\n"); + return -1LL; + } + } +} + +/* If the number in 'buf' can not be decoded then -1 is returned. Accepts a + * hex prefix (0x or 0X) or a 'h' (or 'H') suffix; otherwise decimal is + * assumed. Does not accept multipliers. Accept a comma (","), hyphen ("-"), + * a whitespace or newline as terminator. Only decimal numbers can represent + * negative numbers and '-1' must be treated separately. */ +int64_t +sg_get_llnum_nomult(const char * buf) +{ + int res, len; + int64_t num; + uint64_t unum; + + if ((NULL == buf) || ('\0' == buf[0])) + return -1; + len = strlen(buf); + if (('0' == buf[0]) && (('x' == buf[1]) || ('X' == buf[1]))) { + res = sscanf(buf + 2, "%" SCNx64 "", &unum); + num = unum; + } else if ('H' == toupper(buf[len - 1])) { + res = sscanf(buf, "%" SCNx64 "", &unum); + num = unum; + } else + res = sscanf(buf, "%" SCNd64 "", &num); + return (1 == res) ? num : -1; +} + +#define MAX_NUM_ASCII_LINES 1048576 + +/* Read ASCII hex bytes or binary from fname (a file named '-' taken as + * stdin). If reading ASCII hex then there should be either one entry per + * line or a comma, space, hyphen or tab separated list of bytes. If no_space + * is set then a string of ACSII hex digits is expected, 2 perbyte. + * Everything from and including a '#' on a line is ignored. Returns 0 if ok, + * or an error code. If the error code is SG_LIB_LBA_OUT_OF_RANGE then mp_arr + * would be exceeded and both mp_arr and mp_arr_len are written to. + * The max_arr_len_and argument may carry extra information: when it + * is negative its absolute value is used for the maximum number of bytes to + * write to mp_arr _and_ the first hexadecimal value on each line is skipped. + * Many hexadecimal output programs place a running address (index) as the + * first field on each line. When as_binary and/or no_space are true, the + * absolute value of max_arr_len_and is used. */ +int +sg_f2hex_arr(const char * fname, bool as_binary, bool no_space, + uint8_t * mp_arr, int * mp_arr_len, int max_arr_len_and) +{ + bool has_stdin, split_line, skip_first, redo_first; + int fn_len, in_len, k, j, m, fd, err, max_arr_len; + int off = 0; + int ret = 0; + unsigned int h; + const char * lcp; + FILE * fp = NULL; + struct stat a_stat; + char line[512]; + char carry_over[4]; + + if ((NULL == fname) || (NULL == mp_arr) || (NULL == mp_arr_len)) { + pr2ws("%s: bad arguments\n", __func__); + return SG_LIB_LOGIC_ERROR; + } + if (max_arr_len_and < 0) { + skip_first = true; + max_arr_len = -max_arr_len_and; + } else { + skip_first = false; + max_arr_len = max_arr_len_and; + } + fn_len = strlen(fname); + if (0 == fn_len) + return SG_LIB_SYNTAX_ERROR; + has_stdin = ((1 == fn_len) && ('-' == fname[0])); /* read from stdin */ + if (as_binary) { + if (has_stdin) + fd = STDIN_FILENO; + else { + fd = open(fname, O_RDONLY); + if (fd < 0) { + err = errno; + pr2ws("unable to open binary file %s: %s\n", fname, + safe_strerror(err)); + return sg_convert_errno(err); + } + } + k = read(fd, mp_arr, max_arr_len); + if (k <= 0) { + if (0 == k) { + ret = SG_LIB_FILE_ERROR; + pr2ws("read 0 bytes from binary file %s\n", fname); + } else { + ret = sg_convert_errno(errno); + pr2ws("read from binary file %s: %s\n", fname, + safe_strerror(errno)); + } + } else if ((k < max_arr_len) && (0 == fstat(fd, &a_stat)) && + S_ISFIFO(a_stat.st_mode)) { + /* pipe; keep reading till error or 0 read */ + while (k < max_arr_len) { + m = read(fd, mp_arr + k, max_arr_len - k); + if (0 == m) + break; + if (m < 0) { + err = errno; + pr2ws("read from binary pipe %s: %s\n", fname, + safe_strerror(err)); + ret = sg_convert_errno(err); + break; + } + k += m; + } + } + if (k >= 0) + *mp_arr_len = k; + if ((fd >= 0) && (! has_stdin)) + close(fd); + return ret; + } + + /* So read the file as ASCII hex */ + if (has_stdin) + fp = stdin; + else { + fp = fopen(fname, "r"); + if (NULL == fp) { + err = errno; + pr2ws("Unable to open %s for reading: %s\n", fname, + safe_strerror(err)); + ret = sg_convert_errno(err); + goto fini; + } + } + + carry_over[0] = 0; + for (j = 0; j < MAX_NUM_ASCII_LINES; ++j) { + if (NULL == fgets(line, sizeof(line), fp)) + break; + in_len = strlen(line); + if (in_len > 0) { + if ('\n' == line[in_len - 1]) { + --in_len; + line[in_len] = '\0'; + split_line = false; + } else + split_line = true; + } + if (in_len < 1) { + carry_over[0] = 0; + continue; + } + if (carry_over[0]) { + if (isxdigit(line[0])) { + carry_over[1] = line[0]; + carry_over[2] = '\0'; + if (1 == sscanf(carry_over, "%4x", &h)) { + if (off > 0) { + if (off > max_arr_len) { + pr2ws("%s: array length exceeded\n", __func__); + ret = SG_LIB_LBA_OUT_OF_RANGE; + *mp_arr_len = max_arr_len; + goto fini; + } else + mp_arr[off - 1] = h; /* back up and overwrite */ + } + } else { + pr2ws("%s: carry_over error ['%s'] around line %d\n", + __func__, carry_over, j + 1); + ret = SG_LIB_SYNTAX_ERROR; + goto fini; + } + lcp = line + 1; + --in_len; + } else + lcp = line; + carry_over[0] = 0; + } else + lcp = line; + + m = strspn(lcp, " \t"); + if (m == in_len) + continue; + lcp += m; + in_len -= m; + if ('#' == *lcp) + continue; + k = strspn(lcp, "0123456789aAbBcCdDeEfF ,-\t"); + if ((k < in_len) && ('#' != lcp[k]) && ('\r' != lcp[k])) { + pr2ws("%s: syntax error at line %d, pos %d\n", __func__, + j + 1, m + k + 1); + ret = SG_LIB_SYNTAX_ERROR; + goto fini; + } + if (no_space) { + for (k = 0; isxdigit(*lcp) && isxdigit(*(lcp + 1)); + ++k, lcp += 2) { + if (1 != sscanf(lcp, "%2x", &h)) { + pr2ws("%s: bad hex number in line %d, pos %d\n", + __func__, j + 1, (int)(lcp - line + 1)); + ret = SG_LIB_SYNTAX_ERROR; + goto fini; + } + if ((off + k) >= max_arr_len) { + pr2ws("%s: array length exceeded\n", __func__); + *mp_arr_len = max_arr_len; + ret = SG_LIB_LBA_OUT_OF_RANGE; + goto fini; + } else + mp_arr[off + k] = h; + } + if (isxdigit(*lcp) && (! isxdigit(*(lcp + 1)))) + carry_over[0] = *lcp; + off += k; + } else { /* (white)space separated ASCII hexadecimal bytes */ + for (redo_first = false, k = 0; k < 1024; + k = (redo_first ? k : k + 1)) { + if (1 == sscanf(lcp, "%10x", &h)) { + if (h > 0xff) { + pr2ws("%s: hex number larger than 0xff in line " + "%d, pos %d\n", __func__, j + 1, + (int)(lcp - line + 1)); + ret = SG_LIB_SYNTAX_ERROR; + goto fini; + } + if (split_line && (1 == strlen(lcp))) { + /* single trailing hex digit might be a split pair */ + carry_over[0] = *lcp; + } + if ((off + k) >= max_arr_len) { + pr2ws("%s: array length exceeded\n", __func__); + ret = SG_LIB_LBA_OUT_OF_RANGE; + *mp_arr_len = max_arr_len; + goto fini; + } else if ((0 == k) && skip_first && (! redo_first)) + redo_first = true; + else { + redo_first = false; + mp_arr[off + k] = h; + } + lcp = strpbrk(lcp, " ,-\t"); + if (NULL == lcp) + break; + lcp += strspn(lcp, " ,-\t"); + if ('\0' == *lcp) + break; + } else { + if (('#' == *lcp) || ('\r' == *lcp)) { + --k; + break; + } + pr2ws("%s: error in line %d, at pos %d\n", __func__, + j + 1, (int)(lcp - line + 1)); + ret = SG_LIB_SYNTAX_ERROR; + goto fini; + } + } + off += (k + 1); + } + } /* end of per line loop */ + if (j >= MAX_NUM_ASCII_LINES) { + pr2ws("%s: wow, more than %d lines of ASCII, give up\n", __func__, + SG_LIB_LBA_OUT_OF_RANGE); + return SG_LIB_LBA_OUT_OF_RANGE; + } + *mp_arr_len = off; + if (fp && (! has_stdin)) + fclose(fp); + return 0; +fini: + if (fp && (! has_stdin)) + fclose(fp); + return ret; +} + +/* Extract character sequence from ATA words as in the model string + * in a IDENTIFY DEVICE response. Returns number of characters + * written to 'ochars' before 0 character is found or 'num' words + * are processed. */ +int +sg_ata_get_chars(const uint16_t * word_arr, int start_word, + int num_words, bool is_big_endian, char * ochars) +{ + int k; + char * op = ochars; + + for (k = start_word; k < (start_word + num_words); ++k) { + char a, b; + uint16_t s = word_arr[k]; + + if (is_big_endian) { + a = s & 0xff; + b = (s >> 8) & 0xff; + } else { + a = (s >> 8) & 0xff; + b = s & 0xff; + } + if (a == 0) + break; + *op++ = a; + if (b == 0) + break; + *op++ = b; + } + return op - ochars; +} + +#ifdef SG_LIB_FREEBSD +#include <sys/param.h> +#elif defined(SG_LIB_WIN32) +#include <windows.h> +#endif + +uint32_t +sg_get_page_size(void) +{ +#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE) + { + long res = sysconf(_SC_PAGESIZE); /* POSIX.1 (was getpagesize()) */ + + return (res <= 0) ? 4096 : res; + } +#elif defined(SG_LIB_WIN32) + static bool got_page_size = false; + static uint32_t win_page_size; + + if (! got_page_size) { + SYSTEM_INFO si; + + GetSystemInfo(&si); + win_page_size = si.dwPageSize; + got_page_size = true; + } + return win_page_size; +#elif defined(SG_LIB_FREEBSD) + return PAGE_SIZE; +#else + return 4096; /* give up, pick likely figure */ +#endif +} + +#if defined(SG_LIB_WIN32) +#if defined(MSC_VER) || defined(__MINGW32__) +/* windows.h already included above */ +#define sg_sleep_for(seconds) Sleep( (seconds) * 1000) +#else +#define sg_sleep_for(seconds) sleep(seconds) +#endif +#else +#define sg_sleep_for(seconds) sleep(seconds) +#endif + +void +sg_sleep_secs(int num_secs) +{ + sg_sleep_for(num_secs); +} + +void +sg_warn_and_wait(const char * cmd_name, const char * dev_name, + bool stress_all) +{ + int k, j; + const char * stressp = stress_all ? "ALL d" : "D"; + const char * will_mayp = stress_all ? "will" : "may"; + + for (k = 0, j = 15; k < 3; ++k, j -= 5) { + printf("\nA %s command will commence in %d seconds\n", cmd_name, j); + printf(" %sata on %s %s be DESTROYED%s\n", stressp, dev_name, + will_mayp, (stress_all ? "" : " or modified")); + printf(" Press control-C to abort\n"); + sg_sleep_secs(5); + } + sg_sleep_secs(1); +} + +/* Returns pointer to heap (or NULL) that is aligned to a align_to byte + * boundary. Sends back *buff_to_free pointer in third argument that may be + * different from the return value. If it is different then the *buff_to_free + * pointer should be freed (rather than the returned value) when the heap is + * no longer needed. If align_to is 0 then aligns to OS's page size. Sets all + * returned heap to zeros. If num_bytes is 0 then set to page size. */ +uint8_t * +sg_memalign(uint32_t num_bytes, uint32_t align_to, uint8_t ** buff_to_free, + bool vb) +{ + size_t psz; + + if (buff_to_free) /* make sure buff_to_free is NULL if alloc fails */ + *buff_to_free = NULL; + psz = (align_to > 0) ? align_to : sg_get_page_size(); + if (0 == num_bytes) + num_bytes = psz; /* ugly to handle otherwise */ + +#ifdef HAVE_POSIX_MEMALIGN + { + int err; + uint8_t * res; + void * wp = NULL; + + err = posix_memalign(&wp, psz, num_bytes); + if (err || (NULL == wp)) { + pr2ws("%s: posix_memalign: error [%d], out of memory?\n", + __func__, err); + return NULL; + } + memset(wp, 0, num_bytes); + if (buff_to_free) + *buff_to_free = (uint8_t *)wp; + res = (uint8_t *)wp; + if (vb) { + pr2ws("%s: posix_ma, len=%d, ", __func__, num_bytes); + if (buff_to_free) + pr2ws("wrkBuffp=%p, ", (void *)res); + pr2ws("psz=%u, rp=%p\n", (unsigned int)psz, (void *)res); + } + return res; + } +#else + { + void * wrkBuff; + uint8_t * res; + sg_uintptr_t align_1 = psz - 1; + + wrkBuff = (uint8_t *)calloc(num_bytes + psz, 1); + if (NULL == wrkBuff) { + if (buff_to_free) + *buff_to_free = NULL; + return NULL; + } else if (buff_to_free) + *buff_to_free = (uint8_t *)wrkBuff; + res = (uint8_t *)(void *) + (((sg_uintptr_t)wrkBuff + align_1) & (~align_1)); + if (vb) { + pr2ws("%s: hack, len=%d, ", __func__, num_bytes); + if (buff_to_free) + pr2ws("buff_to_free=%p, ", wrkBuff); + pr2ws("align_1=%" PRIuPTR "u, rp=%p\n", align_1, (void *)res); + } + return res; + } +#endif +} + +/* If byte_count is 0 or less then the OS page size is used as denominator. + * Returns true if the remainder of ((unsigned)pointer % byte_count) is 0, + * else returns false. */ +bool +sg_is_aligned(const void * pointer, int byte_count) +{ + return 0 == ((sg_uintptr_t)pointer % + ((byte_count > 0) ? (uint32_t)byte_count : + sg_get_page_size())); +} + +/* Does similar job to sg_get_unaligned_be*() but this function starts at + * a given start_bit (i.e. within byte, so 7 is MSbit of byte and 0 is LSbit) + * offset. Maximum number of num_bits is 64. For example, these two + * invocations are equivalent (and should yield the same result); + * sg_get_big_endian(from_bp, 7, 16) + * sg_get_unaligned_be16(from_bp) */ +uint64_t +sg_get_big_endian(const uint8_t * from_bp, int start_bit /* 0 to 7 */, + int num_bits /* 1 to 64 */) +{ + uint64_t res; + int sbit_o1 = start_bit + 1; + + res = (*from_bp++ & ((1 << sbit_o1) - 1)); + num_bits -= sbit_o1; + while (num_bits > 0) { + res <<= 8; + res |= *from_bp++; + num_bits -= 8; + } + if (num_bits < 0) + res >>= (-num_bits); + return res; +} + +/* Does similar job to sg_put_unaligned_be*() but this function starts at + * a given start_bit offset. Maximum number of num_bits is 64. Preserves + * residual bits in partially written bytes. start_bit 7 is MSb. */ +void +sg_set_big_endian(uint64_t val, uint8_t * to, + int start_bit /* 0 to 7 */, int num_bits /* 1 to 64 */) +{ + int sbit_o1 = start_bit + 1; + int mask, num, k, x; + + if ((NULL == to) || (start_bit > 7) || (num_bits > 64)) { + pr2ws("%s: bad args: start_bit=%d, num_bits=%d\n", __func__, + start_bit, num_bits); + return; + } + mask = (8 != sbit_o1) ? ((1 << sbit_o1) - 1) : 0xff; + k = start_bit - ((num_bits - 1) % 8); + if (0 != k) + val <<= ((k > 0) ? k : (8 + k)); + num = (num_bits + 15 - sbit_o1) / 8; + for (k = 0; k < num; ++k) { + if ((sbit_o1 - num_bits) > 0) + mask &= ~((1 << (sbit_o1 - num_bits)) - 1); + if (k < (num - 1)) + x = (val >> ((num - k - 1) * 8)) & 0xff; + else + x = val & 0xff; + to[k] = (to[k] & ~mask) | (x & mask); + mask = 0xff; + num_bits -= sbit_o1; + sbit_o1 = 8; + } +} + +const char * +sg_lib_version() +{ + return sg_lib_version_str; +} + + +#ifdef SG_LIB_MINGW +/* Non Unix OSes distinguish between text and binary files. + Set text mode on fd. Does nothing in Unix. Returns negative number on + failure. */ + +#include <fcntl.h> + +int +sg_set_text_mode(int fd) +{ + return setmode(fd, O_TEXT); +} + +/* Set binary mode on fd. Does nothing in Unix. Returns negative number on + failure. */ +int +sg_set_binary_mode(int fd) +{ + return setmode(fd, O_BINARY); +} + +#else +/* For Unix the following functions are dummies. */ +int +sg_set_text_mode(int fd) +{ + return fd; /* fd should be >= 0 */ +} + +int +sg_set_binary_mode(int fd) +{ + return fd; +} + +#endif |