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

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

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <libintl.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <netinet/in.h>
#include "netpr.h"

#define	TIMEOUT		1

static int netpr_send_message(int, char *, ...);
static int xfer_cfAfile(int, char *, char *, uint);

int
bsd_print(int sockfd, caddr_t pa, np_bsdjob_t * bsdjob)
{
	int filesize;
	int xfer;
	int net;

	syslog(LOG_DEBUG, "bsd_print");

	filesize = bsdjob->np_data->np_data_size;
	syslog(LOG_DEBUG, "filesize is %d", filesize);


	if (netpr_send_message(sockfd, "%c%s\n", XFER_REQUEST,
		bsdjob->np_printer) != 0) {
		return (NETWORK_ERROR_SEND_RESPONSE);
	}

	/*
	 * control file
	 */

	if (bsdjob->np_print_order == CONTROL_FIRST) {
		if ((xfer_cfAfile(sockfd, bsdjob->np_cfAfile,
		    bsdjob->np_cfAfilename,
		    bsdjob->np_cfAfilesize)) != 0) {
			(void) fprintf(stderr,
			    gettext("Netpr: Error sending control file\n"));
			syslog(LOG_DEBUG, "Error sending control file");
			    return (NETWORK_ERROR_UNKNOWN);

		}
	}

	/* send msg - get ready for transfer */

	if ((netpr_send_message(sockfd, "%c%d %s\n", XFER_DATA, filesize,
	    bsdjob->np_data->np_dfAfilename)) != 0) {
		return (NETWORK_ERROR_SEND_RESPONSE);
	}

	/*
	 * send the file
	 */

	if ((xfer = xfer_file(sockfd, pa, filesize, bsdjob->np_timeout)) != 0) {
		return (xfer);
	}

	/* send msg - done */
	if ((net = netpr_send_message(sockfd, "", NULL)) != 0) {
		(void) fprintf(stderr,
		gettext("Netpr: network error transfering %s returns: %d\n"),
			bsdjob->np_filename, net);
		syslog(LOG_DEBUG,
			"network error transfering %s returns: %d",
			bsdjob->np_filename, net);
		return (NETWORK_ERROR_WRITE_FAILED);
	}

	/*
	 * control file
	 */

	if (bsdjob->np_print_order == DATA_FIRST) {
		if ((xfer_cfAfile(sockfd, bsdjob->np_cfAfile,
		    bsdjob->np_cfAfilename,
		    bsdjob->np_cfAfilesize)) != 0) {

			(void) fprintf(stderr,
			    gettext("Netpr: Error sending control file\n"));
			    syslog(LOG_DEBUG, "Error sending control file");
			    return (NETWORK_ERROR_UNKNOWN);
		}
	}

	return (0);
}

int
xfer_file(int sockfd, caddr_t pa, int filesize, int seed)
{
	int ctr;
	int timeout;
	int nw;
	int error_msg = 0;
	int pause = 0;

	syslog(LOG_DEBUG, "xfer_file");

	/* send file */
	ctr = filesize;
	timeout = seed = seed ? seed : 10;

	while (ctr > 0) {

	syslog(LOG_DEBUG, "xfer_file: write while loop => ctr = %d", ctr);
	syslog(LOG_DEBUG, "xfer_file: timeout = %d", timeout);

		(void) signal(SIGALRM, null_sighandler);
		(void) alarm(10);
		nw = write(sockfd, pa, ctr);
	syslog(LOG_DEBUG, "xfer_file: write while loop => nw = %d", nw);
		(void) alarm(0);
		if ((nw == 0) || (nw < 0)) {
			if (timeout < (seed * 4)) {
				(void) sleep(timeout);
				timeout *= 2;
			} else if (timeout == (seed * 4)) {
				(void) sleep(timeout);
				timeout *= 2;

				/*
				 * Send message to user once
				 */
				if (error_msg == 0) {
					error_msg++;
					tell_lptell(ERRORMSG,
					gettext("Printer not accepting input;"
					"possibly offline or out of paper."));
				}

			} else if (timeout > (seed * 4)) {
				(void) sleep(timeout);
				if (pause++ > 3)
					timeout = (seed * 10);
			}

		} else {
			ctr -= nw;
			pa += nw;
			if (error_msg) {
				tell_lptell(OKMSG, "Current");
				error_msg = 0;
				pause = 0;
			}
			timeout = seed;
		}
	}

	return (E_SUCCESS);
}

static int
xfer_cfAfile(int sockfd, char * cfAfile, char * cfAname, uint size)
{
	int ctr;
	caddr_t pa;
	int nw = 0;
	int timeout;
	int printererr;

	syslog(LOG_DEBUG, "xfer_cfAfile");

	if ((netpr_send_message(sockfd, "%c%d %s\n", XFER_CONTROL,
		size, cfAname)) != 0) {
		return (NETWORK_ERROR_MSG_FAILED);
	}

	/* send the control file */
	pa = cfAfile;
	ctr = size;
	syslog(LOG_DEBUG, "xfer_cfAfile : cfAfile %s", pa);
	syslog(LOG_DEBUG, "xfer_cfAfile : size %d", size);

	/* send control file */
	timeout = TIMEOUT;
	printererr = 0;
	while (ctr > 0) {
		(void) signal(SIGALRM, null_sighandler);
		(void) alarm(2);
		nw = write(sockfd, pa, size);
		(void) alarm(0);
		if (nw <= 0) {
			if (timeout < 16) {
				(void) sleep(timeout);
				timeout *= 2;
			} else if (timeout == 16) {
			/* talk with the printer and see what's happening */
				/* send message back to caller */
				(void) sleep(timeout);
				timeout *= 2;
				printererr = 1;

				tell_lptell(ERRORMSG,
				gettext("Printer not accepting input;"
				"possibly offline or out of paper."));

			} else if (timeout > 16) {
				(void) sleep(timeout);
			}
		}
		ctr -= nw;
		pa += nw;
	}

	if (printererr == 1) {
		(void) fprintf(stderr, gettext("Printer status ok\n"));
		tell_lptell(OKMSG, "Current");
	}


	/* send msg - done */
	if (netpr_send_message(sockfd, "", NULL) != 0) {
		return (NETWORK_ERROR_MSG_FAILED);
	}

	return (0);
}

/*
 *  netpr_response() reads in a byte from the network printer
 */
static int
netpr_response(int nd)
{
	char    c;
	int msg_given = 0;
	int firstloop = 0;

	syslog(LOG_DEBUG, "netpr_response");

	(void) signal(SIGALRM, null_sighandler);
	(void) alarm(2);
	while (1) {
		errno = 0;
		if ((read(nd, &c, 1) != 1)) {

			if (firstloop == 0) {
				(void) alarm(0);
				firstloop++;
			}

			if (errno == EINTR) {
				if (msg_given == 0) {
				    tell_lptell(ERRORMSG,
				    gettext("Printer not responding;"
				    "Either warming up or needs attention"));
				    msg_given++;
				    syslog(LOG_DEBUG,
					"read hanging in netpr_response: %m");
				}

			} else {
				syslog(LOG_DEBUG,
					"read in netpr_response failed: %m");
				return (NETWORK_READ_RESPONSE_FAILED);
			}

		} else {
			if (c) {
				syslog(LOG_DEBUG,
					"Printer returned error: %m");
				return (NETWORK_PRINTER_REFUSED_CONN);
			} else {
				if (msg_given)
					tell_lptell(OKMSG, "Current");
				return (0);
			}
		}
	}

}

static int
netpr_send_message(int nd, char *fmt, ...)
{
	char    buf[BUFSIZ];
	int ctr;
	char * pa;
	va_list ap;
	int timeout = 1;
	int nw;
	int err_msg = 0;

	syslog(LOG_DEBUG, "netpr_send_message");
	va_start(ap, fmt);
	(void) vsnprintf(buf, sizeof (buf), fmt, ap);
	va_end(ap);

	pa = buf;
	ctr = (strlen(buf) != 0) ? strlen(buf) : 1;

	syslog(LOG_DEBUG, "netpr_send_message : ctr = %d", ctr);
	while (ctr > 0) {
		(void) signal(SIGALRM, null_sighandler);
		(void) alarm(2);
		nw = write(nd, pa, ctr);
	syslog(LOG_DEBUG, "netpr_send_message : nw = %d", nw);
		(void) alarm(0);

		if (nw <= 0) {
			if (timeout < 16) {
				(void) sleep(timeout);
				timeout *= 2;
			} else if (timeout == 16) {
				(void) sleep(timeout);
				timeout *= 2;
				if (err_msg == 0) {
					err_msg++;
					tell_lptell(ERRORMSG,
					gettext("Printer not accepting input;"
					"possibly offline or out of paper."));
				}
			} else
				(void) sleep(timeout);
		} else {
			ctr -= nw;
			pa += nw;
			if (err_msg)
				tell_lptell(OKMSG, "Current");
		}
	}

	return (netpr_response(nd));
}

/*
 *  null() is to be used as a signal handler that does nothing.  It is used in
 *      place of SIG_IGN, because we want the signal to be delivered and
 *      interupt the current system call.
 */
/*ARGSUSED*/
void
null_sighandler(int i)
{
}