files/lib/route-table-solaris.c

/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright (c) 2012 Ed Maste. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <config.h>

#include "route-table.h"
#include <sys/socket.h>
#include <sys/types.h>

#include <net/if.h>
#include <net/route.h>
#include <net/if_dl.h>
#include <netinet/in.h>

#include <string.h>
#include <unistd.h>

#include "util.h"

static int pid;
static unsigned int register_count = 0;

#define ROUNDUP_LONG(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof (long) - 1))) : \
    sizeof (long))
#define RT_ADVANCE(x, n) ((x) += ROUNDUP_LONG(salen(n)))
#define BUF_SIZE 2048

typedef struct rtmsg {
    struct rt_msghdr    m_rtm;
    char            m_space[BUF_SIZE];
} rtmsg_t;

static int
salen(const struct sockaddr *sa)
{
    switch (sa->sa_family) {
    case AF_INET:
        return (sizeof (struct sockaddr_in));
    case AF_LINK:
        return (sizeof (struct sockaddr_dl));
    case AF_INET6:
        return (sizeof (struct sockaddr_in6));
    default:
        return (sizeof (struct sockaddr));
    }
}

bool
route_table_get_name(ovs_be32 ip, char name[IFNAMSIZ])
{
    rtmsg_t         m_rtmsg;
    struct rt_msghdr    *rtm = &m_rtmsg.m_rtm;
    char            *cp = m_rtmsg.m_space;
    int         rtsock_fd;
    struct sockaddr_in  sin;
    struct sockaddr_dl  sdl;
    ssize_t         ssz;
    static int      seq;
    int         rlen;
    int         i;
    int         l;

    rtsock_fd = socket(PF_ROUTE, SOCK_RAW, 0);
    if (rtsock_fd == -1)
        return (false);

    memset(&sin, 0, sizeof (sin));
    sin.sin_family = AF_INET;
    sin.sin_port = 0;
    sin.sin_addr.s_addr = ip;

    memset(&sdl, 0, sizeof (sdl));
    sdl.sdl_family = AF_LINK;

    memset(&m_rtmsg, 0, sizeof (m_rtmsg));
    rtm->rtm_version = RTM_VERSION;
    rtm->rtm_type = RTM_GET;
    rtm->rtm_addrs = RTA_DST|RTA_IFP;
    rtm->rtm_seq = ++seq;

    l = ROUNDUP_LONG(sizeof (struct sockaddr_in));
    (void) memcpy(cp, &sin, l);
    cp += l;

    l = ROUNDUP_LONG(sizeof (struct sockaddr_dl));
    (void) memcpy(cp, &sdl, l);
    cp += l;

    rtm->rtm_msglen = l = cp - (char *)&m_rtmsg;
    if ((rlen = write(rtsock_fd, (char *)&m_rtmsg, l)) < l) {
        close(rtsock_fd);
        return (false);
    }

    do {
        ssz = read(rtsock_fd, &m_rtmsg, sizeof (m_rtmsg));
    } while (ssz > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
    close(rtsock_fd);

    if (ssz < 0)
        return (false);

    cp = (void *)&m_rtmsg.m_space;
    for (i = 1; i; i <<= 1) {
        if ((rtm->rtm_addrs & i) != 0) {
            const struct sockaddr *sa = (const void *)cp;

            if ((i == RTA_IFP) && sa->sa_family == AF_LINK) {
                const struct sockaddr_dl * const sdlp =
                    ALIGNED_CAST(const struct sockaddr_dl *,
                    sa);
                int namelen;

                namelen = sdlp->sdl_nlen;
                if (namelen > IFNAMSIZ - 1)
                    namelen = IFNAMSIZ - 1;
                memcpy(name, sdlp->sdl_data, namelen);
                name[namelen] = '\0';
                return (true);
            }
            RT_ADVANCE(cp, sa);
        }
    }
    return (false);
}

uint64_t
route_table_get_change_seq(void)
{
    return (0);
}

void
route_table_register(void)
{
    if (!register_count) {
        pid = getpid();
    }

    register_count++;
}

void
route_table_unregister(void)
{
    register_count--;
}

void
route_table_run(void)
{
}

void
route_table_wait(void)
{
}