pxe.c revision 301056 
1/*-
2 * Copyright (c) 2000 Alfred Perlstein <alfred@freebsd.org>
3 * Copyright (c) 2000 Paul Saab <ps@freebsd.org>
4 * Copyright (c) 2000 John Baldwin <jhb@freebsd.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: stable/10/sys/boot/i386/libi386/pxe.c 301056 2016-05-31 17:01:54Z ian $");
31
32#include <stand.h>
33#include <string.h>
34#include <stdarg.h>
35
36#include <netinet/in_systm.h>
37#include <netinet/in.h>
38#include <netinet/udp.h>
39
40#include <net.h>
41#include <netif.h>
42#include <nfsv2.h>
43#include <iodesc.h>
44
45#include <bootp.h>
46#include <bootstrap.h>
47#include "btxv86.h"
48#include "pxe.h"
49
50/*
51 * Allocate the PXE buffers statically instead of sticking grimy fingers into
52 * BTX's private data area.  The scratch buffer is used to send information to
53 * the PXE BIOS, and the data buffer is used to receive data from the PXE BIOS.
54 */
55#define	PXE_BUFFER_SIZE		0x2000
56#define	PXE_TFTP_BUFFER_SIZE	512
57static char	scratch_buffer[PXE_BUFFER_SIZE];
58static char	data_buffer[PXE_BUFFER_SIZE];
59
60static pxenv_t	*pxenv_p = NULL;        /* PXENV+ */
61static pxe_t	*pxe_p   = NULL;	/* !PXE */
62static BOOTPLAYER	bootplayer;	/* PXE Cached information. */
63
64static int 	pxe_debug = 0;
65static int	pxe_sock = -1;
66static int	pxe_opens = 0;
67
68void		pxe_enable(void *pxeinfo);
69static void	(*pxe_call)(int func);
70static void	pxenv_call(int func);
71static void	bangpxe_call(int func);
72
73static int	pxe_init(void);
74static int	pxe_strategy(void *devdata, int flag, daddr_t dblk,
75			     size_t size, char *buf, size_t *rsize);
76static int	pxe_open(struct open_file *f, ...);
77static int	pxe_close(struct open_file *f);
78static void	pxe_print(int verbose);
79static void	pxe_cleanup(void);
80static void	pxe_setnfshandle(char *rootpath);
81
82static void	pxe_perror(int error);
83static int	pxe_netif_match(struct netif *nif, void *machdep_hint);
84static int	pxe_netif_probe(struct netif *nif, void *machdep_hint);
85static void	pxe_netif_init(struct iodesc *desc, void *machdep_hint);
86static int	pxe_netif_get(struct iodesc *desc, void *pkt, size_t len,
87			      time_t timeout);
88static int	pxe_netif_put(struct iodesc *desc, void *pkt, size_t len);
89static void	pxe_netif_end(struct netif *nif);
90
91#ifdef OLD_NFSV2
92int nfs_getrootfh(struct iodesc*, char*, u_char*);
93#else
94int nfs_getrootfh(struct iodesc*, char*, uint32_t*, u_char*);
95#endif
96
97extern struct netif_stats	pxe_st[];
98extern u_int16_t		__bangpxeseg;
99extern u_int16_t		__bangpxeoff;
100extern void			__bangpxeentry(void);
101extern u_int16_t		__pxenvseg;
102extern u_int16_t		__pxenvoff;
103extern void			__pxenventry(void);
104
105struct netif_dif pxe_ifs[] = {
106/*      dif_unit        dif_nsel        dif_stats       dif_private     */
107	{0,             1,              &pxe_st[0],     0}
108};
109
110struct netif_stats pxe_st[NENTS(pxe_ifs)];
111
112struct netif_driver pxenetif = {
113	"pxenet",
114	pxe_netif_match,
115	pxe_netif_probe,
116	pxe_netif_init,
117	pxe_netif_get,
118	pxe_netif_put,
119	pxe_netif_end,
120	pxe_ifs,
121	NENTS(pxe_ifs)
122};
123
124struct netif_driver *netif_drivers[] = {
125	&pxenetif,
126	NULL
127};
128
129struct devsw pxedisk = {
130	"pxe",
131	DEVT_NET,
132	pxe_init,
133	pxe_strategy,
134	pxe_open,
135	pxe_close,
136	noioctl,
137	pxe_print,
138	pxe_cleanup
139};
140
141/*
142 * This function is called by the loader to enable PXE support if we
143 * are booted by PXE.  The passed in pointer is a pointer to the
144 * PXENV+ structure.
145 */
146void
147pxe_enable(void *pxeinfo)
148{
149	pxenv_p  = (pxenv_t *)pxeinfo;
150	pxe_p    = (pxe_t *)PTOV(pxenv_p->PXEPtr.segment * 16 +
151				 pxenv_p->PXEPtr.offset);
152	pxe_call = NULL;
153}
154
155/*
156 * return true if pxe structures are found/initialized,
157 * also figures out our IP information via the pxe cached info struct
158 */
159static int
160pxe_init(void)
161{
162	t_PXENV_GET_CACHED_INFO	*gci_p;
163	int	counter;
164	uint8_t checksum;
165	uint8_t *checkptr;
166
167	if(pxenv_p == NULL)
168		return (0);
169
170	/*  look for "PXENV+" */
171	if (bcmp((void *)pxenv_p->Signature, S_SIZE("PXENV+"))) {
172		pxenv_p = NULL;
173		return (0);
174	}
175
176	/* make sure the size is something we can handle */
177	if (pxenv_p->Length > sizeof(*pxenv_p)) {
178	  	printf("PXENV+ structure too large, ignoring\n");
179		pxenv_p = NULL;
180		return (0);
181	}
182
183	/*
184	 * do byte checksum:
185	 * add up each byte in the structure, the total should be 0
186	 */
187	checksum = 0;
188	checkptr = (uint8_t *) pxenv_p;
189	for (counter = 0; counter < pxenv_p->Length; counter++)
190		checksum += *checkptr++;
191	if (checksum != 0) {
192		printf("PXENV+ structure failed checksum, ignoring\n");
193		pxenv_p = NULL;
194		return (0);
195	}
196
197
198	/*
199	 * PXENV+ passed, so use that if !PXE is not available or
200	 * the checksum fails.
201	 */
202	pxe_call = pxenv_call;
203	if (pxenv_p->Version >= 0x0200) {
204		for (;;) {
205			if (bcmp((void *)pxe_p->Signature, S_SIZE("!PXE"))) {
206				pxe_p = NULL;
207				break;
208			}
209			checksum = 0;
210			checkptr = (uint8_t *)pxe_p;
211			for (counter = 0; counter < pxe_p->StructLength;
212			     counter++)
213				checksum += *checkptr++;
214			if (checksum != 0) {
215				pxe_p = NULL;
216				break;
217			}
218			pxe_call = bangpxe_call;
219			break;
220		}
221	}
222
223	printf("\nPXE version %d.%d, real mode entry point ",
224	       (uint8_t) (pxenv_p->Version >> 8),
225	       (uint8_t) (pxenv_p->Version & 0xFF));
226	if (pxe_call == bangpxe_call)
227		printf("@%04x:%04x\n",
228		       pxe_p->EntryPointSP.segment,
229		       pxe_p->EntryPointSP.offset);
230	else
231		printf("@%04x:%04x\n",
232		       pxenv_p->RMEntry.segment, pxenv_p->RMEntry.offset);
233
234	gci_p = (t_PXENV_GET_CACHED_INFO *) scratch_buffer;
235	bzero(gci_p, sizeof(*gci_p));
236	gci_p->PacketType =  PXENV_PACKET_TYPE_BINL_REPLY;
237	pxe_call(PXENV_GET_CACHED_INFO);
238	if (gci_p->Status != 0) {
239		pxe_perror(gci_p->Status);
240		pxe_p = NULL;
241		return (0);
242	}
243	bcopy(PTOV((gci_p->Buffer.segment << 4) + gci_p->Buffer.offset),
244	      &bootplayer, gci_p->BufferSize);
245	return (1);
246}
247
248
249static int
250pxe_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
251		char *buf, size_t *rsize)
252{
253	return (EIO);
254}
255
256static int
257pxe_open(struct open_file *f, ...)
258{
259    va_list args;
260    char *devname;		/* Device part of file name (or NULL). */
261    char temp[FNAME_SIZE];
262    int error = 0;
263    int i;
264
265    va_start(args, f);
266    devname = va_arg(args, char*);
267    va_end(args);
268
269    /* On first open, do netif open, mount, etc. */
270    if (pxe_opens == 0) {
271	/* Find network interface. */
272	if (pxe_sock < 0) {
273	    pxe_sock = netif_open(devname);
274	    if (pxe_sock < 0) {
275		printf("pxe_open: netif_open() failed\n");
276		return (ENXIO);
277	    }
278	    if (pxe_debug)
279		printf("pxe_open: netif_open() succeeded\n");
280	}
281	if (rootip.s_addr == 0) {
282		/*
283		 * Do a bootp/dhcp request to find out where our
284		 * NFS/TFTP server is.  Even if we dont get back
285		 * the proper information, fall back to the server
286		 * which brought us to life and a default rootpath.
287		 */
288		bootp(pxe_sock, BOOTP_PXE);
289		if (rootip.s_addr == 0)
290			rootip.s_addr = bootplayer.sip;
291		if (!rootpath[0])
292			strcpy(rootpath, PXENFSROOTPATH);
293
294		for (i = 0; rootpath[i] != '\0' && i < FNAME_SIZE; i++)
295			if (rootpath[i] == ':')
296				break;
297		if (i && i != FNAME_SIZE && rootpath[i] == ':') {
298			rootpath[i++] = '\0';
299			if (inet_addr(&rootpath[0]) != INADDR_NONE)
300				rootip.s_addr = inet_addr(&rootpath[0]);
301			bcopy(&rootpath[i], &temp[0], strlen(&rootpath[i])+1);
302			bcopy(&temp[0], &rootpath[0], strlen(&rootpath[i])+1);
303		}
304		printf("pxe_open: server addr: %s\n", inet_ntoa(rootip));
305		printf("pxe_open: server path: %s\n", rootpath);
306		printf("pxe_open: gateway ip:  %s\n", inet_ntoa(gateip));
307
308		setenv("boot.netif.ip", inet_ntoa(myip), 1);
309		setenv("boot.netif.netmask", intoa(netmask), 1);
310		setenv("boot.netif.gateway", inet_ntoa(gateip), 1);
311		if (bootplayer.Hardware == ETHER_TYPE) {
312		    sprintf(temp, "%6D", bootplayer.CAddr, ":");
313		    setenv("boot.netif.hwaddr", temp, 1);
314		}
315		if (intf_mtu != 0) {
316			char mtu[16];
317			sprintf(mtu, "%u", intf_mtu);
318			setenv("boot.netif.mtu", mtu, 1);
319		}
320		setenv("boot.nfsroot.server", inet_ntoa(rootip), 1);
321		setenv("boot.nfsroot.path", rootpath, 1);
322		setenv("dhcp.host-name", hostname, 1);
323	}
324    }
325    pxe_opens++;
326    f->f_devdata = &pxe_sock;
327    return (error);
328}
329
330static int
331pxe_close(struct open_file *f)
332{
333
334#ifdef	PXE_DEBUG
335    if (pxe_debug)
336	printf("pxe_close: opens=%d\n", pxe_opens);
337#endif
338
339    /* On last close, do netif close, etc. */
340    f->f_devdata = NULL;
341    /* Extra close call? */
342    if (pxe_opens <= 0)
343	return (0);
344    pxe_opens--;
345    /* Not last close? */
346    if (pxe_opens > 0)
347	return(0);
348
349#ifdef LOADER_NFS_SUPPORT
350    /* get an NFS filehandle for our root filesystem */
351    pxe_setnfshandle(rootpath);
352#endif
353
354    if (pxe_sock >= 0) {
355
356#ifdef PXE_DEBUG
357	if (pxe_debug)
358	    printf("pxe_close: calling netif_close()\n");
359#endif
360	netif_close(pxe_sock);
361	pxe_sock = -1;
362    }
363    return (0);
364}
365
366static void
367pxe_print(int verbose)
368{
369
370	if (pxe_call == NULL)
371		return;
372
373	printf("    pxe0:    %s:%s\n", inet_ntoa(rootip), rootpath);
374}
375
376static void
377pxe_cleanup(void)
378{
379#ifdef PXE_DEBUG
380	t_PXENV_UNLOAD_STACK *unload_stack_p =
381	    (t_PXENV_UNLOAD_STACK *)scratch_buffer;
382	t_PXENV_UNDI_SHUTDOWN *undi_shutdown_p =
383	    (t_PXENV_UNDI_SHUTDOWN *)scratch_buffer;
384#endif
385
386	if (pxe_call == NULL)
387		return;
388
389	pxe_call(PXENV_UNDI_SHUTDOWN);
390
391#ifdef PXE_DEBUG
392	if (pxe_debug && undi_shutdown_p->Status != 0)
393		printf("pxe_cleanup: UNDI_SHUTDOWN failed %x\n",
394		       undi_shutdown_p->Status);
395#endif
396
397	pxe_call(PXENV_UNLOAD_STACK);
398
399#ifdef PXE_DEBUG
400	if (pxe_debug && unload_stack_p->Status != 0)
401		printf("pxe_cleanup: UNLOAD_STACK failed %x\n",
402		    unload_stack_p->Status);
403#endif
404}
405
406void
407pxe_perror(int err)
408{
409	return;
410}
411
412#ifdef LOADER_NFS_SUPPORT
413/*
414 * Reach inside the libstand NFS code and dig out an NFS handle
415 * for the root filesystem.
416 */
417#ifdef OLD_NFSV2
418struct nfs_iodesc {
419	struct	iodesc	*iodesc;
420	off_t	off;
421	u_char	fh[NFS_FHSIZE];
422	/* structure truncated here */
423};
424extern struct	nfs_iodesc nfs_root_node;
425extern int      rpc_port;
426
427static void
428pxe_rpcmountcall()
429{
430	struct	iodesc *d;
431	int     error;
432
433	if (!(d = socktodesc(pxe_sock)))
434		return;
435        d->myport = htons(--rpc_port);
436        d->destip = rootip;
437	if ((error = nfs_getrootfh(d, rootpath, nfs_root_node.fh)) != 0)
438		printf("NFS MOUNT RPC error: %d\n", error);
439	nfs_root_node.iodesc = d;
440}
441
442static void
443pxe_setnfshandle(char *rootpath)
444{
445	int	i;
446	u_char	*fh;
447	char	buf[2 * NFS_FHSIZE + 3], *cp;
448
449	/*
450	 * If NFS files were never opened, we need to do mount call
451	 * ourselves. Use nfs_root_node.iodesc as flag indicating
452	 * previous NFS usage.
453	 */
454	if (nfs_root_node.iodesc == NULL)
455		pxe_rpcmountcall();
456
457	fh = &nfs_root_node.fh[0];
458	buf[0] = 'X';
459	cp = &buf[1];
460	for (i = 0; i < NFS_FHSIZE; i++, cp += 2)
461		sprintf(cp, "%02x", fh[i]);
462	sprintf(cp, "X");
463	setenv("boot.nfsroot.nfshandle", buf, 1);
464}
465#else	/* !OLD_NFSV2 */
466
467#define	NFS_V3MAXFHSIZE		64
468
469struct nfs_iodesc {
470	struct iodesc *iodesc;
471	off_t off;
472	uint32_t fhsize;
473	u_char fh[NFS_V3MAXFHSIZE];
474	/* structure truncated */
475};
476extern struct nfs_iodesc nfs_root_node;
477extern int rpc_port;
478
479static void
480pxe_rpcmountcall()
481{
482	struct iodesc *d;
483	int error;
484
485	if (!(d = socktodesc(pxe_sock)))
486		return;
487        d->myport = htons(--rpc_port);
488        d->destip = rootip;
489	if ((error = nfs_getrootfh(d, rootpath, &nfs_root_node.fhsize,
490	    nfs_root_node.fh)) != 0) {
491		printf("NFS MOUNT RPC error: %d\n", error);
492		nfs_root_node.fhsize = 0;
493	}
494	nfs_root_node.iodesc = d;
495}
496
497static void
498pxe_setnfshandle(char *rootpath)
499{
500	int i;
501	u_char *fh;
502	char buf[2 * NFS_V3MAXFHSIZE + 3], *cp;
503
504	/*
505	 * If NFS files were never opened, we need to do mount call
506	 * ourselves. Use nfs_root_node.iodesc as flag indicating
507	 * previous NFS usage.
508	 */
509	if (nfs_root_node.iodesc == NULL)
510		pxe_rpcmountcall();
511
512	fh = &nfs_root_node.fh[0];
513	buf[0] = 'X';
514	cp = &buf[1];
515	for (i = 0; i < nfs_root_node.fhsize; i++, cp += 2)
516		sprintf(cp, "%02x", fh[i]);
517	sprintf(cp, "X");
518	setenv("boot.nfsroot.nfshandle", buf, 1);
519	sprintf(buf, "%d", nfs_root_node.fhsize);
520	setenv("boot.nfsroot.nfshandlelen", buf, 1);
521}
522#endif	/* OLD_NFSV2 */
523#endif /* LOADER_NFS_SUPPORT */
524
525void
526pxenv_call(int func)
527{
528#ifdef PXE_DEBUG
529	if (pxe_debug)
530		printf("pxenv_call %x\n", func);
531#endif
532
533	bzero(&v86, sizeof(v86));
534	bzero(data_buffer, sizeof(data_buffer));
535
536	__pxenvseg = pxenv_p->RMEntry.segment;
537	__pxenvoff = pxenv_p->RMEntry.offset;
538
539	v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
540	v86.es   = VTOPSEG(scratch_buffer);
541	v86.edi  = VTOPOFF(scratch_buffer);
542	v86.addr = (VTOPSEG(__pxenventry) << 16) | VTOPOFF(__pxenventry);
543	v86.ebx  = func;
544	v86int();
545	v86.ctl  = V86_FLAGS;
546}
547
548void
549bangpxe_call(int func)
550{
551#ifdef PXE_DEBUG
552	if (pxe_debug)
553		printf("bangpxe_call %x\n", func);
554#endif
555
556	bzero(&v86, sizeof(v86));
557	bzero(data_buffer, sizeof(data_buffer));
558
559	__bangpxeseg = pxe_p->EntryPointSP.segment;
560	__bangpxeoff = pxe_p->EntryPointSP.offset;
561
562	v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
563	v86.edx  = VTOPSEG(scratch_buffer);
564	v86.eax  = VTOPOFF(scratch_buffer);
565	v86.addr = (VTOPSEG(__bangpxeentry) << 16) | VTOPOFF(__bangpxeentry);
566	v86.ebx  = func;
567	v86int();
568	v86.ctl  = V86_FLAGS;
569}
570
571
572time_t
573getsecs()
574{
575	time_t n = 0;
576	time(&n);
577	return n;
578}
579
580static int
581pxe_netif_match(struct netif *nif, void *machdep_hint)
582{
583	return 1;
584}
585
586
587static int
588pxe_netif_probe(struct netif *nif, void *machdep_hint)
589{
590	t_PXENV_UDP_OPEN *udpopen_p = (t_PXENV_UDP_OPEN *)scratch_buffer;
591
592	if (pxe_call == NULL)
593		return -1;
594
595	bzero(udpopen_p, sizeof(*udpopen_p));
596	udpopen_p->src_ip = bootplayer.yip;
597	pxe_call(PXENV_UDP_OPEN);
598
599	if (udpopen_p->status != 0) {
600		printf("pxe_netif_probe: failed %x\n", udpopen_p->status);
601		return -1;
602	}
603	return 0;
604}
605
606static void
607pxe_netif_end(struct netif *nif)
608{
609	t_PXENV_UDP_CLOSE *udpclose_p = (t_PXENV_UDP_CLOSE *)scratch_buffer;
610	bzero(udpclose_p, sizeof(*udpclose_p));
611
612	pxe_call(PXENV_UDP_CLOSE);
613	if (udpclose_p->status != 0)
614		printf("pxe_end failed %x\n", udpclose_p->status);
615}
616
617static void
618pxe_netif_init(struct iodesc *desc, void *machdep_hint)
619{
620	int i;
621	for (i = 0; i < 6; ++i)
622		desc->myea[i] = bootplayer.CAddr[i];
623	desc->xid = bootplayer.ident;
624}
625
626static int
627pxe_netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
628{
629	return len;
630}
631
632static int
633pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
634{
635	return len;
636}
637
638ssize_t
639sendudp(struct iodesc *h, void *pkt, size_t len)
640{
641	t_PXENV_UDP_WRITE *udpwrite_p = (t_PXENV_UDP_WRITE *)scratch_buffer;
642	bzero(udpwrite_p, sizeof(*udpwrite_p));
643
644	udpwrite_p->ip             = h->destip.s_addr;
645	udpwrite_p->dst_port       = h->destport;
646	udpwrite_p->src_port       = h->myport;
647	udpwrite_p->buffer_size    = len;
648	udpwrite_p->buffer.segment = VTOPSEG(pkt);
649	udpwrite_p->buffer.offset  = VTOPOFF(pkt);
650
651	if (netmask == 0 || SAMENET(myip, h->destip, netmask))
652		udpwrite_p->gw = 0;
653	else
654		udpwrite_p->gw = gateip.s_addr;
655
656	pxe_call(PXENV_UDP_WRITE);
657
658#if 0
659	/* XXX - I dont know why we need this. */
660	delay(1000);
661#endif
662	if (udpwrite_p->status != 0) {
663		/* XXX: This happens a lot.  It shouldn't. */
664		if (udpwrite_p->status != 1)
665			printf("sendudp failed %x\n", udpwrite_p->status);
666		return -1;
667	}
668	return len;
669}
670
671ssize_t
672readudp(struct iodesc *h, void *pkt, size_t len, time_t timeout)
673{
674	t_PXENV_UDP_READ *udpread_p = (t_PXENV_UDP_READ *)scratch_buffer;
675	struct udphdr *uh = NULL;
676
677	uh = (struct udphdr *) pkt - 1;
678	bzero(udpread_p, sizeof(*udpread_p));
679
680	udpread_p->dest_ip        = h->myip.s_addr;
681	udpread_p->d_port         = h->myport;
682	udpread_p->buffer_size    = len;
683	udpread_p->buffer.segment = VTOPSEG(data_buffer);
684	udpread_p->buffer.offset  = VTOPOFF(data_buffer);
685
686	pxe_call(PXENV_UDP_READ);
687
688#if 0
689	/* XXX - I dont know why we need this. */
690	delay(1000);
691#endif
692	if (udpread_p->status != 0) {
693		/* XXX: This happens a lot.  It shouldn't. */
694		if (udpread_p->status != 1)
695			printf("readudp failed %x\n", udpread_p->status);
696		return -1;
697	}
698	bcopy(data_buffer, pkt, udpread_p->buffer_size);
699	uh->uh_sport = udpread_p->s_port;
700	return udpread_p->buffer_size;
701}
702