libsocket/inet/inet6_rthdr.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 (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This code is conformant to revision 7 of 2292bis.  Some of these functions
 * were provided (named inet6_rthdr_) in a very similar form in RFC 2292.
 * The RFC 2292 variants are not supported.
 */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <unistd.h>
#include <errno.h>

#define MAX_RTHDR0_SEGMENTS 127

/*
 * Return amount of space needed to hold N segments for the specified
 * routing type. Does NOT include space for cmsghdr.
 */
socklen_t
inet6_rth_space(int type, int segments)
{
    if (type != IPV6_RTHDR_TYPE_0 || segments < 0 ||
        segments > MAX_RTHDR0_SEGMENTS)
        return (0);

    return (sizeof (struct ip6_rthdr0) +
        segments * sizeof (struct in6_addr));
}

/*
 * Initializes rthdr structure. Verifies the segments against the length of
 * the buffer.
 * Note that a routing header can only hold 127 segments since the length field
 * in the header is just a byte.
 */
void *
inet6_rth_init(void *bp, socklen_t bp_len, int type, int segments)
{
    struct ip6_rthdr0 *rthdr;

    if (type != IPV6_RTHDR_TYPE_0 || segments < 0 ||
        segments > MAX_RTHDR0_SEGMENTS)
        return (NULL);

    if (bp_len < sizeof (struct ip6_rthdr0) +
        segments * sizeof (struct in6_addr))
        return (NULL);

    rthdr = (struct ip6_rthdr0 *)bp;
    rthdr->ip6r0_nxt = 0;
    rthdr->ip6r0_len = (segments * 2);
    rthdr->ip6r0_type = type;
    rthdr->ip6r0_segleft = 0;   /* Incremented by rthdr_add */
    *(uint32_t *)&rthdr->ip6r0_reserved = 0;
    return (bp);
}

/*
 * Add one more address to the routing header. Fails when there is no more
 * room.
 */
int
inet6_rth_add(void *bp, const struct in6_addr *addr)
{
    struct ip6_rthdr0 *rthdr;
    struct in6_addr *addrs;

    rthdr = (struct ip6_rthdr0 *)bp;
    if ((rthdr->ip6r0_segleft + 1) * 2 > rthdr->ip6r0_len) {
        /* Not room for one more */
        return (-1);
    }
    /* LINTED alignment */
    addrs = (struct in6_addr *)((char *)rthdr + sizeof (*rthdr));
    addrs[rthdr->ip6r0_segleft++] = *addr;
    return (0);
}

/*
 * Reverse a source route. Both arguments can point to the same buffer.
 */
int
inet6_rth_reverse(const void *in, void *out)
{
    struct ip6_rthdr0 *rtin, *rtout;
    int i, segments;
    struct in6_addr tmp;
    struct in6_addr *rtout_addrs;
    struct in6_addr *rtin_addrs;

    rtin = (struct ip6_rthdr0 *)in;
    rtout = (struct ip6_rthdr0 *)out;

    if (rtout->ip6r0_type != 0 || rtin->ip6r0_type != 0 ||
        rtout->ip6r0_len > MAX_RTHDR0_SEGMENTS * 2 ||
        rtin->ip6r0_len > MAX_RTHDR0_SEGMENTS * 2 ||
        rtout->ip6r0_len != rtin->ip6r0_len)
        return (-1);

    segments = rtin->ip6r0_len / 2;
    /* LINTED alignment */
    rtout_addrs = (struct in6_addr *)((char *)rtout + sizeof (*rtout));
    /* LINTED alignment */
    rtin_addrs = (struct in6_addr *)((char *)rtin + sizeof (*rtin));
    for (i = 0; i < (segments + 1)/2; i++) {
        tmp = rtin_addrs[i];
        rtout_addrs[i] = rtin_addrs[segments - 1 - i];
        rtout_addrs[segments - 1 - i] = tmp;
    }
    rtout->ip6r0_segleft = segments;
    return (0);
}

/*
 * Return the number of segments in the routing header.
 */
int
inet6_rth_segments(const void *bp)
{
    struct ip6_rthdr0 *rthdr;

    rthdr = (struct ip6_rthdr0 *)bp;
    if (rthdr->ip6r0_type == 0) {
        if (rthdr->ip6r0_len > MAX_RTHDR0_SEGMENTS * 2) {
            return (-1);
        } else {
            return (rthdr->ip6r0_len / 2);
        }
    } else {
        return (-1);
    }
}

/*
 * Return a pointer to an element in the source route.
 * This uses the C convention for index [0, size-1].
 */
struct in6_addr *
inet6_rth_getaddr(const void *bp, int index)
{
    struct ip6_rthdr0 *rthdr;
    struct in6_addr *rv;

    rthdr = (struct ip6_rthdr0 *)bp;
    if (index >= rthdr->ip6r0_len/2 || index < 0)
        return (NULL);

    /* LINTED alignment */
    rv = (struct in6_addr *)((char *)rthdr + sizeof (*rthdr));
    return (&rv[index]);
}