/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2019, Joyent, Inc.
 */

/*
 * CCID cfgadm plugin
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>

#include <sys/usb/clients/ccid/uccid.h>

#define	CFGA_PLUGIN_LIB
#include <config_admin.h>

int cfga_version = CFGA_HSL_V2;

static cfga_err_t
cfga_ccid_error(cfga_err_t err, char **errp, const char *fmt, ...)
{
	va_list ap;

	if (errp == NULL)
		return (err);

	/*
	 * Try to format a string. However because we have to return allocated
	 * memory, if this fails, then we have no error.
	 */
	va_start(ap, fmt);
	(void) vasprintf(errp, fmt, ap);
	va_end(ap);

	return (err);
}

cfga_err_t
cfga_ccid_modify(uccid_cmd_icc_modify_t *modify, const char *ap,
    struct cfga_confirm *confp, struct cfga_msg *msgp, char **errp,
    boolean_t force)
{
	int fd;
	uccid_cmd_status_t ucs;
	uccid_cmd_txn_begin_t begin;
	boolean_t held = B_FALSE;

	/*
	 * Check ap is valid by doing a status request.
	 */
	if ((fd = open(ap, O_RDWR)) < 0) {
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
		    "failed to open %s: %s", ap, strerror(errno)));
	}

	bzero(&ucs, sizeof (ucs));
	ucs.ucs_version = UCCID_CURRENT_VERSION;

	if (ioctl(fd, UCCID_CMD_STATUS, &ucs) != 0) {
		int e = errno;
		if (errno == ENODEV) {
			(void) close(fd);
			return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
			    "ap %s going away", ap));
		}
		(void) close(fd);
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "ioctl on ap %s failed: %s", ap, strerror(e)));
	}

	/*
	 * Attempt to get a hold. If we cannot obtain a hold, we will not
	 * perform this unless the user has said we should force this.
	 */
	bzero(&begin, sizeof (begin));
	begin.uct_version = UCCID_CURRENT_VERSION;
	begin.uct_flags = UCCID_TXN_DONT_BLOCK;
	if (ioctl(fd, UCCID_CMD_TXN_BEGIN, &begin) != 0) {
		if (errno != EBUSY) {
			int e = errno;
			(void) close(fd);
			return (cfga_ccid_error(CFGA_ERROR, errp, "failed to "
			    "begin ccid transaction on ap %s: %s", ap,
			    strerror(e)));
		}

		/*
		 * If the user didn't force this operation, prompt if we would
		 * interfere.
		 */
		if (!force) {
			int confirm = 0;
			const char *prompt = "CCID slot is held exclusively "
			    "by another program.  Proceeding may interrupt "
			    "their functionality. Continue?";
			if (confp != NULL && confp->appdata_ptr != NULL) {
				confirm = (*confp->confirm)(confp->appdata_ptr,
				    prompt);
			}

			if (confirm == 0) {
				(void) close(fd);
				return (CFGA_NACK);
			}
		}
	} else {
		held = B_TRUE;
	}

	if (ioctl(fd, UCCID_CMD_ICC_MODIFY, modify) != 0) {
		int e = errno;
		(void) close(fd);
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "failed to modify state on ap %s: %s", ap,
		    strerror(e)));
	}

	if (held) {
		uccid_cmd_txn_end_t end;

		bzero(&end, sizeof (end));
		end.uct_version = UCCID_CURRENT_VERSION;
		end.uct_flags = UCCID_TXN_END_RELEASE;

		if (ioctl(fd, UCCID_CMD_TXN_END, &end) != 0) {
			int e = errno;
			(void) close(fd);
			return (cfga_ccid_error(CFGA_ERROR, errp, "failed to "
			    "end transaction on ap %s: %s", ap,
			    strerror(e)));
		}
	}

	(void) close(fd);
	return (CFGA_OK);

}

cfga_err_t
cfga_change_state(cfga_cmd_t cmd, const char *ap, const char *opts,
    struct cfga_confirm *confp, struct cfga_msg *msgp, char **errp,
    cfga_flags_t flags)
{
	uccid_cmd_icc_modify_t modify;

	if (errp != NULL) {
		*errp = NULL;
	}

	if (ap == NULL) {
		return (cfga_ccid_error(CFGA_APID_NOEXIST, errp, NULL));
	}

	if (opts != NULL) {
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "hardware specific options are not supported"));
	}

	bzero(&modify, sizeof (modify));
	modify.uci_version = UCCID_CURRENT_VERSION;
	switch (cmd) {
	case CFGA_CMD_CONFIGURE:
		modify.uci_action = UCCID_ICC_POWER_ON;
		break;
	case CFGA_CMD_UNCONFIGURE:
		modify.uci_action = UCCID_ICC_POWER_OFF;
		break;
	default:
		(void) cfga_help(msgp, opts, flags);
		return (CFGA_OPNOTSUPP);
	}

	return (cfga_ccid_modify(&modify, ap, confp, msgp, errp,
	    (flags & CFGA_FLAG_FORCE) != 0));
}

cfga_err_t
cfga_private_func(const char *function, const char *ap, const char *opts,
    struct cfga_confirm *confp, struct cfga_msg *msgp, char **errp,
    cfga_flags_t flags)
{
	uccid_cmd_icc_modify_t modify;

	if (errp != NULL) {
		*errp = NULL;
	}

	if (function == NULL) {
		return (CFGA_ERROR);
	}

	if (ap == NULL) {
		return (cfga_ccid_error(CFGA_APID_NOEXIST, errp, NULL));
	}

	if (opts != NULL) {
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "hardware specific options are not supported"));
	}

	if (strcmp(function, "warm_reset") != 0) {
		return (CFGA_OPNOTSUPP);
	}

	bzero(&modify, sizeof (modify));
	modify.uci_version = UCCID_CURRENT_VERSION;
	modify.uci_action = UCCID_ICC_WARM_RESET;

	return (cfga_ccid_modify(&modify, ap, confp, msgp, errp,
	    (flags & CFGA_FLAG_FORCE) != 0));
}

/*
 * We don't support the test entry point for CCID.
 */
cfga_err_t
cfga_test(const char *ap, const char *opts, struct cfga_msg *msgp, char **errp,
    cfga_flags_t flags)
{
	(void) cfga_help(msgp, opts, flags);
	return (CFGA_OPNOTSUPP);
}

static void
cfga_ccid_fill_info(const uccid_cmd_status_t *ucs, char *buf, size_t len)
{
	const char *product, *serial, *tran, *prot;
	uint_t bits = CCID_CLASS_F_TPDU_XCHG | CCID_CLASS_F_SHORT_APDU_XCHG |
	    CCID_CLASS_F_EXT_APDU_XCHG;

	if ((ucs->ucs_status & UCCID_STATUS_F_PRODUCT_VALID) != 0) {
		product = ucs->ucs_product;
	} else {
		product = "<unknown>";
	}

	if ((ucs->ucs_status & UCCID_STATUS_F_SERIAL_VALID) != 0) {
		serial = ucs->ucs_serial;
	} else {
		serial = "<unknown>";
	}

	switch (ucs->ucs_class.ccd_dwFeatures & bits) {
	case 0:
		tran = "Character";
		break;
	case CCID_CLASS_F_TPDU_XCHG:
		tran = "TPDU";
		break;
	case CCID_CLASS_F_SHORT_APDU_XCHG:
	case CCID_CLASS_F_EXT_APDU_XCHG:
		tran = "APDU";
		break;
	default:
		tran = "Unknown";
		break;
	}

	if ((ucs->ucs_status & UCCID_STATUS_F_PARAMS_VALID) != 0) {
		switch (ucs->ucs_prot) {
		case UCCID_PROT_T0:
			prot = " (T=0)";
			break;
		case UCCID_PROT_T1:
			prot = " (T=1)";
			break;
		default:
			prot = "<unknown>";
			break;
		}
	} else {
		prot = "<unknown>";
	}

	if ((ucs->ucs_status & UCCID_STATUS_F_CARD_ACTIVE) != 0) {
		(void) snprintf(buf, len, "Product: %s Serial: %s "
		    "Transport: %s Protocol: %s", product, serial,
		    tran, prot);
	} else {
		(void) snprintf(buf, len, "Product: %s Serial: %s ",
		    product, serial);
	}
}

cfga_err_t
cfga_list_ext(const char *ap, struct cfga_list_data **ap_list, int *nlist,
    const char *opts, const char *listopts, char **errp, cfga_flags_t flags)
{
	int fd;
	uccid_cmd_status_t ucs;
	struct cfga_list_data *cld;

	if (errp != NULL) {
		*errp = NULL;
	}

	if (ap == NULL) {
		return (cfga_ccid_error(CFGA_APID_NOEXIST, errp, NULL));
	}

	if (opts != NULL) {
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "hardware specific options are not supported"));
	}

	if ((fd = open(ap, O_RDWR)) < 0) {
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
		    "failed to open %s: %s", ap, strerror(errno)));
	}

	bzero(&ucs, sizeof (ucs));
	ucs.ucs_version = UCCID_CURRENT_VERSION;

	if (ioctl(fd, UCCID_CMD_STATUS, &ucs) != 0) {
		int e = errno;
		(void) close(fd);
		if (e == ENODEV) {
			return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
			    "ap %s going away", ap));
		}
		return (cfga_ccid_error(CFGA_ERROR, errp,
		    "ioctl on ap %s failed: %s", ap, strerror(e)));
	}
	(void) close(fd);

	if ((cld = calloc(1, sizeof (*cld))) == NULL) {
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp, "failed to "
		    "allocate memory for list entry"));
	}

	if (snprintf(cld->ap_log_id, sizeof (cld->ap_log_id), "ccid%d/slot%u",
	    ucs.ucs_instance, ucs.ucs_slot) >= sizeof (cld->ap_log_id)) {
		free(cld);
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp, "ap %s logical id"
		    " was too large", ap));
	}

	if (strlcpy(cld->ap_phys_id, ap, sizeof (cld->ap_phys_id)) >=
	    sizeof (cld->ap_phys_id)) {
		free(cld);
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
		    "ap %s physical id was too long", ap));
	}

	cld->ap_class[0] = '\0';

	if ((ucs.ucs_status & UCCID_STATUS_F_CARD_PRESENT) != 0) {
		cld->ap_r_state = CFGA_STAT_CONNECTED;
		if ((ucs.ucs_status & UCCID_STATUS_F_CARD_ACTIVE) != 0) {
			cld->ap_o_state = CFGA_STAT_CONFIGURED;
		} else {
			cld->ap_o_state = CFGA_STAT_UNCONFIGURED;
		}
	} else {
		cld->ap_r_state = CFGA_STAT_EMPTY;
		cld->ap_o_state = CFGA_STAT_UNCONFIGURED;
	}

	/*
	 * We should probably have a way to indicate that there's an error when
	 * the ICC is basically foobar'd. We should also allow the status ioctl
	 * to know that the slot is resetting or something else is going on.
	 */
	if ((ucs.ucs_class.ccd_dwFeatures &
	    (CCID_CLASS_F_SHORT_APDU_XCHG | CCID_CLASS_F_EXT_APDU_XCHG)) == 0) {
		cld->ap_cond = CFGA_COND_UNUSABLE;
	} else {
		cld->ap_cond = CFGA_COND_OK;
	}
	cld->ap_busy = 0;
	cld->ap_status_time = (time_t)-1;
	cfga_ccid_fill_info(&ucs, cld->ap_info, sizeof (cld->ap_info));
	if (strlcpy(cld->ap_type, "icc", sizeof (cld->ap_type)) >=
	    sizeof (cld->ap_type)) {
		free(cld);
		return (cfga_ccid_error(CFGA_LIB_ERROR, errp,
		    "ap %s type overflowed ICC field", ap));
	}

	*ap_list = cld;
	*nlist = 1;
	return (CFGA_OK);
}

cfga_err_t
cfga_help(struct cfga_msg *msgp, const char *opts, cfga_flags_t flags)
{
	(void) (*msgp->message_routine)(msgp, "CCID specific commands:\n");
	(void) (*msgp->message_routine)(msgp,
	    " cfgadm -c [configure|unconfigure] ap_id [ap_id...]\n");
	(void) (*msgp->message_routine)(msgp,
	    " cfgadm -x warm_reset ap_id [ap_id...]\n");

	return (CFGA_OK);
}

int
cfga_ap_id_cmp(const cfga_ap_log_id_t ap_id1, const cfga_ap_log_id_t ap_id2)
{
	return (strcmp(ap_id1, ap_id2));
}