OpenSolaris_b135/lib/libdhcpagent/common/dhcp_hostconf.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2007 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 <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <netinet/dhcp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <string.h> /* memcpy */
#include <fcntl.h>
#include <limits.h>
#include "dhcp_hostconf.h"
static void relativize_time(DHCP_OPT *, time_t, time_t);
static void relativize_v6(uint32_t *, time_t, time_t);
/*
* ifname_to_hostconf(): converts an interface name into a hostconf file for
* that interface
*
* input: const char *: the interface name
* boolean_t: B_TRUE if using DHCPv6
* output: char *: the hostconf filename
* note: uses an internal static buffer (not threadsafe)
*/
char *
ifname_to_hostconf(const char *ifname, boolean_t isv6)
{
static char filename[sizeof (DHCP_HOSTCONF_TMPL6) + LIFNAMSIZ];
(void) snprintf(filename, sizeof (filename), "%s%s%s",
DHCP_HOSTCONF_PREFIX, ifname,
isv6 ? DHCP_HOSTCONF_SUFFIX6 : DHCP_HOSTCONF_SUFFIX);
return (filename);
}
/*
* remove_hostconf(): removes an interface.dhc file
*
* input: const char *: the interface name
* boolean_t: B_TRUE if using DHCPv6
* output: int: 0 if the file is removed, -1 if it can't be removed
* (errno is set)
*/
int
remove_hostconf(const char *ifname, boolean_t isv6)
{
return (unlink(ifname_to_hostconf(ifname, isv6)));
}
/*
* read_hostconf(): reads the contents of an <if>.dhc file into a PKT_LIST
*
* input: const char *: the interface name
* PKT_LIST **: a pointer to a PKT_LIST * to store the info in
* uint_t: the length of the list of PKT_LISTs
* boolean_t: B_TRUE if using DHCPv6
* output: int: >0 if the file is read and loaded into the PKT_LIST *
* successfully, -1 otherwise (errno is set)
* note: the PKT and PKT_LISTs are dynamically allocated here
*/
int
read_hostconf(const char *ifname, PKT_LIST **plpp, uint_t plplen,
boolean_t isv6)
{
PKT_LIST *plp = NULL;
PKT *pkt = NULL;
int fd;
time_t orig_time, current_time = time(NULL);
uint32_t lease;
uint32_t magic;
int pcnt = 0;
int retval;
fd = open(ifname_to_hostconf(ifname, isv6), O_RDONLY);
if (fd == -1)
return (-1);
if (read(fd, &magic, sizeof (magic)) != sizeof (magic))
goto failure;
if (magic != (isv6 ? DHCP_HOSTCONF_MAGIC6 : DHCP_HOSTCONF_MAGIC))
goto failure;
if (read(fd, &orig_time, sizeof (orig_time)) != sizeof (orig_time))
goto failure;
/*
* read the packet back in from disk, and for v4, run it through
* dhcp_options_scan(). note that we use calloc() because
* dhcp_options_scan() relies on the structure being zeroed.
*/
for (pcnt = 0; pcnt < plplen; pcnt++) {
plp = NULL;
pkt = NULL;
if ((plp = calloc(1, sizeof (PKT_LIST))) == NULL)
goto failure;
retval = read(fd, &plp->len, sizeof (plp->len));
if (retval == 0 && pcnt != 0) {
/*
* Reached end of file on a boundary, but after
* we've read at least one packet, so we consider
* this successful, allowing us to use files from
* older versions of the agent happily.
*/
free(plp);
break;
} else if (retval != sizeof (plp->len))
goto failure;
if ((pkt = malloc(plp->len)) == NULL)
goto failure;
if (read(fd, pkt, plp->len) != plp->len)
goto failure;
plp->pkt = pkt;
plpp[pcnt] = plp;
if (!isv6 && dhcp_options_scan(plp, B_TRUE) != 0)
goto failure;
/*
* First packet used to validate that we're interested,
* the rest are presumed to be historical reference and
* are not relativized
*/
if (pcnt == 0)
continue;
if (isv6) {
dhcpv6_option_t d6o;
dhcpv6_ia_na_t d6in;
dhcpv6_iaaddr_t d6ia;
uchar_t *opts, *optmax, *subomax;
/*
* Loop over contents of the packet to find the address
* options.
*/
opts = (uchar_t *)pkt + sizeof (dhcpv6_message_t);
optmax = (uchar_t *)pkt + plp->len;
while (opts + sizeof (d6o) <= optmax) {
/*
* Extract option header and make sure option
* is intact.
*/
(void) memcpy(&d6o, opts, sizeof (d6o));
d6o.d6o_code = ntohs(d6o.d6o_code);
d6o.d6o_len = ntohs(d6o.d6o_len);
subomax = opts + sizeof (d6o) + d6o.d6o_len;
if (subomax > optmax)
break;
/*
* If this isn't an option that contains
* address or prefix leases, then skip over it.
*/
if (d6o.d6o_code != DHCPV6_OPT_IA_NA &&
d6o.d6o_code != DHCPV6_OPT_IA_TA &&
d6o.d6o_code != DHCPV6_OPT_IA_PD) {
opts = subomax;
continue;
}
/*
* Handle the option first.
*/
if (d6o.d6o_code == DHCPV6_OPT_IA_TA) {
/* no timers in this structure */
opts += sizeof (dhcpv6_ia_ta_t);
} else {
/* both na and pd */
if (opts + sizeof (d6in) > subomax) {
opts = subomax;
continue;
}
(void) memcpy(&d6in, opts,
sizeof (d6in));
relativize_v6(&d6in.d6in_t1, orig_time,
current_time);
relativize_v6(&d6in.d6in_t2, orig_time,
current_time);
(void) memcpy(opts, &d6in,
sizeof (d6in));
opts += sizeof (d6in);
}
/*
* Now handle each suboption (address) inside.
*/
while (opts + sizeof (d6o) <= subomax) {
/*
* Verify the suboption header first.
*/
(void) memcpy(&d6o, opts,
sizeof (d6o));
d6o.d6o_code = ntohs(d6o.d6o_code);
d6o.d6o_len = ntohs(d6o.d6o_len);
if (opts + sizeof (d6o) + d6o.d6o_len >
subomax)
break;
if (d6o.d6o_code != DHCPV6_OPT_IAADDR) {
opts += sizeof (d6o) +
d6o.d6o_len;
continue;
}
/*
* Now process the contents.
*/
if (opts + sizeof (d6ia) > subomax)
break;
(void) memcpy(&d6ia, opts,
sizeof (d6ia));
relativize_v6(&d6ia.d6ia_preflife,
orig_time, current_time);
relativize_v6(&d6ia.d6ia_vallife,
orig_time, current_time);
(void) memcpy(opts, &d6ia,
sizeof (d6ia));
opts += sizeof (d6o) + d6o.d6o_len;
}
opts = subomax;
}
} else {
/*
* make sure the IPv4 DHCP lease is still valid.
*/
if (plp->opts[CD_LEASE_TIME] != NULL &&
plp->opts[CD_LEASE_TIME]->len ==
sizeof (lease_t)) {
(void) memcpy(&lease,
plp->opts[CD_LEASE_TIME]->value,
sizeof (lease_t));
lease = ntohl(lease);
if ((lease != DHCP_PERM) &&
(orig_time + lease) <= current_time)
goto failure;
}
relativize_time(plp->opts[CD_T1_TIME], orig_time,
current_time);
relativize_time(plp->opts[CD_T2_TIME], orig_time,
current_time);
relativize_time(plp->opts[CD_LEASE_TIME], orig_time,
current_time);
}
}
(void) close(fd);
return (pcnt);
failure:
free(pkt);
free(plp);
while (pcnt-- > 0) {
free(plpp[pcnt]->pkt);
free(plpp[pcnt]);
}
(void) close(fd);
return (-1);
}
/*
* write_hostconf(): writes the contents of a PKT_LIST into an <if>.dhc file
*
* input: const char *: the interface name
* PKT_LIST **: a list of pointers to PKT_LIST to write
* uint_t: length of the list of PKT_LIST pointers
* time_t: a starting time to treat the relative lease times
* in the first packet as relative to
* boolean_t: B_TRUE if using DHCPv6
* output: int: 0 if the file is written successfully, -1 otherwise
* (errno is set)
*/
int
write_hostconf(
const char *ifname,
PKT_LIST *pl[],
uint_t pllen,
time_t relative_to,
boolean_t isv6)
{
int fd;
struct iovec iov[IOV_MAX];
int retval;
uint32_t magic;
ssize_t explen = 0; /* Expected length of write */
int i, iovlen = 0;
fd = open(ifname_to_hostconf(ifname, isv6), O_WRONLY|O_CREAT|O_TRUNC,
0600);
if (fd == -1)
return (-1);
/*
* first write our magic number, then the relative time of the
* leases, then for each packet we write the length of the packet
* followed by the packet. we will then use the relative time in
* read_hostconf() to recalculate the lease times for the first packet.
*/
magic = isv6 ? DHCP_HOSTCONF_MAGIC6 : DHCP_HOSTCONF_MAGIC;
iov[iovlen].iov_base = (caddr_t)&magic;
explen += iov[iovlen++].iov_len = sizeof (magic);
iov[iovlen].iov_base = (caddr_t)&relative_to;
explen += iov[iovlen++].iov_len = sizeof (relative_to);
for (i = 0; i < pllen && iovlen < (IOV_MAX - 1); i++) {
iov[iovlen].iov_base = (caddr_t)&pl[i]->len;
explen += iov[iovlen++].iov_len = sizeof (pl[i]->len);
iov[iovlen].iov_base = (caddr_t)pl[i]->pkt;
explen += iov[iovlen++].iov_len = pl[i]->len;
}
retval = writev(fd, iov, iovlen);
(void) close(fd);
if (retval != explen)
return (-1);
return (0);
}
/*
* relativize_time(): re-relativizes a time in a DHCP option
*
* input: DHCP_OPT *: the DHCP option parameter to convert
* time_t: the time the leases in the packet are currently relative to
* time_t: the current time which leases will become relative to
* output: void
*/
static void
relativize_time(DHCP_OPT *option, time_t orig_time, time_t current_time)
{
uint32_t pkt_time;
time_t time_diff = current_time - orig_time;
if (option == NULL || option->len != sizeof (lease_t))
return;
(void) memcpy(&pkt_time, option->value, option->len);
if (ntohl(pkt_time) != DHCP_PERM)
pkt_time = htonl(ntohl(pkt_time) - time_diff);
(void) memcpy(option->value, &pkt_time, option->len);
}
/*
* relativize_v6(): re-relativizes a time in a DHCPv6 option
*
* input: uint32_t *: the time value to convert
* time_t: the time the leases in the packet are currently relative to
* time_t: the current time which leases will become relative to
* output: void
*/
static void
relativize_v6(uint32_t *val, time_t orig_time, time_t current_time)
{
uint32_t hval;
time_t time_diff = current_time - orig_time;
hval = ntohl(*val);
if (hval != DHCPV6_INFTIME) {
if (hval < time_diff)
*val = 0;
else
*val = htonl(hval - time_diff);
}
}