rpcsvc/rpc.bootparamd/bootparam_ip_route.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1991-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/tihdr.h>
#include <sys/tiuser.h>
#include <sys/timod.h>

#include <sys/socket.h>
#include <sys/sockio.h>
#include <netinet/in.h>
#include <net/if.h>

#include <inet/common.h>
#include <inet/mib2.h>
#include <inet/ip.h>
#include <netinet/igmp_var.h>
#include <netinet/ip_mroute.h>

#include <arpa/inet.h>

#include <netdb.h>
#include <nss_dbdefs.h>
#include <fcntl.h>
#include <stropts.h>

#include "bootparam_private.h"

typedef struct mib_item_s {
    struct mib_item_s   *next_item;
    long            group;
    long            mib_id;
    long            length;
    char            *valp;
} mib_item_t;

static void free_itemlist(mib_item_t *);

static mib_item_t *
mibget(int sd)
{
    char            buf[512];
    int         flags;
    int         i, j, getcode;
    struct strbuf       ctlbuf, databuf;
    struct T_optmgmt_req    *tor = (struct T_optmgmt_req *)(void *)buf;
    struct T_optmgmt_ack    *toa = (struct T_optmgmt_ack *)(void *)buf;
    struct T_error_ack  *tea = (struct T_error_ack *)(void *)buf;
    struct opthdr       *req;
    mib_item_t      *first_item = nilp(mib_item_t);
    mib_item_t      *last_item  = nilp(mib_item_t);
    mib_item_t      *temp;

    tor->PRIM_type = T_SVR4_OPTMGMT_REQ;
    tor->OPT_offset = sizeof (struct T_optmgmt_req);
    tor->OPT_length = sizeof (struct opthdr);
    tor->MGMT_flags = T_CURRENT;
    req = (struct opthdr *)&tor[1];
    req->level = MIB2_IP;       /* any MIB2_xxx value ok here */
    req->name  = 0;
    req->len   = 0;

    ctlbuf.buf = buf;
    ctlbuf.len = tor->OPT_length + tor->OPT_offset;
    flags = 0;
    if (putmsg(sd, &ctlbuf, nilp(struct strbuf), flags) == -1) {
        perror("mibget: putmsg(ctl) failed");
        goto error_exit;
    }
    /*
     * each reply consists of a ctl part for one fixed structure
     * or table, as defined in mib2.h.  The format is a T_OPTMGMT_ACK,
     * containing an opthdr structure.  level/name identify the entry,
     * len is the size of the data part of the message.
     */
    req = (struct opthdr *)&toa[1];
    ctlbuf.maxlen = sizeof (buf);
    for (j = 1; ; j++) {
        flags = 0;
        getcode = getmsg(sd, &ctlbuf, nilp(struct strbuf), &flags);
        if (getcode == -1) {
            perror("mibget getmsg(ctl) failed");
            if (debug) {
                msgout("#   level   name    len");
                i = 0;
                for (last_item = first_item; last_item;
                    last_item = last_item->next_item)
                    msgout("%d  %4ld   %5ld   %ld", ++i,
                        last_item->group,
                        last_item->mib_id,
                        last_item->length);
            }
            goto error_exit;
        }
        if ((getcode == 0) &&
            (ctlbuf.len >= sizeof (struct T_optmgmt_ack))&&
            (toa->PRIM_type == T_OPTMGMT_ACK) &&
            (toa->MGMT_flags == T_SUCCESS) &&
            (req->len == 0)) {
            if (debug)
                msgout("mibget getmsg() %d returned EOD "
                    "(level %lu, name %lu)",
                    j, req->level, req->name);
            return (first_item);        /* this is EOD msg */
        }

        if (ctlbuf.len >= sizeof (struct T_error_ack) &&
            tea->PRIM_type == T_ERROR_ACK) {
            msgout("mibget %d gives T_ERROR_ACK: "
                "TLI_error = 0x%lx, UNIX_error = 0x%lx",
                j, tea->TLI_error, tea->UNIX_error);
            errno = (tea->TLI_error == TSYSERR)
                ? tea->UNIX_error : EPROTO;
            goto error_exit;
        }

        if (getcode != MOREDATA ||
            ctlbuf.len < sizeof (struct T_optmgmt_ack) ||
            toa->PRIM_type != T_OPTMGMT_ACK ||
            toa->MGMT_flags != T_SUCCESS) {
            msgout("mibget getmsg(ctl) %d returned %d, "
                "ctlbuf.len = %d, PRIM_type = %ld",
                j, getcode, ctlbuf.len, toa->PRIM_type);
            if (toa->PRIM_type == T_OPTMGMT_ACK)
                msgout("T_OPTMGMT_ACK: MGMT_flags = 0x%lx, "
                    "req->len = %lu",
                    toa->MGMT_flags, req->len);
            errno = ENOMSG;
            goto error_exit;
        }

        temp = (mib_item_t *)malloc(sizeof (mib_item_t));
        if (!temp) {
            perror("mibget malloc failed");
            goto error_exit;
        }
        if (last_item)
            last_item->next_item = temp;
        else
            first_item = temp;
        last_item = temp;
        last_item->next_item = nilp(mib_item_t);
        last_item->group = req->level;
        last_item->mib_id = req->name;
        last_item->length = req->len;
        last_item->valp = (char *)malloc(req->len);
        if (debug)
            msgout(
            "msg %d:  group = %4ld   mib_id = %5ld   length = %ld",
                j, last_item->group, last_item->mib_id,
                last_item->length);

        databuf.maxlen = last_item->length;
        databuf.buf    = last_item->valp;
        databuf.len    = 0;
        flags = 0;
        getcode = getmsg(sd, nilp(struct strbuf), &databuf, &flags);
        if (getcode == -1) {
            perror("mibget getmsg(data) failed");
            goto error_exit;
        } else if (getcode != 0) {
            msgout("xmibget getmsg(data) returned %d, "
                "databuf.maxlen = %d, databuf.len = %d",
                getcode, databuf.maxlen, databuf.len);
            goto error_exit;
        }
    }

error_exit:
    free_itemlist(first_item);
    return (NULL);
}

static void
free_itemlist(mib_item_t *item_list)
{
    mib_item_t  *item;

    while (item_list) {
        item = item_list;
        item_list = item->next_item;
        if (item->valp)
            free(item->valp);
        free(item);
    }
}

/*
 * If we are a router, return address of interface closest to client.
 * If we are not a router, look through our routing table and return
 * address of "best" router that is on same net as client.
 *
 * We expect the router flag to show up first, followed by interface
 * addr group, followed by the routing table.
 */

in_addr_t
get_ip_route(struct in_addr client_addr)
{
    boolean_t   found;
    mib_item_t  *item_list;
    mib_item_t  *item;
    int     sd;
    mib2_ip_t       *mip;
    mib2_ipAddrEntry_t  *map;
    mib2_ipRouteEntry_t *rp;
    int         ip_forwarding = 2;  /* off */
    /* mask of interface used to route to client and best_router */
    struct in_addr      interface_mask;
    /* address of interface used to route to client and best_router */
    struct in_addr      interface_addr;
    /* address of "best router"; i.e. the answer */
    struct in_addr      best_router;

    interface_mask.s_addr = 0L;
    interface_addr.s_addr = 0L;
    best_router.s_addr = 0L;

    /* open a stream to IP */
    sd = open("/dev/ip", O_RDWR);
    if (sd == -1) {
        perror("ip open");
        (void) close(sd);
        msgout("can't open mib stream");
        return (0);
    }

    /* send down a request and suck up all the mib info from IP */
    if ((item_list = mibget(sd)) == nilp(mib_item_t)) {
        msgout("mibget() failed");
        (void) close(sd);
        return (0);
    }

    /*
     * We make three passes through the list of collected IP mib
     * information.  First we figure out if we are a router.  Next,
     * we find which of our interfaces is on the same subnet as
     * the client.  Third, we paw through our own routing table
     * looking for a useful router address.
     */

    /*
     * The general IP group.
     */
    for (item = item_list; item; item = item->next_item) {
        if ((item->group == MIB2_IP) && (item->mib_id == 0)) {
            /* are we an IP router? */
            mip = (mib2_ip_t *)(void *)item->valp;
            ip_forwarding = mip->ipForwarding;
            break;
        }
    }

    /*
     * The interface group.
     */
    for (item = item_list, found = B_FALSE; item != NULL && !found;
        item = item->next_item) {
        if ((item->group == MIB2_IP) && (item->mib_id == MIB2_IP_20)) {
            /*
             * Try to find out which interface is up, configured,
             * not loopback, and on the same subnet as the client.
             * Save its address and netmask.
             */
            map = (mib2_ipAddrEntry_t *)(void *)item->valp;
            while ((char *)map < item->valp + item->length) {
                in_addr_t   addr, mask, net;
                int     ifflags;

                ifflags = map->ipAdEntInfo.ae_flags;
                addr = map->ipAdEntAddr;
                mask =  map->ipAdEntNetMask;
                net = addr & mask;

                if ((ifflags & IFF_LOOPBACK | IFF_UP) ==
                    IFF_UP && addr != INADDR_ANY &&
                    net == (client_addr.s_addr & mask)) {
                    interface_addr.s_addr = addr;
                    interface_mask.s_addr = mask;
                    found = B_TRUE;
                    break;
                }
                map++;
            }
        }
    }

    /*
     * If this exercise found no interface on the same subnet as
     * the client, then we can't suggest any router address to
     * use.
     */
    if (interface_addr.s_addr == 0) {
        if (debug)
            msgout("get_ip_route: no interface on same net "
                "as client");
        (void) close(sd);
        free_itemlist(item_list);
        return (0);
    }

    /*
     * If we are a router, we return to client the address of our
     * interface on the same net as the client.
     */
    if (ip_forwarding == 1) {
        if (debug)
            msgout("get_ip_route: returning local addr %s",
                inet_ntoa(interface_addr));
        (void) close(sd);
        free_itemlist(item_list);
        return (interface_addr.s_addr);
    }

    if (debug) {
        msgout("interface_addr = %s.", inet_ntoa(interface_addr));
        msgout("interface_mask = %s", inet_ntoa(interface_mask));
    }


    /*
     * The routing table group.
     */
    for (item = item_list; item; item = item->next_item) {
        if ((item->group == MIB2_IP) && (item->mib_id == MIB2_IP_21)) {
            if (debug)
                msgout("%lu records for ipRouteEntryTable",
                    item->length /
                    sizeof (mib2_ipRouteEntry_t));

            for (rp = (mib2_ipRouteEntry_t *)(void *)item->valp;
                (char *)rp < item->valp + item->length;
                rp++) {
                if (debug >= 2)
                    msgout("ire_type = %d, next_hop = 0x%x",
                        rp->ipRouteInfo.re_ire_type,
                        rp->ipRouteNextHop);

                /*
                 * We are only interested in real
                 * gateway routes.
                 */
                if ((rp->ipRouteInfo.re_ire_type !=
                    IRE_DEFAULT) &&
                    (rp->ipRouteInfo.re_ire_type !=
                    IRE_PREFIX) &&
                    (rp->ipRouteInfo.re_ire_type !=
                    IRE_HOST) &&
                    (rp->ipRouteInfo.re_ire_type !=
                    IRE_HOST_REDIRECT))
                    continue;

                /*
                 * We are only interested in routes with
                 * a next hop on the same subnet as
                 * the client.
                 */
                if ((rp->ipRouteNextHop &
                    interface_mask.s_addr) !=
                    (interface_addr.s_addr &
                    interface_mask.s_addr))
                    continue;

                /*
                 * We have a valid route.  Give preference
                 * to default routes.
                 */
                if ((rp->ipRouteDest == 0) ||
                    (best_router.s_addr == 0))
                    best_router.s_addr =
                        rp->ipRouteNextHop;
            }
        }
    }

    if (debug && (best_router.s_addr == 0))
        msgout("get_ip_route: no route found for client");

    (void) close(sd);
    free_itemlist(item_list);
    return (best_router.s_addr);
}

/*
 * Return address of server interface closest to client.
 *
 * If the server has only a single IP address return it. Otherwise check
 * if the server has an interface on the same subnet as the client and
 * return the address of that interface.
 */

in_addr_t
find_best_server_int(char **addr_list, char *client_name)
{
    in_addr_t       server_addr = 0;
    struct hostent      h, *hp;
    char            hbuf[NSS_BUFLEN_HOSTS];
    int         err;
    struct in_addr      client_addr;
    mib_item_t      *item_list;
    mib_item_t      *item;
    int         sd;
    mib2_ipAddrEntry_t  *map;
    in_addr_t       client_net = 0, client_mask = 0;
    boolean_t       found_client_int;

    (void) memcpy(&server_addr, addr_list[0], sizeof (in_addr_t));
    if (addr_list[1] == NULL)
        return (server_addr);

    hp = gethostbyname_r(client_name, &h, hbuf, sizeof (hbuf), &err);
    if (hp == NULL)
        return (server_addr);
    (void) memcpy(&client_addr, hp->h_addr_list[0], sizeof (client_addr));

    /* open a stream to IP */
    sd = open("/dev/ip", O_RDWR);
    if (sd == -1) {
        perror("ip open");
        (void) close(sd);
        msgout("can't open mib stream");
        return (server_addr);
    }

    /* send down a request and suck up all the mib info from IP */
    if ((item_list = mibget(sd)) == nilp(mib_item_t)) {
        msgout("mibget() failed");
        (void) close(sd);
        return (server_addr);
    }
    (void) close(sd);

    /*
     * Search through the list for our interface which is on the same
     * subnet as the client and get the netmask.
     */
    for (item = item_list, found_client_int = B_FALSE;
        item != NULL && !found_client_int; item = item->next_item) {
        if ((item->group == MIB2_IP) && (item->mib_id == MIB2_IP_20)) {
            /*
             * Try to find out which interface is up, configured,
             * not loopback, and on the same subnet as the client.
             * Save its address and netmask.
             */
            map = (mib2_ipAddrEntry_t *)(void *)item->valp;
            while ((char *)map < item->valp + item->length) {
                in_addr_t   addr, mask, net;
                int     ifflags;

                ifflags = map->ipAdEntInfo.ae_flags;
                addr = map->ipAdEntAddr;
                mask =  map->ipAdEntNetMask;
                net = addr & mask;

                if ((ifflags & IFF_LOOPBACK|IFF_UP) == IFF_UP &&
                    addr != INADDR_ANY &&
                    (client_addr.s_addr & mask) == net) {
                    client_net = net;
                    client_mask = mask;
                    found_client_int = B_TRUE;
                    break;
                }
                map++;
            }
        }
    }

    /*
     * If we found the interface check which is the best IP address.
     */
    if (found_client_int) {
        while (*addr_list != NULL) {
            in_addr_t   addr;

            (void) memcpy(&addr, *addr_list, sizeof (in_addr_t));
            if ((addr & client_mask) == client_net) {
                server_addr = addr;
                break;
            }
            addr_list++;
        }
    }

    if (debug && server_addr == 0)
        msgout("No usable interface for returning reply");

    free_itemlist(item_list);
    return (server_addr);
}