/*
 * Copyright (c) 2014-2016 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.
 */

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <getopt.h>
#define __STDC_FORMAT_MACROS 1
#include <inttypes.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "sg_lib.h"
#include "sg_lib_data.h"
#include "sg_pt.h"
#include "sg_cmds_basic.h"
#include "sg_unaligned.h"
#include "sg_pr2serr.h"

/* A utility program originally written for the Linux OS SCSI subsystem.
 *
 *
 * This program issues the SCSI REPORT ZONES command to the given SCSI device
 * and decodes the response. Based on zbc-r02.pdf
 */

static const char * version_str = "1.08 20160203";

#define MAX_RZONES_BUFF_LEN (1024 * 1024)
#define DEF_RZONES_BUFF_LEN (1024 * 8)

#define SG_ZONING_IN_CMDLEN 16

#define REPORT_ZONES_SA 0x0

#define SENSE_BUFF_LEN 64       /* Arbitrary, could be larger */
#define DEF_PT_TIMEOUT  60      /* 60 seconds */


static struct option long_options[] = {
        {"help", no_argument, 0, 'h'},
        {"hex", no_argument, 0, 'H'},
        {"maxlen", required_argument, 0, 'm'},
        {"partial", no_argument, 0, 'p'},
        {"raw", no_argument, 0, 'r'},
        {"readonly", no_argument, 0, 'R'},
        {"report", required_argument, 0, 'o'},
        {"start", required_argument, 0, 's'},
        {"verbose", no_argument, 0, 'v'},
        {"version", no_argument, 0, 'V'},
        {0, 0, 0, 0},
};


static void
usage()
{
    pr2serr("Usage: "
            "sg_rep_zones  [--help] [--hex] [--maxlen=LEN] [--partial]\n"
            "                     [--raw] [--readonly] [--report=OPT] "
            "[--start=LBA]\n"
            "                     [--verbose] [--version] DEVICE\n");
    pr2serr("  where:\n"
            "    --help|-h          print out usage message\n"
            "    --hex|-H           output response in hexadecimal; used "
            "twice\n"
            "                       shows decoded values in hex\n"
            "    --maxlen=LEN|-m LEN    max response length (allocation "
            "length in cdb)\n"
            "                           (def: 0 -> 8192 bytes)\n"
            "    --partial|-p       sets PARTIAL bit in cdb\n"
            "    --raw|-r           output response in binary\n"
            "    --readonly|-R      open DEVICE read-only (def: read-write)\n"
            "    --report=OPT|-o OP    reporting options (def: 0: all "
            "zones)\n"
            "    --start=LBA|-s LBA    report zones from the LBA (def: 0)\n"
            "                          need not be a zone starting LBA\n"
            "    --verbose|-v       increase verbosity\n"
            "    --version|-V       print version string and exit\n\n"
            "Performs a SCSI REPORT ZONES command.\n");
}

/* Invokes a SCSI REPORT ZONES command (ZBC).  Return of 0 -> success,
 * various SG_LIB_CAT_* positive values or -1 -> other errors */
static int
sg_ll_report_zones(int sg_fd, uint64_t zs_lba, int partial, int report_opts,
                   void * resp, int mx_resp_len, int * residp, int noisy,
                   int verbose)
{
    int k, ret, res, sense_cat;
    unsigned char rzCmdBlk[SG_ZONING_IN_CMDLEN] =
          {SG_ZONING_IN, REPORT_ZONES_SA, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
           0, 0, 0, 0};
    unsigned char sense_b[SENSE_BUFF_LEN];
    struct sg_pt_base * ptvp;

    sg_put_unaligned_be64(zs_lba, rzCmdBlk + 2);
    sg_put_unaligned_be32((uint32_t)mx_resp_len, rzCmdBlk + 10);
    rzCmdBlk[14] = report_opts & 0x3f;
    if (partial)
        rzCmdBlk[14] |= 0x80;
    if (verbose) {
        pr2serr("    Report zones cdb: ");
        for (k = 0; k < SG_ZONING_IN_CMDLEN; ++k)
            pr2serr("%02x ", rzCmdBlk[k]);
        pr2serr("\n");
    }

    ptvp = construct_scsi_pt_obj();
    if (NULL == ptvp) {
        pr2serr("%s: out of memory\n", __func__);
        return -1;
    }
    set_scsi_pt_cdb(ptvp, rzCmdBlk, sizeof(rzCmdBlk));
    set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
    set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
    res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
    ret = sg_cmds_process_resp(ptvp, "report zones", res, mx_resp_len,
                               sense_b, noisy, verbose, &sense_cat);
    if (-1 == ret)
        ;
    else if (-2 == ret) {
        switch (sense_cat) {
        case SG_LIB_CAT_RECOVERED:
        case SG_LIB_CAT_NO_SENSE:
            ret = 0;
            break;
        default:
            ret = sense_cat;
            break;
        }
    } else
        ret = 0;
    if (residp)
        *residp = get_scsi_pt_resid(ptvp);
    destruct_scsi_pt_obj(ptvp);
    return ret;
}

static void
dStrRaw(const char* str, int len)
{
    int k;

    for (k = 0 ; k < len; ++k)
        printf("%c", str[k]);
}

static const char *
zone_type_str(int zt, char * b, int blen, int vb)
{
    const char * cp;

    if (NULL == b)
        return "zone_type_str: NULL ptr)";
    switch (zt) {
    case 1:
        cp = "Conventional";
        break;
    case 2:
        cp = "Sequential write required";
        break;
    case 3:
        cp = "Sequential write preferred";
        break;
    default:
        cp = NULL;
        break;
    }
    if (cp) {
        if (vb)
            snprintf(b, blen, "%s [0x%x]", cp, zt);
        else
            snprintf(b, blen, "%s", cp);
    } else
        snprintf(b, blen, "Reserved [0x%x]", zt);
    return b;
}

static const char *
zone_condition_str(int zc, char * b, int blen, int vb)
{
    const char * cp;

    if (NULL == b)
        return "zone_condition_str: NULL ptr)";
    switch (zc) {
    case 0:
        cp = "Not write pointer";
        break;
    case 1:
        cp = "Empty";
        break;
    case 2:
        cp = "Implicitly opened";
        break;
    case 3:
        cp = "Explicitly opened";
        break;
    case 4:
        cp = "Closed";
        break;
    case 0xd:
        cp = "Read only";
        break;
    case 0xe:
        cp = "Full";
        break;
    case 0xf:
        cp = "Offline";
        break;
    default:
        cp = NULL;
        break;
    }
    if (cp) {
        if (vb)
            snprintf(b, blen, "%s [0x%x]", cp, zc);
        else
            snprintf(b, blen, "%s", cp);
    } else
        snprintf(b, blen, "Reserved [0x%x]", zc);
    return b;
}

static const char * same_desc_arr[16] = {
    "zone type and length may differ in each descriptor",
    "zone type and length same in each descriptor",
    "zone type and length same apart from length in last descriptor",
    "zone type for each descriptor may be different",
    "Reserved [0x4]", "Reserved [0x5]", "Reserved [0x6]", "Reserved [0x7]",
    "Reserved [0x8]", "Reserved [0x9]", "Reserved [0xa]", "Reserved [0xb]",
    "Reserved [0xc]", "Reserved [0xd]", "Reserved [0xe]", "Reserved [0xf]",
};


int
main(int argc, char * argv[])
{
    int sg_fd, k, res, c, zl_len, len, zones, resid, rlen, zt, zc, same;
    int do_hex = 0;
    int maxlen = 0;
    int do_partial = 0;
    int do_raw = 0;
    int o_readonly = 0;
    int reporting_opt = 0;
    int verbose = 0;
    uint64_t st_lba = 0;
    int64_t ll;
    const char * device_name = NULL;
    unsigned char * reportZonesBuff = NULL;
    unsigned char * ucp;
    int ret = 0;
    char b[80];

    while (1) {
        int option_index = 0;

        c = getopt_long(argc, argv, "hHm:o:prRs:vV", long_options,
                        &option_index);
        if (c == -1)
            break;

        switch (c) {
        case 'h':
        case '?':
            usage();
            return 0;
        case 'H':
            ++do_hex;
            break;
        case 'm':
            maxlen = sg_get_num(optarg);
            if ((maxlen < 0) || (maxlen > MAX_RZONES_BUFF_LEN)) {
                pr2serr("argument to '--maxlen' should be %d or "
                        "less\n", MAX_RZONES_BUFF_LEN);
                return SG_LIB_SYNTAX_ERROR;
            }
            break;
        case 'o':
           reporting_opt = sg_get_num(optarg);
           if ((reporting_opt < 0) || (reporting_opt > 63)) {
                pr2serr("bad argument to '--report=OPT', expect 0 to "
                        "63\n");
                return SG_LIB_SYNTAX_ERROR;
            }
            break;
        case 'p':
            ++do_partial;
            break;
        case 'r':
            ++do_raw;
            break;
        case 'R':
            ++o_readonly;
            break;
        case 's':
            ll = sg_get_llnum(optarg);
            if (-1 == ll) {
                pr2serr("bad argument to '--start=LBA'\n");
                return SG_LIB_SYNTAX_ERROR;
            }
            st_lba = (uint64_t)ll;
            break;
        case 'v':
            ++verbose;
            break;
        case 'V':
            pr2serr("version: %s\n", version_str);
            return 0;
        default:
            pr2serr("unrecognised option code 0x%x ??\n", c);
            usage();
            return SG_LIB_SYNTAX_ERROR;
        }
    }
    if (optind < argc) {
        if (NULL == device_name) {
            device_name = argv[optind];
            ++optind;
        }
        if (optind < argc) {
            for (; optind < argc; ++optind)
                pr2serr("Unexpected extra argument: %s\n", argv[optind]);
            usage();
            return SG_LIB_SYNTAX_ERROR;
        }
    }

    if (NULL == device_name) {
        pr2serr("missing device name!\n");
        usage();
        return SG_LIB_SYNTAX_ERROR;
    }

    if (do_raw) {
        if (sg_set_binary_mode(STDOUT_FILENO) < 0) {
            perror("sg_set_binary_mode");
            return SG_LIB_FILE_ERROR;
        }
    }

    sg_fd = sg_cmds_open_device(device_name, o_readonly, verbose);
    if (sg_fd < 0) {
        pr2serr("open error: %s: %s\n", device_name,
                safe_strerror(-sg_fd));
        return SG_LIB_FILE_ERROR;
    }

    if (0 == maxlen)
        maxlen = DEF_RZONES_BUFF_LEN;
    reportZonesBuff = (unsigned char *)calloc(1, maxlen);
    if (NULL == reportZonesBuff) {
        pr2serr("unable to malloc %d bytes\n", maxlen);
        return SG_LIB_CAT_OTHER;
    }

    res = sg_ll_report_zones(sg_fd, st_lba, do_partial, reporting_opt,
                             reportZonesBuff, maxlen, &resid, 1, verbose);
    ret = res;
    if (0 == res) {
        rlen = maxlen - resid;
        if (rlen < 4) {
            pr2serr("Response length (%d) too short\n", rlen);
            ret = SG_LIB_CAT_MALFORMED;
            goto the_end;
        }
        zl_len = sg_get_unaligned_be32(reportZonesBuff + 0) + 64;
        if (zl_len > rlen) {
            if (verbose)
                pr2serr("zl_len available is %d, response length is %d\n",
                        zl_len, rlen);
            len = rlen;
        } else
            len = zl_len;
        if (do_raw) {
            dStrRaw((const char *)reportZonesBuff, len);
            goto the_end;
        }
        if (do_hex && (2 != do_hex)) {
            dStrHex((const char *)reportZonesBuff, len,
                    ((1 == do_hex) ? 1 : -1));
            goto the_end;
        }
        printf("Report zones response:\n");
        if (len < 64) {
            pr2serr("Zone length [%d] too short (perhaps after truncation\n)",
                    len);
            ret = SG_LIB_CAT_MALFORMED;
            goto the_end;
        }
        same = reportZonesBuff[4] & 0xf;
        printf("  Same=%d: %s\n\n", same, same_desc_arr[same]);
        printf("  Maximum LBA: 0x%" PRIx64 "\n",
               sg_get_unaligned_be64(reportZonesBuff + 8));
        zones = (len - 64) / 64;
        for (k = 0, ucp = reportZonesBuff + 64; k < zones; ++k, ucp += 64) {
            printf(" Zone descriptor: %d\n", k);
            if (do_hex) {
                dStrHex((const char *)ucp, len, -1);
                continue;
            }
            zt = ucp[0] & 0xf;
            zc = (ucp[1] >> 4) & 0xf;
            printf("   Zone type: %s\n", zone_type_str(zt, b, sizeof(b),
                   verbose));
            printf("   Zone condition: %s\n", zone_condition_str(zc, b,
                   sizeof(b), verbose));
            printf("   Non_seq: %d\n", !!(ucp[1] & 0x2));
            printf("   Reset: %d\n", ucp[1] & 0x1);
            printf("   Zone Length: 0x%" PRIx64 "\n",
                   sg_get_unaligned_be64(ucp + 8));
            printf("   Zone start LBA: 0x%" PRIx64 "\n",
                   sg_get_unaligned_be64(ucp + 16));
            printf("   Write pointer LBA: 0x%" PRIx64 "\n",
                   sg_get_unaligned_be64(ucp + 24));
        }
        if ((64 + (64 * zones)) < zl_len)
            printf("\n>>> Beware: Zone list truncated, may need another "
                   "call\n");
    } else if (SG_LIB_CAT_INVALID_OP == res)
        pr2serr("Report zones command not supported\n");
    else {
        sg_get_category_sense_str(res, sizeof(b), b, verbose);
        pr2serr("Report zones command: %s\n", b);
    }

the_end:
    if (reportZonesBuff)
        free(reportZonesBuff);
    res = sg_cmds_close_device(sg_fd);
    if (res < 0) {
        pr2serr("close error: %s\n", safe_strerror(-res));
        if (0 == ret)
            return SG_LIB_FILE_ERROR;
    }
    return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
}
