xref: /onnv-gate/usr/src/cmd/print/bsd-sysv-commands/in.lpd.c (revision 6725)

/*
 * 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.
 *
 */

/* $Id: in.lpd.c 170 2006-05-20 05:58:49Z njacobs $ */

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <syslog.h>
#include <libintl.h>
#include <pwd.h>
#include <grp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/systeminfo.h>

#include <papi.h>
#include <uri.h>
#include "common.h"

#define	ACK(fp)		{ (void) fputc('\0', fp); (void) fflush(fp); }
#define	NACK(fp)	{ (void) fputc('\1', fp); (void) fflush(fp); }

/*
 * This file contains the front-end of the BSD Print Protocol adaptor.  This
 * code assumes a BSD Socket interface to the networking side.
 */

static char *
remote_host_name(FILE *fp)
{
	struct hostent *hp;
	struct sockaddr_in6 peer;
	socklen_t peer_len = sizeof (peer);
	int fd = fileno(fp);
	int error_num;
	char myname[MAXHOSTNAMELEN], tmp_buf[INET6_ADDRSTRLEN];
	char *hostname;

	/* who is our peer ? */
	if (getpeername(fd, (struct sockaddr *)&peer, &peer_len) < 0) {
		if ((errno != ENOTSOCK) && (errno != EINVAL))
			return (NULL);
		else
			return (strdup("localhost"));
	}

	/* get their name or return a string containing their address */
	if ((hp = getipnodebyaddr((const char *)&peer.sin6_addr,
				sizeof (struct in6_addr), AF_INET6,
				&error_num)) == NULL) {
		return (strdup(inet_ntop(peer.sin6_family,
			&peer.sin6_addr, tmp_buf, sizeof (tmp_buf))));
	}

	/* is it "localhost" ? */
	if (strcasecmp(hp->h_name, "localhost") == 0)
		return (strdup("localhost"));

	/* duplicate the name because gethostbyXXXX() is not reentrant */
	hostname = strdup(hp->h_name);
	(void) sysinfo(SI_HOSTNAME, myname, sizeof (myname));

	/* is it from one of my addresses ? */
	if ((hp = getipnodebyname(myname, AF_INET6, AI_ALL|AI_V4MAPPED,
	    &error_num)) != NULL) {
		struct in6_addr **tmp = (struct in6_addr **)hp->h_addr_list;
		int i = 0;

		while (tmp[i] != NULL) {
			if (memcmp(tmp[i++], &peer.sin6_addr, hp->h_length)
			    == 0) {
				free(hostname);
				return (strdup("localhost"));
			}
		}
	}

	/* It must be someone else */
	return (hostname);
}

static void
fatal(FILE *fp, char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vsyslog(LOG_DEBUG, fmt, ap);
	vfprintf(fp, fmt, ap);
	va_end(ap);
	exit(1);
}

static void
cleanup(char ***files, char **cf)
{
	if (*files != NULL) {
		int i;

		for (i = 0; (*files)[i] != NULL; i++) {
			(void) unlink((*files)[i]);
			free((*files)[i]);
		}
		free(*files);
		*files = NULL;
	}

	if (*cf != NULL) {
		free(*cf);
		*cf = NULL;
	}
}

static papi_attribute_t **
parse_cf(papi_service_t svc, char *cf, char **files)
{
	papi_attribute_t **list = NULL;
	char	previous = NULL,
		*entry,
		*s,
		text[BUFSIZ];
	int	count = 0,
		copies_set = 0,
		copies = 0;

	for (entry = strtok(cf, "\n"); entry != NULL;
	    entry = strtok(NULL, "\n")) {
		char *format = NULL;

		/* count the copies */
		if ((entry[0] >= 'a') && (entry[0] <= 'z') &&
		    (copies_set == 0) && (previous == entry[0]))
			copies++;
		else if ((previous >= 'a') && (previous <= 'z'))
			copies_set = 1;
		previous = entry[0];

		/* process the control message */
		switch (entry[0]) {
		/* RFC-1179 options */
		case 'J':	/* RFC-1179 Banner Job Name */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"job-name", ++entry);
			break;
		case 'C':	/* RFC-1179 Banner Class Name */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"rfc-1179-class", ++entry);
			break;
		case 'L':	/* RFC-1179 Banner toggle  */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"job-sheets", "standard");
			break;
		case 'T':	/* RFC-1179 Title (pr)  */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"pr-title", ++entry);
			break;
		case 'H':	/* RFC-1179 Host */
			/*
			 * use the host as known by us, not by them
			 *
			 * papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
			 *		"job-originating-host-name", ++entry);
			 */
			break;
		case 'P':	/* RFC-1179 User */
			++entry;
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"requesting-user-name", entry);
			papiServiceSetUserName(svc, entry);
			break;
		case 'M':	/* RFC-1179 Mail to User */
			papiAttributeListAddBoolean(&list, PAPI_ATTR_EXCL,
				"rfc-1179-mail", 1);
			break;
		case 'W':	/* RFC-1179 Width (pr) */
			papiAttributeListAddInteger(&list, PAPI_ATTR_EXCL,
					"pr-width", atoi(++entry));
			break;
		case 'I':	/* RFC-1179 Indent (pr) */
			papiAttributeListAddInteger(&list, PAPI_ATTR_EXCL,
					"pr-indent", atoi(++entry));
			break;
		case 'N':	/* RFC-1179 Filename */
			/* could have HPUX extension embedded */
			if (entry[1] != ' ') {	/* real pathname */
#ifdef DEBUG
				papiAttributeListAddString(&list,
						PAPI_ATTR_EXCL,
						"flist", ++entry);
#endif
			} else if (entry[2] == 'O') /* HPUX lp -o options */
				papiAttributeListFromString(&list,
						PAPI_ATTR_APPEND, ++entry);
			break;
		case 'U':	/* RFC-1179 Unlink */
			break;	/* ignored */
		case '1':	/* RFC-1179 TROFF Font R */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
				"rfc-1179-font-r", ++entry);
			break;
		case '2':	/* RFC-1179 TROFF Font I */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
				"rfc-1179-font-i", ++entry);
			break;
		case '3':	/* RFC-1179 TROFF Font B */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
				"rfc-1179-font-b", ++entry);
			break;
		case '4':	/* RFC-1179 TROFF Font S */
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
				"rfc-1179-font-s", ++entry);
			break;
		case 'f':	/* RFC-1179 ASCII file (print) */
			format = "text/plain";
			if (is_postscript(files[0]) == 1)
				format = "application/postscript";
			break;
		case 'l':	/* RFC-1179 CATV file (print) */
			format = "application/octet-stream";
			if (is_postscript(files[0]) == 1)
				format = "application/postscript";
			break;
		case 'o':	/* RFC-1179 Postscript file (print) */
			format = "application/postscript";
			break;
		case 'p':	/* RFC-1179 PR file (print) */
			format = "application/x-pr";
			papiAttributeListAddBoolean(&list, PAPI_ATTR_EXCL,
					"pr-filter", 1);
			break;
		case 't':	/* RFC-1179 TROFF file (print) */
			format = "application/x-troff";
			break;
		case 'n':	/* RFC-1179 DITROFF file (print) */
			format = "application/x-ditroff";
			break;
		case 'd':	/* RFC-1179 DVI file (print) */
			format = "application/x-dvi";
			break;
		case 'g':	/* RFC-1179 GRAPH file (print) */
			format = "application/x-plot";
			break;
		case 'c':	/* RFC-1179 CIF file (print) */
			format = "application/x-cif";
			break;
		case 'v':	/* RFC-1179 RASTER file (print) */
			format = "application/x-raster";
			break;
		case 'r':	/* RFC-1179 FORTRAN file (print) */
			format = "application/x-fortran";
			break;
		/* Sun Solaris Extensions */
		case 'O':
			++entry;
			do {
				if (*entry != '"')
					text[count++] = *entry;
			} while (*entry++);
			papiAttributeListFromString(&list, PAPI_ATTR_APPEND,
				text);
			break;
		case '5':
			++entry;
			switch (entry[0]) {
			case 'f':	/* Solaris form */
				papiAttributeListAddString(&list,
						PAPI_ATTR_EXCL,
						"form", ++entry);
				break;
			case 'H':	/* Solaris handling */
				++entry;
				if (strcasecmp(entry, "hold") == 0)
					papiAttributeListAddString(&list,
						PAPI_ATTR_EXCL,
						"job-hold-until", "indefinite");
				else if (strcasecmp(entry, "immediate") == 0)
					papiAttributeListAddString(&list,
						PAPI_ATTR_EXCL,
						"job-hold-until", "no-hold");
				else
					papiAttributeListAddString(&list,
						PAPI_ATTR_EXCL,
						"job-hold-until", entry);
				break;
			case 'p':	/* Solaris notification */
				papiAttributeListAddBoolean(&list,
					PAPI_ATTR_EXCL, "rfc-1179-mail", 1);
				break;
			case 'P': {	/* Solaris page list */
				char buf[BUFSIZ];

				snprintf(buf, sizeof (buf), "page-ranges=%s",
						++entry);
				papiAttributeListFromString(&list,
						PAPI_ATTR_EXCL, buf);
				}
				break;
			case 'q': {	/* Solaris priority */
				int i = atoi(optarg);

				i = 100 - (i * 2.5);
				if ((i < 1) || (i > 100))
					i = 50;
				papiAttributeListAddInteger(&list,
					PAPI_ATTR_EXCL, "job-priority", i);
				}
				break;
			case 'S':	/* Solaris character set */
				papiAttributeListAddString(&list,
					PAPI_ATTR_EXCL, "lp-charset",
					++entry);
				break;
			case 'T':	/* Solaris type */
				format = lp_type_to_mime_type(++entry);
				break;
			case 'y':	/* Solaris mode */
				papiAttributeListAddString(&list,
					PAPI_ATTR_APPEND, "lp-modes", ++entry);
				break;
			default:
				syslog(LOG_INFO|LOG_DEBUG,
					"Warning: cf message (%s) ignored",
					entry);
				break;
			}
			break;
		/* Undefined Extensions: SCO, Ultrix, AIX, ... */

		default:
			syslog(LOG_INFO|LOG_DEBUG,
				"Warning: cf message (%s) ignored", entry);
			break;
		}

		if (format != NULL)
			papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
				"document-format", format);
	}

	papiAttributeListAddInteger(&list, PAPI_ATTR_EXCL,
					"copies", ++copies);
	papiAttributeListAddString(&list, PAPI_ATTR_EXCL,
					"job-sheets", "none");

	return (list);
}

static papi_status_t
submit_job(papi_service_t svc, FILE *ifp, char *printer, char *cf, char **files)
{
	papi_attribute_t **list = NULL;
	papi_status_t status;
	papi_job_t job = NULL;
	char *format = "";

	if ((list = parse_cf(svc, cf, files)) != NULL) {
		/* use the host as known by us, not by them */
		char *host = remote_host_name(ifp);

		if (host != NULL) {
			papiAttributeListAddString(&list, PAPI_ATTR_REPLACE,
					"job-originating-host-name", host);
			free(host);
		}
	}

	status = papiJobSubmit(svc, printer, list, NULL, files, &job);
	syslog(LOG_DEBUG, "submit: %s", papiStatusString(status));
	if (status != PAPI_OK) {
		char *tmp = papiServiceGetStatusMessage(svc);

		syslog(LOG_DEBUG, "submit-detail: %s", tmp ? tmp : "none");
	}
	papiJobFree(job);

	return (status);
}

static char *
receive_control_file(papi_service_t svc, FILE *ifp, FILE *ofp, int size)
{
	char *ptr, *cf_data;

	if ((ptr = cf_data = calloc(1, size + 1)) == NULL) {
		NACK(ofp);
		return (NULL);
	} else
		ACK(ofp);

	while (size > 0) {
		int rc;

		if (((rc = fread(ptr, 1, size, ifp)) == 0) &&
		    (feof(ifp) != 0)) {
			free(cf_data);
			return (NULL);
		} else {
			ptr += rc;
			size -= rc;
		}
	}
	syslog(LOG_DEBUG, "cf_data(%s)", cf_data);

	if (fgetc(ifp) != 0) {
		free(cf_data);
		return (NULL);
	}
	ACK(ofp);

	return (cf_data);
}

static char *
receive_data_file(FILE *ifp, FILE *ofp, int size)
{
	char file[] = "lpdXXXXXX";
	char buf[BUFSIZ];
	int fd;

	if ((fd = mkstemp(file)) < 0) {
		NACK(ofp);
		return (NULL);
	} else
		ACK(ofp);

	while (size > 0) {
		int rc = ((size > BUFSIZ) ? BUFSIZ : size);

		if (((rc = fread(buf, 1, rc, ifp)) == 0) &&
		    (feof(ifp) != 0)) {
			close(fd);
			unlink(file);
			return (NULL);
		} else {
			char *ptr = buf;

			while (rc > 0) {
				int wrc = write(fd, ptr, rc);

				if (wrc < 0) {
					close(fd);
					unlink(file);
					return (NULL);
				}

				ptr += wrc;
				size -= wrc;
				rc -= wrc;
			}
		}
	}
	close(fd);
	if (fgetc(ifp) != 0) {
		unlink(file);
		return (NULL);
	}
	ACK(ofp);

	return (strdup(file));
}

static papi_status_t
berkeley_receive_files(papi_service_t svc, FILE *ifp, FILE *ofp, char *printer)
{
	papi_status_t status = PAPI_OK;
	char *file, **files = NULL;	/* the job data files */
	char *cf = NULL;
	char buf[BUFSIZ];

	while (fgets(buf, sizeof (buf), ifp) != NULL) {
		int size;

		syslog(LOG_DEBUG, "XFER CMD: (%d)%s\n", buf[0], &buf[1]);
#ifdef DEBUG	/* translate [1-3]... messages to \[1-3] to run by hand */
		if ((buf[0] > '0') && (buf[0] < '4'))
			buf[0] -= '0';
#endif
		switch (buf[0]) {
		case 0x01:	/* Abort */
			cleanup(&files, &cf);
			break;
		case 0x02: {	/* Receive control file */
			cf = receive_control_file(svc, ifp, ofp, atoi(&buf[1]));
			if (cf == NULL) {
				cleanup(&files, &cf);
				return (PAPI_BAD_REQUEST);
			} else if (files != NULL) {
				status = submit_job(svc, ifp, printer, cf,
							files);
				cleanup(&files, &cf);
			}
			}
			break;
		case 0x03: {	/* Receive data file */
			file = receive_data_file(ifp, ofp, atoi(&buf[1]));
			if (file == NULL) {
				cleanup(&files, &cf);
				return (PAPI_TEMPORARY_ERROR);
			}
			list_append(&files, file);
			}
			break;
		default:
			cleanup(&files, &cf);
			fatal(ofp, "protocol screwup");
			break;
		}
	}

	if ((cf != NULL) && (files != NULL))
		status = submit_job(svc, ifp, printer, cf, files);

	cleanup(&files, &cf);

	return (status);
}

static papi_status_t
berkeley_transfer_files(papi_service_t svc, FILE *ifp, FILE *ofp,
		char *printer)
{
	papi_status_t status;
	papi_printer_t p = NULL;
	char *keys[] = { "printer-is-accepting-jobs", NULL };

	status = papiPrinterQuery(svc, printer, keys, NULL, &p);
	if ((status == PAPI_OK) && (p != NULL)) {
		papi_attribute_t **attrs = papiPrinterGetAttributeList(p);
		char accepting = PAPI_FALSE;

		papiAttributeListGetBoolean(attrs, NULL,
				"printer-is-accepting-jobs", &accepting);

		if (accepting == PAPI_TRUE) {
			ACK(ofp);
			status = berkeley_receive_files(svc, ifp, ofp, printer);
		} else
			NACK(ofp);

		papiPrinterFree(p);
	} else
		NACK(ofp);

	return (status);
}

static int
cyclical_service_check(char *svc_name)
{
	papi_attribute_t **list;
	char buf[BUFSIZ];
	uri_t *uri = NULL;
	char *s = NULL;

	/* was there a printer? */
	if (svc_name == NULL)
		return (0);

	if ((list = getprinterbyname(svc_name, NULL)) == NULL)
		return (0);	/* if it doesnt' resolve, we will fail later */

	papiAttributeListGetString(list, NULL, "printer-uri-supported", &s);
	if ((s == NULL) || (strcasecmp(svc_name, s) != 0))
		return (0);	/* they don't match */

	/* is it in uri form? */
	if (uri_from_string(s, &uri) < 0)
		return (0);

	if ((uri == NULL) || (uri->scheme == NULL) || (uri->host == NULL)) {
		uri_free(uri);
		return (0);
	}

	/* is it in lpd form? */
	if (strcasecmp(uri->scheme, "lpd") != 0) {
		uri_free(uri);
		return (0);
	}

	/* is it the local host? */
	sysinfo(SI_HOSTNAME, buf, sizeof (buf));
	if ((strcasecmp(uri->host, "localhost") != 0) &&
	    (strcasecmp(uri->host, buf) != 0)) {
		uri_free(uri);
		return (0);
	}

	uri_free(uri);
	return (1);
}


/*
 * This is the entry point for this program.  The program takes the
 * following options:
 * 	(none)
 */
int
main(int ac, char *av[])
{
	papi_status_t status;
	papi_service_t svc = NULL;
	papi_encryption_t encryption = PAPI_ENCRYPT_NEVER;
	FILE	*ifp = stdin,
		*ofp = stdout;
	int	c;
	char	buf[BUFSIZ],
		**args,
		*printer,
		*run_dir = "/var/run/in.lpd",
		*run_user = NULL;
	struct passwd *pw = NULL;

	(void) chdir("/tmp");		/* run in /tmp by default */
	openlog("bsd-gw", LOG_PID, LOG_LPR);

	while ((c = getopt(ac, av, "Ed:u:")) != EOF)
		switch (c) {
		case 'E':
			encryption = PAPI_ENCRYPT_ALWAYS;
			break;
		case 'd':	/* run where they tell you */
			run_dir = optarg;
			break;
		case 'u':	/* run as */
			run_user = optarg;
			break;
		default:
			;
		}

	if (run_user != NULL)	/* get the requested user info */
		pw = getpwnam(run_user);

	if (run_dir != NULL) {	/* setup the run_dir */
		(void) mkdir(run_dir, 0700);
		if (pw != NULL)
			(void) chown(run_dir, pw->pw_uid, pw->pw_gid);
	}

	if (pw != NULL) {	/* run as the requested user */
		syslog(LOG_DEBUG, "name: %s, uid: %d, gid: %d",
				pw->pw_name, pw->pw_uid, pw->pw_gid);
		initgroups(pw->pw_name, pw->pw_gid);
		setgid(pw->pw_gid);
		setuid(pw->pw_uid);
	}

	if (run_dir != NULL)	/* move to the run_dir */
		if (chdir(run_dir) < 0) {
			syslog(LOG_DEBUG, "failed to chdir(%s)", run_dir);
			exit(1);
		}

	syslog(LOG_DEBUG, "$CWD = %s", getwd(NULL));

	if (fgets(buf, sizeof (buf), ifp) == NULL) {
		if (feof(ifp) == 0)
			syslog(LOG_ERR, "Error reading from connection: %s",
				strerror(errno));
		exit(1);
	}

	syslog(LOG_DEBUG, "CMD: (%d)%s\n", buf[0], &buf[1]);

#ifdef DEBUG	/* translate [1-5]... messages to \[1-5] to run by hand */
	if ((buf[0] > '0') && (buf[0] < '6'))
		buf[0] -= '0';
#endif

	if ((buf[0] < 1) || (buf[0] > 5)) {
		fatal(ofp, "Invalid protocol request (%d): %c%s\n",
			buf[0], buf[0], buf);
		exit(1);
	}

	args = strsplit(&buf[1], "\t\n ");
	printer = *args++;

	if (printer == NULL) {
		fatal(ofp, "Can't determine requested printer");
		exit(1);
	}

	if (cyclical_service_check(printer) != 0) {
		fatal(ofp, "%s is cyclical\n", printer);
		exit(1);
	}

	status = papiServiceCreate(&svc, printer, NULL, NULL, NULL,
					encryption, NULL);
	if (status != PAPI_OK) {
		fatal(ofp, "Failed to contact service for %s: %s\n", printer,
			verbose_papi_message(svc, status));
		exit(1);
	}

	/*
	 * Trusted Solaris can't be trusting of intermediaries.  Pass
	 * the socket connection to the print service to retrieve the
	 * sensativity label off of a multi-level port.
	 */
	(void) papiServiceSetPeer(svc, fileno(ifp));

	switch (buf[0]) {
	case '\1':	/* restart printer */
		ACK(ofp);	/* there is no equivalent */
		break;
	case '\2':	/* transfer job(s) */
		status = berkeley_transfer_files(svc, ifp, ofp, printer);
		break;
	case '\3':	/* show queue (short) */
	case '\4': {	/* show queue (long) */
		int count;

		for (count = 0; args[count] != 0; count++);

		berkeley_queue_report(svc, ofp, printer, buf[0], count, args);
		}
		break;
	case '\5': {	/* cancel job(s) */
		char *user = *args++;
		char *host = remote_host_name(ifp);
		int count;

		if (host != NULL) {
			char buf[BUFSIZ];

			snprintf(buf, sizeof (buf), "%s@%s", user, host);
			status = papiServiceSetUserName(svc, buf);
		} else
			status = papiServiceSetUserName(svc, user);

		for (count = 0; args[count] != 0; count++);

		berkeley_cancel_request(svc, ofp, printer, count, args);
		}
		break;
	default:
		fatal(ofp, "unsupported protocol request (%c), %s",
			buf[0], &buf[1]);
	}

	(void) fflush(ofp);

	syslog(LOG_DEBUG, "protocol request(%d) for %s completed: %s",
		buf[0], printer, papiStatusString(status));
	if (status != PAPI_OK)
		syslog(LOG_DEBUG, "detail: %s",
				verbose_papi_message(svc, status));

	papiServiceDestroy(svc);

	return (0);
}