sol-netctl.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 <stdint.h>
#include <sol-network.h>
#include <sol-buffer.h>
#include <sol-vector.h>


#ifdef __cplusplus
extern "C" {
#endif

struct sol_netctl_service;
typedef struct sol_netctl_service sol_netctl_service;

typedef struct sol_netctl_network_params {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_NETWORK_PARAMS_API_VERSION (1)

    uint16_t api_version;
#endif

    struct sol_network_link_addr addr;
    struct sol_network_link_addr netmask;
    struct sol_network_link_addr gateway;
} sol_netctl_network_params;

#define SOL_NETCTL_AGENT_NAME         "Name"    
#define SOL_NETCTL_AGENT_IDENTITY     "Identity"    
#define SOL_NETCTL_AGENT_PASSPHRASE   "Passphrase"    
#define SOL_NETCTL_AGENT_WPS          "WPS"    
#define SOL_NETCTL_AGENT_USERNAME     "Username"    
#define SOL_NETCTL_AGENT_PASSWORD     "Password"    
enum sol_netctl_service_state {
    /*
     * @brief the service is unknow
     *
     * a service is unknow when the service is init
     * and the service state can't be given.
     */
    SOL_NETCTL_SERVICE_STATE_UNKNOWN = 0,
    /*
     * @brief the service is idle
     *
     * a service is idle when the service is not in use
     * at all at the moment and it is not attempting to
     * connect or do anything.
     */
    SOL_NETCTL_SERVICE_STATE_IDLE,
    /*
     * @brief the service is association
     *
     * a service is association when the service tries to
     * establish a low-level connection to the network.
     */
    SOL_NETCTL_SERVICE_STATE_ASSOCIATION,
    /*
     * @brief the service is configuration
     *
     * a service is configuration when the service is trying to
     * retrieve/configure IP settings.
     */
    SOL_NETCTL_SERVICE_STATE_CONFIGURATION,
    /*
     * @brief the service is ready
     *
     * a service is ready when a successfully connected device.
     */
    SOL_NETCTL_SERVICE_STATE_READY,
    /*
     * @brief the service is online
     *
     * a service is online when an internet connection is available
     * and has been verified.
     */
    SOL_NETCTL_SERVICE_STATE_ONLINE,
    /*
     * @brief the service is disconnect
     *
     * a service is disconnect when the service is going to terminate
     * the current connection and will return to "idle".
     */
    SOL_NETCTL_SERVICE_STATE_DISCONNECT,
    /*
     * @brief the service is failure
     *
     * a service is failure when the service indicates a wrong behavior.
     */
    SOL_NETCTL_SERVICE_STATE_FAILURE,
    /*
     * @brief the service is remove
     *
     * a service is remove when the service is not available and removed
     * from the network system. At the same time, the service handle(pointer)
     * will become invalid.
     */
    SOL_NETCTL_SERVICE_STATE_REMOVE,
};

enum sol_netctl_proxy_method {
    SOL_NETCTL_PROXY_METHOD_DIRECT,
    SOL_NETCTL_PROXY_METHOD_AUTO,
    SOL_NETCTL_PROXY_METHOD_MANUAL,
};

typedef struct sol_netctl_proxy {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_PROXY_API_VERSION (1)

    uint16_t api_version;
#endif

    enum sol_netctl_proxy_method method;
    char *url;
    sol_ptr_vector servers;
    sol_ptr_vector excludes;
} sol_netctl_proxy;

typedef struct sol_netctl_provider {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_PROVIDER_API_VERSION (1)

    uint16_t api_version;
#endif

    char *host;
    char *domain;
    char *name;
    char *type;
} sol_netctl_provider;

typedef struct sol_netctl_ethernet {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_ETHERNET_API_VERSION (1)

    uint16_t api_version;
#endif

    char *method;
    char *interface;
    char *address;
    char *duplex;
    uint16_t mtu;
    uint16_t speed;
} sol_netctl_ethernet;

#define SOL_NETCTL_SERVICE_TYPE_ETHERNET   "ethernet"  
#define SOL_NETCTL_SERVICE_TYPE_WIFI       "wifi"      
#define SOL_NETCTL_SERVICE_TYPE_BLUETOOTH  "bluetooth" 
#define SOL_NETCTL_SERVICE_TYPE_CELLULAR   "cellular"   
#define SOL_NETCTL_SERVICE_TYPE_GPS        "gps"       
#define SOL_NETCTL_SERVICE_TYPE_VPN        "vpn"       
#define SOL_NETCTL_SERVICE_TYPE_GADGET     "gadget"    
#define SOL_NETCTL_SERVICE_TYPE_P2P        "p2p"       
enum sol_netctl_state {
    /*
     * @brief the state is unknow
     *
     * a state is unknow when the state is init
     * and the state can't be given.
     */
    SOL_NETCTL_STATE_UNKNOWN = 0,
    /*
     * @brief the state is idle
     *
     * a state is idle when no serives is in either "ready" or "online" state.
     */
    SOL_NETCTL_STATE_IDLE,
    /*
     * @brief the state is ready
     *
     * a state is ready when at least one service is in "ready"
     * state and no service is in "online" state.
     */
    SOL_NETCTL_STATE_READY,
    /*
     * @brief the state is online
     *
     * a state is online when at least one service is in "online".
     */
    SOL_NETCTL_STATE_ONLINE,
    /*
     * @brief the state is offline
     *
     * a state is offline when the device is in offline mode and
     * the user doesn't re-enable individual technologies like
     * WiFi and Bluetooth while in offline mode.
     */
    SOL_NETCTL_STATE_OFFLINE,
};

typedef struct sol_netctl_agent_input {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_AGENT_INPUT_API_VERSION (1)

    uint16_t api_version;
#endif

    char *type;
    char *input;
} sol_netctl_agent_input;

typedef struct sol_netctl_agent {
#ifndef SOL_NO_API_VERSION
#define SOL_NETCTL_AGENT_API_VERSION (1)
    uint16_t api_version;
#endif

    void (*report_error)(void *data, const struct sol_netctl_service *service,
        const char *error);
    void (*request_input)(void *data, const struct sol_netctl_service *service,
        const struct sol_ptr_vector *inputs);
    void (*cancel)(void *data);
    void (*release)(void *data);
} sol_netctl_agent;

typedef void (*sol_netctl_service_monitor_cb)
    (void *data,
    const struct sol_netctl_service *service);

typedef void (*sol_netctl_manager_monitor_cb)(void *data);

typedef void (*sol_netctl_error_monitor_cb)
    (void *data, const struct sol_netctl_service *service,
    unsigned int error);

const char *sol_netctl_service_get_name(
    const struct sol_netctl_service *service);

enum sol_netctl_service_state sol_netctl_service_get_state(
    const struct sol_netctl_service *service);

const struct sol_ptr_vector *
    sol_netctl_service_get_security(const struct sol_netctl_service *service);

const char *sol_netctl_service_get_error(
    const struct sol_netctl_service *service);

const char *sol_netctl_service_get_type(
    const struct sol_netctl_service *service);

int sol_netctl_service_get_network_address(
    const struct sol_netctl_service *service, struct sol_network_link **link);

int32_t sol_netctl_service_get_strength(
    const struct sol_netctl_service *service);

bool sol_netctl_service_is_favorite(
    const struct sol_netctl_service *service);

bool sol_netctl_service_is_immutable(
    const struct sol_netctl_service *service);

bool sol_netctl_service_is_autoconnect(
    const struct sol_netctl_service *service);

bool sol_netctl_service_is_roaming(
    const struct sol_netctl_service *service);

const struct sol_ptr_vector *
sol_netctl_service_get_nameservers(const struct sol_netctl_service *service);

const struct sol_ptr_vector *
sol_netctl_service_get_timeservers(const struct sol_netctl_service *service);

const struct sol_ptr_vector *
sol_netctl_service_get_domains(const struct sol_netctl_service *service);

const struct sol_netctl_proxy *
sol_netctl_service_get_proxy(const struct sol_netctl_service *service);

const struct sol_netctl_provider *
sol_netctl_service_get_provider(const struct sol_netctl_service *service);

const struct sol_netctl_ethernet *
sol_netctl_service_get_ethernet(const struct sol_netctl_service *service);

enum sol_netctl_state sol_netctl_get_state(void);

int sol_netctl_set_radios_offline(bool enabled);

bool sol_netctl_get_radios_offline(void);

int sol_netctl_service_connect(struct sol_netctl_service *service);

int sol_netctl_service_disconnect(struct sol_netctl_service *service);

int sol_netctl_add_service_monitor(sol_netctl_service_monitor_cb cb,
    const void *data);

int sol_netctl_del_service_monitor(sol_netctl_service_monitor_cb cb,
    const void *data);

int sol_netctl_add_manager_monitor(sol_netctl_manager_monitor_cb cb,
    const void *data);

int sol_netctl_del_manager_monitor(sol_netctl_manager_monitor_cb cb,
    const void *data);

int sol_netctl_add_error_monitor(sol_netctl_error_monitor_cb cb,
    const void *data);

int sol_netctl_del_error_monitor(sol_netctl_error_monitor_cb cb,
    const void *data);
const struct sol_ptr_vector *sol_netctl_get_services(void);

enum sol_netctl_service_state sol_netctl_service_state_from_str(const char *state)
#ifndef DOXYGEN_RUN
SOL_ATTR_WARN_UNUSED_RESULT
#endif
;

const char *sol_netctl_service_state_to_str(enum sol_netctl_service_state state)
#ifndef DOXYGEN_RUN
SOL_ATTR_WARN_UNUSED_RESULT
#endif
;

static inline struct sol_netctl_service *
sol_netctl_find_service_by_name(const char *service_name)
{
    const struct sol_ptr_vector *service_list;
    struct sol_netctl_service *service;
    const char *name;
    uint16_t i;

    service_list = sol_netctl_get_services();
    if (!service_list)
        return NULL;

    SOL_PTR_VECTOR_FOREACH_IDX (service_list, service, i) {
        name = sol_netctl_service_get_name(service);
        if (name && strcmp(name, service_name) == 0)
            return service;
    }
    return NULL;
}

int sol_netctl_register_agent(const struct sol_netctl_agent *agent, const void *data);

int sol_netctl_unregister_agent(void);

int sol_netctl_request_retry(struct sol_netctl_service *service,
    bool retry);

int sol_netctl_request_input(struct sol_netctl_service *service,
    const struct sol_ptr_vector *inputs);

int sol_netctl_scan(void);

#ifdef __cplusplus
}
#endif