/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <strings.h>
#include <ctype.h>
#include <libgen.h>
#include <libintl.h>

#include <libxml/tree.h>
#include <libxml/parser.h>

#include <kmfapiP.h>
#include "util.h"


/* Supporting structures and global variables for getopt_av(). */
typedef struct	av_opts_s {
	int		shortnm;	/* short name character */
	char		*longnm;	/* long name string, NOT terminated */
	int		longnm_len;	/* length of long name string */
	boolean_t	has_arg;	/* takes optional argument */
} av_opts;

static av_opts		*opts_av = NULL;
static const char	*_save_optstr = NULL;
static int		_save_numopts = 0;
int			optind_av = 1;
char			*optarg_av = NULL;

void
free_policy_list(POLICY_LIST *plist)
{
	POLICY_LIST *n = plist, *old;

	if (plist == NULL)
		return;

	while (n != NULL) {
		old = n;
		kmf_free_policy_record(&n->plc);
		n = n->next;
		free(old);
	}
	plist = NULL;
}

int
load_policies(char *file, POLICY_LIST **policy_list)
{
	int rv = KC_OK;
	KMF_RETURN kmfrv = KMF_OK;
	POLICY_LIST *newitem, *plist = NULL;
	xmlParserCtxtPtr ctxt;
	xmlDocPtr doc = NULL;
	xmlNodePtr cur, node;

	/* Create a parser context */
	ctxt = xmlNewParserCtxt();
	if (ctxt == NULL)
		return (KMF_ERR_POLICY_DB_FORMAT);

	/* Read the policy DB and verify it against the schema. */
	doc = xmlCtxtReadFile(ctxt, file, NULL,
	    XML_PARSE_DTDVALID | XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
	if (doc == NULL || ctxt->valid == 0) {
		kmfrv = KMF_ERR_POLICY_DB_FORMAT;
		goto end;
	}

	cur = xmlDocGetRootElement(doc);
	if (cur == NULL) {
		kmfrv = KMF_ERR_POLICY_DB_FORMAT;
		goto end;
	}

	node = cur->xmlChildrenNode;
	while (node != NULL) {
		char *c;
		/*
		 * Search for the policy that matches the given name.
		 */
		if (!xmlStrcmp((const xmlChar *)node->name,
		    (const xmlChar *)KMF_POLICY_ELEMENT)) {
			/* Check the name attribute */
			c = (char *)xmlGetProp(node,
			    (const xmlChar *)KMF_POLICY_NAME_ATTR);

			/* If a match, parse the rest of the data */
			if (c != NULL) {
				xmlFree(c);
				newitem = malloc(sizeof (POLICY_LIST));
				if (newitem != NULL) {
					(void) memset(newitem, 0,
					    sizeof (POLICY_LIST));
					kmfrv = parsePolicyElement(node,
					    &newitem->plc);
				} else {
					kmfrv = KMF_ERR_MEMORY;
					goto end;
				}
				/* add to linked list */
				if (plist == NULL) {
					plist = newitem;
				} else {
					POLICY_LIST *n = plist;
					while (n->next != NULL)
						n = n->next;

					n->next = newitem;
					newitem->next = NULL;
				}
			}
		}
		node = node->next;
	}

end:
	if (ctxt != NULL)
		xmlFreeParserCtxt(ctxt);

	if (doc != NULL)
		xmlFreeDoc(doc);

	if (kmfrv != KMF_OK) {
		free_policy_list(plist);
		rv = KC_ERR_LOADDB;
	} else {
		*policy_list = plist;
	}

	return (rv);
}

/*
 * Return 0 if there is any error in the input string.
 */
uint16_t
parseKUlist(char *kustring)
{
	uint16_t cur_bit;
	uint16_t kubits = 0;
	char *p;

	p = strtok(kustring, ",");
	while (p != NULL) {
		cur_bit = kmf_string_to_ku(p);
		if (cur_bit == 0) {
			kubits = 0;
			break;
		}
		kubits |= cur_bit;
		p = strtok(NULL, ",");
	}

	return (kubits);
}

static void
addToEKUList(KMF_EKU_POLICY *ekus, KMF_OID *newoid)
{
	if (newoid != NULL && ekus != NULL) {
		ekus->eku_count++;
		ekus->ekulist = realloc(
		    ekus->ekulist, ekus->eku_count * sizeof (KMF_OID));
		if (ekus->ekulist != NULL) {
			ekus->ekulist[ekus->eku_count-1] = *newoid;
		}
	}
}

int
parseEKUNames(char *ekulist, KMF_POLICY_RECORD *plc)
{
	int rv = KC_OK;
	char *p;
	KMF_OID *newoid;
	KMF_EKU_POLICY *ekus = &plc->eku_set;

	if (ekulist == NULL || !strlen(ekulist))
		return (0);

	/*
	 * The list should be comma separated list of EKU Names.
	 */
	p = strtok(ekulist, ",");

	/* If no tokens found, then maybe its just a single EKU value */
	if (p == NULL) {
		newoid = kmf_ekuname_to_oid(ekulist);
		if (newoid != NULL) {
			addToEKUList(ekus, newoid);
			free(newoid);
		} else {
			rv = KC_ERR_USAGE;
		}
	}

	while (p != NULL) {
		newoid = kmf_ekuname_to_oid(p);
		if (newoid != NULL) {
			addToEKUList(ekus, newoid);
			free(newoid);
		} else {
			rv = KC_ERR_USAGE;
			break;
		}
		p = strtok(NULL, ",");
	}

	if (rv != KC_OK)
		kmf_free_eku_policy(ekus);

	return (rv);
}

int
parseEKUOIDs(char *ekulist, KMF_POLICY_RECORD *plc)
{
	int rv = KC_OK;
	char *p;
	KMF_OID newoid = { 0, NULL };
	KMF_EKU_POLICY *ekus = &plc->eku_set;

	if (ekulist == NULL || !strlen(ekulist))
		return (0);

	/*
	 * The list should be comma separated list of EKU Names.
	 */
	p = strtok(ekulist, ",");
	if (p == NULL) {
		if (kmf_string_to_oid(ekulist, &newoid) == KMF_OK) {
			addToEKUList(ekus, &newoid);
		} else {
			rv = KC_ERR_USAGE;
		}
	}

	while (p != NULL && rv == 0) {
		if (kmf_string_to_oid(p, &newoid) == KMF_OK) {
			addToEKUList(ekus, &newoid);
		} else {
			rv = KC_ERR_USAGE;
			break;
		}
		p = strtok(NULL, ",");
	}

	if (rv != KC_OK)
		kmf_free_eku_policy(ekus);

	return (rv);
}

int
get_boolean(char *arg)
{
	if (arg == NULL)
		return (-1);
	if (strcasecmp(arg, "true") == 0)
		return (1);
	if (strcasecmp(arg, "false") == 0)
		return (0);
	return (-1);
}

/*
 * This function processes the input string.  It removes the beginning
 * and ending blank's first, makes a copy of the resulting string and
 * return it.
 *
 * This function returns NULL, if there is an error in the
 * input string or when the system is out of memory.  The output
 * "err_flag" argument will record the error code, if it is not NULL.
 */
char *
get_string(char *str, int *err_flag)
{
	char *p;
	int len, i;
	char *retstr = NULL;

	if (str == NULL) {
		if (err_flag != NULL)
			*err_flag = KC_ERR_USAGE;
		return (NULL);
	}

	/* Remove beginning whitespace */
	p = str;
	while (p != NULL && isspace(*p))
		p++;

	if (p == NULL) {
		if (err_flag != NULL)
			*err_flag = KC_ERR_USAGE;
		return (NULL);
	}

	/* Remove the trailing blanks */
	len = strlen(p);
	while (len > 0 && isspace(p[len-1]))
		len--;

	if (len == 0) {
		if (err_flag != NULL)
			*err_flag = KC_ERR_USAGE;
		return (NULL);
	}

	/* Check if there is any non-printable character */
	i = 0;
	while (i < len) {
		if (isprint(p[i]))
			i++;
		else {
			if (err_flag != NULL)
				*err_flag = KC_ERR_USAGE;
			return (NULL);
		}
	}

	/* Make a copy of the string and return it */
	retstr = malloc(len + 1);
	if (retstr == NULL) {
		if (err_flag != NULL)
			*err_flag = KC_ERR_MEMORY;
		return (NULL);
	}

	if (err_flag != NULL)
		*err_flag = KC_OK;

	(void) strncpy(retstr, p, len);
	retstr[len] = '\0';
	return (retstr);
}

/*
 * Breaks out the getopt-style option string into a structure that can be
 * traversed later for calls to getopt_av().  Option string is NOT altered,
 * but the struct fields point to locations within option string.
 */
static int
populate_opts(char *optstring)
{
	int		i;
	av_opts		*temp;
	char		*marker;

	if (optstring == NULL || *optstring == '\0')
		return (0);

	/*
	 * This tries to imitate getopt(3c) Each option must conform to:
	 * <short name char> [ ':' ] [ '(' <long name string> ')' ]
	 * If long name is missing, the short name is used for long name.
	 */
	for (i = 0; *optstring != '\0'; i++) {
		if ((temp = (av_opts *)((i == 0) ? malloc(sizeof (av_opts)) :
		    realloc(opts_av, (i+1) * sizeof (av_opts)))) == NULL) {
			free(opts_av);
			opts_av = NULL;
			return (0);
		} else
			opts_av = (av_opts *)temp;

		marker = optstring;		/* may need optstring later */

		opts_av[i].shortnm = *marker++;	/* set short name */

		if (*marker == ':') {		/* check for opt arg */
			marker++;
			opts_av[i].has_arg = B_TRUE;
		}

		if (*marker == '(') {		/* check and set long name */
			marker++;
			opts_av[i].longnm = marker;
			opts_av[i].longnm_len = strcspn(marker, ")");
			optstring = marker + opts_av[i].longnm_len + 1;
		} else {
			/* use short name option character */
			opts_av[i].longnm = optstring;
			opts_av[i].longnm_len = 1;
			optstring = marker;
		}
	}

	return (i);
}

/*
 * getopt_av() is very similar to getopt(3c) in that the takes an option
 * string, compares command line arguments for matches, and returns a single
 * letter option when a match is found.  However, getopt_av() differs from
 * getopt(3c) by allowing both longname options and values be found
 * on the command line.
 */
int
getopt_av(int argc, char * const *argv, const char *optstring)
{
	int	i;
	int	len;

	if (optind_av >= argc)
		return (EOF);

	/* First time or when optstring changes from previous one */
	if (_save_optstr != optstring) {
		if (opts_av != NULL)
			free(opts_av);
		opts_av = NULL;
		_save_optstr = optstring;
		_save_numopts = populate_opts((char *)optstring);
	}

	for (i = 0; i < _save_numopts; i++) {
		if (strcmp(argv[optind_av], "--") == 0) {
			optind_av++;
			break;
		}

		len = strcspn(argv[optind_av], "=");

		if (len == opts_av[i].longnm_len && strncmp(argv[optind_av],
		    opts_av[i].longnm, opts_av[i].longnm_len) == 0) {
			/* matched */
			if (!opts_av[i].has_arg) {
				optind_av++;
				return (opts_av[i].shortnm);
			}

			/* needs optarg */
			if (argv[optind_av][len] == '=') {
				optarg_av = &(argv[optind_av][len+1]);
				optind_av++;
				return (opts_av[i].shortnm);
			}

			optarg_av = NULL;
			optind_av++;
			return ((int)'?');
		}
	}

	return (EOF);
}

void
print_sanity_error(KMF_RETURN ret)
{
	switch (ret) {
	case KMF_ERR_POLICY_NAME:
		(void) fprintf(stderr, gettext("Error in the policy name\n"));
		break;
	case KMF_ERR_TA_POLICY:
		(void) fprintf(stderr,
		    gettext("Error in trust anchor attributes\n"));
		break;
	case KMF_ERR_OCSP_POLICY:
		(void) fprintf(stderr,
		    gettext("Error in OCSP policy attributes\n"));
		break;
	default:
		break;
	}
}


conf_entry_t *
get_keystore_entry(char *kstore_name)
{
	conf_entrylist_t *phead = NULL;
	conf_entrylist_t *ptr;
	conf_entry_t	*rtn_entry = NULL;

	if (kstore_name == NULL)
		return (NULL);

	if (get_entrylist(&phead) != KMF_OK)
		return (NULL);

	ptr = phead;
	while (ptr != NULL) {
		if (strcmp(ptr->entry->keystore, kstore_name) == 0)
			break;
		ptr = ptr->next;
	}

	if (ptr != NULL) /* found the entry */
		rtn_entry = dup_entry(ptr->entry);

	free_entrylist(phead);
	return (rtn_entry);
}