sol-network.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. 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.
 */

#pragma once

#include <stdbool.h>

#include <sol-common-buildopts.h>
#include <sol-vector.h>
#include <sol-str-slice.h>
#include <sol-buffer.h>
#include <sol-util.h>

#ifdef __cplusplus
extern "C" {
#endif

#define SOL_NETWORK_INET_ADDR_STR_LEN 48

#define SOL_BLUETOOTH_ADDR_STRLEN 18

struct sol_network_hostname_pending;
typedef struct sol_network_hostname_pending sol_network_hostname_pending;

enum sol_network_event {
    SOL_NETWORK_LINK_ADDED,
    SOL_NETWORK_LINK_REMOVED,
    SOL_NETWORK_LINK_CHANGED,
};

enum sol_network_link_flags {
    SOL_NETWORK_LINK_UP            = (1 << 0),
    SOL_NETWORK_LINK_BROADCAST     = (1 << 1),
    SOL_NETWORK_LINK_LOOPBACK      = (1 << 2),
    SOL_NETWORK_LINK_MULTICAST     = (1 << 3),
    SOL_NETWORK_LINK_RUNNING       = (1 << 4),
};

enum sol_network_family {
    SOL_NETWORK_FAMILY_UNSPEC,
    SOL_NETWORK_FAMILY_INET,
    SOL_NETWORK_FAMILY_INET6,
    SOL_NETWORK_FAMILY_BLUETOOTH,
    SOL_NETWORK_FAMILY_BLUETOOTH_RFCOMM,
    SOL_NETWORK_FAMILY_BLUETOOTH_L2CAP,
};

enum sol_network_bt_addr_type {
    SOL_NETWORK_BT_ADDR_BASIC_RATE,
    SOL_NETWORK_BT_ADDR_LE_PUBLIC,
    SOL_NETWORK_BT_ADDR_LE_RANDOM,
};

typedef struct sol_network_link_addr {
    enum sol_network_family family; 
    union {
        uint8_t in[4];
        uint8_t in6[16];
        struct {
            uint8_t bt_type;
            uint8_t bt_addr[6];
        };
    } addr; 
    uint16_t port; 
} sol_network_link_addr;

typedef struct sol_network_link {
#ifndef SOL_NO_API_VERSION
#define SOL_NETWORK_LINK_API_VERSION (1)
    uint16_t api_version; 
#endif
    uint16_t index; 
    enum sol_network_link_flags flags; 
    struct sol_vector addrs;
} sol_network_link;

#ifndef SOL_NO_API_VERSION

#define SOL_NETWORK_LINK_CHECK_VERSION(link_, ...) \
    if (SOL_UNLIKELY((link_)->api_version != \
        SOL_NETWORK_LINK_API_VERSION)) { \
        SOL_WRN("Unexpected API version (message is %u, expected %u)", \
            (link_)->api_version, SOL_NETWORK_LINK_API_VERSION); \
        return __VA_ARGS__; \
    }
#else
#define SOL_NETWORK_LINK_CHECK_VERSION(link_, ...)
#endif

const char *sol_network_link_addr_to_str(const struct sol_network_link_addr *addr, struct sol_buffer *buf);

const struct sol_network_link_addr *sol_network_link_addr_from_str(struct sol_network_link_addr *addr, const char *buf);

static inline bool
sol_network_link_addr_eq_full(const struct sol_network_link_addr *a,
    const struct sol_network_link_addr *b, bool compare_ports)
{
    size_t bytes;

    if (compare_ports && (a->port != b->port))
        return false;

    if (a->family == b->family) {
        const uint8_t *addr_a, *addr_b;

        if (a->family == SOL_NETWORK_FAMILY_INET) {
            addr_a = a->addr.in;
            addr_b = b->addr.in;
            bytes = sizeof(a->addr.in);
        } else if (a->family == SOL_NETWORK_FAMILY_INET6) {
            addr_a = a->addr.in6;
            addr_b = b->addr.in6;
            bytes = sizeof(a->addr.in6);
        } else if (a->family == SOL_NETWORK_FAMILY_BLUETOOTH) {
            if (a->addr.bt_type != b->addr.bt_type)
                return false;

            addr_a = a->addr.bt_addr;
            addr_b = b->addr.bt_addr;
            bytes = sizeof(a->addr.bt_addr);
        } else
            return false;
        return !memcmp(addr_a, addr_b, bytes);
    }

    if ((a->family == SOL_NETWORK_FAMILY_INET &&
        b->family == SOL_NETWORK_FAMILY_INET6) ||
        (a->family == SOL_NETWORK_FAMILY_INET6 &&
        b->family == SOL_NETWORK_FAMILY_INET)) {

        struct ipv6_map_prefix {
            const uint8_t zeroes[10];
            const uint16_t ones;
        } __attribute__ ((packed)) prefix = {
            { 0 }, sol_util_be16_to_cpu(0xffff)
        };
        const uint8_t *addr_ipv6, *addr_ipv4;


        if (a->family == SOL_NETWORK_FAMILY_INET6) {
            addr_ipv6 = a->addr.in6;
            addr_ipv4 = b->addr.in;
        } else {
            addr_ipv6 = b->addr.in6;
            addr_ipv4 = a->addr.in;
        }

        bytes = sizeof(a->addr.in);

        if (!memcmp(addr_ipv6, &prefix, sizeof(struct ipv6_map_prefix)) &&
            !memcmp(addr_ipv6 + 12, addr_ipv4, bytes))
            return true;
    }

    return false;
}

static inline bool
sol_network_link_addr_eq(const struct sol_network_link_addr *a,
    const struct sol_network_link_addr *b)
{
    return sol_network_link_addr_eq_full(a, b, false);
}
int sol_network_subscribe_events(void (*cb)(void *data, const struct sol_network_link *link,
    enum sol_network_event event),
    const void *data);

int sol_network_unsubscribe_events(void (*cb)(void *data, const struct sol_network_link *link,
    enum sol_network_event event),
    const void *data);

const struct sol_vector *sol_network_get_available_links(void);

char *sol_network_link_get_name(const struct sol_network_link *link);

int sol_network_link_up(uint16_t link_index);

int sol_network_link_down(uint16_t link_index);

struct sol_network_hostname_pending *
sol_network_get_hostname_address_info(const struct sol_str_slice hostname,
    enum sol_network_family family, void (*host_info_cb)(void *data,
    const struct sol_str_slice hostname, const struct sol_vector *addrs_list),
    const void *data);

int sol_network_hostname_pending_cancel(struct sol_network_hostname_pending *handle);

#ifdef __cplusplus
}
#endif