/*      $NetBSD: nfs_boot.c,v 1.90 2024/07/05 04:31:54 rin Exp $        */

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

/*
 * Support for NFS diskless booting, specifically getting information
 * about where to mount root from, what pathnames, etc.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: nfs_boot.c,v 1.90 2024/07/05 04:31:54 rin Exp $");

#ifdef _KERNEL_OPT
#include "opt_nfs.h"
#include "opt_tftproot.h"
#include "opt_nfs_boot.h"
#endif

#ifdef NFS_BOOT_TCP
#undef NFS_BOOT_UDP
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/mbuf.h>
#include <sys/reboot.h>
#include <sys/socket.h>
#include <sys/socketvar.h>

#include <net/if.h>
#include <net/route.h>
#include <net/if_ether.h>
#include <net/if_types.h>

#include <netinet/in.h>
#include <netinet/if_inarp.h>

#include <nfs/rpcv2.h>
#include <nfs/krpc.h>
#include <nfs/xdr_subs.h>

#include <nfs/nfsproto.h>
#include <nfs/nfs.h>
#include <nfs/nfsmount.h>
#include <nfs/nfsdiskless.h>

/*
 * There are three implementations of NFS diskless boot.
 * One implementation uses BOOTP (RFC951, RFC1048),
 * Sun RPC/bootparams or static configuration.  See the
 * files:
 *    nfs_bootdhcp.c:   BOOTP (RFC951, RFC1048)
 *    nfs_bootparam.c:  Sun RPC/bootparams
 *    nfs_bootstatic.c: honour config(1) description
 */
#if defined(NFS_BOOT_BOOTP) || defined(NFS_BOOT_DHCP)
int nfs_boot_rfc951 = 1; /* BOOTP enabled (default) */
#endif
#ifdef NFS_BOOT_BOOTPARAM
int nfs_boot_bootparam = 1; /* BOOTPARAM enabled (default) */
#endif
#ifdef NFS_BOOT_BOOTSTATIC
int nfs_boot_bootstatic = 1; /* BOOTSTATIC enabled (default) */
#endif

#define IP_MIN_MTU 576

/* mountd RPC */
static int md_mount(struct sockaddr_in *mdsin, char *path,
        struct nfs_args *argp, struct lwp *l);

static int nfs_boot_delroute_matcher(struct rtentry *, void *);
static void nfs_boot_defrt(struct in_addr *);
static  int nfs_boot_getfh(struct nfs_dlmount *ndm, struct lwp *);


/*
 * Called with an empty nfs_diskless struct to be filled in.
 * Find an interface, determine its ip address (etc.) and
 * save all the boot parameters in the nfs_diskless struct.
 */
int
nfs_boot_init(struct nfs_diskless *nd, struct lwp *lwp)
{
        struct ifnet *ifp;
        int error = 0;
        int flags __unused;

        /* Explicitly necessary or build fails
         * due to unused variable, otherwise.
         */
        flags = 0;

        /*
         * Find the network interface.
         */
        ifp = ifunit(device_xname(root_device));
        if (ifp == NULL) {
                printf("nfs_boot: '%s' not found\n",
                       device_xname(root_device));
                return (ENXIO);
        }
        nd->nd_ifp = ifp;

        error = EADDRNOTAVAIL; /* ??? */
#if defined(NFS_BOOT_BOOTSTATIC)
        if (error && nfs_boot_bootstatic) {
                printf("nfs_boot: trying static\n");
                error = nfs_bootstatic(nd, lwp, &flags);
        }
#endif
#if defined(NFS_BOOT_BOOTP) || defined(NFS_BOOT_DHCP)
        if (error && nfs_boot_rfc951) {
#if defined(NFS_BOOT_DHCP)
                printf("nfs_boot: trying DHCP/BOOTP\n");
#else
                printf("nfs_boot: trying BOOTP\n");
#endif
                error = nfs_bootdhcp(nd, lwp, &flags);
        }
#endif
#ifdef NFS_BOOT_BOOTPARAM
        if (error && nfs_boot_bootparam) {
                printf("nfs_boot: trying RARP (and RPC/bootparam)\n");
                error = nfs_bootparam(nd, lwp, &flags);
        }
#endif
        if (error)
                return (error);

        /*
         * Set MTU if passed
         */
        if (nd->nd_mtu >= IP_MIN_MTU )
                nfs_boot_setmtu(nd->nd_ifp, nd->nd_mtu, lwp);
        
        /*
         * If the gateway address is set, add a default route.
         * (The mountd RPCs may go across a gateway.)
         */
        if (nd->nd_gwip.s_addr)
                nfs_boot_defrt(&nd->nd_gwip);

#ifdef TFTPROOT
        if (nd->nd_nomount)
                goto out;
#endif
        /*
         * Now fetch the NFS file handles as appropriate.
         */
        error = nfs_boot_getfh(&nd->nd_root, lwp);

        if (error)
                nfs_boot_cleanup(nd, lwp);

#ifdef TFTPROOT
out:
#endif
        return (error);
}

void
nfs_boot_cleanup(struct nfs_diskless *nd, struct lwp *lwp)
{

        nfs_boot_deladdress(nd->nd_ifp, lwp, nd->nd_myip.s_addr);
        nfs_boot_ifupdown(nd->nd_ifp, lwp, 0);
        nfs_boot_flushrt(nd->nd_ifp);
}

int
nfs_boot_ifupdown(struct ifnet *ifp, struct lwp *lwp, int up)
{
        struct socket *so;
        struct ifreq ireq;
        int error;

        memset(&ireq, 0, sizeof(ireq));
        memcpy(ireq.ifr_name, ifp->if_xname, IFNAMSIZ);

        /*
         * Get a socket to use for various things in here.
         * After this, use "goto out" to cleanup and return.
         */
        error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL);
        if (error) {
                printf("ifupdown: socreate, error=%d\n", error);
                return (error);
        }

        /*
         * Bring up the interface. (just set the "up" flag)
         * Get the old interface flags and or IFF_UP into them so
         * things like media selection flags are not clobbered.
         */
        error = ifioctl(so, SIOCGIFFLAGS, (void *)&ireq, lwp);
        if (error) {
                printf("ifupdown: GIFFLAGS, error=%d\n", error);
                goto out;
        }
        if (up)
                ireq.ifr_flags |= IFF_UP;
        else
                ireq.ifr_flags &= ~IFF_UP;
        error = ifioctl(so, SIOCSIFFLAGS, &ireq, lwp);
        if (error) {
                printf("ifupdown: SIFFLAGS, error=%d\n", error);
                goto out;
        }

        if (up)
                /* give the link some time to get up */
                tsleep(nfs_boot_ifupdown, PZERO, "nfsbif", 3 * hz);
out:
        soclose(so);
        return (error);
}

void
nfs_boot_setmtu(struct ifnet *ifp, int mtu, struct lwp *lwp)
{
        struct socket *so;
        struct ifreq ireq;
        int error;

        memset(&ireq, 0, sizeof(ireq));
        memcpy(ireq.ifr_name, ifp->if_xname, IFNAMSIZ);

        /*
         * Get a socket to use for various things in here.
         * After this, use "goto out" to cleanup and return.
         */
        error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL);
        if (error) {
                printf("setmtu: socreate, error=%d\n", error);
                return;
        }

        /*
         * Get structure, set the new MTU, push structure.
         */
        error = ifioctl(so, SIOCGIFMTU, (void *)&ireq, lwp);
        if (error) {
                printf("setmtu: GIFMTU, error=%d\n", error);
                goto out;
        }

        ireq.ifr_mtu = mtu;

        error = ifioctl(so, SIOCSIFMTU, &ireq, lwp);
        if (error) {
                printf("setmtu: SIFMTU, error=%d\n", error);
                goto out;
        }

out:
        soclose(so);
        return;
}

int
nfs_boot_setaddress(struct ifnet *ifp, struct lwp *lwp,
                uint32_t addr, uint32_t netmask, uint32_t braddr)
{
        struct socket *so;
        struct ifaliasreq iareq;
        struct sockaddr_in *sin;
        int error;

        /*
         * Get a socket to use for various things in here.
         * After this, use "goto out" to cleanup and return.
         */
        error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL);
        if (error) {
                printf("setaddress: socreate, error=%d\n", error);
                return (error);
        }

        memset(&iareq, 0, sizeof(iareq));
        memcpy(iareq.ifra_name, ifp->if_xname, IFNAMSIZ);

        /* Set the I/F address */
        sin = (struct sockaddr_in *)&iareq.ifra_addr;
        sin->sin_len = sizeof(*sin);
        sin->sin_family = AF_INET;
        sin->sin_addr.s_addr = addr;

        /* Set the netmask */
        if (netmask != INADDR_ANY) {
                sin = (struct sockaddr_in *)&iareq.ifra_mask;
                sin->sin_len = sizeof(*sin);
                sin->sin_family = AF_INET;
                sin->sin_addr.s_addr = netmask;
        } /* else leave subnetmask unspecified (len=0) */

        /* Set the broadcast addr. */
        if (braddr != INADDR_ANY) {
                sin = (struct sockaddr_in *)&iareq.ifra_broadaddr;
                sin->sin_len = sizeof(*sin);
                sin->sin_family = AF_INET;
                sin->sin_addr.s_addr = braddr;
        } /* else leave broadcast addr unspecified (len=0) */

        error = ifioctl(so, SIOCAIFADDR, (void *)&iareq, lwp);
        if (error) {
                printf("setaddress, error=%d\n", error);
                goto out;
        }

        /* give the link some time to get up */
        tsleep(nfs_boot_setaddress, PZERO, "nfsbtd", 3 * hz);
out:
        soclose(so);
        return (error);
}

int
nfs_boot_deladdress(struct ifnet *ifp, struct lwp *lwp, uint32_t addr)
{
        struct socket *so;
        struct ifreq ifr;
        struct sockaddr_in sin;
        struct in_addr ia = {.s_addr = addr};
        int error;

        /*
         * Get a socket to use for various things in here.
         * After this, use "goto out" to cleanup and return.
         */
        error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL);
        if (error) {
                printf("deladdress: socreate, error=%d\n", error);
                return (error);
        }

        memset(&ifr, 0, sizeof(ifr));
        memcpy(ifr.ifr_name, ifp->if_xname, IFNAMSIZ);

        sockaddr_in_init(&sin, &ia, 0);
        ifreq_setaddr(SIOCDIFADDR, &ifr, sintocsa(&sin));

        error = ifioctl(so, SIOCDIFADDR, &ifr, lwp);
        if (error) {
                printf("deladdress, error=%d\n", error);
                goto out;
        }

out:
        soclose(so);
        return (error);
}

int
nfs_boot_setrecvtimo(struct socket *so)
{
        struct timeval tv;

        tv.tv_sec = 1;
        tv.tv_usec = 0;

        return (so_setsockopt(NULL, so, SOL_SOCKET, SO_RCVTIMEO, &tv,
            sizeof(tv)));
}

int
nfs_boot_enbroadcast(struct socket *so)
{
        int32_t on;

        on = 1;
        return (so_setsockopt(NULL, so, SOL_SOCKET, SO_BROADCAST, &on,
            sizeof(on)));
}

int
nfs_boot_sobind_ipport(struct socket *so, uint16_t port, struct lwp *l)
{
        struct sockaddr_in sin;
        int error;

        sin.sin_len = sizeof(sin);
        sin.sin_family = AF_INET;
        sin.sin_addr.s_addr = INADDR_ANY;
        sin.sin_port = htons(port);
        error = sobind(so, (struct sockaddr *)&sin, l);
        return (error);
}

/*
 * What is the longest we will wait before re-sending a request?
 * Note this is also the frequency of "timeout" messages.
 * The re-send loop counts up linearly to this maximum, so the
 * first complaint will happen after (1+2+3+4+5)=15 seconds.
 */
#define MAX_RESEND_DELAY 5      /* seconds */
#define TOTAL_TIMEOUT   30      /* seconds */

int
nfs_boot_sendrecv(struct socket *so, struct sockaddr_in *nam,
                int (*sndproc)(struct mbuf *, void *, int),
                struct mbuf *snd,
                int (*rcvproc)(struct mbuf **, void *),
                struct mbuf **rcv, struct mbuf **from_p,
                void *context, struct lwp *lwp)
{
        int error, rcvflg, timo, secs, waited;
        struct mbuf *m, *from;
        struct uio uio;

        /* Free at end if not null. */
        from = NULL;

        /*
         * Send it, repeatedly, until a reply is received,
         * but delay each re-send by an increasing amount.
         * If the delay hits the maximum, start complaining.
         */
        waited = timo = 0;
send_again:
        waited += timo;
        if (waited >= TOTAL_TIMEOUT)
                return (ETIMEDOUT);

        /* Determine new timeout. */
        if (timo < MAX_RESEND_DELAY)
                timo++;
        else
                printf("nfs_boot: timeout...\n");

        if (sndproc) {
                error = (*sndproc)(snd, context, waited);
                if (error)
                        goto out;
        }

        /* Send request (or re-send). */
        m = m_copypacket(snd, M_WAIT);
        if (m == NULL) {
                error = ENOBUFS;
                goto out;
        }
        error = (*so->so_send)(so, (struct sockaddr *)nam, NULL,
            m, NULL, 0, lwp);
        if (error) {
                printf("nfs_boot: sosend: %d\n", error);
                goto out;
        }
        m = NULL;

        /*
         * Wait for up to timo seconds for a reply.
         * The socket receive timeout was set to 1 second.
         */

        secs = timo;
        for (;;) {
                m_freem(from);
                from = NULL;
                m_freem(m);
                m = NULL;
                uio.uio_resid = 1 << 16; /* ??? */
                rcvflg = 0;
                error = (*so->so_receive)(so, &from, &uio, &m, NULL, &rcvflg);
                if (error == EWOULDBLOCK) {
                        if (--secs <= 0)
                                goto send_again;
                        continue;
                }
                if (error)
                        goto out;
#ifdef DIAGNOSTIC
                if (!m || !(m->m_flags & M_PKTHDR)
                    || (1 << 16) - uio.uio_resid != m->m_pkthdr.len)
                        panic("nfs_boot_sendrecv: return size");
#endif

                if ((*rcvproc)(&m, context))
                        continue;

                if (rcv)
                        *rcv = m;
                else
                        m_freem(m);
                if (from_p) {
                        *from_p = from;
                        from = NULL;
                }
                break;
        }
out:
        m_freem(from);
        return (error);
}

/*
 * Install a default route to the passed IP address.
 */
static void
nfs_boot_defrt(struct in_addr *gw_ip)
{
        struct sockaddr dst, gw, mask;
        struct sockaddr_in *sin;
        int error;

        /* Destination: (default) */
        memset((void *)&dst, 0, sizeof(dst));
        dst.sa_len = sizeof(dst);
        dst.sa_family = AF_INET;
        /* Gateway: */
        memset((void *)&gw, 0, sizeof(gw));
        sin = (struct sockaddr_in *)&gw;
        sin->sin_len = sizeof(*sin);
        sin->sin_family = AF_INET;
        sin->sin_addr.s_addr = gw_ip->s_addr;
        /* Mask: (zero length) */
        /* XXX - Just pass a null pointer? */
        memset(&mask, 0, sizeof(mask));

        /* add, dest, gw, mask, flags, 0 */
        error = rtrequest(RTM_ADD, &dst, &gw, &mask,
                          (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL);
        if (error) {
                printf("nfs_boot: add route, error=%d\n", error);
                error = 0;
        }
}

static int
nfs_boot_delroute_matcher(struct rtentry *rt, void *w)
{

        if ((void *)rt->rt_ifp != w)
                return 0;

        return 1;
}

void
nfs_boot_flushrt(struct ifnet *ifp)
{

        rt_delete_matched_entries(AF_INET, nfs_boot_delroute_matcher, ifp, false);
}

/*
 * Get an initial NFS file handle using Sun RPC/mountd.
 * Separate function because we used to call it twice.
 * (once for root and once for swap)
 *
 * ndm  output
 */
static int
nfs_boot_getfh(struct nfs_dlmount *ndm, struct lwp *l)
{
        struct nfs_args *args;
        struct sockaddr_in *sin;
        char *pathname;
        int error;
        u_int16_t port;

        args = &ndm->ndm_args;

        /* Initialize mount args. */
        memset((void *) args, 0, sizeof(*args));
        args->addr     = &ndm->ndm_saddr;
        args->addrlen  = args->addr->sa_len;
#ifdef NFS_BOOT_UDP
        args->sotype   = SOCK_DGRAM;
#else
        args->sotype   = SOCK_STREAM;
#endif
        args->fh       = ndm->ndm_fh;
        args->hostname = ndm->ndm_host;
        args->flags    = NFSMNT_NOCONN | NFSMNT_RESVPORT;

#ifndef NFS_V2_ONLY
        args->flags    |= NFSMNT_NFSV3;
#endif
#ifdef  NFS_BOOT_OPTIONS
        args->flags    |= NFS_BOOT_OPTIONS;
#endif
#ifdef  NFS_BOOT_RWSIZE
        /*
         * Reduce rsize,wsize for interfaces that consistently
         * drop fragments of long UDP messages.  (i.e. wd8003).
         * You can always change these later via remount.
         */
        args->flags   |= NFSMNT_WSIZE | NFSMNT_RSIZE;
        args->wsize    = NFS_BOOT_RWSIZE;
        args->rsize    = NFS_BOOT_RWSIZE;
#endif

        /*
         * Find the pathname part of the "server:pathname"
         * string left in ndm->ndm_host by nfs_boot_init.
         */
        pathname = strchr(ndm->ndm_host, ':');
        if (pathname == 0) {
                printf("nfs_boot: getfh - no pathname\n");
                return (EIO);
        }
        pathname++;

        /*
         * Get file handle using RPC to mountd/mount
         */
        sin = (struct sockaddr_in *)&ndm->ndm_saddr;
        error = md_mount(sin, pathname, args, l);
        if (error) {
                printf("nfs_boot: mountd `%s', error=%d\n",
                       ndm->ndm_host, error);
                return (error);
        }

        /* Set port number for NFS use. */
        /* XXX: NFS port is always 2049, right? */
retry:
        error = krpc_portmap(sin, NFS_PROG,
                    (args->flags & NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2,
                    (args->sotype == SOCK_STREAM) ? IPPROTO_TCP : IPPROTO_UDP,
                    &port, l);
        if (port == htons(0))
                error = EIO;
        if (error) {
                if (args->sotype == SOCK_STREAM) {
                        args->sotype = SOCK_DGRAM;
                        goto retry;
                }
                printf("nfs_boot: portmap NFS, error=%d\n", error);
                return (error);
        }
        sin->sin_port = port;
        return (0);
}


/*
 * RPC: mountd/mount
 * Given a server pathname, get an NFS file handle.
 * Also, sets sin->sin_port to the NFS service port.
 *
 * mdsin   mountd server address
 */
static int
md_mount(struct sockaddr_in *mdsin, char *path,
         struct nfs_args *argp, struct lwp *lwp)
{
        /* The RPC structures */
        struct rdata {
                u_int32_t errno;
                union {
                        u_int8_t  v2fh[NFSX_V2FH];
                        struct {
                                u_int32_t fhlen;
                                u_int8_t  fh[1];
                        } v3fh;
                } fh;
        } *rdata;
        struct mbuf *m;
        u_int8_t *fh;
        int minlen, error;
        int mntver;

        mntver = (argp->flags & NFSMNT_NFSV3) ? 3 : 2;
        do {
                /*
                 * Get port number for MOUNTD.
                 */
                error = krpc_portmap(mdsin, RPCPROG_MNT, mntver,
                                    IPPROTO_UDP, &mdsin->sin_port, lwp);
                if (error)
                        continue;

                /* This mbuf is consumed by krpc_call. */
                m = xdr_string_encode(path, strlen(path));
                if (m == NULL)
                        return ENOMEM;

                /* Do RPC to mountd. */
                error = krpc_call(mdsin, RPCPROG_MNT, mntver,
                                  RPCMNT_MOUNT, &m, NULL, lwp);
                if (error != EPROGMISMATCH)
                        break;
                /* Try lower version of mountd. */
        } while (--mntver >= 1);
        if (error) {
                printf("nfs_boot: mountd error=%d\n", error);
                return error;
        }
        if (mntver != 3)
                argp->flags &= ~NFSMNT_NFSV3;

        /* The reply might have only the errno. */
        if (m->m_len < 4)
                goto bad;
        /* Have at least errno, so check that. */
        rdata = mtod(m, struct rdata *);
        error = fxdr_unsigned(u_int32_t, rdata->errno);
        if (error)
                goto out;

        /* Have errno==0, so the fh must be there. */
        if (mntver == 3) {
                argp->fhsize   = fxdr_unsigned(u_int32_t, rdata->fh.v3fh.fhlen);
                if (argp->fhsize > NFSX_V3FHMAX)
                        goto bad;
                minlen = 2 * sizeof(u_int32_t) + argp->fhsize;
        } else {
                argp->fhsize   = NFSX_V2FH;
                minlen = sizeof(u_int32_t) + argp->fhsize;
        }

        if (m->m_len < minlen) {
                m = m_pullup(m, minlen);
                if (m == NULL)
                        return(EBADRPC);
                rdata = mtod(m, struct rdata *);
        }

        fh = (mntver == 3) ?
                rdata->fh.v3fh.fh : rdata->fh.v2fh;
        memcpy(argp->fh, fh, argp->fhsize);

        goto out;

bad:
        error = EBADRPC;

out:
        m_freem(m);
        return error;
}