int ipvs_nl_send_message(struct nl_msg *msg, nl_recvmsg_msg_cb_t func, void *arg)
{
int err = EINVAL;
sock = nl_socket_alloc();
if (!sock) {
nlmsg_free(msg);
return -1;
}
if (genl_connect(sock) < 0)
goto fail_genl;
family = genl_ctrl_resolve(sock, IPVS_GENL_NAME);
if (family < 0)
goto fail_genl;
/* To test connections and set the family */
if (msg == NULL) {
nl_socket_free(sock);
sock = NULL;
return 0;
}
if (nl_socket_modify_cb(sock, NL_CB_VALID, NL_CB_CUSTOM, func, arg) != 0)
goto fail_genl;
if (nl_send_auto_complete(sock, msg) < 0)
goto fail_genl;
if ((err = -nl_recvmsgs_default(sock)) > 0)
goto fail_genl;
nlmsg_free(msg);
nl_socket_free(sock);
return 0;
fail_genl:
nl_socket_free(sock);
sock = NULL;
nlmsg_free(msg);
errno = err;
#ifndef FALLBACK_LIBNL1
errno = nlerr2syserr(err);
#endif
return -1;
}
static gboolean
sync_connection_setup (NMNetlinkMonitor *self, GError **error)
{
NMNetlinkMonitorPrivate *priv = NM_NETLINK_MONITOR_GET_PRIVATE (self);
/* Set up the event listener connection */
priv->nlh_sync = nl_socket_alloc ();
if (!priv->nlh_sync) {
g_set_error (error, NM_NETLINK_MONITOR_ERROR,
NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE,
_("unable to allocate netlink handle for monitoring link status: %s"),
nl_geterror (ENOMEM));
goto error;
}
if (!nlh_setup (priv->nlh_sync, NULL, self, error))
goto error;
return TRUE;
error:
if (priv->nlh_sync) {
nl_socket_free (priv->nlh_sync);
priv->nlh_sync = NULL;
}
return FALSE;
}
void
ind_ovs_port_deleted(uint32_t port_no)
{
assert(port_no < IND_OVS_MAX_PORTS);
struct ind_ovs_port *port = ind_ovs_ports[port_no];
if (port == NULL) {
return;
}
ind_ovs_upcall_quiesce(port);
ind_ovs_upcall_unregister(port);
if (port_status_notify(port_no, OF_PORT_CHANGE_REASON_DELETE) < 0) {
LOG_ERROR("failed to notify controller of port deletion");
}
LOG_INFO("Deleted port %s", port->ifname);
ind_ovs_fwd_write_lock();
nl_socket_free(port->notify_socket);
pthread_mutex_destroy(&port->quiesce_lock);
pthread_cond_destroy(&port->quiesce_cvar);
free(port);
ind_ovs_ports[port_no] = NULL;
ind_ovs_fwd_write_unlock();
ind_ovs_kflow_invalidate_all();
}
/**
* Allocate new cache manager
* @arg sk Netlink socket or NULL to auto allocate
* @arg protocol Netlink protocol this manager is used for
* @arg flags Flags (\c NL_AUTO_PROVIDE)
* @arg result Result pointer
*
* Allocates a new cache manager for the specified netlink protocol.
*
* 1. If sk is not specified (\c NULL) a netlink socket matching the
* specified protocol will be automatically allocated.
*
* 2. The socket will be put in non-blocking mode and sequence checking
* will be disabled regardless of whether the socket was provided by
* the caller or automatically allocated.
*
* 3. The socket will be connected.
*
* If the flag \c NL_AUTO_PROVIDE is specified, any cache added to the
* manager will automatically be made available to other users using
* nl_cache_mngt_provide().
*
* @note If the socket is provided by the caller, it is NOT recommended
* to use the socket for anything else besides receiving netlink
* notifications.
*
* @return 0 on success or a negative error code.
*/
int nl_cache_mngr_alloc(struct nl_sock *sk, int protocol, int flags,
struct nl_cache_mngr **result)
{
struct nl_cache_mngr *mngr;
int err = -NLE_NOMEM;
/* Catch abuse of flags */
if (flags & NL_ALLOCATED_SOCK)
BUG();
mngr = calloc(1, sizeof(*mngr));
if (!mngr)
return -NLE_NOMEM;
if (!sk) {
if (!(sk = nl_socket_alloc()))
goto errout;
flags |= NL_ALLOCATED_SOCK;
}
mngr->cm_sock = sk;
mngr->cm_nassocs = NASSOC_INIT;
mngr->cm_protocol = protocol;
mngr->cm_flags = flags;
mngr->cm_assocs = calloc(mngr->cm_nassocs,
sizeof(struct nl_cache_assoc));
if (!mngr->cm_assocs)
goto errout;
/* Required to receive async event notifications */
nl_socket_disable_seq_check(mngr->cm_sock);
if ((err = nl_connect(mngr->cm_sock, protocol)) < 0)
goto errout;
if ((err = nl_socket_set_nonblocking(mngr->cm_sock)) < 0)
goto errout;
/* Create and allocate socket for sync cache fills */
mngr->cm_sync_sock = nl_socket_alloc();
if (!mngr->cm_sync_sock) {
err = -NLE_NOMEM;
goto errout;
}
if ((err = nl_connect(mngr->cm_sync_sock, protocol)) < 0)
goto errout_free_sync_sock;
NL_DBG(1, "Allocated cache manager %p, protocol %d, %d caches\n",
mngr, protocol, mngr->cm_nassocs);
*result = mngr;
return 0;
errout_free_sync_sock:
nl_socket_free(mngr->cm_sync_sock);
errout:
nl_cache_mngr_free(mngr);
return err;
}
void
tools_delete_router_address (const gchar *address)
{
struct nl_sock *sock = NULL;
struct nl_addr *dst = NULL;
struct nl_addr *gw = NULL;
struct rtnl_nexthop *nhop = NULL;
struct rtnl_route *route = NULL;
sock = nl_socket_alloc ();
nl_connect (sock, NETLINK_ROUTE);
nhop = rtnl_route_nh_alloc ();
nl_addr_parse (address, AF_INET, &gw);
rtnl_route_nh_set_gateway (nhop, gw);
rtnl_route_nh_set_flags (nhop, 0);
route = rtnl_route_alloc ();
rtnl_route_set_family (route, AF_INET);
nl_addr_parse ("default", AF_INET, &dst);
rtnl_route_add_nexthop (route, nhop);
if (rtnl_route_delete (sock, route, NLM_F_CREATE | NLM_F_REPLACE) != 0)
g_warning (_("Failed to delete default route."));
nl_socket_free (sock);
rtnl_route_put (route);
nl_addr_put (dst);
nl_addr_put (gw);
}
void
iface_mon_stop(void)
{
if(iface_mon_sock)
nl_socket_free(iface_mon_sock);
iface_mon_sock = NULL;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_msg *msg;
void *hdr;
int err;
sock = nlt_alloc_socket();
nlt_connect(sock, NETLINK_GENERIC);
msg = nlmsg_alloc();
if (msg == NULL)
fatal(NLE_NOMEM, "Unable to allocate netlink message");
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, GENL_ID_CTRL,
0, 0, CTRL_CMD_GETFAMILY, 1);
if (hdr == NULL)
fatal(ENOMEM, "Unable to write genl header");
if ((err = nla_put_u32(msg, CTRL_ATTR_FAMILY_ID, GENL_ID_CTRL)) < 0)
fatal(err, "Unable to add attribute: %s", nl_geterror(err));
if ((err = nl_send_auto_complete(sock, msg)) < 0)
fatal(err, "Unable to send message: %s", nl_geterror(err));
if ((err = nl_recvmsgs_default(sock)) < 0)
fatal(err, "Unable to receive message: %s", nl_geterror(err));
nlmsg_free(msg);
nl_close(sock);
nl_socket_free(sock);
return 0;
}
int
iface_mon_start(iface_mon_cb cb)
{
int err;
iface_mon_sock = nl_socket_alloc();
if (!iface_mon_sock) {
fprintf(stderr, "Failed to allocate netlink socket.\n");
return -ENOMEM;
}
nl_socket_disable_seq_check(iface_mon_sock);
nl_socket_modify_cb(iface_mon_sock, NL_CB_VALID, NL_CB_CUSTOM, iface_mon_handler, cb);
if (nl_connect(iface_mon_sock, NETLINK_ROUTE)) {
fprintf(stderr, "Failed to connect to generic netlink.\n");
err = -ENOLINK;
goto out_handle_destroy;
}
nl_socket_add_membership(iface_mon_sock, RTNLGRP_LINK);
return 0;
out_handle_destroy:
nl_socket_free(iface_mon_sock);
return err;
}
/**
* Free cache manager and all caches.
* @arg mngr Cache manager.
*
* Release all resources held by a cache manager.
*/
void nl_cache_mngr_free(struct nl_cache_mngr *mngr)
{
int i;
if (!mngr)
return;
if (mngr->cm_sock)
nl_close(mngr->cm_sock);
if (mngr->cm_flags & NL_ALLOCATED_SOCK)
nl_socket_free(mngr->cm_sock);
for (i = 0; i < mngr->cm_nassocs; i++) {
if (mngr->cm_assocs[i].ca_cache) {
nl_cache_mngt_unprovide(mngr->cm_assocs[i].ca_cache);
nl_cache_free(mngr->cm_assocs[i].ca_cache);
}
}
free(mngr->cm_assocs);
free(mngr);
NL_DBG(1, "Cache manager %p freed\n", mngr);
}
int sysnet_interface_set_mtu(VPNInterface *i, unsigned int mtu)
{
int err;
struct nl_cache *link_cache;
struct nl_sock *sock;
struct rtnl_link *link;
struct rtnl_link *new_link;
sock = nl_socket_alloc();
nl_connect(sock, NETLINK_ROUTE);
rtnl_link_alloc_cache(sock, AF_UNSPEC, &link_cache);
link = rtnl_link_get_by_name(link_cache, i->name);
new_link = rtnl_link_alloc();
if (!link)
{
tox_trace(i->context->tox, "can't find link \"%s\"", i->name);
return -1;
}
rtnl_link_set_mtu(new_link, mtu);
if ((err = rtnl_link_change(sock, link, new_link, 0)) < 0) {
tox_trace(i->context->tox, "unable to change link \"%s\" flags: %s", rtnl_link_get_name(link), nl_geterror(err));
}
rtnl_link_put(link);
rtnl_link_put(new_link);
nl_cache_free(link_cache);
nl_socket_free(sock);
return 0;
}
static int open_netlink(void)
{
int err;
if (sock != NULL)
return 0;
if (nl_failed != 0) /* don't bother re-opening */
return -1;
sock = nl_socket_alloc();
if (sock == NULL) {
fprintf(stderr, "nl: cannot open netlink\n");
goto error;
}
if ((err = nl_connect(sock, NETLINK_ROUTE)) < 0) {
fprintf(stderr, "nl: error in nl_connect");
goto error;
}
return 0;
error:
if (sock != NULL) {
nl_socket_free(sock);
sock = NULL;
}
nl_failed = 1;
return -1;
}
static void nl80211_cleanup(struct nl80211_state *state)
{
genl_family_put(state->nl80211);
nl_cache_free(state->nl_cache);
nl_socket_free(state->nl_sock);
}
static int nl80211_init(struct nl80211_state *state)
{
int err;
state->nl_sock = nl_socket_alloc();
if (!state->nl_sock) {
fprintf(stderr, "Failed to allocate netlink socket.\n");
return -ENOMEM;
}
nl_socket_set_buffer_size(state->nl_sock, 8192, 8192);
if (genl_connect(state->nl_sock)) {
fprintf(stderr, "Failed to connect to generic netlink.\n");
err = -ENOLINK;
goto out_handle_destroy;
}
state->nl80211_id = genl_ctrl_resolve(state->nl_sock, "nl80211");
if (state->nl80211_id < 0) {
fprintf(stderr, "nl80211 not found.\n");
err = -ENOENT;
goto out_handle_destroy;
}
return 0;
out_handle_destroy:
nl_socket_free(state->nl_sock);
return err;
}
static nl_sock * wifi_create_nl_socket(int port)
{
// ALOGI("Creating socket");
struct nl_sock *sock = nl_socket_alloc();
if (sock == NULL) {
ALOGE("Could not create handle");
return NULL;
}
wifi_socket_set_local_port(sock, port);
struct sockaddr_nl *addr_nl = &(sock->s_local);
/* ALOGI("socket address is %d:%d:%d:%d",
addr_nl->nl_family, addr_nl->nl_pad, addr_nl->nl_pid, addr_nl->nl_groups); */
struct sockaddr *addr = NULL;
// ALOGI("sizeof(sockaddr) = %d, sizeof(sockaddr_nl) = %d", sizeof(*addr), sizeof(*addr_nl));
// ALOGI("Connecting socket");
if (nl_connect(sock, NETLINK_GENERIC)) {
ALOGE("Could not connect handle");
nl_socket_free(sock);
return NULL;
}
ALOGI("Socket Value:%p", sock);
return sock;
}
int dhd_nl_sock_connect(struct dhd_netlink_info *dhd_nli)
{
dhd_nli->nl = nl_socket_alloc();
if (dhd_nli->nl == NULL)
return -1;
if (genl_connect(dhd_nli->nl) < 0) {
fprintf(stderr, "netlink connection failed\n");
goto err;
}
dhd_nli->nl_id = genl_ctrl_resolve(dhd_nli->nl, "nl80211");
if (dhd_nli->nl_id < 0) {
fprintf(stderr, "'nl80211' netlink not found\n");
goto err;
}
dhd_nli->cb = nl_cb_alloc(NL_CB_DEBUG);
if (dhd_nli->cb == NULL)
goto err;
nl_socket_set_cb(dhd_nli->nl, dhd_nli->cb);
return 0;
err:
nl_cb_put(dhd_nli->cb);
nl_socket_free(dhd_nli->nl);
fprintf(stderr, "nl80211 connection failed\n");
return -1;
}
static gboolean
event_connection_setup (NMNetlinkMonitor *self, GError **error)
{
NMNetlinkMonitorPrivate *priv = NM_NETLINK_MONITOR_GET_PRIVATE (self);
GError *channel_error = NULL;
GIOFlags channel_flags;
int fd;
g_return_val_if_fail (priv->io_channel == NULL, FALSE);
/* Set up the event listener connection */
priv->nlh_event = nl_socket_alloc ();
if (!priv->nlh_event) {
g_set_error (error, NM_NETLINK_MONITOR_ERROR,
NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE,
_("unable to allocate netlink handle for monitoring link status: %s"),
nl_geterror (ENOMEM));
goto error;
}
if (!nlh_setup (priv->nlh_event, event_msg_ready, self, error))
goto error;
nl_socket_disable_seq_check (priv->nlh_event);
/* Subscribe to the LINK group for internal carrier signals */
if (!nm_netlink_monitor_subscribe (self, RTNLGRP_LINK, error))
goto error;
fd = nl_socket_get_fd (priv->nlh_event);
priv->io_channel = g_io_channel_unix_new (fd);
g_io_channel_set_encoding (priv->io_channel, NULL, &channel_error);
/* Encoding is NULL, so no conversion error can possibly occur */
g_assert (channel_error == NULL);
g_io_channel_set_close_on_unref (priv->io_channel, TRUE);
channel_flags = g_io_channel_get_flags (priv->io_channel);
channel_error = NULL;
g_io_channel_set_flags (priv->io_channel,
channel_flags | G_IO_FLAG_NONBLOCK,
&channel_error);
if (channel_error != NULL) {
g_propagate_error (error, channel_error);
goto error;
}
return TRUE;
error:
if (priv->io_channel)
nm_netlink_monitor_close_connection (self);
if (priv->nlh_event) {
nl_socket_free (priv->nlh_event);
priv->nlh_event = NULL;
}
return FALSE;
}
static gboolean
sync_connection_setup (NMNetlinkMonitor *self, GError **error)
{
NMNetlinkMonitorPrivate *priv = NM_NETLINK_MONITOR_GET_PRIVATE (self);
#ifdef LIBNL_NEEDS_ADDR_CACHING_WORKAROUND
struct nl_cache *addr_cache;
#endif
int err;
/* Set up the event listener connection */
priv->nlh_sync = nl_socket_alloc ();
if (!priv->nlh_sync) {
g_set_error (error, NM_NETLINK_MONITOR_ERROR,
NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE,
_("unable to allocate netlink handle for monitoring link status: %s"),
nl_geterror (ENOMEM));
goto error;
}
if (!nlh_setup (priv->nlh_sync, NULL, self, error))
goto error;
#ifdef LIBNL_NEEDS_ADDR_CACHING_WORKAROUND
/* Work around apparent libnl bug; rtnl_addr requires that all
* addresses have the "peer" attribute set in order to be compared
* for equality, but this attribute is not normally set. As a
* result, most addresses will not compare as equal even to
* themselves, busting caching.
*/
rtnl_addr_alloc_cache (priv->nlh_sync, &addr_cache);
g_warn_if_fail (addr_cache != NULL);
nl_cache_get_ops (addr_cache)->co_obj_ops->oo_id_attrs &= ~0x80;
nl_cache_free (addr_cache);
#endif
err = rtnl_link_alloc_cache (priv->nlh_sync, AF_UNSPEC, &priv->link_cache);
if (err < 0) {
g_set_error (error, NM_NETLINK_MONITOR_ERROR,
NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_LINK_CACHE,
_("unable to allocate netlink link cache for monitoring link status: %s"),
nl_geterror (err));
goto error;
}
nl_cache_mngt_provide (priv->link_cache);
return TRUE;
error:
if (priv->link_cache) {
nl_cache_free (priv->link_cache);
priv->link_cache = NULL;
}
if (priv->nlh_sync) {
nl_socket_free (priv->nlh_sync);
priv->nlh_sync = NULL;
}
return FALSE;
}
void
ind_ovs_port_finish(void)
{
ind_soc_socket_unregister(nl_cache_mngr_get_fd(route_cache_mngr));
nl_cache_mngr_free(route_cache_mngr);
nl_socket_free(route_cache_sock);
}
int match_nl_table_cmd_to_type(FILE *fp, bool print, int valid,
struct nlattr *tb[])
{
unsigned int type, ifindex;
int err;
char iface[IFNAMSIZ];
struct nl_sock *fd = NULL;
if (!tb[NET_MAT_IDENTIFIER_TYPE]) {
MAT_LOG(ERR,
"Warning: received rule msg without identifier type!\n");
return -EINVAL;
}
if (!tb[NET_MAT_IDENTIFIER]) {
MAT_LOG(ERR,
"Warning: received rule msg without identifier!\n");
return -EINVAL;
}
if (valid > 0 && !tb[valid]) {
MAT_LOG(ERR, "Warning: received cmd without valid attribute expected %i\n", valid);
return -ENOMSG;
}
if (nla_len(tb[NET_MAT_IDENTIFIER_TYPE]) < (int)sizeof(type)) {
MAT_LOG(ERR, "Warning: invalid identifier type len\n");
return -EINVAL;
}
type = nla_get_u32(tb[NET_MAT_IDENTIFIER_TYPE]);
switch (type) {
case NET_MAT_IDENTIFIER_IFINDEX:
fd = nl_socket_alloc();
err = nl_connect(fd, NETLINK_ROUTE);
if (err < 0) {
MAT_LOG(ERR,"Warning: Unable to connect socket\n");
break;
}
err = rtnl_link_alloc_cache(fd, AF_UNSPEC, &link_cache);
if (err < 0) {
MAT_LOG(ERR,"Warning: Unable to allocate cache\n");
break;
}
ifindex = nla_get_u32(tb[NET_MAT_IDENTIFIER]);
rtnl_link_i2name(link_cache, (int)ifindex, iface, IFNAMSIZ);
if (ifindex)
pfprintf(fp, print, "%s (%u):\n", iface, ifindex);
break;
default:
MAT_LOG(ERR, "Warning: unknown interface identifier type %i\n", type);
break;
}
if (fd) {
nl_close(fd);
nl_socket_free(fd);
}
return 0;
}
static bool nl80211_init()
{
int err;
sock = nl_socket_alloc();
if (!sock) {
fprintf(stderr, "failed to allocate netlink socket\n");
goto out;
}
err = genl_connect(sock);
if (err) {
nl_perror(err, "failed to make generic netlink connection");
goto out;
}
err = genl_ctrl_alloc_cache(sock, &cache);
if (err) {
nl_perror(err, "failed to allocate netlink controller cache");
goto out;
}
family = genl_ctrl_search_by_name(cache, NL80211_GENL_NAME);
if (!family) {
fprintf(stderr, "failed to find nl80211\n");
goto out;
}
return true;
out:
genl_family_put(family);
nl_cache_free(cache);
nl_socket_free(sock);
return false;
}
static nl_sock * wifi_create_nl_socket(int port)
{
// ALOGI("Creating socket");
struct nl_sock *sock = nl_socket_alloc();
if (sock == NULL) {
ALOGE("Could not create handle");
return NULL;
}
wifi_socket_set_local_port(sock, port);
struct sockaddr *addr = NULL;
// ALOGI("sizeof(sockaddr) = %d, sizeof(sockaddr_nl) = %d", sizeof(*addr), sizeof(*addr_nl));
// ALOGI("Connecting socket");
if (nl_connect(sock, NETLINK_GENERIC)) {
ALOGE("Could not connect handle");
nl_socket_free(sock);
return NULL;
}
// ALOGI("Making socket nonblocking");
/*
if (nl_socket_set_nonblocking(sock)) {
ALOGE("Could make socket non-blocking");
nl_socket_free(sock);
return NULL;
}
*/
return sock;
}
void TNl::Disconnect() {
if (Sock) {
nl_close(Sock);
nl_socket_free(Sock);
Sock = nullptr;
}
}
static void internal_cleaned_up_handler(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
wifi_cleaned_up_handler cleaned_up_handler = info->cleaned_up_handler;
if (info->cmd_sock != 0) {
nl_socket_free(info->cmd_sock);
nl_socket_free(info->event_sock);
info->cmd_sock = NULL;
info->event_sock = NULL;
}
if (info->cldctx != NULL) {
cld80211lib_cleanup(info);
} else if (info->user_sock != 0) {
nl_socket_free(info->user_sock);
info->user_sock = NULL;
}
if (info->pkt_stats)
free(info->pkt_stats);
if (info->rx_aggr_pkts)
free(info->rx_aggr_pkts);
wifi_logger_ring_buffers_deinit(info);
cleanupGscanHandlers(info);
cleanupRSSIMonitorHandler(info);
if (info->exit_sockets[0] >= 0) {
close(info->exit_sockets[0]);
info->exit_sockets[0] = -1;
}
if (info->exit_sockets[1] >= 0) {
close(info->exit_sockets[1]);
info->exit_sockets[1] = -1;
}
if (info->pkt_fate_stats) {
free(info->pkt_fate_stats);
info->pkt_fate_stats = NULL;
}
(*cleaned_up_handler)(handle);
pthread_mutex_destroy(&info->cb_lock);
pthread_mutex_destroy(&info->pkt_fate_stats_lock);
free(info);
}
static void internal_cleaned_up_handler(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
wifi_cleaned_up_handler cleaned_up_handler = info->cleaned_up_handler;
if (info->cmd_sock != 0) {
nl_socket_free(info->cmd_sock);
nl_socket_free(info->event_sock);
info->cmd_sock = NULL;
info->event_sock = NULL;
}
(*cleaned_up_handler)(handle);
free(info);
ALOGI("Internal cleanup completed");
}
void ompi_btl_usnic_rtnl_sk_free(struct usnic_rtnl_sk *unlsk)
{
if (unlsk != NULL) {
nl_close(unlsk->sock);
nl_socket_free(unlsk->sock);
free(unlsk);
}
}
int nl80211_connect(const char *interface, void **handle, void **cache,
void **family, char *errstr) {
#ifndef HAVE_LINUX_NETLINK
snprintf(errstr, LORCON_STATUS_MAX, "LORCON was not compiled with netlink/nl80211 "
"support, check the output of ./configure for why");
return -1;
#else
struct nl_sock *nl_handle;
struct nl_cache *nl_cache;
struct genl_family *nl80211;
if ((nl_handle = nl_socket_alloc()) == NULL) {
snprintf(errstr, LORCON_STATUS_MAX, "%s failed to allocate nlhandle",
__FUNCTION__);
return -1;
}
if (genl_connect(nl_handle)) {
snprintf(errstr, LORCON_STATUS_MAX, "%s failed to connect to generic netlink",
__FUNCTION__);
nl_socket_free(nl_handle);
return -1;
}
if (genl_ctrl_alloc_cache(nl_handle, &nl_cache) != 0) {
snprintf(errstr, LORCON_STATUS_MAX, "%s failed to allocate "
"generic netlink cache", __FUNCTION__);
nl_socket_free(nl_handle);
return -1;
}
if ((nl80211 = genl_ctrl_search_by_name(nl_cache, "nl80211")) == NULL) {
snprintf(errstr, LORCON_STATUS_MAX, "%s failed to find "
"nl80211 controls, kernel may be too old", __FUNCTION__);
nl_socket_free(nl_handle);
return -1;
}
(*handle) = (void *) nl_handle;
(*cache) = (void *) nl_cache;
(*family) = (void *) nl80211;
return 1;
#endif
}
static void
wifi_nl80211_deinit (WifiData *parent)
{
WifiDataNl80211 *nl80211 = (WifiDataNl80211 *) parent;
if (nl80211->nl_sock)
nl_socket_free (nl80211->nl_sock);
if (nl80211->nl_cb)
nl_cb_put (nl80211->nl_cb);
}
static void
_g_water_nl_source_finalize(GSource *source)
{
GWaterNlSource *self = (GWaterNlSource *)source;
if ( self->owned )
{
nl_socket_free(self->sock);
nl_cache_mngr_free(self->cache_mngr);
}
}
static void lib_fini(void)
{
if (lib_cfg.head == NULL) {
#ifdef KNET_LINUX
nl_close(lib_cfg.nlsock);
nl_socket_free(lib_cfg.nlsock);
#endif
close(lib_cfg.ioctlfd);
lib_init = 0;
}
}
int main(int argc, char *argv[])
{
struct rtnl_link *link;
struct nl_cache *link_cache;
struct nl_sock *sk;
int err;
sk = nl_socket_alloc();
if ((err = nl_connect(sk, NETLINK_ROUTE)) < 0) {
nl_perror(err, "Unable to connect socket");
return err;
}
if ((err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache)) < 0) {
nl_perror(err, "Unable to allocate cache");
return err;
}
if ((err = create_bridge(sk, link_cache, TEST_BRIDGE_NAME)) < 0) {
nl_perror(err, "Unable to allocate testbridge");
return err;
}
nl_cache_refill(sk, link_cache);
link = rtnl_link_get_by_name(link_cache, TEST_BRIDGE_NAME);
struct rtnl_link *ltap = rtnl_link_get_by_name(link_cache, TEST_INTERFACE_NAME);
if (!ltap) {
fprintf(stderr, "You should create a tap interface before lunch this test (# tunctl -t %s)\n", TEST_INTERFACE_NAME);
return -1;
}
if ((err = rtnl_link_enslave(sk, link, ltap)) < 0) {
nl_perror(err, "Unable to enslave interface to his bridge\n");
return err;
}
if(rtnl_link_is_bridge(link) == 0) {
fprintf(stderr, "Link is not a bridge\n");
return -2;
}
if(rtnl_link_get_master(ltap) <= 0) {
fprintf(stderr, "Interface is not attached to a bridge\n");
return -3;
}
rtnl_link_put(ltap);
rtnl_link_put(link);
nl_cache_free(link_cache);
nl_socket_free(sk);
return 0;
}
