Xinu7/src/cmd/download/vax/src/edl.c

/*----------------------------------------------------------------------*/
/*									*/
/*	edl	--  Download to VAX over Ethernet			*/
/*									*/
/* This program takes VAX a.out format files and downloads them		*/
/* into a VAX.								*/
/*									*/
/* Usage:								*/
/*  (This program is exec'd by download; the following arguments are	*/
/*   accepted by download:)						*/
/*  download [file] [-cCLASS] [-lLSI#] [-a[delay]]			*/
/*	     [-Bbaudrate] [-a[# of Secs]] [-h] [-v] [-s]		*/
/*									*/
/* Author:								*/
/*	Tom Stonecypher							*/
/*		based on the PDP-11 downloader, written by:		*/
/*		R. Brown, Doug Comer, D. Hachigian			*/
/*		Purdue University CS Deptartment			*/
/*									*/
/* (c) Copyright, 1986, All rights reserved.				*/
/*									*/
/*----------------------------------------------------------------------*/

/*    Include files - Unix domain                           		*/
#include "/usr/include/errno.h"
#include "/usr/include/setjmp.h"
#include "/usr/include/signal.h"
#include "/usr/include/sgtty.h"
#include "/usr/include/stdio.h"
#include "/usr/include/sys/file.h"
#include "/usr/include/sys/types.h"
#include "/usr/include/ctype.h"
#include "/usr/include/a.out.h"

/* 4.3 Network include files						*/
#include "/usr/include/netinet/in.h"
#include "/usr/include/sys/socket.h"
#include "/usr/include/netdb.h"

/*    Include files - XINU domain                           		*/
#include <getdev.h>
#include <download.h>
#include <dlpack.h>
#include <vaxdl.h>
#include <ethdown.h>
#include "../eload/src/.version"

struct	arglist A;
jmp_buf	env;			/* used to return from read time-outs	*/
static	char *alarm_msg;	/* message printed when alarm signalled	*/
char	*Openfiles[MAXFILES];	/* open file names for error reporting	*/
char	*locknm;		/* name of lock file			*/
extern	int errno;
int	Sfd;			/* socket descriptor for upd write/reads*/

/*
 * MAIN -- download user's program from host into VAX's memory
 */
main ( argc, argv )
int argc;
char *argv[];
{
	char	*machine, *cputype;
	int	eloadfd, retry;
	u_long	ip_addr;
	struct	exec ehdr, aouthdr;

	locknm = argv[--argc];
	machine = argv[--argc];
					/* cputype = get_cputype(machine); */
	procargs(argc, argv);		/* process arguments into struct A */
	initsigs();

	Openfiles[DEVFD] = get_name(machine);
	Openfiles[AOUTFD] = A.filename;

	getudp_port(&ip_addr, machine);
	gethdr(AOUTFD, &aouthdr, TRUE);

	if (ip_addr != 0) {		/* do an ethernet download */
	   retry = 0;
	   do {
		lseek(AOUTFD, N_TXTOFF(aouthdr), 0);
		if ( A.reloadether || retry == 1 ) {
			if (!A.verbose && !A.silent)
				fprintf(stderr,"%sloading eload...\n",
						(A.reloadether?NULL:"re"));
			eloadfd = openfile(ELOAD, O_RDONLY);
			gethdr(eloadfd, &ehdr, TRUE);
			initcpu();
			load_args(ip_addr);
			serial_load(eloadfd, ETH_INITPC, &ehdr, NOAUTOSTART);
		}
		if (ethload(&aouthdr, ip_addr, &ehdr) == ETH_OK)
			break;
	   } while (++retry == 1 && !A.reloadether);
	}
	if (ip_addr == 0 || retry == 2 || (retry == 1 && A.reloadether)) {
		message("performing serial download...");
		serial_load(AOUTFD, LOADSTART, &aouthdr, A.startdelay);
	}
	touch(locknm);
	message("done         ");
	printstart(&aouthdr);
	callexit(0);
}

/*
 *====================================================================
 * procargs - parse and check command line, setup global A structure
 *====================================================================
 */
procargs(argc, argv)
int	argc;
char	*argv[];
{
	int arg, i;

	A.filename  = DEFFILE;
	A.baudrate = B9600;
	A.class = NULL;
	A.machnum = GD_ANYDEV;
	A.devflags = FALSE;
	A.reloadether = FALSE;
	A.verbose = FALSE;
	A.silent = FALSE;
	A.autostart = FALSE;
	A.startdelay = NOAUTOSTART;

	for ( arg=1 ; arg<argc ; arg++ ) {
		if ( argv[arg][0] == '-' ) {
			switch ( argv[arg][1] ) {
			case 'l':
				A.machnum=atoi(argv[arg]+2);
				break;
			case 'h':
				A.devflags |= GD_HLDDEVS;
				break;
			case 'e':
				A.reloadether = TRUE;
				break;
			case 'v':
				A.verbose = TRUE;
				break;
			case 's':
				A.silent = TRUE;
				break;
			case 'a':
				A.autostart = TRUE;
				A.startdelay = atoi(&argv[arg][2]);
				break;
			default:
				break; /* ignore other args */
			}
		} else
			A.filename = argv[arg];
	}
}

/*
 *=================================================================
 * initsigs - prepare to reset on an interrupt & setup for alarms
 *=================================================================
 */
initsigs()
{
	int alarmhandler(), inthandler();

	if ( signal(SIGINT,SIG_IGN) != SIG_IGN )
		signal(SIGINT,inthandler);
	if ( signal(SIGTERM,SIG_IGN) != SIG_IGN )
		signal(SIGTERM,inthandler);
	if ( signal(SIGQUIT,SIG_IGN) != SIG_IGN )
		signal(SIGQUIT,inthandler);
	signal(SIGALRM, alarmhandler);
}

/*=======================================================================
 * serial_load - download an a.out image over serial line
 *=======================================================================
 * input  state: <undefined>
 * output state: a.out in memory, executing autostart else cpu halted
 */
serial_load(aout_fd, load_addr, aout_hdr, delay)
int	aout_fd;
char	*load_addr;
struct	exec	*aout_hdr;
int	delay;
{
	int	ldrfd;
	struct	exec ldr_hdr;

	ldrfd = openfile(VAXLOADER, O_RDONLY);
	gethdr(ldrfd, &ldr_hdr, FALSE);
	initcpu();
	message("loading boot program...");
	bootload(aout_hdr, ldrfd, &ldr_hdr, delay);
	slowload(aout_fd, aout_hdr, load_addr);
	close(ldrfd);
}

/*
 *=============================================
 * bootload - load bootstrap loader via console
 *=============================================
 * input state: after console prompt, cpu initialized (interrupts disabled)
 * output state: same, bootstrap loader in memory and running
 */
bootload(aout_hdr, fdin, ldr_hdr, delay)
int	fdin, delay;
struct	exec  *aout_hdr, *ldr_hdr;
{
	FILE *infile;
	int length, stklen, i, ph0len;
	unsigned long val;
	char buf[32], *stack, ch, resp;

	infile = fdopen(dup(fdin),"r");
	fseek(infile, N_TXTOFF(*ldr_hdr),0);
	length = ldr_hdr->a_text + ldr_hdr->a_data;
	/*
	 * load phase1 of the boot loader at location P0BSTRT.
	 */
	fread (&val, sizeof val, 1, infile);
	sprintf(buf, "D/L/P %x %x\r",P0BSTRT, val); /* initialize console */
	sendcons(buf, TRUE);
	getprompt(6);
	fread ( &val, sizeof val, 1, infile);
	ph0len = sizeof (unsigned long) * 2;
	while ( val != (unsigned)0xffffffff ) {
		sprintf(buf, "D + %x\r", val);
		sendcons(buf, TRUE);
		getprompt(6);
		if ( !A.silent && ! A.verbose )
			displayval(ph0len);
		fread ( &val, sizeof val, 1, infile);
		ph0len += sizeof (unsigned long);
	}
	if ( !A.silent && !A.verbose )
                fprintf(stderr,"\r");
	sendcons("\r",TRUE);
	getprompt(5);
	/*
	 * send the boot loader in reverse order, remove trailing zeros
	 */
	stack = (char *)malloc(length);
	for (stklen = 0; ph0len+stklen < length; stklen++)
		stack[stklen] = getc(infile);
	setreg(0, stklen);
	setreg(1, HIADDR);
	setreg(2, delay);
	setreg(3, aout_hdr->a_entry);
	sprintf(buf, "S %x\r", P0BSTRT);
        sendcons(buf, TRUE);
	usleep(1000000);
	buf[0] = ESC;
	/* escape bytes for big VAXen */
	for ( i=stklen-1 ; i>=0 ; i-- ) {
		if( (ch = stack[i])==CNSINTRC || ch==CNSINTRC2 || ch==ESC ) {
			buf[1] = ch|STUFFBIT;
			write(DEVFD, buf, 2);
		} else
			write(DEVFD, &ch, 1);
		if ( A.verbose )
			fprintf(stderr,"%03x ",stack[i]&0xff);
	}
        if ( A.verbose )
                fprintf(stderr,"\n");
}

/*
 *============================================
 * getserack - get an ack from destination VAX
 *============================================
 */
getserack()
{
	char ch;

	settimer(6, "getack read timed out");
	if (setjmp(env)	== EINTR)
		callexit(1);
	else if (read(DEVFD, &ch, 1) < 0) {
		perror(Openfiles[DEVFD]);
		message("getserack: no ack");
		ch = EOS;
	} else
		canceltimer();
	if (A.verbose)
		fprintf(stderr,"IN(getack): %s\n", unctrl(ch));
	return(ch);
}

FILE *Slowline;
char Slowbuf[BUFSIZ];

/*============================================================
 * slowload - load user program via packets over serial line
 *============================================================
 * input  state: serial downloader running, ready to receive packets
 * output state: a.out file loaded into memory; a.out running if auto-
 *		 start, before console prompt if no autostart
 */
slowload(aoutfd, ahdr, load_addr)
int	aoutfd;
struct	exec *ahdr;
int	load_addr;
{
        int words, addr, length;
	FILE *infile;
	unsigned short buf[PACKSIZE];
	char resp;

	words = (ahdr->a_text+ahdr->a_data) / sizeof (unsigned short);
	Slowline = fdopen(DEVFD,"w");
	setbuf(Slowline,Slowbuf);
	infile = fdopen(aoutfd,"r");
	fseek(infile, N_TXTOFF(*ahdr), 0);
	addr = load_addr;
	while ( words > 0 ) {
		length = (words>PACKSIZE ? PACKSIZE : words);
		fread(buf,sizeof(unsigned short),length,infile);
		do {
			sendserpack(addr,length,buf);
			settimer(6, "slowload read timed out");
			if (setjmp(env)	== EINTR)
				callexit(1);
			if ( read ( DEVFD, &resp, 1) != 1 ) {
				perror(Openfiles[DEVFD]);
				exit(1);
			}
			canceltimer();
			if ( A.verbose )
			     fprintf(stderr,"response is %s\n",unctrl(resp));
			else if (resp == NAK )
				fprintf(stderr,"NAK\n");
		} while ( resp != ACK );

		addr += length * sizeof (unsigned short);
		words -= length;
                if ( !A.silent && !A.verbose )
                        displayval(words);
	}
        if ( !A.silent && !A.verbose ) {
                displayval(0);
                fprintf(stderr,"\r");
        }
	do {
	       sendserpack ( addr, 0, buf );
	} while (getserack() != ACK);
}

/*
 *====================================
 * sendserpack - send a packet to the VAX
 *====================================
 */
#define putwsum(w) putw(w), sum += w
#define rawputc(c) putc(c, Slowline)

sendserpack(addr, length, buf)
unsigned int addr, length;
unsigned short *buf;
{
short	sum;
int	i;

	if ( A.verbose ) {
		fprintf(stderr,"Sending packet addr=%8x len=%d\n",addr,length);
		for ( i=0 ; i<length ; i++ )
			fprintf(stderr,"%02x  ",buf[i]&0xff);
		fprintf(stderr,"\n");
        }
	rawputc(SOH);
	sum = 0;
	putwsum(addr & LOW16);		/* put low word of address	*/
	putwsum(addr>>16);		/* put high word of address	*/
	putwsum(length);
	for ( i=0 ; i<length ; i++ )
		putwsum(buf[i]);
        if ( A.verbose )
		fprintf(stderr, "sum is %d\n", -sum);
        putwsum(-sum);
	fflush(Slowline);
}

/*
 *==================================================
 * putw - write a word to the slow-speed serial line
 *==================================================
 */
putw(word)
unsigned short word;
{
	putch((char)(word&LOWBYTE));
	putch((char)((word>>8)&LOWBYTE));
}

/*
 *==============================================================
 * putch - put a character on the high speed line, with escaping
 *==============================================================
 */
putch(ch)
char ch;
{
	if ( ch == ESC || ch == SOH || ch == CNSINTRC || ch == CNSINTRC2 ) {
		rawputc(ESC);
		rawputc(ch|STUFFBIT);
	} else
		rawputc(ch);
}

/*
 *===================================================
 * printstart - print start location for serial loads
 *===================================================
 */
printstart(hdr)
struct exec *hdr;
{
	if ( !A.autostart && !A.silent )
		fprintf(stderr,"\rHalt the cpu, then start at 0x%x\n",
			  hdr->a_entry+sizeof(short));
}

/*
 *=================================================
 * getudp_port - get a udp port for packet transfer
 *=================================================
 */
getudp_port(ip_addr, machine)
u_long	*ip_addr;
char	*machine;
{
	struct	sockaddr_in sin, sout;
	struct	hostent	*phost;
	char	*hostname;

	hostname = get_hname(machine);
	if (isdigit(*hostname))	/* IP dot notation instead of name */
		*ip_addr = inet_addr(hostname);
	else {			/* hostname format */
		phost = gethostbyname(hostname);
		if ((char *)phost != NULL && phost->h_addrtype == AF_INET)
			bcopy(phost->h_addr, ip_addr, sizeof ip_addr);
		else
			*ip_addr = 0;
	}
	if ((Sfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
		perror("creating socket");
		callexit(1);
	}
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;
	sin.sin_port = 0;
	if (bind(Sfd, (caddr_t) &sin, sizeof(sin)) < 0) {
		perror("bind");
		callexit(1);
	}
	sout.sin_family = AF_INET;
	sout.sin_addr.s_addr = *ip_addr;
	sout.sin_port = htons((u_short) DLUDP);

	if (connect(Sfd, &sout, sizeof(sout)) < 0) {
		perror("connect");
		callexit(1);
	}
}

/*==========================================
 * start_eload - init lsi and start up eload
 *==========================================
 * input  state: after the console prompt
 * output state: undefined (waiting for an ack from eload)
 * actions:
 *    set PC to address of eload
 *    disable interrupts
 *    give download IP address of target VAX as arg to ELOAD
 *    start LSI
 */
start_eload()
{
	char	buf[32];

	initcpu();
	setreg(KSPREG, ETH_INITSP);
	sprintf(buf, "S %x\r", ETH_INITPC);
	sendcons(buf, TRUE);
}

/*
 *============================================================
 * load_args - put arguments to ELOAD into the appropriate loc
 *============================================================
 */
load_args(ip_addr)
u_long	ip_addr;
{
	setmem(ETH_INITPC-4, ip_addr);	
}

/*
 *================================
 * gethdr - read an a.out header
 *================================
 */
gethdr(fd, hdr, cfile)
int	fd;
struct	exec *hdr;
Bool	cfile;
{
	if ( read(fd, hdr, sizeof *hdr) != sizeof *hdr) {
		fprintf(stderr,"%s: EOF reading a.out header\n",Openfiles[fd]);
		callexit(1);
	}
	if (cfile && hdr->a_magic != NMAGIC && hdr->a_magic != ZMAGIC ) {
		fprintf(stderr,"%s: wrong magic number\n",Openfiles[fd]);
		callexit(1);
	}
}

/*
 *==========================================================
 * openfile - try to open file, exit with message if error
 *==========================================================
 */
openfile(name,mode)
char	*name;
int	mode;
{
	int fd;
	settimer(10, "open timed out");
	if (setjmp(env) == EINTR)
		callexit(1);
	if ((fd=open(name,mode)) < 0 ) {
		perror(name);
		callexit(1);
	}
	canceltimer();
	Openfiles[fd] = name;
	return(fd);
}

/*
 *==================================================
 * readuntil - read from line until some character
 *==================================================
 */
readuntil ( ch, time )
char	ch;
int	time;
{
	char	input;

	settimer(time, "\rread timed out");
	if (setjmp(env)	== EINTR) {
		fprintf(stderr, "readuntil did not find %s\n", unctrl(ch));
		callexit(1);
	}
	if ( A.verbose ) {
		fprintf(stderr,"IN: "); fflush(stderr);
	}
	do {
		if ( read(DEVFD, &input, 1) != 1 ) {
			perror(Openfiles[DEVFD]);
			callexit(1);
		}
		if (A.verbose ) {
			fprintf(stderr,"%s",unctrl(input)); fflush(stderr);
		}
	} while ( input == EOS || input != ch);
	canceltimer();
	if ( A.verbose )
		fprintf(stderr,"\n");
}

/*
 *=========================================
 * alarmhandler - return from alarm calls
 *=========================================
 */
alarmhandler()
{
	signal(SIGALRM, alarmhandler);
	if (alarm_msg != NULL)
		fprintf(stderr, "%s\n", alarm_msg);
	longjmp(env, EINTR);
	/* not reached */
}

/*
 *=====================================
 * inthandler -- interrupt processing
 *=====================================
 */
inthandler()
{
	touch(locknm);
	callexit(2);
}
/*
 *=======================================
 * callexit - restore ttymodes and exit
 *=======================================
 */
callexit(ret)
int ret;
{
	exit(ret);
}

/*
 *==================================================
 * sendcons - send a message to console half duplex
 *==================================================
 */
sendcons(msg, wait)
char *msg;
Bool wait;
{
	char	*ptr;

	ptr = msg;
	while (*msg!=EOS) {
		if (islower(*msg))
			*msg = *msg - 32;
		write(DEVFD,msg,1);
                if ( wait )
                        readuntil(*msg, 6);
		msg++;
	}
	if ( A.verbose ) {
		fprintf(stderr,"OUT: ");
		while (*ptr!=EOS) {
			fprintf(stderr,"%s",unctrl(*ptr));
			ptr++;
		}
		fprintf(stderr,"\n");
	}
}

/*
 *================================================
 * setreg - preload a register through VAX console
 *================================================
 */
setreg(reg, value)
int reg, value;
{
	char buf[32];

	/* there's no machine-independent way to load PSL, so let	*/
	/* console Initialize command take care of that			*/
	if (reg == KSPREG)
		sprintf (buf, "D/I 0 %x\r", value);
        else if ( reg >= 0 ) /* general register */
                sprintf(buf,"D/G %x %x\r", reg, value);
	else /* internal privileged register -reg */
		sprintf(buf, "D/I %x %x\r", -reg, value);
	sendcons(buf, TRUE);
        if ( !A.silent && !A.verbose )
                displayreg(reg);
	getprompt (6);
}

/*
 *===================================
 * getprompt - get VAX console prompt 
 *===================================
*/
getprompt (time)
int time;
{
	int i;

	for (i=0; i<3; i++)
		readuntil ('>', time);
}
	
/*
 *======================================================
 * initcpu - get VAX console's attention, initialize cpu
 *======================================================
 * Input state - undefined
 * Output state - immediately after VAX console prompt
 */
initcpu()
{
	message("getting console");

	/* get console, if it's a big VAX */
	write(DEVFD, CONSKILL, 1);	/* ^U erases current cmd. line	*/
	write(DEVFD, CONSABRT, 1);	/* ^C enables console input	*/
	write(DEVFD, CONSINTR, 1);	/* ^P breaks to console mode	*/
	usleep(100000);

	/* get console, if it's a UVAX */
	ioctl(DEVFD, TIOCSBRK, NULL);
	usleep(300000);
	ioctl(DEVFD, TIOCCBRK, NULL);
	/* now have console, initialize cpu */
	getprompt(15);
	sendcons(CPUHALT, TRUE);	/* halt the processor		*/
	sendcons("\r", TRUE);
	getprompt(6);
	sendcons(CPUNJAM, TRUE);	/* unjam bus			*/
	getprompt(15);			/* high waits for big VAXen	*/
	sendcons(CPUINIT, TRUE);	/* init: interrupts disab, etc.	*/
	getprompt(15);			/* takes a while on big VAXen	*/
}

/*
 *============================================================
 * setmem - load a 32-bit memory location through VAX console
 *============================================================
 */
setmem(loc, value)
int loc, value;
{
	char buf[128];

        sprintf(buf,"D/L/P %x %x\r",loc,value);
	sendcons(buf, TRUE);
	getprompt(6);
}

/*
 *=================================================
 * message - conditionally display status message
 *=================================================
 */
message(str)
char *str;
{
	if ( !A.silent ) {
		fprintf(stderr,"\r%s\n",str);
	}
}


/*
 *============================================
 * displayval - display a number on one line
 *============================================
 */
displayval(val)
int val;
{
	fprintf(stderr,"\r%d     ",val);
	fflush(stderr);
}

/*
 *==============================================
 * displayreg - display a register on one line
 *==============================================
 */
displayreg(val)
int val;
{
        if ( val < 0 )
		fprintf(stderr,"\rPS           ");
        else
		fprintf(stderr,"\rR%d          ",val);
	fflush(stderr);
}

struct	dl_pack	ackdl;

/*
 *=============================================
 * getack - get an ack from ELOAD over ethernet
 *=============================================
 */
struct	dl_pack	*getack()
{
	char	*ackmsg;

	settimer(ACKTIME, NULL);
	if (setjmp(env)	== EINTR)		/* timed out		*/
		return(NULL);
	if (read(Sfd, &ackdl, sizeof ackdl) < 0) {
		perror("udp packet read");
		callexit(1);
	}
	canceltimer();
	if (A.verbose) {
		switch (ackdl.dl_hdr.dl_op) {

		case DLACK:
			ackmsg = "ACK";
			break;
		case DLNAK:
			ackmsg = "NAK";
			break;
		case DLRAK:
			ackmsg = "ready-ack";
			break;
		case DLQAK:
			ackmsg = "quit-ack";
			break;
		default:
			ackmsg = "invalid ack command";
			break;
		}
		fprintf(stderr,"IN(getack): %s, addr = 0x%x\n", ackmsg,
			ntohl(ackdl.dl_hdr.dl_addr));
	}
	return(&ackdl);
}

/*
 *===========================================
 * ethload - download program over ethernet
 *===========================================
 */
ethload(aouthdr, ip_addr, ehdr)
int ip_addr;
struct exec *aouthdr, *ehdr;
{
	u_long	addr;
	u_short	len, i;
	int	aoutsize, iNak, version;
	struct	dl_pack packet, *pDlAck;

	message("starting resident loader");
	start_eload();
	build_dlpack(DLID, 0, 0, &packet);
	usleep(400000);
	for (iNak = 0; iNak < ETHRETRY; iNak++ ) {
		if (iNak > 0)
			fprintf(stderr,"\rretrying...");
		send_dlpack(Sfd, &packet);
		pDlAck = getack();
		if (pDlAck != NULL && pDlAck->dl_hdr.dl_op == DLRAK)
			break;
	}
	if (iNak == ETHRETRY) {
		message("can't start eload");
		return(ETH_FAILED);
	}
	if ( (version = pDlAck->dl_hdr.dl_vers & LOWBYTE) != VERSION &&
		version != ROMVERS ) {
		message("version mismatch");
		return(ETH_FAILED);
	}
	aoutsize = aouthdr->a_text + aouthdr->a_data;
	addr = LOADSTART;
	while (aoutsize > 0) {
		if (addr >= ETH_INITPC) {
			fprintf(stderr,"a.out image too large\n");
			callexit(1);
		}
		len = aoutsize > DLMAXD ? DLMAXD : aoutsize;
		build_dlpack(DLDEP, len, addr, &packet);
		for ( iNak = 0; iNak < ETHRETRY; iNak++ ) {
			if (iNak > 0)
				fprintf(stderr,"\rretrying...");
			send_dlpack(Sfd, &packet);
			pDlAck = getack();
			/* test for ACK & correct address sequence number */
			if ( pDlAck != NULL &&
			     pDlAck->dl_hdr.dl_op == DLACK &&
			     ntohl(pDlAck->dl_hdr.dl_addr) == addr )
				break;
		}
		if (iNak == ETHRETRY) {
			message("ethernet download failed");
			return(ETH_FAILED);
		}
		if (!A.silent && !A.verbose)
			if ( (addr % 0x2000) == 0 ) {
				fprintf(stderr,
					"\rpage %d       ",
					addr/0x200);
			}
		addr += len;
		aoutsize -= len;
	}
	packet.dl_pt.dl_srt.dl_entry = htonl(aouthdr->a_entry &(~1));
	packet.dl_pt.dl_srt.dl_delay = htonl(A.startdelay);
	build_dlpack(DLSRT, 0, 0, &packet);
	for ( iNak = 0; iNak < ETHRETRY; iNak++ ) {
		if (iNak > 0)
			fprintf(stderr,"\rretrying...");
		send_dlpack(Sfd, &packet);
		pDlAck = getack();
		if ( pDlAck != NULL && pDlAck->dl_hdr.dl_op == DLQAK )
			break;
	}
	return(iNak < ETHRETRY ? ETH_OK : ETH_FAILED);
}

/*
 *=============================================================
 * build_dlpack - construct a packet in ether download format
 *=============================================================
 */
build_dlpack(op, datalen, addr, packet)
char	 op;
unsigned short	 datalen;
unsigned long	 addr;
struct	 dl_pack *packet;
{
	int	i;

	packet->dl_hdr.dl_op = op;
	packet->dl_hdr.dl_vers = VERSION;

	switch (op) {

	case DLDEP:
		packet->dl_hdr.dl_len = htons(datalen);
		packet->dl_hdr.dl_addr = htonl(addr);
		if (datalen > 0)
		  if ( read(AOUTFD, packet->dl_pt.dl_data, datalen)
		     < datalen ) {
			fprintf(stderr, "read error\n");
			callexit(1);
		  }
		break;

	case DLSRT:
	case DLID:
		break;

	default:
		fprintf(stderr, "build_dlpack: invalid output packet type\n");
		break;
	}
}

/*
 *============================================================
 * send_dlpack - send a downloader format packet out via UDP
 *============================================================
 */
send_dlpack(sockfd, dlpacket)
int sockfd;
struct dl_pack *dlpacket;
{
	unsigned short	len;
	unsigned long	addr;
	unsigned int	pktsize;

	switch (dlpacket->dl_hdr.dl_op) {

	case DLDEP:
		pktsize = sizeof(struct dl_pack);
		break;

	case DLSRT:
		pktsize = sizeof(struct dl_header)
					+ sizeof(struct dl_srtval);
		break;

	default:
		pktsize = sizeof(struct dl_header);
		break;
	}
	if (A.verbose) {
		fprintf(stderr,"packet:  ");
		switch(dlpacket->dl_hdr.dl_op) {
		case DLDEP:
			addr =  ntohl(dlpacket->dl_hdr.dl_addr);
			len  =  ntohs(dlpacket->dl_hdr.dl_len);
			fprintf(stderr, "deposit, addr = 0x%#x,\
				len = 0x%#x\n",	addr, (int) len);
			break;
		case DLSRT:
			fprintf( stderr,
				"start program, delay = %d, entry = 0x%x\n",
				ntohl(dlpacket->dl_pt.dl_srt.dl_delay),
				ntohl(dlpacket->dl_pt.dl_srt.dl_entry) );
			break;
		case DLID:
			fprintf(stderr, "ID packet\n");
			break;
		default:
			fprintf(stderr, "send_dlpack: invalid packet type\n");
			return;
		}
	}
	if (send(sockfd, dlpacket, pktsize, 0) < 0) {
		perror("udp packet send");
		callexit(1);
	}
}