path: root/usr/src/cmd/lp/lib/printers/getprinter.c

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

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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/* EMACS_MODES: !fill, lnumb, !overwrite, !nodelete, !picture */

#include "stdio.h"
#include "string.h"
#include "errno.h"
#include "sys/types.h"
#include "stdlib.h"
#include <syslog.h>

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

extern struct {
	char			*v;
	short			len,
				okremote;
}			prtrheadings[];

/**
 ** getprinter() - EXTRACT PRINTER STRUCTURE FROM DISK FILE
 **/

PRINTER *
getprinter(char *name)
{
	static long		lastdir		= -1;

	PRINTER		*prp;

	char			buf[BUFSIZ];

	short			daisy;

	int			fld;

	int fd;

	FALERT			*pa;

	register char *		p;
	register char **	pp;
	register char ***	ppp;
	register char *		path;
	int			isNameAll;



	if (!name || !*name) {
		errno = EINVAL;
		return (0);
	}

	syslog(LOG_DEBUG, "getprinter(%s)", name ? name : "");
	/*
	 * Getting ``all''? If so, jump into the directory
	 * wherever we left off.
	 */
	isNameAll = STREQU(NAME_ALL, name);
	for (; ; ) {  
		/* fix for bug 1117241 
		 * occasionally when a printer is removed, a printer directory
		 * is left behind, but the CONFIGFILE is removed.  In this
		 * case this directory terminates the search for additional
		 * printers as we have been returning 0 in this case.
		 * Now, we loop back and try the next directory until
		 * we have no more directories or we find a directory with
		 * a CONFIGFILE 
		 */
		if (isNameAll) {
			if (!(name = next_dir(Lp_A_Printers, &lastdir)))
				return (0);
		} else
			lastdir = -1;

		/*
		 * Get the printer configuration information.
		 */

		path = getprinterfile(name, CONFIGFILE);
		if (!path) {
			if (isNameAll)
				Free(name);
			return (0);
		}

		if ((fd = open_locked(path, "r", 0)) < 0) {
			Free(path);	/*
					 * go around to loop again for
					 * NAME_ALL case
					 */

			if (!isNameAll) /* fix for bug 1117241 */
				return(0);
			else
				Free(name);
		}
		else
			break;
	}
	Free (path);

	/*
	 * Initialize the entire structure, to ensure no random
	 * values get in it. However, make sure some values won't
	 * be null or empty. Do the latter here as opposed to
	 * after reading the file, because sometimes the file
	 * contains an empty header to FORCE a null/empty value.
	 */
	prp = calloc(sizeof (*prp), 1);
	prp->name = Strdup(name);
	if (isNameAll)
		Free(name);
	prp->printer_types = getlist(NAME_UNKNOWN, LP_WS, LP_SEP);
	prp->input_types = getlist(NAME_SIMPLE, LP_WS, LP_SEP);
#if	defined(CAN_DO_MODULES)
	prp->modules = getlist(NAME_DEFAULT, LP_WS, LP_SEP);
#endif

	/*
	 * Read the file.
	 */
	errno = 0;
	while (fdgets(buf, BUFSIZ, fd) != NULL) {

		buf[strlen(buf) - 1] = 0;

		for (fld = 0; fld < PR_MAX; fld++)
			if (
				prtrheadings[fld].v
			     && prtrheadings[fld].len
			     && STRNEQU(
					buf,
					prtrheadings[fld].v,
					prtrheadings[fld].len
				)
			) {
				p = buf + prtrheadings[fld].len;
				while (*p && *p == ' ')
					p++;
				break;
			}

		/*
		 * To allow future extensions to not impact applications
		 * using old versions of this routine, ignore strange
		 * fields.
		 */
		if (fld >= PR_MAX) 
			continue;

		switch (fld) {

		case PR_BAN:
			if ((pp = getlist(p, LP_WS, ":"))) {
				if (pp[0] != NULL) {
					if (strcmp(pp[0], NAME_OPTIONAL) == 0)
						prp->banner = BAN_OPTIONAL;
					else if (strcmp(pp[0], NAME_OFF) == 0)
						prp->banner = BAN_NEVER;
					else if (strcmp(pp[0], NAME_ON) == 0)
						prp->banner = BAN_ALWAYS;
					else /* default to the LP default */
						prp->banner = BAN_ALWAYS;
				}
				if (pp[1] && CS_STREQU(pp[1], NAME_ALWAYS))
					prp->banner |= BAN_ALWAYS;
				freelist (pp);
			}
			break;

		case PR_LOGIN:
			prp->login = LOG_IN;
			break;

		case PR_CPI:
			prp->cpi = getcpi(p);
			break;

		case PR_LPI:
			prp->lpi = getsdn(p);
			break;

		case PR_LEN:
			prp->plen = getsdn(p);
			break;

		case PR_WIDTH:
			prp->pwid = getsdn(p);
			break;

		case PR_CS:
			ppp = &(prp->char_sets);
			goto CharStarStar;

		case PR_ITYPES:
			ppp = &(prp->input_types);
CharStarStar:		if (*ppp)
				freelist (*ppp);
			*ppp = getlist(p, LP_WS, LP_SEP);
			break;

		case PR_DEV:
			pp = &(prp->device);
			goto CharStar;

		case PR_DIAL:
			pp = &(prp->dial_info);
			goto CharStar;

		case PR_RECOV:
			pp = &(prp->fault_rec);
			goto CharStar;

		case PR_INTFC:
			pp = &(prp->interface);
			goto CharStar;

		case PR_PTYPE:
			ppp = &(prp->printer_types);
			goto CharStarStar;

		case PR_REMOTE:
			pp = &(prp->remote);
			goto CharStar;

		case PR_SPEED:
			pp = &(prp->speed);
			goto CharStar;

		case PR_STTY:
			pp = &(prp->stty);
CharStar:		if (*pp)
				Free (*pp);
			*pp = Strdup(p);
			break;

#if	defined(CAN_DO_MODULES)
		case PR_MODULES:
			ppp = &(prp->modules);
			goto CharStarStar;
#endif

		case PR_OPTIONS:
			ppp = &(prp->options);
			goto CharStarStar;
			break;

		case PR_PPD:
		{
			pp = &(prp->ppd);
			goto CharStar;
		}
		}

	}
	if (errno != 0) {
		int			save_errno = errno;

		freeprinter (prp);
		close(fd);
		errno = save_errno;
		return (0);
	}
	close(fd);

	/*
	 * Get the printer description (if it exists).
	 */
	if (!(path = getprinterfile(prp->name, COMMENTFILE)))
		return (0);
	if (!(prp->description = loadstring(path)) && errno != ENOENT) {
		Free (path);
		freeprinter (prp);
		return (0);
	}
	Free (path);

	/*
	 * Get the information for the alert. Don't fail if we can't
	 * read it because of access permission UNLESS we're "root"
	 * or "lp"
	 */
	if (!(pa = getalert(Lp_A_Printers, prp->name))) {
		if (
			errno != ENOENT
		     && (
				errno != EACCES
			     || !getpid()		  /* we be root */
			     || STREQU(getname(), LPUSER) /* we be lp   */
			)
		) {
			freeprinter (prp);
			return (0);
		}
	} else
		prp->fault_alert = *pa;

	/*
	 * Now go through the structure and see if we have
	 * anything strange.
	 */
	if (!okprinter(prp->name, prp, 0)) {
		freeprinter (prp);
		errno = EBADF;
		return (0);
	}

	/*
	 * Just in case somebody tried to pull a fast one
	 * by giving a printer type header by itself....
	 */
	if (!prp->printer_types)
		prp->printer_types = getlist(NAME_UNKNOWN, LP_WS, LP_SEP);

	/*
	 * If there are more than one printer type, then we can't
	 * have any input types, except perhaps ``simple''.
	 */
	if (
		lenlist(prp->printer_types) > 1
	     && prp->input_types
	     && (
			lenlist(prp->input_types) > 1
		     || !STREQU(NAME_SIMPLE, *prp->input_types)
		)
	) {
		freeprinter (prp);
		badprinter = BAD_ITYPES;
		errno = EBADF;
		return (0);
	}

	/*
	 * If there are more than one printer types, none can
	 * be ``unknown''.
	 */
	if (
		lenlist(prp->printer_types) > 1
	     && searchlist(NAME_UNKNOWN, prp->printer_types)
	) {
		freeprinter (prp);
		badprinter = BAD_PTYPES;
		errno = EBADF;
		return (0);
	}

	/*
	 * All the printer types had better agree on whether the
	 * printer takes print wheels!
	 */
	prp->daisy = -1;
	for (pp = prp->printer_types; *pp; pp++) {
		tidbit (*pp, "daisy", &daisy);
		if (daisy == -1)
			daisy = 0;
		if (prp->daisy == -1)
			prp->daisy = daisy;
		else if (prp->daisy != daisy) {
			freeprinter (prp);
			badprinter = BAD_DAISY;
			errno = EBADF;
			return (0);
		}
	}

	/*
	 * Help out those who are still using the obsolete
	 * "printer_type" member.
	 */
	prp->printer_type = Strdup(*prp->printer_types);

	return (prp);
}