/*	$OpenBSD: process.c,v 1.25 2023/03/08 04:43:14 guenther Exp $ */

/*
 * Copyright (c) 1993-95 Mats O Jansson.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "os.h"
#include "common/common.h"
#include "common/mopdef.h"
#include "common/nmadef.h"
#include "common/get.h"
#include "common/put.h"
#include "common/print.h"
#include "common/pf.h"
#include "common/cmp.h"
#include "common/dl.h"
#include "common/rc.h"
#include "common/file.h"

extern int	DebugFlag;

struct dllist dllist[MAXDL];		/* dump/load list		*/

void
mopProcessInfo(u_char *pkt, int *idx, u_short moplen, struct dllist *dl_rpr,
    int trans)
{
	u_short	itype, tmps;
	u_char	ilen, tmpc, device;

	device = 0;

	switch (trans) {
	case TRANS_ETHER:
		moplen = moplen + 16;
		break;
	case TRANS_8023:
		moplen = moplen + 14;
		break;
	}

	itype = mopGetShort(pkt, idx);

	while (*idx < (int)(moplen)) {
		ilen  = mopGetChar(pkt, idx);
		switch (itype) {
		case 0:
			tmpc = mopGetChar(pkt, idx);
			*idx = *idx + tmpc;
			break;
		case MOP_K_INFO_VER:
			*idx = *idx + 3;
			break;
		case MOP_K_INFO_MFCT:
		case MOP_K_INFO_RTM:
		case MOP_K_INFO_CSZ:
		case MOP_K_INFO_RSZ:
			mopGetShort(pkt, idx);
			break;
		case MOP_K_INFO_CNU:
		case MOP_K_INFO_HWA:
			*idx = *idx + 6;
			break;
		case MOP_K_INFO_TIME:
			*idx = *idx + 10;
			break;
		case MOP_K_INFO_SOFD:
			device = mopGetChar(pkt, idx);
			break;
		case MOP_K_INFO_SFID:
			tmpc = mopGetChar(pkt, idx);
			*idx = *idx + tmpc;
			break;
		case MOP_K_INFO_PRTY:
		case MOP_K_INFO_DLTY:
			mopGetChar(pkt, idx);
			break;
		case MOP_K_INFO_DLBSZ:
			tmps = mopGetShort(pkt, idx);
			dl_rpr->dl_bsz = tmps;
			break;
		default:
			if (((device == NMA_C_SOFD_LCS) ||  /* DECserver 100 */
			     (device == NMA_C_SOFD_DS2) ||  /* DECserver 200 */
			     (device == NMA_C_SOFD_DP2) ||  /* DECserver 250 */
			     (device == NMA_C_SOFD_DS3)) && /* DECserver 300 */
			    ((itype > 101) && (itype < 107))) {
				switch (itype) {
				case 102:
				case 103:
				case 105:
				case 106:
					*idx = *idx + ilen;
					break;
				case 104:
					mopGetShort(pkt, idx);
					break;
				}
			} else
				*idx = *idx + ilen;
		}
		itype = mopGetShort(pkt, idx);
	}
}

void
mopSendASV(u_char *dst, u_char *src, struct if_info *ii, int trans)
{
	u_char	 pkt[200];
	int	 idx;

	idx = 0;
	mopPutHeader(pkt, &idx, dst, src, MOP_K_PROTO_DL, trans);

	mopPutChar(pkt, &idx, MOP_K_CODE_ASV);

	mopPutLength(pkt, trans, idx);

	if (DebugFlag == DEBUG_ONELINE)
		mopPrintOneline(stdout, pkt, trans);

	if (DebugFlag >= DEBUG_HEADER) {
		mopPrintHeader(stdout, pkt, trans);
		mopPrintMopHeader(stdout, pkt, trans);
	}

	if (DebugFlag >= DEBUG_INFO)
		mopDumpDL(stdout, pkt, trans);

	if (pfWrite(ii->fd, pkt, idx, trans) != idx)
		if (DebugFlag)
			warnx("pfWrite() error");
}

void
mopStartLoad(u_char *dst, u_char *src, struct dllist *dl_rpr, int trans)
{
	int	 len;
	int	 i, slot;
	u_char	 pkt[BUFSIZE];
	int	 idx;
	u_char	 mopcode = MOP_K_CODE_MLD;

	slot = -1;

	/* Look if we have a non terminated load, if so, use its slot */
	for (i = 0; i < MAXDL && slot == -1; i++)
		if (dllist[i].status != DL_STATUS_FREE)
			if (mopCmpEAddr(dllist[i].eaddr, dst) == 0)
				slot = i;

	/* If no slot yet, then find first free */
	for (i = 0; slot == -1 && i < MAXDL; i++)
		if (dllist[i].status == DL_STATUS_FREE) {
			slot = i;
			bcopy(dst,  dllist[i].eaddr, 6);
		}

	/* If no slot yet, then return. No slot is free */	
	if (slot == -1)
		return;

	/* Ok, save info from RPR */
	dllist[slot] = *dl_rpr;
	dllist[slot].status = DL_STATUS_READ_IMGHDR;

	/* Get Load and Transfer Address. */
	GetFileInfo(&dllist[slot], 0);

	dllist[slot].nloadaddr = dllist[slot].loadaddr;
	dllist[slot].lseek     = lseek(dllist[slot].ldfd, 0L, SEEK_CUR);
	dllist[slot].a_lseek   = 0;

	dllist[slot].count     = 0;
	if ((dllist[slot].dl_bsz >= 1492) || (dllist[slot].dl_bsz == 0))
		dllist[slot].dl_bsz = 1492;
	if (dllist[slot].dl_bsz == 1030)	/* VS/uVAX 2000 needs this */
		dllist[slot].dl_bsz = 1000;
	if (trans == TRANS_8023)
		dllist[slot].dl_bsz = dllist[slot].dl_bsz - 8;

	idx = 0;
	mopPutHeader(pkt, &idx, dst, src, MOP_K_PROTO_DL, trans);
	mopPutChar(pkt, &idx, mopcode);

	mopPutChar(pkt, &idx, dllist[slot].count);
	mopPutLong(pkt, &idx, dllist[slot].loadaddr);

	len = mopFileRead(&dllist[slot], &pkt[idx]);

	dllist[slot].nloadaddr = dllist[slot].loadaddr + len;
	idx = idx + len;

	mopPutLength(pkt, trans, idx);

	if (DebugFlag == DEBUG_ONELINE)
		mopPrintOneline(stdout, pkt, trans);

	if (DebugFlag >= DEBUG_HEADER) {
		mopPrintHeader(stdout, pkt, trans);
		mopPrintMopHeader(stdout, pkt, trans);
	}

	if (DebugFlag >= DEBUG_INFO)
		mopDumpDL(stdout, pkt, trans);

	if (pfWrite(dllist[slot].ii->fd, pkt, idx, trans) != idx)
		if (DebugFlag)
			warnx("pfWrite() error");

	dllist[slot].status = DL_STATUS_SENT_MLD;
}

void
mopNextLoad(u_char *dst, u_char *src, u_char new_count, int trans)
{
	int	 len;
	int	 i, slot;
	u_char	 pkt[BUFSIZE];
	int	 idx, pidx;
	char	 line[100],hname[17],*p;

	slot = -1;

	for (i = 0; i < MAXDL && slot == -1; i++)
		if (dllist[i].status != DL_STATUS_FREE) {
			if (mopCmpEAddr(dst, dllist[i].eaddr) == 0)
				slot = i;
		}

	/* If no slot yet, then return. No slot is free */	
	if (slot == -1)
		return;

	if (new_count == ((dllist[slot].count+1) % 256)) {
		dllist[slot].loadaddr = dllist[slot].nloadaddr;
		dllist[slot].count    = new_count;
	} else
		return;

	if (dllist[slot].status == DL_STATUS_SENT_PLT) {
		close(dllist[slot].ldfd);
		dllist[slot].ldfd = 0;
		dllist[slot].status = DL_STATUS_FREE;
		snprintf(line, sizeof(line),
		    "%x:%x:%x:%x:%x:%x Load completed",
		    dst[0], dst[1], dst[2], dst[3], dst[4], dst[5]);
		syslog(LOG_INFO, "%s", line);
		return;
	}

	dllist[slot].lseek = lseek(dllist[slot].ldfd, 0L, SEEK_CUR);

	if (dllist[slot].dl_bsz >= 1492)
		dllist[slot].dl_bsz = 1492;

	idx = 0;
	mopPutHeader(pkt, &idx, dst, src, MOP_K_PROTO_DL, trans);
	pidx = idx;
	mopPutChar(pkt, &idx, MOP_K_CODE_MLD);
	mopPutChar(pkt, &idx, dllist[slot].count);
	mopPutLong(pkt, &idx, dllist[slot].loadaddr);

	len = mopFileRead(&dllist[slot], &pkt[idx]);

	if (len > 0) {
		dllist[slot].nloadaddr = dllist[slot].loadaddr + len;
		idx = idx + len;

		mopPutLength(pkt, trans, idx);
	} else {
		if (len == 0) {
			i = gethostname(hname, sizeof(hname));
			p = strchr(hname, '.');
			if (p != NULL)
				*p = 0;

			idx = pidx;
			mopPutChar(pkt, &idx, MOP_K_CODE_PLT);
			mopPutChar(pkt, &idx, dllist[slot].count);
			mopPutChar(pkt, &idx, MOP_K_PLTP_HSN);
			mopPutChar(pkt, &idx, (int)strlen(hname));
			mopPutMulti(pkt, &idx, (u_char *)hname, (int)strlen(hname));
			mopPutChar(pkt, &idx, MOP_K_PLTP_HSA);
			mopPutChar(pkt, &idx, 6);
			mopPutMulti(pkt, &idx, src, 6);
			mopPutChar(pkt, &idx, MOP_K_PLTP_HST);
			mopPutTime(pkt, &idx, 0);
			mopPutChar(pkt, &idx, 0);
			mopPutLong(pkt, &idx, dllist[slot].xferaddr);

			mopPutLength(pkt, trans, idx);

			dllist[slot].status = DL_STATUS_SENT_PLT;
		} else {
			dllist[slot].status = DL_STATUS_FREE;
			return;
		}
	}

	if (DebugFlag == DEBUG_ONELINE)
		mopPrintOneline(stdout, pkt, trans);

	if (DebugFlag >= DEBUG_HEADER) {
		mopPrintHeader(stdout, pkt, trans);
		mopPrintMopHeader(stdout, pkt, trans);
	}

	if (DebugFlag >= DEBUG_INFO)
		mopDumpDL(stdout, pkt, trans);

	if (pfWrite(dllist[slot].ii->fd, pkt, idx, trans) != idx)
		if (DebugFlag)
			warnx("pfWrite() error");
}

void
mopProcessDL(FILE *fd, struct if_info *ii, u_char *pkt, int *idx, u_char *dst,
    u_char *src, int trans, u_short len)
{
	u_char		tmpc;
	u_short		moplen;
	u_char		pfile[129], mopcode;
	char		filename[FILENAME_MAX];
	char		line[100];
	int		i, nfd;
	struct dllist	dl, *dl_rpr;
	u_char		load;

	if (DebugFlag == DEBUG_ONELINE)
		mopPrintOneline(stdout, pkt, trans);

	if (DebugFlag >= DEBUG_HEADER) {
		mopPrintHeader(stdout, pkt, trans);
		mopPrintMopHeader(stdout, pkt, trans);
	}

	if (DebugFlag >= DEBUG_INFO)
		mopDumpDL(stdout, pkt, trans);

	moplen  = mopGetLength(pkt, trans);
	mopcode = mopGetChar(pkt, idx);

	switch (mopcode) {
	case MOP_K_CODE_MLT:
		break;
	case MOP_K_CODE_DCM:
		break;
	case MOP_K_CODE_MLD:
		break;
	case MOP_K_CODE_ASV:
		break;
	case MOP_K_CODE_RMD:
		break;
	case MOP_K_CODE_RPR:
		mopGetChar(pkt, idx);			/* Device Type */
		tmpc = mopGetChar(pkt, idx);		/* Format Version */
		if ((tmpc != MOP_K_RPR_FORMAT) &&
		    (tmpc != MOP_K_RPR_FORMAT_V3)) {
			fprintf(stderr, "mopd: Unknown RPR Format (%d) from ",
			    tmpc);
			mopPrintHWA(stderr, src);
			fprintf(stderr, "\n");
		}

		mopGetChar(pkt, idx);			/* Program Type */

		tmpc = mopGetChar(pkt, idx);		/* Software ID Len */
		if (tmpc > sizeof(pfile) - 1)
			return;
		for (i = 0; i < tmpc; i++) {
			pfile[i] = mopGetChar(pkt, idx);
			pfile[i+1] = '\0';
		}

		if (tmpc == 0) {
			/* In a normal implementation of a MOP Loader this */
			/* would cause a question to NML (DECnet) if this  */
			/* node is known and if so what image to load. But */
			/* we don't have DECnet so we don't have anybody   */
			/* to ask. My solution is to use the ethernet addr */
			/* as filename. Implementing a database would be   */
			/* overkill.					   */
			snprintf((char *)pfile, sizeof pfile,
			    "%02x%02x%02x%02x%02x%02x%c",
			    src[0], src[1], src[2], src[3], src[4], src[5], 0);
		}

		mopGetChar(pkt, idx);			/* Processor */

		dl_rpr = &dl;
		bzero(dl_rpr, sizeof(*dl_rpr));
		dl_rpr->ii = ii;
		bcopy(src, dl_rpr->eaddr, 6);
		mopProcessInfo(pkt, idx, moplen, dl_rpr, trans);

		snprintf(filename, sizeof(filename), "%s.SYS", pfile);
		if ((mopCmpEAddr(dst, dl_mcst) == 0)) {
			if ((nfd = open(filename, O_RDONLY)) != -1) {
				close(nfd);
				mopSendASV(src, ii->eaddr, ii, trans);
				snprintf(line, sizeof(line),
				    "%x:%x:%x:%x:%x:%x (%d) Do you have %s? "
				    "(Yes)", src[0], src[1], src[2], src[3],
				    src[4], src[5], trans, pfile);
			} else {
				snprintf(line, sizeof(line),
				    "%x:%x:%x:%x:%x:%x (%d) Do you have %s? "
				    "(No)", src[0], src[1], src[2], src[3],
				    src[4], src[5], trans, pfile);
			}
			syslog(LOG_INFO, "%s", line);
		} else {
			if ((mopCmpEAddr(dst, ii->eaddr) == 0)) {
				dl_rpr->ldfd = open(filename, O_RDONLY);
				mopStartLoad(src, ii->eaddr, dl_rpr, trans);
				snprintf(line, sizeof(line),
				    "%x:%x:%x:%x:%x:%x Send me %s",
				    src[0], src[1], src[2], src[3], src[4],
				    src[5], pfile);
				syslog(LOG_INFO, "%s", line);
			}
		}
		break;
	case MOP_K_CODE_RML:
		load = mopGetChar(pkt, idx);		/* Load Number	*/
		mopGetChar(pkt, idx);			/* Error	*/
		if ((mopCmpEAddr(dst, ii->eaddr) == 0))
			mopNextLoad(src, ii->eaddr, load, trans);
		break;
	case MOP_K_CODE_RDS:
		break;
	case MOP_K_CODE_MDD:
		break;
	case MOP_K_CODE_CCP:
		break;
	case MOP_K_CODE_PLT:
		break;
	default:
		break;
	}
}

void
mopProcessRC(FILE *fd, struct if_info *ii, u_char *pkt, int *idx, u_char dst,
    u_char *src, int trans, u_short len)
{
	u_char		tmpc;
	u_short		tmps, moplen = 0;
	u_char		mopcode;
	struct dllist	dl, *dl_rpr;

	if (DebugFlag == DEBUG_ONELINE)
		mopPrintOneline(stdout, pkt, trans);

	if (DebugFlag >= DEBUG_HEADER) {
		mopPrintHeader(stdout, pkt, trans);
		mopPrintMopHeader(stdout, pkt, trans);
	}

	if (DebugFlag >= DEBUG_INFO)
		mopDumpRC(stdout, pkt, trans);

	moplen  = mopGetLength(pkt, trans);
	mopcode = mopGetChar(pkt, idx);

	switch (mopcode) {
	case MOP_K_CODE_RID:
		break;
	case MOP_K_CODE_BOT:
		break;
	case MOP_K_CODE_SID:
		tmpc = mopGetChar(pkt, idx);		/* Reserved */

		if ((DebugFlag >= DEBUG_INFO))
			fprintf(stderr, "Reserved     :   %02x\n", tmpc);

		tmps = mopGetShort(pkt, idx);		/* Receipt # */
		if ((DebugFlag >= DEBUG_INFO))
			fprintf(stderr, "Receipt Nbr  : %04x\n", tmps);

		dl_rpr = &dl;
		bzero(dl_rpr, sizeof(*dl_rpr));
		dl_rpr->ii = ii;
		bcopy(src, dl_rpr->eaddr, 6);
		mopProcessInfo(pkt, idx, moplen, dl_rpr, trans);
		break;
	case MOP_K_CODE_RQC:
		break;
	case MOP_K_CODE_CNT:
		break;
	case MOP_K_CODE_RVC:
		break;
	case MOP_K_CODE_RLC:
		break;
	case MOP_K_CODE_CCP:
		break;
	case MOP_K_CODE_CRA:
		break;
	default:
		break;
	}
}