/*      $NetBSD: util.c,v 1.24 2020/06/17 00:16:22 kamil Exp $  */
/* $FreeBSD: head/usr.sbin/rpcbind/util.c 300973 2016-05-29 20:28:01Z ngie $ */

/*-
 * Copyright (c) 2000 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Frank van der Linden.
 *
 * 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.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <net/if.h>
#include <netinet/in.h>
#include <assert.h>
#include <ifaddrs.h>
#include <poll.h>
#include <rpc/rpc.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <netconfig.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <err.h>

#ifdef RPCBIND_RUMP
#include <rump/rump.h>
#include <rump/rump_syscallshotgun.h>
#include <rump/rump_syscalls.h>
#endif

#include "rpcbind.h"

static struct sockaddr_in *local_in4;
#ifdef INET6
static struct sockaddr_in6 *local_in6;
#endif

static int bitmaskcmp(void *, void *, void *, int);

/*
 * For all bits set in "mask", compare the corresponding bits in
 * "dst" and "src", and see if they match. Returns 0 if the addresses
 * match.
 */
static int
bitmaskcmp(void *dst, void *src, void *mask, int bytelen)
{
        int i, j;
        u_int8_t *p1 = dst, *p2 = src, *netmask = mask;
        u_int8_t bitmask;

        for (i = 0; i < bytelen; i++) {
                for (j = 0; j < 8; j++) {
                        bitmask = 1 << j;
                        if (!(netmask[i] & bitmask))
                                continue;
                        if ((p1[i] & bitmask) != (p2[i] & bitmask))
                                return 1;
                }
        }

        return 0;
}

char *
addrmerge(struct netbuf *caller, char *serv_uaddr, char *clnt_uaddr,
    const char *netid)
{
        struct ifaddrs *ifap, *ifp, *bestif;
#ifdef INET6
        struct sockaddr_in6 *servsin6, *sin6mask, *clntsin6, *ifsin6, *realsin6;
        struct sockaddr_in6 *newsin6;
#endif
        struct sockaddr_in *servsin, *sinmask, *clntsin, *newsin, *ifsin;
        struct netbuf *serv_nbp, *clnt_nbp = NULL, tbuf;
        struct sockaddr *serv_sa;
        struct sockaddr *clnt_sa;
        struct sockaddr_storage ss;
        struct netconfig *nconf;
        struct sockaddr *clnt = caller->buf;
        char *ret = NULL;

#ifdef INET6
        servsin6 = ifsin6 = newsin6 = NULL;     /* XXXGCC -Wuninitialized */
#endif
        servsin = newsin = NULL;                /* XXXGCC -Wuninitialized */

#ifdef RPCBIND_DEBUG
        if (debugging)
                fprintf(stderr, "addrmerge(caller, %s, %s, %s\n", serv_uaddr,
                    clnt_uaddr, netid);
#endif
        nconf = getnetconfigent(netid);
        if (nconf == NULL)
                return NULL;

        /*
         * Local merge, just return a duplicate.
         */
        if (clnt_uaddr != NULL && strncmp(clnt_uaddr, "0.0.0.0.", 8) == 0)
                return strdup(clnt_uaddr);

        serv_nbp = uaddr2taddr(nconf, serv_uaddr);
        if (serv_nbp == NULL)
                return NULL;

        serv_sa = serv_nbp->buf;
        if (clnt_uaddr != NULL) {
                clnt_nbp = uaddr2taddr(nconf, clnt_uaddr);
                if (clnt_nbp == NULL) {
                        free(serv_nbp);
                        return NULL;
                }
                clnt_sa = clnt_nbp->buf;
                if (clnt_sa->sa_family == AF_LOCAL) {
                        free(serv_nbp);
                        free(clnt_nbp);
                        free(clnt_sa);
                        return strdup(serv_uaddr);
                }
        } else {
                clnt_sa = malloc(clnt->sa_len);
                if (clnt_sa == NULL) {
                        free(serv_nbp);
                        return NULL;
                }
                memcpy(clnt_sa, clnt, clnt->sa_len);
        }

        if (getifaddrs(&ifp) < 0) {
                free(serv_nbp);
                free(clnt_sa);
                if (clnt_nbp != NULL)
                        free(clnt_nbp);
                return 0;
        }

        /*
         * Loop through all interfaces. For each interface, see if the
         * network portion of its address is equal to that of the client.
         * If so, we have found the interface that we want to use.
         */
        for (ifap = ifp; ifap != NULL; ifap = ifap->ifa_next) {
                if (ifap->ifa_addr->sa_family != clnt->sa_family ||
                    !(ifap->ifa_flags & IFF_UP))
                        continue;

                switch (clnt->sa_family) {
                case AF_INET:
                        /*
                         * realsin: address that recvfrom gave us.
                         * ifsin: address of interface being examined.
                         * clntsin: address that client want us to contact
                         *           it on
                         * servsin: local address of RPC service.
                         * sinmask: netmask of this interface
                         * newsin: initially a copy of clntsin, eventually
                         *         the merged address
                         */
                        servsin = (struct sockaddr_in *)serv_sa;
                        clntsin = (struct sockaddr_in *)clnt_sa;
                        sinmask = (struct sockaddr_in *)ifap->ifa_netmask;
                        newsin = (struct sockaddr_in *)&ss;
                        ifsin = (struct sockaddr_in *)ifap->ifa_addr;
                        if (!bitmaskcmp(&ifsin->sin_addr, &clntsin->sin_addr,
                            &sinmask->sin_addr, sizeof (struct in_addr))) {
                                goto found;
                        }
                        break;
#ifdef INET6
                case AF_INET6:
                        /*
                         * realsin6: address that recvfrom gave us.
                         * ifsin6: address of interface being examined.
                         * clntsin6: address that client want us to contact
                         *           it on
                         * servsin6: local address of RPC service.
                         * sin6mask: netmask of this interface
                         * newsin6: initially a copy of clntsin, eventually
                         *          the merged address
                         *
                         * For v6 link local addresses, if the client contacted
                         * us via a link-local address, and wants us to reply
                         * to one, use the scope id to see which one.
                         */
                        realsin6 = (struct sockaddr_in6 *)clnt;
                        ifsin6 = (struct sockaddr_in6 *)ifap->ifa_addr;
                        inet6_getscopeid(ifsin6, 1);
                        clntsin6 = (struct sockaddr_in6 *)clnt_sa;
                        servsin6 = (struct sockaddr_in6 *)serv_sa;
                        sin6mask = (struct sockaddr_in6 *)ifap->ifa_netmask;
                        newsin6 = (struct sockaddr_in6 *)&ss;
                        if (IN6_IS_ADDR_LINKLOCAL(&ifsin6->sin6_addr) &&
                            IN6_IS_ADDR_LINKLOCAL(&realsin6->sin6_addr) &&
                            IN6_IS_ADDR_LINKLOCAL(&clntsin6->sin6_addr)) {
                                if (ifsin6->sin6_scope_id !=
                                    realsin6->sin6_scope_id)
                                        continue;
                                goto found;
                        }
                        if (!bitmaskcmp(&ifsin6->sin6_addr,
                            &clntsin6->sin6_addr, &sin6mask->sin6_addr,
                            sizeof (struct in6_addr)))
                                goto found;
                        break;
#endif
                default:
                        goto freeit;
                }
        }
        /*
         * Didn't find anything. Get the first possibly useful interface,
         * preferring "normal" interfaces to point-to-point and loopback
         * ones.
         */
        bestif = NULL;
        for (ifap = ifp; ifap != NULL; ifap = ifap->ifa_next) {
                if (ifap->ifa_addr->sa_family != clnt->sa_family ||
                    !(ifap->ifa_flags & IFF_UP))
                        continue;
                if (!(ifap->ifa_flags & IFF_LOOPBACK) &&
                    !(ifap->ifa_flags & IFF_POINTOPOINT)) {
                        bestif = ifap;
                        break;
                }
                if (bestif == NULL)
                        bestif = ifap;
                else if ((bestif->ifa_flags & IFF_LOOPBACK) &&
                    !(ifap->ifa_flags & IFF_LOOPBACK))
                        bestif = ifap;
        }
        ifap = bestif;
found:
        switch (clnt->sa_family) {
        case AF_INET:
                memcpy(newsin, ifap->ifa_addr, clnt_sa->sa_len);
                newsin->sin_port = servsin->sin_port;
                tbuf.len = clnt_sa->sa_len;
                tbuf.maxlen = sizeof (struct sockaddr_storage);
                tbuf.buf = newsin;
                break;                          
#ifdef INET6
        case AF_INET6:
                memcpy(newsin6, ifsin6, clnt_sa->sa_len);
                newsin6->sin6_port = servsin6->sin6_port;
                tbuf.maxlen = sizeof (struct sockaddr_storage);
                tbuf.len = clnt_sa->sa_len;
                tbuf.buf = newsin6;
                break;
#endif
        default:
                goto freeit;
        }
        if (ifap != NULL)
                ret = taddr2uaddr(nconf, &tbuf);
freeit:
        freenetconfigent(nconf);
        free(serv_sa);
        free(serv_nbp);
        if (clnt_sa != NULL)
                free(clnt_sa);
        if (clnt_nbp != NULL)
                free(clnt_nbp);
        freeifaddrs(ifp);

#ifdef RPCBIND_DEBUG
        if (debugging)
                fprintf(stderr, "addrmerge: returning %s\n", ret);
#endif
        return ret;
}

void
network_init()
{
#ifdef INET6
        struct ifaddrs *ifap, *ifp;
        struct ipv6_mreq mreq6;
        unsigned int ifindex;
        int s;
#endif
        int ecode;
        struct addrinfo hints, *res;

        memset(&hints, 0, sizeof hints);
        hints.ai_family = AF_INET;
        if ((ecode = getaddrinfo(NULL, "sunrpc", &hints, &res))) {
                if (debugging)
                        fprintf(stderr, "can't get local ip4 address: %s\n",
                            gai_strerror(ecode));
        } else {
                local_in4 = malloc(sizeof(*local_in4));
                if (local_in4 == NULL) {
                        if (debugging)
                                fprintf(stderr, "can't alloc local ip4 addr\n");
                }
                memcpy(local_in4, res->ai_addr, sizeof *local_in4);
        }

#ifdef INET6
        hints.ai_family = AF_INET6;
        if ((ecode = getaddrinfo(NULL, "sunrpc", &hints, &res))) {
                if (debugging)
                        fprintf(stderr, "can't get local ip6 address: %s\n",
                            gai_strerror(ecode));
        } else {
                local_in6 = malloc(sizeof(*local_in6));
                if (local_in6 == NULL) {
                        if (debugging)
                                fprintf(stderr, "can't alloc local ip6 addr\n");
                }
                memcpy(local_in6, res->ai_addr, sizeof *local_in6);
        }

        /*
         * Now join the RPC ipv6 multicast group on all interfaces.
         */
        if (getifaddrs(&ifp) < 0)
                return;

        mreq6.ipv6mr_interface = 0;
        inet_pton(AF_INET6, RPCB_MULTICAST_ADDR, &mreq6.ipv6mr_multiaddr);

        s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);

        /*
         * Loop through all interfaces. For each interface, see if the
         * network portion of its address is equal to that of the client.
         * If so, we have found the interface that we want to use.
         */
        for (ifap = ifp; ifap != NULL; ifap = ifap->ifa_next) {
                if (ifap->ifa_addr->sa_family != AF_INET6 ||
                    !(ifap->ifa_flags & IFF_MULTICAST))
                        continue;
                ifindex = if_nametoindex(ifap->ifa_name);
                if (ifindex == mreq6.ipv6mr_interface)
                        /*
                         * Already did this one.
                         */
                        continue;
                mreq6.ipv6mr_interface = ifindex;
                if (setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6,
                    sizeof mreq6) < 0)
                        if (debugging)
                                warn("setsockopt v6 multicast");
        }
        freeifaddrs(ifp);
#endif

        /* close(s); */
}

struct sockaddr *
local_sa(int af)
{
        switch (af) {
        case AF_INET:
                return (struct sockaddr *)local_in4;
#ifdef INET6
        case AF_INET6:
                return (struct sockaddr *)local_in6;
#endif
        default:
                return NULL;
        }
}