sys/boot/i386/libi386/pxe.c

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