/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2019 Joyent, Inc.
 */

#include <scsi/libses.h>
#include "ses_impl.h"

__thread ses_errno_t _ses_errno;
__thread char _ses_errmsg[1024];
__thread char _ses_nverr_member[256];

static void ses_vpanic(const char *, va_list) __NORETURN;

static void
ses_vpanic(const char *fmt, va_list ap)
{
	int oserr = errno;
	char msg[BUFSIZ];
	size_t len;

	(void) snprintf(msg, sizeof (msg), "ABORT: ");
	len = strlen(msg);
	(void) vsnprintf(msg + len, sizeof (msg) - len, fmt, ap);

	if (strchr(fmt, '\n') == NULL) {
		len = strlen(msg);
		(void) snprintf(msg + len, sizeof (msg) - len, ": %s\n",
		    strerror(oserr));
	}

	(void) write(STDERR_FILENO, msg, strlen(msg));

	abort();
}

/*PRINTFLIKE1*/
void
ses_panic(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	ses_vpanic(fmt, ap);
	va_end(ap);
}

int
ses_assert(const char *expr, const char *file, int line)
{
	ses_panic("\"%s\", line %d: assertion failed: %s\n", file, line, expr);

	/*NOTREACHED*/
	return (0);
}

int
nvlist_add_fixed_string(nvlist_t *nvl, const char *name,
    const char *buf, size_t len)
{
	char *str = alloca(len + 1);
	bcopy(buf, str, len);
	str[len] = '\0';

	return (nvlist_add_string(nvl, name, str));
}

/*
 * Like fixed_string, but clears any leading or trailing spaces.
 */
int
nvlist_add_fixed_string_trunc(nvlist_t *nvl, const char *name,
    const char *buf, size_t len)
{
	while (buf[0] == ' ' && len > 0) {
		buf++;
		len--;
	}

	while (len > 0 && buf[len - 1] == ' ')
		len--;

	return (nvlist_add_fixed_string(nvl, name, buf, len));
}

ses_errno_t
ses_errno(void)
{
	return (_ses_errno);
}

const char *
ses_errmsg(void)
{
	if (_ses_errmsg[0] == '\0')
		(void) snprintf(_ses_errmsg, sizeof (_ses_errmsg), "%s",
		    ses_strerror(_ses_errno));

	return (_ses_errmsg);
}

const char *
ses_nv_error_member(void)
{
	if (_ses_nverr_member[0] != '\0')
		return (_ses_nverr_member);
	else
		return (NULL);
}

static int
__ses_set_errno(ses_errno_t err, const char *nvm)
{
	if (nvm == NULL) {
		_ses_nverr_member[0] = '\0';
	} else {
		(void) strlcpy(_ses_nverr_member, nvm,
		    sizeof (_ses_nverr_member));
	}
	_ses_errmsg[0] = '\0';
	_ses_errno = err;

	return (-1);
}

int
ses_set_errno(ses_errno_t err)
{
	return (__ses_set_errno(err, NULL));
}

int
ses_set_nverrno(int err, const char *member)
{
	ses_errno_t se = (err == ENOMEM || err == EAGAIN) ?
	    ESES_NOMEM : ESES_NVL;

	/*
	 * If the error is ESES_NVL, then we should always have a member
	 * available.  The only time 'member' is NULL is when nvlist_alloc()
	 * fails, which should only be possible if memory allocation fails.
	 */
	assert(se == ESES_NOMEM || member != NULL);

	return (__ses_set_errno(se, member));
}

static int
ses_verror(ses_errno_t err, const char *fmt, va_list ap)
{
	int syserr = errno;
	size_t n;
	char *errmsg;

	errmsg = alloca(sizeof (_ses_errmsg));
	(void) vsnprintf(errmsg, sizeof (_ses_errmsg), fmt, ap);
	(void) ses_set_errno(err);

	n = strlen(errmsg);

	while (n != 0 && errmsg[n - 1] == '\n')
		errmsg[--n] = '\0';

	bcopy(errmsg, _ses_errmsg, sizeof (_ses_errmsg));
	errno = syserr;

	return (-1);
}

static int
ses_vnverror(int err, const char *member, const char *fmt,
    va_list ap)
{
	int syserr = errno;
	size_t n;
	char *errmsg;

	errmsg = alloca(sizeof (_ses_errmsg));
	(void) vsnprintf(errmsg, sizeof (_ses_errmsg), fmt, ap);
	(void) ses_set_nverrno(err, member);

	n = strlen(errmsg);

	while (n != 0 && errmsg[n - 1] == '\n')
		errmsg[--n] = '\0';

	(void) snprintf(errmsg + n, sizeof (_ses_errmsg) - n, ": %s",
	    strerror(err));

	bcopy(errmsg, _ses_errmsg, sizeof (_ses_errmsg));
	errno = syserr;

	return (-1);
}

int
ses_error(ses_errno_t err, const char *fmt, ...)
{
	va_list ap;
	int rv;

	va_start(ap, fmt);
	rv = ses_verror(err, fmt, ap);
	va_end(ap);

	return (rv);
}

int
ses_nverror(int err, const char *member, const char *fmt, ...)
{
	va_list ap;
	int rv;

	va_start(ap, fmt);
	rv = ses_vnverror(err, member, fmt, ap);
	va_end(ap);

	return (rv);
}

int
ses_libscsi_error(libscsi_hdl_t *shp, const char *fmt, ...)
{
	va_list ap;
	char errmsg[LIBSES_ERRMSGLEN];
	libscsi_errno_t se = libscsi_errno(shp);
	ses_errno_t e;

	switch (se) {
	case ESCSI_NONE:
		return (0);
	case ESCSI_NOMEM:
		e = ESES_NOMEM;
		break;
	case ESCSI_NOTSUP:
		e = ESES_NOTSUP;
		break;
	case ESCSI_ZERO_LENGTH:
	case ESCSI_VERSION:
	case ESCSI_BADFLAGS:
	case ESCSI_BOGUSFLAGS:
	case ESCSI_BADLENGTH:
	case ESCSI_NEEDBUF:
		va_start(ap, fmt);
		(void) vsnprintf(errmsg, sizeof (errmsg), fmt, ap);
		va_end(ap);
		ses_panic("%s: unexpected libscsi error %s: %s", errmsg,
		    libscsi_errname(se), libscsi_errmsg(shp));
		break;
	case ESCSI_UNKNOWN:
		e = ESES_UNKNOWN;
		break;
	default:
		e = ESES_LIBSCSI;
		break;
	}

	va_start(ap, fmt);
	(void) vsnprintf(errmsg, sizeof (errmsg), fmt, ap);
	va_end(ap);

	return (ses_error(e, "%s: %s", errmsg, libscsi_errmsg(shp)));
}

int
ses_scsi_error(libscsi_action_t *ap, const char *fmt, ...)
{
	va_list args;
	char errmsg[LIBSES_ERRMSGLEN];
	uint64_t asc = 0, ascq = 0, key = 0;
	const char *code, *keystr;

	va_start(args, fmt);
	(void) vsnprintf(errmsg, sizeof (errmsg), fmt, args);
	va_end(args);

	if (libscsi_action_parse_sense(ap, &key, &asc, &ascq, NULL) != 0)
		return (ses_error(ESES_LIBSCSI,
		    "%s: SCSI status %d (no sense data available)", errmsg,
		    libscsi_action_get_status(ap)));

	code = libscsi_sense_code_name(asc, ascq);
	keystr = libscsi_sense_key_name(key);

	return (ses_error(ESES_LIBSCSI, "%s: SCSI status %d sense key %llu "
	    "(%s) additional sense code 0x%llx/0x%llx (%s)", errmsg,
	    libscsi_action_get_status(ap), key, keystr ? keystr : "<unknown>",
	    asc, ascq, code ? code : "<unknown>"));
}

void *
ses_alloc(size_t sz)
{
	void *p;

	if (sz == 0)
		ses_panic("attempted zero-length allocation");

	if ((p = malloc(sz)) == NULL)
		(void) ses_set_errno(ESES_NOMEM);

	return (p);
}

void *
ses_zalloc(size_t sz)
{
	void *p;

	if ((p = ses_alloc(sz)) != NULL)
		bzero(p, sz);

	return (p);
}

char *
ses_strdup(const char *s)
{
	char *p;
	size_t len;

	if (s == NULL)
		ses_panic("attempted zero-length allocation");

	len = strlen(s) + 1;

	if ((p = ses_alloc(len)) != NULL)
		bcopy(s, p, len);

	return (p);
}

void *
ses_realloc(void *p, size_t sz)
{
	if (sz == 0)
		ses_panic("attempted zero-length allocation");

	if ((p = realloc(p, sz)) == NULL)
		(void) ses_set_errno(ESES_NOMEM);

	return (p);
}

/*ARGSUSED*/
void
ses_free(void *p)
{
	free(p);
}