/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

#include "ctype.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include <libintl.h>

#include "lp.h"
#include "printers.h"

#define	WHO_AM_I	I_AM_LPADMIN
#include "oam.h"

#include "lpadmin.h"

#ifdef LP_USE_PAPI_ATTR
#if	defined(CAN_DO_MODULES)
#define	OPT_LIST "A:ac:d:D:e:f:F:H:hi:I:lm:Mn:o:p:Q:r:S:s:T:u:U:v:W:x:t:P:"
#else
#define	OPT_LIST "A:ac:d:D:e:f:F:hi:I:lm:Mn:o:p:Q:r:S:s:T:u:U:v:W:x:t:P:"
#endif

#else
#if	defined(CAN_DO_MODULES)
#define	OPT_LIST	"A:ac:d:D:e:f:F:H:hi:I:lm:Mo:p:Q:r:S:s:T:u:U:v:W:x:t:P:"
#else
#define	OPT_LIST	"A:ac:d:D:e:f:F:hi:I:lm:Mo:p:Q:r:S:s:T:u:U:v:W:x:t:P:"
#endif
#endif

#define	MALLOC(pointer) \
	if (!(pointer = strdup(optarg))) { \
		LP_ERRMSG (ERROR, E_LP_MALLOC); \
		done (1); \
	} else

#define	REALLOC(pointer) \
	if (!(pointer = realloc(pointer, (unsigned) (strlen(pointer) + 1 + strlen(optarg) + 1)))) { \
		LP_ERRMSG (ERROR, E_LP_MALLOC); \
		done (1); \
	} else if (strcat(pointer, " ")) \
		(void)strcat (pointer, optarg); \
	else

extern char		*optarg;

extern int		optind,
			opterr,
			optopt;

extern double		strtod();

extern long		strtol();

int			a	= 0,	/* alignment needed for mount */
			banner	= -1,	/* allow/don't-allow nobanner */
#if	defined(DIRECT_ACCESS)
			C	= 0,	/* direct a.o.t. normal access */
#endif
		filebreak	= 0,
		h	= 0,	/* hardwired terminal */
		j	= 0,	/* do -F just for current job */
		l	= 0,	/* login terminal */
		M	= 0,	/* do mount */
		t	= 0,	/* tray number*/
		o	= 0,	/* some -o options given */
		Q	= -1,	/* queue threshold for alert */
		W	= -1;	/* alert interval */

char		*A	= 0,	/* alert type */
		*c	= 0,	/* class name */
		*cpi	= 0,	/* string value of -o cpi= */
		*d	= 0,	/* default destination */
		*D	= 0,	/* description */
		*e	= 0,	/* copy existing interface */
		*f	= 0,	/* forms list - allow/deny */
		*P	= 0,	/* paper list  */
		*F	= 0,	/* fault recovery */
		**H	= 0,	/* list of modules to push */
		*i	= 0,	/* interface pathname */
		**I	= 0,	/* content-type-list */
		*length	= 0,	/* string value of -o length= */
		*lpi	= 0,	/* string value of -o lpi= */
		*m	= 0,	/* model name */
		modifications[128], /* list of mods to make */
#ifdef LP_USE_PAPI_ATTR
		*n_opt	= NULL,	/* PPD file name */
#endif
		*p	= 0,	/* printer name */
		*r	= 0,	/* class to remove printer from */
		*s	= 0,	/* system printer is on */
		*stty_opt= 0,	/* string value of -o stty= */
		**o_options = 0,/* undefined lpadmin -o options */
		**S	= 0,	/* -set/print-wheel list */
		**T	= 0,	/* terminfo names */
		*u	= 0,	/* user allow/deny list */
		*U	= 0,	/* dialer_info */
		*v	= 0,	/* device pathname */
		*width	= 0,	/* string value of -o width= */
		*x	= 0;	/* destination to be deleted */

SCALED		cpi_sdn = { 0, 0 },
		length_sdn = { 0, 0 },
		lpi_sdn = { 0, 0 },
		width_sdn = { 0, 0 };

static char	*modp	= modifications;

static void	oparse();

static char *	empty_list[] = { 0 };

/**
 ** options() - PARSE COMMAND LINE ARGUMENTS INTO OPTIONS
 **/

void			options (argc, argv)
	int			argc;
	char			*argv[];
{
	int		optsw,
			ac,
			Aflag = 0;

	char		*cp,
			*rest,
			**av;
	char		stroptsw[] = "-X";

#if	defined(__STDC__)
	typedef char * const *	stupid;	/* dumb-ass ANSI C */
#else
	typedef char **		stupid;
#endif


	/*
	 * Add a fake value to the end of the "argv" list, to
	 * catch the case that a valued-option comes last.
	 */
	av = malloc((argc + 2) * sizeof(char *));
	for (ac = 0; ac < argc; ac++)
		av[ac] = argv[ac];
	av[ac++] = "--";

	opterr = 0;
	while ((optsw = getopt(ac, (stupid)av, OPT_LIST)) != EOF) {

		switch (optsw) {

		/*
		 * These options MAY take a value. Check the value;
		 * if it begins with a '-', assume it's really the next
		 * option.
		 */
		case 'd':
		case 'p':	/* MR bl87-27863 */
		case 'I':
#if	defined(CAN_DO_MODULES)
		case 'H':
#endif
			if (*optarg == '-') {
				/*
				 * This will work if we were given
				 *
				 *	-x -foo
				 *
				 * but would fail if we were given
				 *
				 *	-x-foo
				 */
				optind--;
				switch (optsw) {
				case 'd':
#if	defined(CAN_DO_MODULES)
				case 'H':
#endif
					optarg = NAME_NONE;
					break;
				case 'p':
					optarg = NAME_ALL;
					break;
				case 'I':
					optarg = 0;
					break;
				}
			}
			break;

		/*
		 * These options MUST have a value. Check the value;
		 * if it begins with a dash or is null, complain.
		 */
		case 'Q':
		case 'W':
		case 't':
			/*
			 * These options take numeric values, which might
			 * be negative. Negative values are handled later,
			 * but here we just screen them.
			 */
			(void)strtol(optarg, &rest, 10);
			if (!rest || !*rest)
				break;
			/*FALLTHROUGH*/
		case 'A':
		case 'c':
		case 'e':
		case 'f':
		case 'P':
		case 'F':
		case 'i':
		case 'm':
#ifdef LP_USE_PAPI_ATTR
		case 'n':
#endif
		case 'o':
/*		case 'p': */	/* MR bl87-27863 */
		case 'r':
		case 'S':
		case 's':
		case 'T':
		case 'u':
		case 'U':
		case 'v':
		case 'x':
			/*
			 * These options also must have non-null args.
			 */
			if (!*optarg) {
				stroptsw[1] = optsw;
				LP_ERRMSG1 (ERROR, E_LP_NULLARG, stroptsw);
				done (1);
			}
			if (*optarg == '-') {
				stroptsw[1] = optsw;
				LP_ERRMSG1 (ERROR, E_LP_OPTARG, stroptsw);
				done (1);
			}
			if (optsw == 'A')
				Aflag++;
			break;
		case 'D':
			/*
			 * These options can have a null arg.
			 */
			if (*optarg == '-') {
				stroptsw[1] = optsw;
				LP_ERRMSG1 (ERROR, E_LP_OPTARG, stroptsw);
				done (1);
			}
			break;
		}
	
		switch (optsw) {

		case 'a':	/* alignment pattern needed for mount */
			a = 1;
			break;

		case 'A':	/* alert type */
			if (A)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'A');
			MALLOC(A);
			Aflag++;
			if (!STREQU(A, NAME_QUIET) && !STREQU(A, NAME_LIST))
				*modp++ = 'A';
			break;

		case 'c':	/* class to insert printer p */
			if (c)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'c');
			MALLOC(c);
		break;

#if	defined(DIRECT_ACCESS)
		case 'C':	
			C = 1;
			break;
#endif

		case 'd':	/* system default destination */
			if (d)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'd');
			MALLOC(d);
			break;

		case 'D':	/* description */
			if (D)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'D');
			MALLOC(D);
			*modp++ = 'D';
			break;

		case 'e':	/* existing printer interface */
			if (e)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'e');
			MALLOC(e);
			*modp++ = 'e';
			break;

		case 'f':	/* set up forms allow/deny */
			if (f)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'f');
			MALLOC(f);
			break;

		case 'P':	/* set up forms allow/deny */
			if (P)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'P');
			MALLOC(P);
			break;

		case 'F':	/* fault recovery */
			if (F)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'F');
			MALLOC(F);
			*modp++ = 'F';
			break;

#if	defined(CAN_DO_MODULES)
		case 'H':
			if (H)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'H');
			if (!optarg || !*optarg || STREQU(NAME_NONE, optarg))
				H = empty_list;
			if (!(H = getlist(optarg, LP_WS, LP_SEP))) {
				LP_ERRMSG (ERROR, E_LP_MALLOC);
				done(1);
			}
			*modp++ = 'H';
			break;
#endif
			
		case 'h':	/* hardwired terminal */
			h = 1;
			*modp++ = 'h';
			break;

		case 'i':	/* interface pathname */
			if (i)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'i');
			MALLOC(i);
			*modp++ = 'i';
			break;

		case 'I':	/* content-type-list */
			if (I)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'I');
			if (!optarg || !*optarg || STREQU(NAME_NONE, optarg))
				I = empty_list;
			else if (!(I = getlist(optarg, LP_WS, LP_SEP))) {
				LP_ERRMSG (ERROR, E_LP_MALLOC);
				done (1);
			}
			*modp++ = 'I';
			break;

#if	defined(J_OPTION)
		case 'j':	/* fault recovery just for current job */
			j = 1;
(void) printf (gettext("Sorry, the -j option is currently broken\n"));
			break;
#endif

		case 'l':	/* login terminal */
			l = 1;
			*modp++ = 'l';
			break;

		case 'm':	/* model interface */
			if (m) 
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'm');
			MALLOC(m);
			*modp++ = 'm';
			break;

#ifdef LP_USE_PAPI_ATTR
		case 'n':	/* PPD file */
			if (n_opt)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'n');
			MALLOC(n_opt);
			*modp++ = 'n';
			break;
#endif

		case 'M':	/* a mount request */
			M = 1;
			break;

		case 'o':	/* several different options */
			oparse (optarg);
			o = 1;
			break;

		case 'p':	/* printer name */
			if (p) 
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'p');
			MALLOC(p);
			break;

		case 'Q':
			if (Q != -1)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'Q');
			if (STREQU(NAME_ANY, optarg))
				Q = 1;
			else {
				Q = strtol(optarg, &rest, 10);
				if (Q < 0) {
					LP_ERRMSG1 (ERROR, E_LP_NEGARG, 'Q');
					done (1);
				}
				if (rest && *rest) {
					LP_ERRMSG1 (ERROR, E_LP_GARBNMB, 'Q');
					done (1);
				}
				if (Q == 0) {
					LP_ERRMSG1 (ERROR, E_ADM_ZEROARG, 'Q');
					done (1);
				}
			}
			*modp++ = 'Q';
			break;

		case 'r':	/* class to remove p from */
			if (r) 
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'r');
			MALLOC(r);
			break;

		case 'S':	/* char_set/print-wheels */
			if (S) 
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'S');
			if (!(S = getlist(optarg, LP_WS, LP_SEP))) {
				LP_ERRMSG (ERROR, E_LP_MALLOC);
				done (1);
			}
			*modp++ = 'S';
			break;

		case 's':
			if (s)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 's');

			if ((cp = strchr(optarg, '!')))
				*cp = '\0';

			if ((STREQU(optarg, NAME_NONE)) ||
				(STREQU(optarg, "localhost")))

				s = Local_System;
			else if (STREQU(optarg, Local_System)) {
				if (cp) {
					LP_ERRMSG (ERROR, E_ADM_NAMEONLOCAL);
					done(1);
				} else
					s = Local_System;
			} else {
				if (cp)
				    *cp = '!';

				MALLOC(s);
			}

			/* 's' already used for stty 'R' for remote? */
			*modp++ = 'R';
			break;

		case 't':	/* tray number*/
			if (t != 0) LP_ERRMSG1 (WARNING, E_LP_2MANY, 't');
			t = strtol(optarg, &rest, 10);
			if (t <= 0) {
				LP_ERRMSG1 (ERROR, E_LP_NEGARG, 't');
				done (1);
			}
			if (rest && *rest) {
				LP_ERRMSG1 (ERROR, E_LP_GARBNMB, 't');
				done (1);
			}
			break;

		case 'T':	/* terminfo names for p */
			if (T)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'T');
			if (!(T = getlist(optarg, LP_WS, LP_SEP))) {
				LP_ERRMSG (ERROR, E_LP_MALLOC);
				done (1);
			}
			*modp++ = 'T';
			break;

		case 'u':	/* user allow/deny list */
			if (u)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'u');
			MALLOC(u);
			break;

		case 'U':	/* dialer_info */
			if (U)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'U');
			MALLOC(U);
			*modp++ = 'U';
			break;

		case 'v':	/* device pathname */
			if (v)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'v');
			MALLOC(v);
			*modp++ = 'v';
			break;

		case 'W':	/* alert interval */
			if (W != -1)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'W');
			if (STREQU(NAME_ONCE, optarg))
				W = 0;
			else {
				W = strtol(optarg, &rest, 10);
				if (W < 0) {
					LP_ERRMSG1 (ERROR, E_LP_NEGARG, 'W');
					done (1);
				}
				if (rest && *rest) {
					LP_ERRMSG1 (ERROR, E_LP_GARBNMB, 'W');
					done (1);
				}
			}
			*modp++ = 'W';
			break;

		case 'x':	/* destination to be deleted */
			if (x)
				LP_ERRMSG1 (WARNING, E_LP_2MANY, 'x');
			MALLOC(x);
			break;

		default:
			if (optopt == '?') {
				usage ();
				done (0);

			} else {
				stroptsw[1] = optsw;

				if (strchr(OPT_LIST, optopt))
					LP_ERRMSG1 (ERROR, E_LP_OPTARG,
					    stroptsw);
				else
					LP_ERRMSG1 (ERROR, E_LP_OPTION,
					    stroptsw);
				done (1);
			}
		}
	}

	if (optind < argc)
		LP_ERRMSG1 (WARNING, E_LP_EXTRA, argv[optind]);

	if ((v) && (!Aflag)) {
		if (!(A = strdup("write"))) {
			LP_ERRMSG (ERROR, E_LP_MALLOC);
			done (1);
		}
		*modp++ = 'A';
	}

	return;
}

/**
 ** oparse() - PARSE -o OPTION
 **/

static void		oparse (optarg)
	char			*optarg;
{
	register char		**list	= dashos(optarg);


	if (!list)
		return;

	for ( ; (optarg = *list); list++)

		if (STREQU(optarg, "banner")) {
			if (banner != -1)
				LP_ERRMSG1 (
					WARNING,
					E_ADM_2MANY,
					"banner/nobanner"
				);
			banner = BAN_ALWAYS;
			*modp++ = 'b';

		} else if (STREQU(optarg, "nobanner")) {
			if (banner != -1)
				LP_ERRMSG1 (
					WARNING,
					E_ADM_2MANY,
					"banner/nobanner"
				);
			banner = BAN_OPTIONAL;
			*modp++ = 'b';

		/* handle banner=(always|optional|never) */
		} else if (STRNEQU(optarg, "banner=", 7)) {
			char *ptr;

			ptr = (optarg += 7);
			if (banner != -1)
				LP_ERRMSG1 ( WARNING, E_ADM_2MANY,
				"banner/nobanner/banner=(always|optional|never)"
				);

			/* like "banner", always print a banner */
			if (strcasecmp(ptr, "always") == 0)
				banner = BAN_ALWAYS;
			/* like "nobanner", print a banner unless requested */
			if (strcasecmp(ptr, "optional") == 0)
				banner = BAN_OPTIONAL;
			/* never print a banner */
			if (strcasecmp(ptr, "never") == 0)
				banner = BAN_NEVER;
			*modp++ = 'b';
			
		} else if (STRNEQU(optarg, "length=", 7)) {
			if (length)
				LP_ERRMSG1 (
					WARNING,
					E_ADM_2MANY,
					"length="
				);
			length = (optarg += 7);

			if (!*optarg) {
				length_sdn.val = 0;
				length_sdn.sc = 0;

			} else {
				length_sdn = _getsdn(optarg, &optarg, 0);
				if (errno == EINVAL) {
					LP_ERRMSG (ERROR, E_LP_BADSCALE);
					done (1);
				}
			}
			*modp++ = 'L';

		} else if (STRNEQU(optarg, "width=", 6)) {
			if (width)
				LP_ERRMSG1 (
					WARNING,
					E_ADM_2MANY,
					"width="
				);
			width = (optarg += 6);

			if (!*optarg) {
				width_sdn.val = 0;
				width_sdn.sc = 0;

			} else {
				width_sdn = _getsdn(optarg, &optarg, 0);
				if (errno == EINVAL) {
					LP_ERRMSG (ERROR, E_LP_BADSCALE);
					done (1);
				}
			}
			*modp++ = 'w';

		} else if (STRNEQU(optarg, "cpi=", 4)) {
			if (cpi)
				LP_ERRMSG1 (WARNING, E_ADM_2MANY, "cpi=");

			cpi = (optarg += 4);

			if (!*optarg) {
				cpi_sdn.val = 0;
				cpi_sdn.sc = 0;

			} else {
				cpi_sdn = _getsdn(optarg, &optarg, 1);
				if (errno == EINVAL) {
					LP_ERRMSG (ERROR, E_LP_BADSCALE);
					done (1);
				}
			}
			*modp++ = 'c';

		} else if (STRNEQU(optarg, "lpi=", 4)) {
			if (lpi)
				LP_ERRMSG1 (WARNING, E_ADM_2MANY, "lpi=");
			lpi = (optarg += 4);

			if (!*optarg) {
				lpi_sdn.val = 0;
				lpi_sdn.sc = 0;

			} else {
				lpi_sdn = _getsdn(optarg, &optarg, 0);
				if (errno == EINVAL) {
					LP_ERRMSG (ERROR, E_LP_BADSCALE);
					done (1);
				}
			}
			*modp++ = 'M';

		} else if (STRNEQU(optarg, "stty=", 5)) {

			optarg += 5;
			if (!*optarg)
				stty_opt = 0;

			else {
				if (strchr(LP_QUOTES, *optarg)) {
					register int		len
							= strlen(optarg);

					if (optarg[len - 1] == *optarg)
						optarg[len - 1] = 0;
					optarg++;
				}
				if (stty_opt)
					REALLOC (stty_opt);
				else
					MALLOC (stty_opt);
			}
			*modp++ = 's';

		} else if (STREQU(optarg, "filebreak")) {
			filebreak = 1;

		} else if (STREQU(optarg, "nofilebreak")) {
			filebreak = 0;

		/* added support for using -o to pass any key=value pair */
		} else if (*optarg) {

			if ((addlist(&o_options, optarg)) != 0) {
				fprintf(stderr, gettext("System Error %d\n"), errno);
			}

			*modp++ = 'o';
			optarg++;
		}

	return;
}