sys/nfsclient/bootp_subr.c

   1 /*-
   2  * Copyright (c) 1995 Gordon Ross, Adam Glass
   3  * Copyright (c) 1992 Regents of the University of California.
   4  * All rights reserved.
   5  *
   6  * This software was developed by the Computer Systems Engineering group
   7  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   8  * contributed to Berkeley.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Lawrence Berkeley Laboratory and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  * based on:
  39  *      nfs/krpc_subr.c
  40  *      $NetBSD: krpc_subr.c,v 1.10 1995/08/08 20:43:43 gwr Exp $
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include "opt_bootp.h"
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/jail.h>
  51 #include <sys/kernel.h>
  52 #include <sys/sockio.h>
  53 #include <sys/malloc.h>
  54 #include <sys/mount.h>
  55 #include <sys/mbuf.h>
  56 #include <sys/proc.h>
  57 #include <sys/socket.h>
  58 #include <sys/socketvar.h>
  59 #include <sys/sysctl.h>
  60 #include <sys/uio.h>
  61
  62 #include <net/if.h>
  63 #include <net/route.h>
  64
  65 #include <netinet/in.h>
  66 #include <net/if_types.h>
  67 #include <net/if_dl.h>
  68 #include <net/vnet.h>
  69
  70 #include <nfs/nfsproto.h>
  71 #include <nfsclient/nfs.h>
  72 #include <nfsclient/nfsdiskless.h>
  73 #include <nfsclient/krpc.h>
  74 #include <nfs/xdr_subs.h>
  75
  76
  77 #define BOOTP_MIN_LEN           300     /* Minimum size of bootp udp packet */
  78
  79 #ifndef BOOTP_SETTLE_DELAY
  80 #define BOOTP_SETTLE_DELAY 3
  81 #endif
  82
  83 /*
  84  * What is the longest we will wait before re-sending a request?
  85  * Note this is also the frequency of "RPC timeout" messages.
  86  * The re-send loop count sup linearly to this maximum, so the
  87  * first complaint will happen after (1+2+3+4+5)=15 seconds.
  88  */
  89 #define MAX_RESEND_DELAY 5      /* seconds */
  90
  91 /* Definitions from RFC951 */
  92 struct bootp_packet {
  93         u_int8_t op;
  94         u_int8_t htype;
  95         u_int8_t hlen;
  96         u_int8_t hops;
  97         u_int32_t xid;
  98         u_int16_t secs;
  99         u_int16_t flags;
 100         struct in_addr ciaddr;
 101         struct in_addr yiaddr;
 102         struct in_addr siaddr;
 103         struct in_addr giaddr;
 104         unsigned char chaddr[16];
 105         char sname[64];
 106         char file[128];
 107         unsigned char vend[1222];
 108 };
 109
 110 struct bootpc_ifcontext {
 111         struct bootpc_ifcontext *next;
 112         struct bootp_packet call;
 113         struct bootp_packet reply;
 114         int replylen;
 115         int overload;
 116         struct socket *so;
 117         struct ifreq ireq;
 118         struct ifnet *ifp;
 119         struct sockaddr_dl *sdl;
 120         struct sockaddr_in myaddr;
 121         struct sockaddr_in netmask;
 122         struct sockaddr_in gw;
 123         struct sockaddr_in broadcast;   /* Different for each interface */
 124         int gotgw;
 125         int gotnetmask;
 126         int gotrootpath;
 127         int outstanding;
 128         int sentmsg;
 129         u_int32_t xid;
 130         enum {
 131                 IF_BOOTP_UNRESOLVED,
 132                 IF_BOOTP_RESOLVED,
 133                 IF_BOOTP_FAILED,
 134                 IF_DHCP_UNRESOLVED,
 135                 IF_DHCP_OFFERED,
 136                 IF_DHCP_RESOLVED,
 137                 IF_DHCP_FAILED,
 138         } state;
 139         int dhcpquerytype;              /* dhcp type sent */
 140         struct in_addr dhcpserver;
 141         int gotdhcpserver;
 142 };
 143
 144 #define TAG_MAXLEN 1024
 145 struct bootpc_tagcontext {
 146         char buf[TAG_MAXLEN + 1];
 147         int overload;
 148         int badopt;
 149         int badtag;
 150         int foundopt;
 151         int taglen;
 152 };
 153
 154 struct bootpc_globalcontext {
 155         struct bootpc_ifcontext *interfaces;
 156         struct bootpc_ifcontext *lastinterface;
 157         u_int32_t xid;
 158         int gotrootpath;
 159         int gotgw;
 160         int ifnum;
 161         int secs;
 162         int starttime;
 163         struct bootp_packet reply;
 164         int replylen;
 165         struct bootpc_ifcontext *setrootfs;
 166         struct bootpc_ifcontext *sethostname;
 167         struct bootpc_tagcontext tmptag;
 168         struct bootpc_tagcontext tag;
 169 };
 170
 171 #define IPPORT_BOOTPC 68
 172 #define IPPORT_BOOTPS 67
 173
 174 #define BOOTP_REQUEST 1
 175 #define BOOTP_REPLY 2
 176
 177 /* Common tags */
 178 #define TAG_PAD           0  /* Pad option, implicit length 1 */
 179 #define TAG_SUBNETMASK    1  /* RFC 950 subnet mask */
 180 #define TAG_ROUTERS       3  /* Routers (in order of preference) */
 181 #define TAG_HOSTNAME     12  /* Client host name */
 182 #define TAG_ROOT         17  /* Root path */
 183
 184 /* DHCP specific tags */
 185 #define TAG_OVERLOAD     52  /* Option Overload */
 186 #define TAG_MAXMSGSIZE   57  /* Maximum DHCP Message Size */
 187
 188 #define TAG_END         255  /* End Option (i.e. no more options) */
 189
 190 /* Overload values */
 191 #define OVERLOAD_FILE     1
 192 #define OVERLOAD_SNAME    2
 193
 194 /* Site specific tags: */
 195 #define TAG_ROOTOPTS    130
 196 #define TAG_COOKIE      134     /* ascii info for userland, via sysctl */
 197
 198 #define TAG_DHCP_MSGTYPE 53
 199 #define TAG_DHCP_REQ_ADDR 50
 200 #define TAG_DHCP_SERVERID 54
 201 #define TAG_DHCP_LEASETIME 51
 202
 203 #define TAG_VENDOR_INDENTIFIER 60
 204
 205 #define DHCP_NOMSG    0
 206 #define DHCP_DISCOVER 1
 207 #define DHCP_OFFER    2
 208 #define DHCP_REQUEST  3
 209 #define DHCP_ACK      5
 210
 211 /* NFS read/write block size */
 212 #ifndef BOOTP_BLOCKSIZE
 213 #define BOOTP_BLOCKSIZE 8192
 214 #endif
 215
 216 static char bootp_cookie[128];
 217 SYSCTL_STRING(_kern, OID_AUTO, bootp_cookie, CTLFLAG_RD,
 218         bootp_cookie, 0, "Cookie (T134) supplied by bootp server");
 219
 220 /* mountd RPC */
 221 static int      md_mount(struct sockaddr_in *mdsin, char *path, u_char *fhp,
 222                     int *fhsizep, struct nfs_args *args, struct thread *td);
 223 static int      setfs(struct sockaddr_in *addr, char *path, char *p,
 224                     const struct in_addr *siaddr);
 225 static int      getdec(char **ptr);
 226 static int      getip(char **ptr, struct in_addr *ip);
 227 static void     mountopts(struct nfs_args *args, char *p);
 228 static int      xdr_opaque_decode(struct mbuf **ptr, u_char *buf, int len);
 229 static int      xdr_int_decode(struct mbuf **ptr, int *iptr);
 230 static void     print_in_addr(struct in_addr addr);
 231 static void     print_sin_addr(struct sockaddr_in *addr);
 232 static void     clear_sinaddr(struct sockaddr_in *sin);
 233 static void     allocifctx(struct bootpc_globalcontext *gctx);
 234 static void     bootpc_compose_query(struct bootpc_ifcontext *ifctx,
 235                     struct bootpc_globalcontext *gctx, struct thread *td);
 236 static unsigned char *bootpc_tag(struct bootpc_tagcontext *tctx,
 237                     struct bootp_packet *bp, int len, int tag);
 238 static void bootpc_tag_helper(struct bootpc_tagcontext *tctx,
 239                     unsigned char *start, int len, int tag);
 240
 241 #ifdef BOOTP_DEBUG
 242 void bootpboot_p_sa(struct sockaddr *sa, struct sockaddr *ma);
 243 void bootpboot_p_rtentry(struct rtentry *rt);
 244 void bootpboot_p_tree(struct radix_node *rn);
 245 void bootpboot_p_rtlist(void);
 246 void bootpboot_p_if(struct ifnet *ifp, struct ifaddr *ifa);
 247 void bootpboot_p_iflist(void);
 248 #endif
 249
 250 static int      bootpc_call(struct bootpc_globalcontext *gctx,
 251                     struct thread *td);
 252
 253 static int      bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx,
 254                     struct bootpc_globalcontext *gctx, struct thread *td);
 255
 256 static int      bootpc_adjust_interface(struct bootpc_ifcontext *ifctx,
 257                     struct bootpc_globalcontext *gctx, struct thread *td);
 258
 259 static void     bootpc_decode_reply(struct nfsv3_diskless *nd,
 260                     struct bootpc_ifcontext *ifctx,
 261                     struct bootpc_globalcontext *gctx);
 262
 263 static int      bootpc_received(struct bootpc_globalcontext *gctx,
 264                     struct bootpc_ifcontext *ifctx);
 265
 266 static __inline int bootpc_ifctx_isresolved(struct bootpc_ifcontext *ifctx);
 267 static __inline int bootpc_ifctx_isunresolved(struct bootpc_ifcontext *ifctx);
 268 static __inline int bootpc_ifctx_isfailed(struct bootpc_ifcontext *ifctx);
 269
 270 /*
 271  * In order to have multiple active interfaces with address 0.0.0.0
 272  * and be able to send data to a selected interface, we perform
 273  * some tricks:
 274  *
 275  *  - The 'broadcast' address is different for each interface.
 276  *
 277  *  - We temporarily add routing pointing 255.255.255.255 to the
 278  *    selected interface broadcast address, thus the packet sent
 279  *    goes to that interface.
 280  */
 281
 282 #ifdef BOOTP_DEBUG
 283 void
 284 bootpboot_p_sa(struct sockaddr *sa, struct sockaddr *ma)
 285 {
 286
 287         if (sa == NULL) {
 288                 printf("(sockaddr *) <null>");
 289                 return;
 290         }
 291         switch (sa->sa_family) {
 292         case AF_INET:
 293         {
 294                 struct sockaddr_in *sin;
 295
 296                 sin = (struct sockaddr_in *) sa;
 297                 printf("inet ");
 298                 print_sin_addr(sin);
 299                 if (ma != NULL) {
 300                         sin = (struct sockaddr_in *) ma;
 301                         printf(" mask ");
 302                         print_sin_addr(sin);
 303                 }
 304         }
 305         break;
 306         case AF_LINK:
 307         {
 308                 struct sockaddr_dl *sli;
 309                 int i;
 310
 311                 sli = (struct sockaddr_dl *) sa;
 312                 printf("link %.*s ", sli->sdl_nlen, sli->sdl_data);
 313                 for (i = 0; i < sli->sdl_alen; i++) {
 314                         if (i > 0)
 315                                 printf(":");
 316                         printf("%x", ((unsigned char *) LLADDR(sli))[i]);
 317                 }
 318         }
 319         break;
 320         default:
 321                 printf("af%d", sa->sa_family);
 322         }
 323 }
 324
 325 void
 326 bootpboot_p_rtentry(struct rtentry *rt)
 327 {
 328
 329         bootpboot_p_sa(rt_key(rt), rt_mask(rt));
 330         printf(" ");
 331         bootpboot_p_sa(rt->rt_gateway, NULL);
 332         printf(" ");
 333         printf("flags %x", (unsigned short) rt->rt_flags);
 334         printf(" %d", (int) rt->rt_rmx.rmx_expire);
 335         printf(" %s\n", rt->rt_ifp->if_xname);
 336 }
 337
 338 void
 339 bootpboot_p_tree(struct radix_node *rn)
 340 {
 341
 342         while (rn != NULL) {
 343                 if (rn->rn_bit < 0) {
 344                         if ((rn->rn_flags & RNF_ROOT) != 0) {
 345                         } else {
 346                                 bootpboot_p_rtentry((struct rtentry *) rn);
 347                         }
 348                         rn = rn->rn_dupedkey;
 349                 } else {
 350                         bootpboot_p_tree(rn->rn_left);
 351                         bootpboot_p_tree(rn->rn_right);
 352                         return;
 353                 }
 354         }
 355 }
 356
 357 void
 358 bootpboot_p_rtlist(void)
 359 {
 360         struct radix_node_head *rnh;
 361
 362         printf("Routing table:\n");
 363         rnh = rt_tables_get_rnh(0, AF_INET);
 364         if (rnh == NULL)
 365                 return;
 366         RADIX_NODE_HEAD_RLOCK(rnh);     /* could sleep XXX */
 367         bootpboot_p_tree(rnh->rnh_treetop);
 368         RADIX_NODE_HEAD_RUNLOCK(rnh);
 369 }
 370
 371 void
 372 bootpboot_p_if(struct ifnet *ifp, struct ifaddr *ifa)
 373 {
 374
 375         printf("%s flags %x, addr ",
 376                ifp->if_xname, ifp->if_flags);
 377         print_sin_addr((struct sockaddr_in *) ifa->ifa_addr);
 378         printf(", broadcast ");
 379         print_sin_addr((struct sockaddr_in *) ifa->ifa_dstaddr);
 380         printf(", netmask ");
 381         print_sin_addr((struct sockaddr_in *) ifa->ifa_netmask);
 382         printf("\n");
 383 }
 384
 385 void
 386 bootpboot_p_iflist(void)
 387 {
 388         struct ifnet *ifp;
 389         struct ifaddr *ifa;
 390
 391         printf("Interface list:\n");
 392         IFNET_RLOCK();
 393         for (ifp = TAILQ_FIRST(&V_ifnet);
 394              ifp != NULL;
 395              ifp = TAILQ_NEXT(ifp, if_link)) {
 396                 for (ifa = TAILQ_FIRST(&ifp->if_addrhead);
 397                      ifa != NULL;
 398                      ifa = TAILQ_NEXT(ifa, ifa_link))
 399                         if (ifa->ifa_addr->sa_family == AF_INET)
 400                                 bootpboot_p_if(ifp, ifa);
 401         }
 402         IFNET_RUNLOCK();
 403 }
 404 #endif /* defined(BOOTP_DEBUG) */
 405
 406 static void
 407 clear_sinaddr(struct sockaddr_in *sin)
 408 {
 409
 410         bzero(sin, sizeof(*sin));
 411         sin->sin_len = sizeof(*sin);
 412         sin->sin_family = AF_INET;
 413         sin->sin_addr.s_addr = INADDR_ANY; /* XXX: htonl(INAADDR_ANY) ? */
 414         sin->sin_port = 0;
 415 }
 416
 417 static void
 418 allocifctx(struct bootpc_globalcontext *gctx)
 419 {
 420         struct bootpc_ifcontext *ifctx;
 421         ifctx = (struct bootpc_ifcontext *) malloc(sizeof(*ifctx),
 422                                                    M_TEMP, M_WAITOK | M_ZERO);
 423         if (ifctx == NULL)
 424                 panic("Failed to allocate bootp interface context structure");
 425
 426         ifctx->xid = gctx->xid;
 427 #ifdef BOOTP_NO_DHCP
 428         ifctx->state = IF_BOOTP_UNRESOLVED;
 429 #else
 430         ifctx->state = IF_DHCP_UNRESOLVED;
 431 #endif
 432         gctx->xid += 0x100;
 433         if (gctx->interfaces != NULL)
 434                 gctx->lastinterface->next = ifctx;
 435         else
 436                 gctx->interfaces = ifctx;
 437         gctx->lastinterface = ifctx;
 438 }
 439
 440 static __inline int
 441 bootpc_ifctx_isresolved(struct bootpc_ifcontext *ifctx)
 442 {
 443
 444         if (ifctx->state == IF_BOOTP_RESOLVED ||
 445             ifctx->state == IF_DHCP_RESOLVED)
 446                 return 1;
 447         return 0;
 448 }
 449
 450 static __inline int
 451 bootpc_ifctx_isunresolved(struct bootpc_ifcontext *ifctx)
 452 {
 453
 454         if (ifctx->state == IF_BOOTP_UNRESOLVED ||
 455             ifctx->state == IF_DHCP_UNRESOLVED)
 456                 return 1;
 457         return 0;
 458 }
 459
 460 static __inline int
 461 bootpc_ifctx_isfailed(struct bootpc_ifcontext *ifctx)
 462 {
 463
 464         if (ifctx->state == IF_BOOTP_FAILED ||
 465             ifctx->state == IF_DHCP_FAILED)
 466                 return 1;
 467         return 0;
 468 }
 469
 470 static int
 471 bootpc_received(struct bootpc_globalcontext *gctx,
 472     struct bootpc_ifcontext *ifctx)
 473 {
 474         unsigned char dhcpreplytype;
 475         char *p;
 476
 477         /*
 478          * Need timeout for fallback to less
 479          * desirable alternative.
 480          */
 481
 482         /* This call used for the side effect (badopt flag) */
 483         (void) bootpc_tag(&gctx->tmptag, &gctx->reply,
 484                           gctx->replylen,
 485                           TAG_END);
 486
 487         /* If packet is invalid, ignore it */
 488         if (gctx->tmptag.badopt != 0)
 489                 return 0;
 490
 491         p = bootpc_tag(&gctx->tmptag, &gctx->reply,
 492                        gctx->replylen, TAG_DHCP_MSGTYPE);
 493         if (p != NULL)
 494                 dhcpreplytype = *p;
 495         else
 496                 dhcpreplytype = DHCP_NOMSG;
 497
 498         switch (ifctx->dhcpquerytype) {
 499         case DHCP_DISCOVER:
 500                 if (dhcpreplytype != DHCP_OFFER         /* Normal DHCP offer */
 501 #ifndef BOOTP_FORCE_DHCP
 502                     && dhcpreplytype != DHCP_NOMSG      /* Fallback to BOOTP */
 503 #endif
 504                         )
 505                         return 0;
 506                 break;
 507         case DHCP_REQUEST:
 508                 if (dhcpreplytype != DHCP_ACK)
 509                         return 0;
 510         case DHCP_NOMSG:
 511                 break;
 512         }
 513
 514         /* Ignore packet unless it gives us a root tag we didn't have */
 515
 516         if ((ifctx->state == IF_BOOTP_RESOLVED ||
 517              (ifctx->dhcpquerytype == DHCP_DISCOVER &&
 518               (ifctx->state == IF_DHCP_OFFERED ||
 519                ifctx->state == IF_DHCP_RESOLVED))) &&
 520             (bootpc_tag(&gctx->tmptag, &ifctx->reply,
 521                         ifctx->replylen,
 522                         TAG_ROOT) != NULL ||
 523              bootpc_tag(&gctx->tmptag, &gctx->reply,
 524                         gctx->replylen,
 525                         TAG_ROOT) == NULL))
 526                 return 0;
 527
 528         bcopy(&gctx->reply, &ifctx->reply, gctx->replylen);
 529         ifctx->replylen = gctx->replylen;
 530
 531         /* XXX: Only reset if 'perfect' response */
 532         if (ifctx->state == IF_BOOTP_UNRESOLVED)
 533                 ifctx->state = IF_BOOTP_RESOLVED;
 534         else if (ifctx->state == IF_DHCP_UNRESOLVED &&
 535                  ifctx->dhcpquerytype == DHCP_DISCOVER) {
 536                 if (dhcpreplytype == DHCP_OFFER)
 537                         ifctx->state = IF_DHCP_OFFERED;
 538                 else
 539                         ifctx->state = IF_BOOTP_RESOLVED;       /* Fallback */
 540         } else if (ifctx->state == IF_DHCP_OFFERED &&
 541                    ifctx->dhcpquerytype == DHCP_REQUEST)
 542                 ifctx->state = IF_DHCP_RESOLVED;
 543
 544
 545         if (ifctx->dhcpquerytype == DHCP_DISCOVER &&
 546             ifctx->state != IF_BOOTP_RESOLVED) {
 547                 p = bootpc_tag(&gctx->tmptag, &ifctx->reply,
 548                                ifctx->replylen, TAG_DHCP_SERVERID);
 549                 if (p != NULL && gctx->tmptag.taglen == 4) {
 550                         memcpy(&ifctx->dhcpserver, p, 4);
 551                         ifctx->gotdhcpserver = 1;
 552                 } else
 553                         ifctx->gotdhcpserver = 0;
 554                 return 1;
 555         }
 556
 557         ifctx->gotrootpath = (bootpc_tag(&gctx->tmptag, &ifctx->reply,
 558                                          ifctx->replylen,
 559                                          TAG_ROOT) != NULL);
 560         ifctx->gotgw = (bootpc_tag(&gctx->tmptag, &ifctx->reply,
 561                                    ifctx->replylen,
 562                                    TAG_ROUTERS) != NULL);
 563         ifctx->gotnetmask = (bootpc_tag(&gctx->tmptag, &ifctx->reply,
 564                                         ifctx->replylen,
 565                                         TAG_SUBNETMASK) != NULL);
 566         return 1;
 567 }
 568
 569 static int
 570 bootpc_call(struct bootpc_globalcontext *gctx, struct thread *td)
 571 {
 572         struct socket *so;
 573         struct sockaddr_in *sin, dst;
 574         struct uio auio;
 575         struct sockopt sopt;
 576         struct iovec aio;
 577         int error, on, rcvflg, timo, len;
 578         time_t atimo;
 579         time_t rtimo;
 580         struct timeval tv;
 581         struct bootpc_ifcontext *ifctx;
 582         int outstanding;
 583         int gotrootpath;
 584         int retry;
 585         const char *s;
 586
 587         CURVNET_SET(TD_TO_VNET(td));
 588
 589         /*
 590          * Create socket and set its recieve timeout.
 591          */
 592         error = socreate(AF_INET, &so, SOCK_DGRAM, 0, td->td_ucred, td);
 593         if (error != 0)
 594                 goto out0;
 595
 596         tv.tv_sec = 1;
 597         tv.tv_usec = 0;
 598         bzero(&sopt, sizeof(sopt));
 599         sopt.sopt_dir = SOPT_SET;
 600         sopt.sopt_level = SOL_SOCKET;
 601         sopt.sopt_name = SO_RCVTIMEO;
 602         sopt.sopt_val = &tv;
 603         sopt.sopt_valsize = sizeof tv;
 604
 605         error = sosetopt(so, &sopt);
 606         if (error != 0)
 607                 goto out;
 608
 609         /*
 610          * Enable broadcast.
 611          */
 612         on = 1;
 613         sopt.sopt_name = SO_BROADCAST;
 614         sopt.sopt_val = &on;
 615         sopt.sopt_valsize = sizeof on;
 616
 617         error = sosetopt(so, &sopt);
 618         if (error != 0)
 619                 goto out;
 620
 621         /*
 622          * Disable routing.
 623          */
 624
 625         on = 1;
 626         sopt.sopt_name = SO_DONTROUTE;
 627         sopt.sopt_val = &on;
 628         sopt.sopt_valsize = sizeof on;
 629
 630         error = sosetopt(so, &sopt);
 631         if (error != 0)
 632                 goto out;
 633
 634         /*
 635          * Bind the local endpoint to a bootp client port.
 636          */
 637         sin = &dst;
 638         clear_sinaddr(sin);
 639         sin->sin_port = htons(IPPORT_BOOTPC);
 640         error = sobind(so, (struct sockaddr *)sin, td);
 641         if (error != 0) {
 642                 printf("bind failed\n");
 643                 goto out;
 644         }
 645
 646         /*
 647          * Setup socket address for the server.
 648          */
 649         sin = &dst;
 650         clear_sinaddr(sin);
 651         sin->sin_addr.s_addr = INADDR_BROADCAST;
 652         sin->sin_port = htons(IPPORT_BOOTPS);
 653
 654         /*
 655          * Send it, repeatedly, until a reply is received,
 656          * but delay each re-send by an increasing amount.
 657          * If the delay hits the maximum, start complaining.
 658          */
 659         timo = 0;
 660         rtimo = 0;
 661         for (;;) {
 662
 663                 outstanding = 0;
 664                 gotrootpath = 0;
 665
 666                 for (ifctx = gctx->interfaces;
 667                      ifctx != NULL;
 668                      ifctx = ifctx->next) {
 669                         if (bootpc_ifctx_isresolved(ifctx) != 0 &&
 670                             bootpc_tag(&gctx->tmptag, &ifctx->reply,
 671                                        ifctx->replylen,
 672                                        TAG_ROOT) != NULL)
 673                                 gotrootpath = 1;
 674                 }
 675
 676                 for (ifctx = gctx->interfaces;
 677                      ifctx != NULL;
 678                      ifctx = ifctx->next) {
 679                         ifctx->outstanding = 0;
 680                         if (bootpc_ifctx_isresolved(ifctx)  != 0 &&
 681                             gotrootpath != 0) {
 682                                 continue;
 683                         }
 684                         if (bootpc_ifctx_isfailed(ifctx) != 0)
 685                                 continue;
 686
 687                         outstanding++;
 688                         ifctx->outstanding = 1;
 689
 690                         /* Proceed to next step in DHCP negotiation */
 691                         if ((ifctx->state == IF_DHCP_OFFERED &&
 692                              ifctx->dhcpquerytype != DHCP_REQUEST) ||
 693                             (ifctx->state == IF_DHCP_UNRESOLVED &&
 694                              ifctx->dhcpquerytype != DHCP_DISCOVER) ||
 695                             (ifctx->state == IF_BOOTP_UNRESOLVED &&
 696                              ifctx->dhcpquerytype != DHCP_NOMSG)) {
 697                                 ifctx->sentmsg = 0;
 698                                 bootpc_compose_query(ifctx, gctx, td);
 699                         }
 700
 701                         /* Send BOOTP request (or re-send). */
 702
 703                         if (ifctx->sentmsg == 0) {
 704                                 switch(ifctx->dhcpquerytype) {
 705                                 case DHCP_DISCOVER:
 706                                         s = "DHCP Discover";
 707                                         break;
 708                                 case DHCP_REQUEST:
 709                                         s = "DHCP Request";
 710                                         break;
 711                                 case DHCP_NOMSG:
 712                                 default:
 713                                         s = "BOOTP Query";
 714                                         break;
 715                                 }
 716                                 printf("Sending %s packet from "
 717                                        "interface %s (%*D)\n",
 718                                        s,
 719                                        ifctx->ireq.ifr_name,
 720                                        ifctx->sdl->sdl_alen,
 721                                        (unsigned char *) LLADDR(ifctx->sdl),
 722                                        ":");
 723                                 ifctx->sentmsg = 1;
 724                         }
 725
 726                         aio.iov_base = (caddr_t) &ifctx->call;
 727                         aio.iov_len = sizeof(ifctx->call);
 728
 729                         auio.uio_iov = &aio;
 730                         auio.uio_iovcnt = 1;
 731                         auio.uio_segflg = UIO_SYSSPACE;
 732                         auio.uio_rw = UIO_WRITE;
 733                         auio.uio_offset = 0;
 734                         auio.uio_resid = sizeof(ifctx->call);
 735                         auio.uio_td = td;
 736
 737                         /* Set netmask to 0.0.0.0 */
 738
 739                         sin = (struct sockaddr_in *) &ifctx->ireq.ifr_addr;
 740                         clear_sinaddr(sin);
 741                         error = ifioctl(ifctx->so, SIOCSIFNETMASK,
 742                                         (caddr_t) &ifctx->ireq, td);
 743                         if (error != 0)
 744                                 panic("bootpc_call:"
 745                                       "set if netmask, error=%d",
 746                                       error);
 747
 748                         error = sosend(so, (struct sockaddr *) &dst,
 749                                        &auio, NULL, NULL, 0, td);
 750                         if (error != 0) {
 751                                 printf("bootpc_call: sosend: %d state %08x\n",
 752                                        error, (int) so->so_state);
 753                         }
 754
 755                         /* XXX: Is this needed ? */
 756                         pause("bootpw", hz/10);
 757
 758                         /* Set netmask to 255.0.0.0 */
 759
 760                         sin = (struct sockaddr_in *) &ifctx->ireq.ifr_addr;
 761                         clear_sinaddr(sin);
 762                         sin->sin_addr.s_addr = htonl(0xff000000u);
 763                         error = ifioctl(ifctx->so, SIOCSIFNETMASK,
 764                                         (caddr_t) &ifctx->ireq, td);
 765                         if (error != 0)
 766                                 panic("bootpc_call:"
 767                                       "set if netmask, error=%d",
 768                                       error);
 769
 770                 }
 771
 772                 if (outstanding == 0 &&
 773                     (rtimo == 0 || time_second >= rtimo)) {
 774                         error = 0;
 775                         goto gotreply;
 776                 }
 777
 778                 /* Determine new timeout. */
 779                 if (timo < MAX_RESEND_DELAY)
 780                         timo++;
 781                 else {
 782                         printf("DHCP/BOOTP timeout for server ");
 783                         print_sin_addr(&dst);
 784                         printf("\n");
 785                 }
 786
 787                 /*
 788                  * Wait for up to timo seconds for a reply.
 789                  * The socket receive timeout was set to 1 second.
 790                  */
 791                 atimo = timo + time_second;
 792                 while (time_second < atimo) {
 793                         aio.iov_base = (caddr_t) &gctx->reply;
 794                         aio.iov_len = sizeof(gctx->reply);
 795
 796                         auio.uio_iov = &aio;
 797                         auio.uio_iovcnt = 1;
 798                         auio.uio_segflg = UIO_SYSSPACE;
 799                         auio.uio_rw = UIO_READ;
 800                         auio.uio_offset = 0;
 801                         auio.uio_resid = sizeof(gctx->reply);
 802                         auio.uio_td = td;
 803
 804                         rcvflg = 0;
 805                         error = soreceive(so, NULL, &auio,
 806                                           NULL, NULL, &rcvflg);
 807                         gctx->secs = time_second - gctx->starttime;
 808                         for (ifctx = gctx->interfaces;
 809                              ifctx != NULL;
 810                              ifctx = ifctx->next) {
 811                                 if (bootpc_ifctx_isresolved(ifctx) != 0 ||
 812                                     bootpc_ifctx_isfailed(ifctx) != 0)
 813                                         continue;
 814
 815                                 ifctx->call.secs = htons(gctx->secs);
 816                         }
 817                         if (error == EWOULDBLOCK)
 818                                 continue;
 819                         if (error != 0)
 820                                 goto out;
 821                         len = sizeof(gctx->reply) - auio.uio_resid;
 822
 823                         /* Do we have the required number of bytes ? */
 824                         if (len < BOOTP_MIN_LEN)
 825                                 continue;
 826                         gctx->replylen = len;
 827
 828                         /* Is it a reply? */
 829                         if (gctx->reply.op != BOOTP_REPLY)
 830                                 continue;
 831
 832                         /* Is this an answer to our query */
 833                         for (ifctx = gctx->interfaces;
 834                              ifctx != NULL;
 835                              ifctx = ifctx->next) {
 836                                 if (gctx->reply.xid != ifctx->call.xid)
 837                                         continue;
 838
 839                                 /* Same HW address size ? */
 840                                 if (gctx->reply.hlen != ifctx->call.hlen)
 841                                         continue;
 842
 843                                 /* Correct HW address ? */
 844                                 if (bcmp(gctx->reply.chaddr,
 845                                          ifctx->call.chaddr,
 846                                          ifctx->call.hlen) != 0)
 847                                         continue;
 848
 849                                 break;
 850                         }
 851
 852                         if (ifctx != NULL) {
 853                                 s =  bootpc_tag(&gctx->tmptag,
 854                                                 &gctx->reply,
 855                                                 gctx->replylen,
 856                                                 TAG_DHCP_MSGTYPE);
 857                                 if (s != NULL) {
 858                                         switch (*s) {
 859                                         case DHCP_OFFER:
 860                                                 s = "DHCP Offer";
 861                                                 break;
 862                                         case DHCP_ACK:
 863                                                 s = "DHCP Ack";
 864                                                 break;
 865                                         default:
 866                                                 s = "DHCP (unexpected)";
 867                                                 break;
 868                                         }
 869                                 } else
 870                                         s = "BOOTP Reply";
 871
 872                                 printf("Received %s packet"
 873                                        " on %s from ",
 874                                        s,
 875                                        ifctx->ireq.ifr_name);
 876                                 print_in_addr(gctx->reply.siaddr);
 877                                 if (gctx->reply.giaddr.s_addr !=
 878                                     htonl(INADDR_ANY)) {
 879                                         printf(" via ");
 880                                         print_in_addr(gctx->reply.giaddr);
 881                                 }
 882                                 if (bootpc_received(gctx, ifctx) != 0) {
 883                                         printf(" (accepted)");
 884                                         if (ifctx->outstanding) {
 885                                                 ifctx->outstanding = 0;
 886                                                 outstanding--;
 887                                         }
 888                                         /* Network settle delay */
 889                                         if (outstanding == 0)
 890                                                 atimo = time_second +
 891                                                         BOOTP_SETTLE_DELAY;
 892                                 } else
 893                                         printf(" (ignored)");
 894                                 if (ifctx->gotrootpath) {
 895                                         gotrootpath = 1;
 896                                         rtimo = time_second +
 897                                                 BOOTP_SETTLE_DELAY;
 898                                         printf(" (got root path)");
 899                                 } else
 900                                         printf(" (no root path)");
 901                                 printf("\n");
 902                         }
 903                 } /* while secs */
 904 #ifdef BOOTP_TIMEOUT
 905                 if (gctx->secs > BOOTP_TIMEOUT && BOOTP_TIMEOUT > 0)
 906                         break;
 907 #endif
 908                 /* Force a retry if halfway in DHCP negotiation */
 909                 retry = 0;
 910                 for (ifctx = gctx->interfaces; ifctx != NULL;
 911                      ifctx = ifctx->next) {
 912                         if (ifctx->state == IF_DHCP_OFFERED) {
 913                                 if (ifctx->dhcpquerytype == DHCP_DISCOVER)
 914                                         retry = 1;
 915                                 else
 916                                         ifctx->state = IF_DHCP_UNRESOLVED;
 917                         }
 918                 }
 919
 920                 if (retry != 0)
 921                         continue;
 922
 923                 if (gotrootpath != 0) {
 924                         gctx->gotrootpath = gotrootpath;
 925                         if (rtimo != 0 && time_second >= rtimo)
 926                                 break;
 927                 }
 928         } /* forever send/receive */
 929
 930         /*
 931          * XXX: These are errors of varying seriousness being silently
 932          * ignored
 933          */
 934
 935         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) {
 936                 if (bootpc_ifctx_isresolved(ifctx) == 0) {
 937                         printf("%s timeout for interface %s\n",
 938                                ifctx->dhcpquerytype != DHCP_NOMSG ?
 939                                "DHCP" : "BOOTP",
 940                                ifctx->ireq.ifr_name);
 941                 }
 942         }
 943         if (gctx->gotrootpath != 0) {
 944 #if 0
 945                 printf("Got a root path, ignoring remaining timeout\n");
 946 #endif
 947                 error = 0;
 948                 goto out;
 949         }
 950 #ifndef BOOTP_NFSROOT
 951         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) {
 952                 if (bootpc_ifctx_isresolved(ifctx) != 0) {
 953                         error = 0;
 954                         goto out;
 955                 }
 956         }
 957 #endif
 958         error = ETIMEDOUT;
 959         goto out;
 960
 961 gotreply:
 962 out:
 963         soclose(so);
 964 out0:
 965         CURVNET_RESTORE();
 966         return error;
 967 }
 968
 969 static int
 970 bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx,
 971     struct bootpc_globalcontext *gctx, struct thread *td)
 972 {
 973         struct sockaddr_in *sin;
 974         int error;
 975         struct ifreq *ireq;
 976         struct socket *so;
 977         struct ifaddr *ifa;
 978         struct sockaddr_dl *sdl;
 979
 980         CURVNET_SET(TD_TO_VNET(td));
 981
 982         error = socreate(AF_INET, &ifctx->so, SOCK_DGRAM, 0, td->td_ucred, td);
 983         if (error != 0)
 984                 panic("nfs_boot: socreate, error=%d", error);
 985
 986         ireq = &ifctx->ireq;
 987         so = ifctx->so;
 988
 989         /*
 990          * Bring up the interface.
 991          *
 992          * Get the old interface flags and or IFF_UP into them; if
 993          * IFF_UP set blindly, interface selection can be clobbered.
 994          */
 995         error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td);
 996         if (error != 0)
 997                 panic("bootpc_fakeup_interface: GIFFLAGS, error=%d", error);
 998         ireq->ifr_flags |= IFF_UP;
 999         error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td);
1000         if (error != 0)
1001                 panic("bootpc_fakeup_interface: SIFFLAGS, error=%d", error);
1002
1003         /*
1004          * Do enough of ifconfig(8) so that the chosen interface
1005          * can talk to the servers.  (just set the address)
1006          */
1007
1008         /* addr is 0.0.0.0 */
1009
1010         sin = (struct sockaddr_in *) &ireq->ifr_addr;
1011         clear_sinaddr(sin);
1012         error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td);
1013         if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces))
1014                 panic("bootpc_fakeup_interface: "
1015                       "set if addr, error=%d", error);
1016
1017         /* netmask is 255.0.0.0 */
1018
1019         sin = (struct sockaddr_in *) &ireq->ifr_addr;
1020         clear_sinaddr(sin);
1021         sin->sin_addr.s_addr = htonl(0xff000000u);
1022         error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ireq, td);
1023         if (error != 0)
1024                 panic("bootpc_fakeup_interface: set if netmask, error=%d",
1025                       error);
1026
1027         /* Broadcast is 255.255.255.255 */
1028
1029         sin = (struct sockaddr_in *)&ireq->ifr_addr;
1030         clear_sinaddr(sin);
1031         clear_sinaddr(&ifctx->broadcast);
1032         sin->sin_addr.s_addr = htonl(INADDR_BROADCAST);
1033         ifctx->broadcast.sin_addr.s_addr = sin->sin_addr.s_addr;
1034
1035         error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t)ireq, td);
1036         if (error != 0)
1037                 panic("bootpc_fakeup_interface: "
1038                       "set if broadcast addr, error=%d",
1039                       error);
1040
1041         /* Get HW address */
1042
1043         sdl = NULL;
1044         TAILQ_FOREACH(ifa, &ifctx->ifp->if_addrhead, ifa_link)
1045                 if (ifa->ifa_addr->sa_family == AF_LINK) {
1046                         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
1047                         if (sdl->sdl_type == IFT_ETHER)
1048                                 break;
1049                 }
1050
1051         if (sdl == NULL)
1052                 panic("bootpc: Unable to find HW address for %s",
1053                       ifctx->ireq.ifr_name);
1054         ifctx->sdl = sdl;
1055
1056         CURVNET_RESTORE();
1057
1058         return error;
1059 }
1060
1061
1062 static int
1063 bootpc_adjust_interface(struct bootpc_ifcontext *ifctx,
1064     struct bootpc_globalcontext *gctx, struct thread *td)
1065 {
1066         int error;
1067         struct sockaddr_in defdst;
1068         struct sockaddr_in defmask;
1069         struct sockaddr_in *sin;
1070         struct ifreq *ireq;
1071         struct socket *so;
1072         struct sockaddr_in *myaddr;
1073         struct sockaddr_in *netmask;
1074         struct sockaddr_in *gw;
1075
1076         ireq = &ifctx->ireq;
1077         so = ifctx->so;
1078         myaddr = &ifctx->myaddr;
1079         netmask = &ifctx->netmask;
1080         gw = &ifctx->gw;
1081
1082         if (bootpc_ifctx_isresolved(ifctx) == 0) {
1083
1084                 /* Shutdown interfaces where BOOTP failed */
1085
1086                 printf("Shutdown interface %s\n", ifctx->ireq.ifr_name);
1087                 error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td);
1088                 if (error != 0)
1089                         panic("bootpc_adjust_interface: "
1090                               "SIOCGIFFLAGS, error=%d", error);
1091                 ireq->ifr_flags &= ~IFF_UP;
1092                 error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td);
1093                 if (error != 0)
1094                         panic("bootpc_adjust_interface: "
1095                               "SIOCSIFFLAGS, error=%d", error);
1096
1097                 sin = (struct sockaddr_in *) &ireq->ifr_addr;
1098                 clear_sinaddr(sin);
1099                 error = ifioctl(so, SIOCDIFADDR, (caddr_t) ireq, td);
1100                 if (error != 0 && (error != EEXIST ||
1101                                    ifctx == gctx->interfaces))
1102                         panic("bootpc_adjust_interface: "
1103                               "SIOCDIFADDR, error=%d", error);
1104
1105                 return 0;
1106         }
1107
1108         printf("Adjusted interface %s\n", ifctx->ireq.ifr_name);
1109         /*
1110          * Do enough of ifconfig(8) so that the chosen interface
1111          * can talk to the servers.  (just set the address)
1112          */
1113         bcopy(netmask, &ireq->ifr_addr, sizeof(*netmask));
1114         error = ifioctl(so, SIOCSIFNETMASK, (caddr_t) ireq, td);
1115         if (error != 0)
1116                 panic("bootpc_adjust_interface: "
1117                       "set if netmask, error=%d", error);
1118
1119         /* Broadcast is with host part of IP address all 1's */
1120
1121         sin = (struct sockaddr_in *) &ireq->ifr_addr;
1122         clear_sinaddr(sin);
1123         sin->sin_addr.s_addr = myaddr->sin_addr.s_addr |
1124                 ~ netmask->sin_addr.s_addr;
1125         error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t) ireq, td);
1126         if (error != 0)
1127                 panic("bootpc_adjust_interface: "
1128                       "set if broadcast addr, error=%d", error);
1129
1130         bcopy(myaddr, &ireq->ifr_addr, sizeof(*myaddr));
1131         error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td);
1132         if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces))
1133                 panic("bootpc_adjust_interface: "
1134                       "set if addr, error=%d", error);
1135
1136         /* Add new default route */
1137
1138         if (ifctx->gotgw != 0 || gctx->gotgw == 0) {
1139                 clear_sinaddr(&defdst);
1140                 clear_sinaddr(&defmask);
1141                 /* XXX MRT just table 0 */
1142                 error = rtrequest_fib(RTM_ADD,
1143                                   (struct sockaddr *) &defdst,
1144                                   (struct sockaddr *) gw,
1145                                   (struct sockaddr *) &defmask,
1146                                   (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL, 0);
1147                 if (error != 0) {
1148                         printf("bootpc_adjust_interface: "
1149                                "add net route, error=%d\n", error);
1150                         return error;
1151                 }
1152         }
1153
1154         return 0;
1155 }
1156
1157 static int
1158 setfs(struct sockaddr_in *addr, char *path, char *p,
1159     const struct in_addr *siaddr)
1160 {
1161
1162         if (getip(&p, &addr->sin_addr) == 0) {
1163                 if (siaddr != NULL && *p == '/')
1164                         bcopy(siaddr, &addr->sin_addr, sizeof(struct in_addr));
1165                 else
1166                         return 0;
1167         } else {
1168                 if (*p != ':')
1169                         return 0;
1170                 p++;
1171         }
1172
1173         addr->sin_len = sizeof(struct sockaddr_in);
1174         addr->sin_family = AF_INET;
1175
1176         strlcpy(path, p, MNAMELEN);
1177         return 1;
1178 }
1179
1180 static int
1181 getip(char **ptr, struct in_addr *addr)
1182 {
1183         char *p;
1184         unsigned int ip;
1185         int val;
1186
1187         p = *ptr;
1188         ip = 0;
1189         if (((val = getdec(&p)) < 0) || (val > 255))
1190                 return 0;
1191         ip = val << 24;
1192         if (*p != '.')
1193                 return 0;
1194         p++;
1195         if (((val = getdec(&p)) < 0) || (val > 255))
1196                 return 0;
1197         ip |= (val << 16);
1198         if (*p != '.')
1199                 return 0;
1200         p++;
1201         if (((val = getdec(&p)) < 0) || (val > 255))
1202                 return 0;
1203         ip |= (val << 8);
1204         if (*p != '.')
1205                 return 0;
1206         p++;
1207         if (((val = getdec(&p)) < 0) || (val > 255))
1208                 return 0;
1209         ip |= val;
1210
1211         addr->s_addr = htonl(ip);
1212         *ptr = p;
1213         return 1;
1214 }
1215
1216 static int
1217 getdec(char **ptr)
1218 {
1219         char *p;
1220         int ret;
1221
1222         p = *ptr;
1223         ret = 0;
1224         if ((*p < '0') || (*p > '9'))
1225                 return -1;
1226         while ((*p >= '0') && (*p <= '9')) {
1227                 ret = ret * 10 + (*p - '0');
1228                 p++;
1229         }
1230         *ptr = p;
1231         return ret;
1232 }
1233
1234 static void
1235 mountopts(struct nfs_args *args, char *p)
1236 {
1237         args->version = NFS_ARGSVERSION;
1238         args->rsize = BOOTP_BLOCKSIZE;
1239         args->wsize = BOOTP_BLOCKSIZE;
1240         args->flags = NFSMNT_RSIZE | NFSMNT_WSIZE | NFSMNT_RESVPORT;
1241         args->sotype = SOCK_DGRAM;
1242         if (p != NULL)
1243                 nfs_parse_options(p, args);
1244 }
1245
1246 static int
1247 xdr_opaque_decode(struct mbuf **mptr, u_char *buf, int len)
1248 {
1249         struct mbuf *m;
1250         int alignedlen;
1251
1252         m = *mptr;
1253         alignedlen = ( len + 3 ) & ~3;
1254
1255         if (m->m_len < alignedlen) {
1256                 m = m_pullup(m, alignedlen);
1257                 if (m == NULL) {
1258                         *mptr = NULL;
1259                         return EBADRPC;
1260                 }
1261         }
1262         bcopy(mtod(m, u_char *), buf, len);
1263         m_adj(m, alignedlen);
1264         *mptr = m;
1265         return 0;
1266 }
1267
1268 static int
1269 xdr_int_decode(struct mbuf **mptr, int *iptr)
1270 {
1271         u_int32_t i;
1272
1273         if (xdr_opaque_decode(mptr, (u_char *) &i, sizeof(u_int32_t)) != 0)
1274                 return EBADRPC;
1275         *iptr = fxdr_unsigned(u_int32_t, i);
1276         return 0;
1277 }
1278
1279 static void
1280 print_sin_addr(struct sockaddr_in *sin)
1281 {
1282
1283         print_in_addr(sin->sin_addr);
1284 }
1285
1286 static void
1287 print_in_addr(struct in_addr addr)
1288 {
1289         unsigned int ip;
1290
1291         ip = ntohl(addr.s_addr);
1292         printf("%d.%d.%d.%d",
1293                ip >> 24, (ip >> 16) & 255, (ip >> 8) & 255, ip & 255);
1294 }
1295
1296 static void
1297 bootpc_compose_query(struct bootpc_ifcontext *ifctx,
1298     struct bootpc_globalcontext *gctx, struct thread *td)
1299 {
1300         unsigned char *vendp;
1301         unsigned char vendor_client[64];
1302         uint32_t leasetime;
1303         uint8_t vendor_client_len;
1304
1305         ifctx->gotrootpath = 0;
1306
1307         bzero((caddr_t) &ifctx->call, sizeof(ifctx->call));
1308
1309         /* bootpc part */
1310         ifctx->call.op = BOOTP_REQUEST;         /* BOOTREQUEST */
1311         ifctx->call.htype = 1;                  /* 10mb ethernet */
1312         ifctx->call.hlen = ifctx->sdl->sdl_alen;/* Hardware address length */
1313         ifctx->call.hops = 0;
1314         if (bootpc_ifctx_isunresolved(ifctx) != 0)
1315                 ifctx->xid++;
1316         ifctx->call.xid = txdr_unsigned(ifctx->xid);
1317         bcopy(LLADDR(ifctx->sdl), &ifctx->call.chaddr, ifctx->sdl->sdl_alen);
1318
1319         vendp = ifctx->call.vend;
1320         *vendp++ = 99;          /* RFC1048 cookie */
1321         *vendp++ = 130;
1322         *vendp++ = 83;
1323         *vendp++ = 99;
1324         *vendp++ = TAG_MAXMSGSIZE;
1325         *vendp++ = 2;
1326         *vendp++ = (sizeof(struct bootp_packet) >> 8) & 255;
1327         *vendp++ = sizeof(struct bootp_packet) & 255;
1328
1329         snprintf(vendor_client, sizeof(vendor_client), "%s:%s:%s",
1330                 ostype, MACHINE, osrelease);
1331         vendor_client_len = strlen(vendor_client);
1332         *vendp++ = TAG_VENDOR_INDENTIFIER;
1333         *vendp++ = vendor_client_len;
1334         memcpy(vendp, vendor_client, vendor_client_len);
1335         vendp += vendor_client_len;
1336         ifctx->dhcpquerytype = DHCP_NOMSG;
1337         switch (ifctx->state) {
1338         case IF_DHCP_UNRESOLVED:
1339                 *vendp++ = TAG_DHCP_MSGTYPE;
1340                 *vendp++ = 1;
1341                 *vendp++ = DHCP_DISCOVER;
1342                 ifctx->dhcpquerytype = DHCP_DISCOVER;
1343                 ifctx->gotdhcpserver = 0;
1344                 break;
1345         case IF_DHCP_OFFERED:
1346                 *vendp++ = TAG_DHCP_MSGTYPE;
1347                 *vendp++ = 1;
1348                 *vendp++ = DHCP_REQUEST;
1349                 ifctx->dhcpquerytype = DHCP_REQUEST;
1350                 *vendp++ = TAG_DHCP_REQ_ADDR;
1351                 *vendp++ = 4;
1352                 memcpy(vendp, &ifctx->reply.yiaddr, 4);
1353                 vendp += 4;
1354                 if (ifctx->gotdhcpserver != 0) {
1355                         *vendp++ = TAG_DHCP_SERVERID;
1356                         *vendp++ = 4;
1357                         memcpy(vendp, &ifctx->dhcpserver, 4);
1358                         vendp += 4;
1359                 }
1360                 *vendp++ = TAG_DHCP_LEASETIME;
1361                 *vendp++ = 4;
1362                 leasetime = htonl(300);
1363                 memcpy(vendp, &leasetime, 4);
1364                 vendp += 4;
1365                 break;
1366         default:
1367                 break;
1368         }
1369         *vendp = TAG_END;
1370
1371         ifctx->call.secs = 0;
1372         ifctx->call.flags = htons(0x8000); /* We need a broadcast answer */
1373 }
1374
1375 static int
1376 bootpc_hascookie(struct bootp_packet *bp)
1377 {
1378
1379         return (bp->vend[0] == 99 && bp->vend[1] == 130 &&
1380                 bp->vend[2] == 83 && bp->vend[3] == 99);
1381 }
1382
1383 static void
1384 bootpc_tag_helper(struct bootpc_tagcontext *tctx,
1385     unsigned char *start, int len, int tag)
1386 {
1387         unsigned char *j;
1388         unsigned char *ej;
1389         unsigned char code;
1390
1391         if (tctx->badtag != 0 || tctx->badopt != 0)
1392                 return;
1393
1394         j = start;
1395         ej = j + len;
1396
1397         while (j < ej) {
1398                 code = *j++;
1399                 if (code == TAG_PAD)
1400                         continue;
1401                 if (code == TAG_END)
1402                         return;
1403                 if (j >= ej || j + *j + 1 > ej) {
1404                         tctx->badopt = 1;
1405                         return;
1406                 }
1407                 len = *j++;
1408                 if (code == tag) {
1409                         if (tctx->taglen + len > TAG_MAXLEN) {
1410                                 tctx->badtag = 1;
1411                                 return;
1412                         }
1413                         tctx->foundopt = 1;
1414                         if (len > 0)
1415                                 memcpy(tctx->buf + tctx->taglen,
1416                                        j, len);
1417                         tctx->taglen += len;
1418                 }
1419                 if (code == TAG_OVERLOAD)
1420                         tctx->overload = *j;
1421
1422                 j += len;
1423         }
1424 }
1425
1426 static unsigned char *
1427 bootpc_tag(struct bootpc_tagcontext *tctx,
1428     struct bootp_packet *bp, int len, int tag)
1429 {
1430         tctx->overload = 0;
1431         tctx->badopt = 0;
1432         tctx->badtag = 0;
1433         tctx->foundopt = 0;
1434         tctx->taglen = 0;
1435
1436         if (bootpc_hascookie(bp) == 0)
1437                 return NULL;
1438
1439         bootpc_tag_helper(tctx, &bp->vend[4],
1440                           (unsigned char *) bp + len - &bp->vend[4], tag);
1441
1442         if ((tctx->overload & OVERLOAD_FILE) != 0)
1443                 bootpc_tag_helper(tctx,
1444                                   (unsigned char *) bp->file,
1445                                   sizeof(bp->file),
1446                                   tag);
1447         if ((tctx->overload & OVERLOAD_SNAME) != 0)
1448                 bootpc_tag_helper(tctx,
1449                                   (unsigned char *) bp->sname,
1450                                   sizeof(bp->sname),
1451                                   tag);
1452
1453         if (tctx->badopt != 0 || tctx->badtag != 0 || tctx->foundopt == 0)
1454                 return NULL;
1455         tctx->buf[tctx->taglen] = '\0';
1456         return tctx->buf;
1457 }
1458
1459 static void
1460 bootpc_decode_reply(struct nfsv3_diskless *nd, struct bootpc_ifcontext *ifctx,
1461     struct bootpc_globalcontext *gctx)
1462 {
1463         char *p;
1464         unsigned int ip;
1465
1466         ifctx->gotgw = 0;
1467         ifctx->gotnetmask = 0;
1468
1469         clear_sinaddr(&ifctx->myaddr);
1470         clear_sinaddr(&ifctx->netmask);
1471         clear_sinaddr(&ifctx->gw);
1472
1473         ifctx->myaddr.sin_addr = ifctx->reply.yiaddr;
1474
1475         ip = ntohl(ifctx->myaddr.sin_addr.s_addr);
1476
1477         printf("%s at ", ifctx->ireq.ifr_name);
1478         print_sin_addr(&ifctx->myaddr);
1479         printf(" server ");
1480         print_in_addr(ifctx->reply.siaddr);
1481
1482         ifctx->gw.sin_addr = ifctx->reply.giaddr;
1483         if (ifctx->reply.giaddr.s_addr != htonl(INADDR_ANY)) {
1484                 printf(" via gateway ");
1485                 print_in_addr(ifctx->reply.giaddr);
1486         }
1487
1488         /* This call used for the side effect (overload flag) */
1489         (void) bootpc_tag(&gctx->tmptag,
1490                           &ifctx->reply, ifctx->replylen, TAG_END);
1491
1492         if ((gctx->tmptag.overload & OVERLOAD_SNAME) == 0)
1493                 if (ifctx->reply.sname[0] != '\0')
1494                         printf(" server name %s", ifctx->reply.sname);
1495         if ((gctx->tmptag.overload & OVERLOAD_FILE) == 0)
1496                 if (ifctx->reply.file[0] != '\0')
1497                         printf(" boot file %s", ifctx->reply.file);
1498
1499         printf("\n");
1500
1501         p = bootpc_tag(&gctx->tag, &ifctx->reply, ifctx->replylen,
1502                        TAG_SUBNETMASK);
1503         if (p != NULL) {
1504                 if (gctx->tag.taglen != 4)
1505                         panic("bootpc: subnet mask len is %d",
1506                               gctx->tag.taglen);
1507                 bcopy(p, &ifctx->netmask.sin_addr, 4);
1508                 ifctx->gotnetmask = 1;
1509                 printf("subnet mask ");
1510                 print_sin_addr(&ifctx->netmask);
1511                 printf(" ");
1512         }
1513
1514         p = bootpc_tag(&gctx->tag, &ifctx->reply, ifctx->replylen,
1515                        TAG_ROUTERS);
1516         if (p != NULL) {
1517                 /* Routers */
1518                 if (gctx->tag.taglen % 4)
1519                         panic("bootpc: Router Len is %d", gctx->tag.taglen);
1520                 if (gctx->tag.taglen > 0) {
1521                         bcopy(p, &ifctx->gw.sin_addr, 4);
1522                         printf("router ");
1523                         print_sin_addr(&ifctx->gw);
1524                         printf(" ");
1525                         ifctx->gotgw = 1;
1526                         gctx->gotgw = 1;
1527                 }
1528         }
1529
1530         p = bootpc_tag(&gctx->tag, &ifctx->reply, ifctx->replylen,
1531                        TAG_ROOT);
1532         if (p != NULL) {
1533                 if (gctx->setrootfs != NULL) {
1534                         printf("rootfs %s (ignored) ", p);
1535                 } else  if (setfs(&nd->root_saddr,
1536                                   nd->root_hostnam, p, &ifctx->reply.siaddr)) {
1537                         if (*p == '/') {
1538                                 printf("root_server ");
1539                                 print_sin_addr(&nd->root_saddr);
1540                                 printf(" ");
1541                         }
1542                         printf("rootfs %s ", p);
1543                         gctx->gotrootpath = 1;
1544                         ifctx->gotrootpath = 1;
1545                         gctx->setrootfs = ifctx;
1546
1547                         p = bootpc_tag(&gctx->tag, &ifctx->reply,
1548                                        ifctx->replylen,
1549                                        TAG_ROOTOPTS);
1550                         if (p != NULL) {
1551                                 mountopts(&nd->root_args, p);
1552                                 printf("rootopts %s ", p);
1553                         }
1554                 } else
1555                         panic("Failed to set rootfs to %s", p);
1556         }
1557
1558         p = bootpc_tag(&gctx->tag, &ifctx->reply, ifctx->replylen,
1559                        TAG_HOSTNAME);
1560         if (p != NULL) {
1561                 if (gctx->tag.taglen >= MAXHOSTNAMELEN)
1562                         panic("bootpc: hostname >= %d bytes",
1563                               MAXHOSTNAMELEN);
1564                 if (gctx->sethostname != NULL) {
1565                         printf("hostname %s (ignored) ", p);
1566                 } else {
1567                         strcpy(nd->my_hostnam, p);
1568                         mtx_lock(&prison0.pr_mtx);
1569                         strcpy(prison0.pr_hostname, p);
1570                         mtx_unlock(&prison0.pr_mtx);
1571                         printf("hostname %s ", p);
1572                         gctx->sethostname = ifctx;
1573                 }
1574         }
1575         p = bootpc_tag(&gctx->tag, &ifctx->reply, ifctx->replylen,
1576                         TAG_COOKIE);
1577         if (p != NULL) {        /* store in a sysctl variable */
1578                 int i, l = sizeof(bootp_cookie) - 1;
1579                 for (i = 0; i < l && p[i] != '\0'; i++)
1580                         bootp_cookie[i] = p[i];
1581                 p[i] = '\0';
1582         }
1583
1584
1585         printf("\n");
1586
1587         if (ifctx->gotnetmask == 0) {
1588                 if (IN_CLASSA(ntohl(ifctx->myaddr.sin_addr.s_addr)))
1589                         ifctx->netmask.sin_addr.s_addr = htonl(IN_CLASSA_NET);
1590                 else if (IN_CLASSB(ntohl(ifctx->myaddr.sin_addr.s_addr)))
1591                         ifctx->netmask.sin_addr.s_addr = htonl(IN_CLASSB_NET);
1592                 else
1593                         ifctx->netmask.sin_addr.s_addr = htonl(IN_CLASSC_NET);
1594         }
1595         if (ifctx->gotgw == 0) {
1596                 /* Use proxyarp */
1597                 ifctx->gw.sin_addr.s_addr = ifctx->myaddr.sin_addr.s_addr;
1598         }
1599 }
1600
1601 void
1602 bootpc_init(void)
1603 {
1604         struct bootpc_ifcontext *ifctx, *nctx;  /* Interface BOOTP contexts */
1605         struct bootpc_globalcontext *gctx;      /* Global BOOTP context */
1606         struct ifnet *ifp;
1607         int error;
1608 #ifndef BOOTP_WIRED_TO
1609         int ifcnt;
1610 #endif
1611         struct nfsv3_diskless *nd;
1612         struct thread *td;
1613
1614         nd = &nfsv3_diskless;
1615         td = curthread;
1616
1617         /*
1618          * If already filled in, don't touch it here
1619          */
1620         if (nfs_diskless_valid != 0)
1621                 return;
1622
1623         gctx = malloc(sizeof(*gctx), M_TEMP, M_WAITOK | M_ZERO);
1624         if (gctx == NULL)
1625                 panic("Failed to allocate bootp global context structure");
1626
1627         gctx->xid = ~0xFFFF;
1628         gctx->starttime = time_second;
1629
1630         /*
1631          * Find a network interface.
1632          */
1633 #ifdef BOOTP_WIRED_TO
1634         printf("bootpc_init: wired to interface '%s'\n",
1635                __XSTRING(BOOTP_WIRED_TO));
1636         allocifctx(gctx);
1637 #else
1638         /*
1639          * Preallocate interface context storage, if another interface
1640          * attaches and wins the race, it won't be eligible for bootp.
1641          */
1642         IFNET_RLOCK();
1643         for (ifp = TAILQ_FIRST(&V_ifnet), ifcnt = 0;
1644              ifp != NULL;
1645              ifp = TAILQ_NEXT(ifp, if_link)) {
1646                 if ((ifp->if_flags &
1647                      (IFF_LOOPBACK | IFF_POINTOPOINT | IFF_BROADCAST)) !=
1648                     IFF_BROADCAST)
1649                         continue;
1650                 ifcnt++;
1651         }
1652         IFNET_RUNLOCK();
1653         if (ifcnt == 0)
1654                 panic("bootpc_init: no eligible interfaces");
1655         for (; ifcnt > 0; ifcnt--)
1656                 allocifctx(gctx);
1657 #endif
1658
1659         IFNET_RLOCK();
1660         for (ifp = TAILQ_FIRST(&V_ifnet), ifctx = gctx->interfaces;
1661              ifp != NULL && ifctx != NULL;
1662              ifp = TAILQ_NEXT(ifp, if_link)) {
1663                 strlcpy(ifctx->ireq.ifr_name, ifp->if_xname,
1664                     sizeof(ifctx->ireq.ifr_name));
1665 #ifdef BOOTP_WIRED_TO
1666                 if (strcmp(ifctx->ireq.ifr_name,
1667                            __XSTRING(BOOTP_WIRED_TO)) != 0)
1668                         continue;
1669 #else
1670                 if ((ifp->if_flags &
1671                      (IFF_LOOPBACK | IFF_POINTOPOINT | IFF_BROADCAST)) !=
1672                     IFF_BROADCAST)
1673                         continue;
1674 #endif
1675                 ifctx->ifp = ifp;
1676                 ifctx = ifctx->next;
1677         }
1678         IFNET_RUNLOCK();
1679
1680         if (gctx->interfaces == NULL || gctx->interfaces->ifp == NULL) {
1681 #ifdef BOOTP_WIRED_TO
1682                 panic("bootpc_init: Could not find interface specified "
1683                       "by BOOTP_WIRED_TO: "
1684                       __XSTRING(BOOTP_WIRED_TO));
1685 #else
1686                 panic("bootpc_init: no suitable interface");
1687 #endif
1688         }
1689
1690         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)
1691                 bootpc_fakeup_interface(ifctx, gctx, td);
1692
1693         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)
1694                 bootpc_compose_query(ifctx, gctx, td);
1695
1696         error = bootpc_call(gctx, td);
1697
1698         if (error != 0) {
1699 #ifdef BOOTP_NFSROOT
1700                 panic("BOOTP call failed");
1701 #else
1702                 printf("BOOTP call failed\n");
1703 #endif
1704         }
1705
1706         rootdevnames[0] = "nfs:";
1707         mountopts(&nd->root_args, NULL);
1708
1709         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)
1710                 if (bootpc_ifctx_isresolved(ifctx) != 0)
1711                         bootpc_decode_reply(nd, ifctx, gctx);
1712
1713 #ifdef BOOTP_NFSROOT
1714         if (gctx->gotrootpath == 0)
1715                 panic("bootpc: No root path offered");
1716 #endif
1717
1718         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) {
1719                 bootpc_adjust_interface(ifctx, gctx, td);
1720
1721                 soclose(ifctx->so);
1722         }
1723
1724         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next)
1725                 if (ifctx->gotrootpath != 0)
1726                         break;
1727         if (ifctx == NULL) {
1728                 for (ifctx = gctx->interfaces;
1729                      ifctx != NULL;
1730                      ifctx = ifctx->next)
1731                         if (bootpc_ifctx_isresolved(ifctx) != 0)
1732                                 break;
1733         }
1734         if (ifctx == NULL)
1735                 goto out;
1736
1737         if (gctx->gotrootpath != 0) {
1738
1739                 setenv("boot.netif.name", ifctx->ifp->if_xname);
1740
1741                 error = md_mount(&nd->root_saddr, nd->root_hostnam,
1742                                  nd->root_fh, &nd->root_fhsize,
1743                                  &nd->root_args, td);
1744                 if (error != 0)
1745                         panic("nfs_boot: mountd root, error=%d", error);
1746
1747                 nfs_diskless_valid = 3;
1748         }
1749
1750         strcpy(nd->myif.ifra_name, ifctx->ireq.ifr_name);
1751         bcopy(&ifctx->myaddr, &nd->myif.ifra_addr, sizeof(ifctx->myaddr));
1752         bcopy(&ifctx->myaddr, &nd->myif.ifra_broadaddr, sizeof(ifctx->myaddr));
1753         ((struct sockaddr_in *) &nd->myif.ifra_broadaddr)->sin_addr.s_addr =
1754                 ifctx->myaddr.sin_addr.s_addr |
1755                 ~ ifctx->netmask.sin_addr.s_addr;
1756         bcopy(&ifctx->netmask, &nd->myif.ifra_mask, sizeof(ifctx->netmask));
1757
1758 out:
1759         for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = nctx) {
1760                 nctx = ifctx->next;
1761                 free(ifctx, M_TEMP);
1762         }
1763         free(gctx, M_TEMP);
1764 }
1765
1766 /*
1767  * RPC: mountd/mount
1768  * Given a server pathname, get an NFS file handle.
1769  * Also, sets sin->sin_port to the NFS service port.
1770  */
1771 static int
1772 md_mount(struct sockaddr_in *mdsin, char *path, u_char *fhp, int *fhsizep,
1773     struct nfs_args *args, struct thread *td)
1774 {
1775         struct mbuf *m;
1776         int error;
1777         int authunixok;
1778         int authcount;
1779         int authver;
1780
1781 #define RPCPROG_MNT     100005
1782 #define RPCMNT_VER1     1
1783 #define RPCMNT_VER3     3
1784 #define RPCMNT_MOUNT    1
1785 #define AUTH_SYS        1               /* unix style (uid, gids) */
1786 #define AUTH_UNIX       AUTH_SYS
1787
1788         /* XXX honor v2/v3 flags in args->flags? */
1789 #ifdef BOOTP_NFSV3
1790         /* First try NFS v3 */
1791         /* Get port number for MOUNTD. */
1792         error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER3,
1793                              &mdsin->sin_port, td);
1794         if (error == 0) {
1795                 m = xdr_string_encode(path, strlen(path));
1796
1797                 /* Do RPC to mountd. */
1798                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER3,
1799                                   RPCMNT_MOUNT, &m, NULL, td);
1800         }
1801         if (error == 0) {
1802                 args->flags |= NFSMNT_NFSV3;
1803         } else {
1804 #endif
1805                 /* Fallback to NFS v2 */
1806
1807                 /* Get port number for MOUNTD. */
1808                 error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1,
1809                                      &mdsin->sin_port, td);
1810                 if (error != 0)
1811                         return error;
1812
1813                 m = xdr_string_encode(path, strlen(path));
1814
1815                 /* Do RPC to mountd. */
1816                 error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1,
1817                                   RPCMNT_MOUNT, &m, NULL, td);
1818                 if (error != 0)
1819                         return error;   /* message already freed */
1820
1821 #ifdef BOOTP_NFSV3
1822         }
1823 #endif
1824
1825         if (xdr_int_decode(&m, &error) != 0 || error != 0)
1826                 goto bad;
1827
1828         if ((args->flags & NFSMNT_NFSV3) != 0) {
1829                 if (xdr_int_decode(&m, fhsizep) != 0 ||
1830                     *fhsizep > NFSX_V3FHMAX ||
1831                     *fhsizep <= 0)
1832                         goto bad;
1833         } else
1834                 *fhsizep = NFSX_V2FH;
1835
1836         if (xdr_opaque_decode(&m, fhp, *fhsizep) != 0)
1837                 goto bad;
1838
1839         if (args->flags & NFSMNT_NFSV3) {
1840                 if (xdr_int_decode(&m, &authcount) != 0)
1841                         goto bad;
1842                 authunixok = 0;
1843                 if (authcount < 0 || authcount > 100)
1844                         goto bad;
1845                 while (authcount > 0) {
1846                         if (xdr_int_decode(&m, &authver) != 0)
1847                                 goto bad;
1848                         if (authver == AUTH_UNIX)
1849                                 authunixok = 1;
1850                         authcount--;
1851                 }
1852                 if (authunixok == 0)
1853                         goto bad;
1854         }
1855
1856         /* Set port number for NFS use. */
1857         error = krpc_portmap(mdsin, NFS_PROG,
1858                              (args->flags &
1859                               NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2,
1860                              &mdsin->sin_port, td);
1861
1862         goto out;
1863
1864 bad:
1865         error = EBADRPC;
1866
1867 out:
1868         m_freem(m);
1869         return error;
1870 }
1871
1872 SYSINIT(bootp_rootconf, SI_SUB_ROOT_CONF, SI_ORDER_FIRST, bootpc_init, NULL);