xnsprint.c

早期freebsd实现

			break;
		default:
			attnmsg("GetStat: Some random error, code %d\n",
				Exception.Code);
			break;
		}
	    if (remove && !attn) 
		attnmsg("Output left in %s\n", FileName);
	    exit(ExitStatus);
	    } END_HANDLER;

	    CourierClose(conn);
	} while (printresults(StatusResult.status) != 0);
}

/* 
 * display printer status, return 0 IFF spooler is available 
 */
int
printresults(status)
	PrinterStatus status;
{
	int i, typ;
	static char *spoollist[] = {"available","busy","disabled","full"};
	static char *formatlist[] = {"available","busy","disabled"};
	static char *printlist[] = {"available","busy","disabled",
			"needs attention","needs key operator"};
	int error = 1;
	char bufr[256];

	bufr[0] = '\0';
	for (i = 0; i < status.length; i++) {
		switch (status.sequence[i].designator) {
		case spooler:
			typ = (int) status.sequence[i].spooler_case;
			if (!quiet || typ > 1)
			    sprintf(bufr+strlen(bufr),
				"Spooler: %s; ", spoollist[typ]);
			error = typ;
			break;
		case formatter:
			typ = (int) status.sequence[i].formatter_case;
			if (!quiet || typ > 1)
			    sprintf(bufr+strlen(bufr),
				"Formatter: %s; ", formatlist[typ]);
			break;
		case printer:
			typ = (int) status.sequence[i].printer_case;
			if (!quiet || typ > 1)
			    sprintf(bufr+strlen(bufr),
				"Printer: %s. ", printlist[typ]);
			break;
		case media:
			/* printmedia(status.sequence[i].media_case); */
			break;
		}
	}
	if (bufr[0] != '\0')
	{
	    if (attn)
		attnmsg("%s\n",bufr);
	    else
	        printf("%s\n",bufr);
	}

	switch(error) {
		case 0:
			break;
		case 1:
			if (!quiet)
			    printf("Retrying... ");
			if (bufr[0] != '\0' && attn)
			    attnmsg("Status: Busy.  Retrying...\n");
			fflush(stdout);
			sleep(15);
			break;
		default:
			if(remove && !attn)
			    attnmsg( "Output left in %s\n", FileName);
			exit(1);
	}
	return(error);
}


attnmsg(fmt,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)
	char *fmt;
{
	char bufr[256];
	int af;

	if (attn)
	{
	    if ((af = open(attnfile,O_TRUNC|O_WRONLY|O_CREAT,0666)) < 0)
		    return; /* Oh Well. */

	    sprintf(bufr,fmt,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);

	    (void) write(af,bufr,strlen(bufr));	/* In case of error??? */
	    close(af);
	}
	else
	    fprintf(stderr,fmt,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);
}

sendIPfile(ipfile,destaddr)
	FILE *ipfile;
	struct ns_addr *destaddr;
{
	PrintResults result;
	CourierConnection *conn;
	PrintAttributes attributes;
	PrintOptions options;
	char *malloc();

	/* only use sender name and file name, no date */
	attributes.length = 2;
	attributes.sequence = malloc(attributes.length *
					sizeof(*attributes.sequence));
	attributes.sequence[0].designator = printObjectName;
	attributes.sequence[0].printObjectName_case = Banner;
	attributes.sequence[1].designator = senderName;
	attributes.sequence[1].senderName_case = UserName;

	options.length = 3;
	options.sequence = malloc(options.length *
					sizeof(*options.sequence));
	options.sequence[0].designator = copyCount;
	options.sequence[0].copyCount_case = copies;
	options.sequence[1].designator = mediumHint;
	options.sequence[1].mediumHint_case = paperchoice;
	options.sequence[2].designator = message;
	options.sequence[2].message_case =
		UserMessage ? UserMessage :
			      sprintf(malloc(44),"%s:%s:%s",
					hostname.object,hostname.domain,
					hostname.organization)
		;

again:
	if (!quiet)
		printf("Opening connection to %s. ",xnshost);
	if (attn)
		attnmsg("Opening connection to %s.\n",xnshost);

	if ((conn = CourierOpen(destaddr)) == NULL) {
		attnmsg("Can't open connection to %s\n",xnshost);
		if(remove && !attn)
		    attnmsg("Output left in %s\n", FileName);
		exit(X_LIMRETRY);
	}

	if (!quiet)
		printf("Connected.\n");
	if (attn)
		attnmsg("Sending to %s\n",xnshost);

	DURING
		result = Print(conn, SendSource, BulkData1_immediateSource,
					attributes, options);
	HANDLER {
		ExitStatus = X_RETRY;
		switch (Exception.Code) {
		case Busy:
			if (!quiet)
			    printf("Busy, retrying...\n");
			if (attn)
			    attnmsg("Busy, retrying...\n");
			CourierClose(conn);
			sleep(15);
			if (rewind(ipfile) < 0) {
				ExitStatus = X_LIMRETRY;
				attnmsg("Can't rewind file\n");
			}
			goto again;
		case ConnectionError:
			ExitStatus = X_LIMRETRY;
			attnmsg("Connection error, %d\n",
				CourierErrArgs(ConnectionErrorArgs,problem));
			break;
		case InsufficientSpoolSpace:
			attnmsg("Insufficient Spool Space error\n");
			break;
		case InvalidPrintParameters:
			ExitStatus = X_LIMRETRY;
			attnmsg("InvalidPrintParameters error\n");
			break;
		case MasterTooLarge:
			ExitStatus=X_NORETRY;
			attnmsg("MasterTooLarge error\n");
			break;
		case MediumUnavailable:
			ExitStatus=X_NORETRY;
			attnmsg("MediumUnavailable error\n");
			break;
		case ServiceUnavailable:
			ExitStatus=X_NORETRY;
			attnmsg("ServiceUnavailable error\n");
			break;
		case SpoolingDisabled:
			attnmsg("SpoolingDisabled\n");
			break;
		case SpoolingQueueFull:
			attnmsg("SpoolingQueueFull error\n");
			break;
		case SystemError:
			ExitStatus = X_LIMRETRY;
			attnmsg("System Error\n");
			break;
		case TooManyClients:
			attnmsg("TooManyClients error\n");
			break;
		case TransferError:
			ExitStatus = X_LIMRETRY;
			attnmsg("TransferError error\n");
			break;
		case Undefined:
			attnmsg("Undefined error, number %d\n",
				CourierErrArgs(UndefinedArgs,problem));
			break;
		case REJECT_ERROR:
			ExitStatus = X_LIMRETRY;
			attnmsg("REJECT:  type = %d\n",
				CourierErrArgs(rejectionDetails, designator));
			break;
		default:
			ExitStatus = X_LIMRETRY;
			attnmsg("Some random error, code %d\n",
				Exception.Code);
			break;
		}
		if(remove && !attn)
		    attnmsg("Output left in %s\n", FileName);
		exit(ExitStatus);
	} END_HANDLER;

	if (WaitFlag)			/* wait for completion LCM */
		WaitForCompletion(conn, result.printRequestID);
	CourierClose(conn);

	/* RETURNS [printRequestID: RequestID] */
	if(remove) unlink(FileName);
}	

/*
 * Wait for the job to complete
 */
WaitForCompletion(conn, printRequestID)
    CourierConnection *conn;
    Printing3_RequestID printRequestID;
{
	static char *statusStrings[] = {"pending", "inProgress", "completed",
		"completedWithWarning", "unknown", "rejected", "aborted",
		"canceled", "held"};
#define DONE	0
#define WAIT	1
	static char statusActions[] = {WAIT,      WAIT,         DONE,
		DONE,			DONE,	   DONE,       DONE,
		DONE,       WAIT};
	int i, typ,
		cycle,
		action;
	GetPrintRequestStatusResults result;

	for(cycle = 0;; cycle++) {
		if (!quiet)
			printf("try #%d\n", cycle);

		DURING
			result = GetPrintRequestStatus(conn, NULL, printRequestID);
		HANDLER {
			ExitStatus = X_NORETRY;	   /* if it got this far... */

			switch (Exception.Code) {
			case ServiceUnavailable:
				attnmsg("GetReqStat: Service unavailable\n");
				break;
			case SystemError:
				attnmsg("GetReqStat: System error\n");
				break;
			case Undefined:
				attnmsg("GetReqStat: Undefined error, number %d\n",
					CourierErrArgs(UndefinedArgs, problem));

			case REJECT_ERROR:
				attnmsg("GetReqStat: REJECT: type = %d\n",
					CourierErrArgs(rejectionDetails, designator));
				break;
			default:
				attnmsg("GetStat: Some random error, code %d\n",
					Exception.Code);
				break;
			}

		exit(ExitStatus);
		} END_HANDLER;

		action = WAIT;

		/* check out the returned status */
		for( i = 0; i < result.status.length; i++ ) {
			switch (result.status.sequence[i].designator) {
			case status:
				typ = (int) result.status.sequence[i].status_case;
				action = statusActions[typ];

				if (!quiet)
					printf("\tstatus: %s\n", statusStrings[typ]);

				break;

			case statusMessage:
				if(!quiet)
					printf("\tstatus message (%d bytes): %s\n",
						strlen(result.status.sequence[i].statusMessage_case),
						result.status.sequence[i].statusMessage_case);
				break;

			default:
				printf("GetReqStatu: help!\n");
			}
		}

		if( action == DONE )
			return;

		sleep(3);	/* wait three seconds before trying again */
	}
}