laps.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

			default:
				break;
		}
	}
	return(NULL);
}

/*
 *		d e c o d e _ s t a t u s _ b l o c k
 *
 * This routine is called to store information returned in a status block.
 *
 * Returns:		NULL on success
 *			EOF on error
 *
 * Inputs:
 *	type		= Block type
 *	ptr		= Pointer to data in block
 *	len		= Length of data in block
 *
 *  NOTE:      
 *  To correct unalinged access problem on MIPS, USE tmp, instead of 
 *  referencing struct directly (see code below between "!!"):
 *
 */
decode_status_block(type, ptr, len)
FIELD8 type;
FIELD8 *ptr;
int len;
{
        extern FIELD32 total_page_cnt;            /* total page count */
	int status = NULL;
 
	if (len == 0)
		return(NULL);	/* ignore 0 length blocks */
	errno = ENOPROTOOPT;	/* assume protocol error */
	switch (type)
	{
		case LBT_STA_PAGE_CNT:
			if (len != LBL_STA_PAGE_CNT)
				status = EOF;
			else {
                             FIELD32 *tmp;
                             tmp = (FIELD32 *)ptr;
                             bcopy (tmp, &cur_page_cnt, 4);

			   /*!!  cur_page_cnt = *(FIELD32 *)ptr; !!*/
                             total_page_cnt += cur_page_cnt;
			}
			break;
		case LBT_STA_JOB_STATE:
			if (len != LBL_STA_JOB_STATE)
				status = EOF;
			else {
                                FIELD16 *tmp;
                                tmp = (FIELD16 *)ptr;
                                bcopy (tmp, &cur_job_state, 2);

				/*!! cur_job_state = *(FIELD16 *)ptr; !!*/
			      }
			break;
		case LBT_STA_CON_STATE:
			if (len != LBL_STA_CON_STATE)
				status = EOF;
			else {
                                FIELD16 *tmp;
                                tmp = (FIELD16 *)ptr;
                                bcopy (tmp, &cur_con_state, 2);

				/*!! cur_con_state = *(FIELD16 *)ptr; !!*/
			      }
			break;
		case LBT_STA_PRO_VER:
			if (len != LBL_STA_PRO_VER)
				status = EOF;
			else
				bcopy(ptr, &station_pro_ver, PRO_VER_LEN);
			break;
		case LBT_STA_JOB_ID:
			if (len != LBL_STA_JOB_ID)
				status = EOF;
			else
				station_job_id = *(FIELD32 *)ptr;
			break;
		case LBT_STA_DATA:
			proc_cond_rec(ptr, len);
			break;
		case LBT_STA_RES_AVAIL:
                        if (len > LBL_STA_RES_AVAIL)
                                status = EOF;
                        else
                                if ((cur_con_state != LBV_STA_C_ACCEPTED) &&
                                    (!accepted_flag))
                                         status = EOF;
                        else
			{
                                report_resource(ptr, len);
                                rrecv++;
			}
			break;		  
		case LBT_STA_RES_COUNT:   /* resource promised block */
                        if (len != LBL_STA_RES_COUNT)
                                status = EOF;
                        else /* res. count is already recd OR accpted-ERROR */
			{
                                if (rcount_flag || 
                                    (cur_con_state != LBV_STA_C_ACCEPTED))
                                         status = EOF;
                                else  /* more than 1 count */
				{
                                    rcount_flag = 1;
                                    rpromised = *(FIELD8 *)ptr;
				}
			}
                        break;                
		case LBT_STA_RETURNSTATUS:
                        ((struct cond_hdr *)ptr)->msg_code +=
                                                  RETURNSTATUS_START;
                        if (((((struct cond_hdr *)ptr)->msg_code) &
                                  FACILITY_MASK) > RTNSTAT_FACILITY)
			{
                             ((struct cond_hdr *)ptr)->msg_code = LPS$_UNKMSG;
                             ((struct cond_hdr *)ptr)->argc = 0;
			}
			proc_cond_rec(ptr, len);
                        break;                            
		default:
			break;
	}
	return(status);
}

/*
 *		s e n d _ d a t a _ m s g
 *
 * This routine is called to send a data message to a printer
 *
 * Returns:		NULL on success
 *			EOF on failure
 *
 * Inputs:
 *	buf		= Pointer to data to be written
 *	len		= Length of data
 *	eos		= End-of-stream flag
 *	desc		= Description of data
 *	type		= Type of data
 */
send_data_msg(buf, len, eos, desc, type)
FIELD8 *buf;
int len;
int eos;
FIELD8 desc;
FIELD8 type;
{
	FIELD8 *ptr;
	FIELD8 flags;
 
	init_msg_hdr(LMT_DATA);
	/*
	 * insert message flags if needed for end-of-stream
	 */
	if (eos)
	{
		flags = LBV_DAT_EOD;
		insert_block(LBT_DAT_MSGFLGS, &flags, LBL_DAT_MSGFLGS);
	}
	/*
	 * insert the data description
	 */
	if (desc == 0)
		desc = LBV_DAT_PRINT_DATA;
	insert_block(LBT_DAT_DESC, &desc, LBL_DAT_DESC);
	if (desc == LBV_DAT_PRINT_DATA)
	{
		/*
		 * default print data type to postscript
		 */
		if (type == 0)
			type = 14;
		insert_block(LBT_DAT_TYPE, &type, LBL_DAT_TYPE);
	}
	if (desc == LBV_DAT_RESOURCE_DATA)
	{
		/*
		 * default resource data type to "font"
		 */
		if (type == 0)
			type = 1;
		insert_block(LBT_DAT_TYPE, &type, LBL_DAT_TYPE);
	}
	/*
	 * insert the actual data, and send the message off
	 */
	insert_block(LBT_DAT_DATA, buf, len);
	return(flush_xmit());
}

/*
 *		s e n d _ e o j _ m s g
 *
 * This routine is called to send an end-of-job message to a printer
 *
 * Returns:		NULL on success
 *			EOF on failure
 *
 * Inputs:
 *	reason		= Reason job is being ended
 */
send_eoj_msg(reason)
FIELD8 reason;
{
	init_msg_hdr(LMT_EOJ);
	/*
	 * insert reson for eoj
	 */
	insert_block(LBT_EOJ_REASON, &reason, LBL_EOJ_REASON);
	/*
	 * send the message off
	 */
	return(flush_xmit());
}

/*
 * LAPS trace data
 */
char *trc_msg_types[] =
{
	"UNKNOWN",
	"CONNECT",
	"DATA",
	"CONTROL",
	"END-OF-JOB",
	"STATUS",
	"RESOURCE FAULT",
	"RESOURCE STATUS"
};
 
char *trc_conn_blks[] =
{
	"UNKNOWN",
	"HIGH VERSION",
	"DATA",
	"LOW VERSION",
	"PRINTER"
};
 
char *trc_data_blks[] =
{
	"UNKNOWN",
	"DESCRIPTION",
	"TYPE",
	"DATA",
	"FLAGS"
};
 
char *trc_ctl_blks[] =
{
	"UNKNOWN",
	"COMMAND",
	"DATA",
	"LOW VERSION",
	"RESOURCE SERVER"
};
 
char *trc_eoj_blks[] =
{
	"UNKNOWN",
	"REASON",
	"DATA"
};
 
char *trc_sta_blks[] =
{
	"UNKNOWN",
	"PAGE COUNT",
	"JOB STATE",
	"CONNECTION STATE",
	"PROTOCOL VERSION",
	"JOB ID",
	"DATA",
	"UPLINE DATA",
	"LOW VERSION",
	"HIGH VERSION"
};
 
char *trc_rf_blks[] =
{
	"UNKNOWN",
	"NAME",
	"TYPE",
	"LOW VERSION",
	"HIGH VERSION"
};
 
char *trc_rs_blks[] =
{
	"UNKNOWN",
	"DISPOSITION",
	"STATUS",
	"SUBSTITUTE FILE",
	"SUBSITUTE SPECIFICATION",
	"LOW VERSION",
	"HIGH VERSION",
	"RESOURCE VERSION"
};
 
char **trc_blk_tbls[] =
{
	NULL,
	trc_conn_blks,
	trc_data_blks,
	trc_ctl_blks,
	trc_eoj_blks,
	trc_sta_blks,
	trc_rf_blks,
	trc_rs_blks
};
 
int trc_blk_limits[] =
{
	0,
	sizeof(trc_conn_blks) / sizeof(trc_conn_blks[0]),
	sizeof(trc_data_blks) / sizeof(trc_data_blks[0]),
	sizeof(trc_ctl_blks) / sizeof(trc_ctl_blks[0]),
	sizeof(trc_eoj_blks) / sizeof(trc_eoj_blks[0]),
	sizeof(trc_sta_blks) / sizeof(trc_sta_blks[0]),
	sizeof(trc_rf_blks) / sizeof(trc_rf_blks[0]),
	sizeof(trc_rs_blks) / sizeof(trc_rs_blks[0])
};

/*
 *		t r a c e _ r c v
 *
 * This routine is called to trace a LAPS message received.
 *
 * Returns:		Nothing
 *
 * Inputs:
 *	msgp		= Pointer to message
 */
trace_rcv(msgp)
register FIELD8 *msgp;
{
	trace_msg(msgp, "->");
}

/*
 *		t r a c e _ x m i t
 *
 * This routine is called to trace a LAPS message transmitted.
 *
 * Returns:		Nothing
 *
 * Inputs:
 *	msgp		= Pointer to message
 */
trace_xmit(msgp)
register FIELD8 *msgp;
{
	trace_msg(msgp, "<-");
}

/*
 *		t r a c e _ m s g
 *
 * This routine is called to format and print a LAPS message.
 *
 * Returns:		None
 *
 * Inputs:
 *	msgp		= Pointer to message
 *	direction	= Pointer to string to indicate "received" or "transmit"
 */
trace_msg(msgp, direction)
FIELD8 *msgp;
char *direction;
{
	struct msg_hdr *msg_ptr;
	int i;
	int len;
	FIELD8 *ptr;
	FIELD8 msg_type;
	char tmpbuf[10];
	char *msg_string;
 
	msg_ptr = (struct msg_hdr *)msgp;
	msg_type = msg_ptr->msg_type;
	if (msg_type > (sizeof(trc_msg_types)/sizeof(trc_msg_types[0])))
	{
		sprintf(tmpbuf, "%d", msg_type);
		msg_type = 0;
		msg_string = tmpbuf;
	} else {
		msg_string = trc_msg_types[msg_type];
	}
 
	printf("\n%s %s message (%d blocks), length = %d\n",
	direction, msg_string, msg_ptr->msg_blkcnt, 
	msg_ptr->msg_len);
	ptr = msgp + MSG_HDR_LEN;
	for (i = msg_ptr->msg_blkcnt; i; i--)
	{
		trace_blk(ptr, msg_type);
		len = *(FIELD16 *)(((struct blk_hdr *)ptr)->blk_len);
		ptr += (len + BLK_HDR_LEN);
	}
}

/*
 *		t r a c e _ b l k
 *
 * This routine is called to format and print a LAPS block
 *
 * Returns:		Nothing
 *
 * Inputs:
 *	blkp		= Pointer to block
 *	msg_type	= Type of message block was in
 */
trace_blk(blkp, msg_type)
FIELD8 *blkp;
FIELD8 msg_type;
{
	int i;
	int len;
	int cur_x;
	int bol, eol;
	unsigned char c;
	char tmpbuf[20];
	char *blk_string;
	FIELD8 *datap = blkp + BLK_HDR_LEN;
	struct blk_hdr *blk_ptr = (struct blk_hdr *)blkp;
	FIELD8 blk_type = blk_ptr->blk_type;
 
	if (blk_type > trc_blk_limits[msg_type])
	{
		sprintf(tmpbuf, "%d", blk_type);
		blk_type = 0;
		blk_string = tmpbuf;
	} else {
		blk_string = trc_blk_tbls[msg_type][blk_type];
	}
	len = *(FIELD16 *)(blk_ptr->blk_len);
	printf("   %s block, length = %d\n", blk_string, len);
 
	if ((msg_type != LMT_DATA) || (blk_type != LBT_DAT_DATA) ||
	(trace_flag & TRACE_DATA))
	{
		if (len != 0)
		{
			for ( i = 0 ; i < len ; i++ )
			{
				cur_x = i % 16;
				if (cur_x == 0)
				{
					bol = 1;
					bzero(tmpbuf, sizeof(tmpbuf));
				} else
					bol = 0;
				if ((cur_x == 15) || ((i + 1) == len))
					eol = 1;
				else
					eol = 0;
 
				c = *datap++ & 0xff;
				printf("%s%03u%s", bol ? "     " : " ",
				c, eol ? "\n" : "");
 
				if (trace_flag & TRACE_ASCII)
				{
					tmpbuf[cur_x] = ((c > 037) ? c : '.');
					if (eol)
						printf("     %s\n", tmpbuf);
				}
			}
		}
	}
}