OpenSolaris_b135/cmd/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);
}