/**
* 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;
}
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;
}
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;
}
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);
}
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;
}
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;
}
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;
}
int main(int argc, char *argv[])
{
struct rtnl_link *link;
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;
}
link = rtnl_link_alloc();
rtnl_link_set_name(link, "my_bond");
if ((err = rtnl_link_delete(sk, link)) < 0) {
nl_perror(err, "Unable to delete link");
return err;
}
rtnl_link_put(link);
nl_close(sk);
return 0;
}
static inline struct nl_sock *nl80211_nl_socket_xalloc(void)
{
struct nl_sock *ret = nl_socket_alloc();
if (!ret)
panic("Cannot allocate nl socket memory!\n");
return ret;
}
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;
}
bool TaskstatsSocket::Open() {
std::unique_ptr<nl_sock, decltype(&nl_socket_free)> nl(
nl_socket_alloc(), nl_socket_free);
if (!nl.get()) {
LOG(ERROR) << "Failed to allocate netlink socket";
return false;
}
int ret = genl_connect(nl.get());
if (ret < 0) {
LOG(ERROR) << nl_geterror(ret) << std::endl << "Unable to open netlink socket (are you root?)";
return false;
}
int family_id = genl_ctrl_resolve(nl.get(), TASKSTATS_GENL_NAME);
if (family_id < 0) {
LOG(ERROR) << nl_geterror(family_id) << std::endl << "Unable to determine taskstats family id (does your kernel support taskstats?)";
return false;
}
nl_ = std::move(nl);
family_id_ = family_id;
return true;
}
GWaterNlSource *
g_water_nl_source_new_cache_mngr(GMainContext *context, gint protocol, gint flags, gint *error)
{
g_return_val_if_fail(error == NULL || *error == 0, NULL);
struct nl_sock *sock;
struct nl_cache_mngr *cache_mngr;
gint _inner_error_;
GWaterNlSource *self;
sock = nl_socket_alloc();
if ( sock == NULL )
return NULL;
_inner_error_ = nl_cache_mngr_alloc(sock, protocol, flags, &cache_mngr);
if ( _inner_error_ < 0 )
{
if ( error != NULL )
*error = _inner_error_;
return NULL;
}
self = g_water_nl_source_new_for_cache_mngr(context, cache_mngr);
self->sock = sock;
self->owned = TRUE;
return self;
}
void
ind_ovs_port_init(void)
{
int nlerr;
route_cache_sock = nl_socket_alloc();
if (route_cache_sock == NULL) {
LOG_ERROR("nl_socket_alloc failed");
abort();
}
if ((nlerr = nl_cache_mngr_alloc(route_cache_sock, NETLINK_ROUTE,
0, &route_cache_mngr)) < 0) {
LOG_ERROR("nl_cache_mngr_alloc failed: %s", nl_geterror(nlerr));
abort();
}
if ((nlerr = nl_cache_mngr_add(route_cache_mngr, "route/link", link_change_cb, NULL, &link_cache)) < 0) {
LOG_ERROR("nl_cache_mngr_add failed: %s", nl_geterror(nlerr));
abort();
}
if (ind_soc_socket_register(nl_cache_mngr_get_fd(route_cache_mngr),
(ind_soc_socket_ready_callback_f)route_cache_mngr_socket_cb,
NULL) < 0) {
LOG_ERROR("failed to register socket");
abort();
}
netlink_callbacks = nl_cb_alloc(NL_CB_DEFAULT);
if (netlink_callbacks == NULL) {
LOG_ERROR("failed to allocate netlink callbacks");
abort();
}
}
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 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;
}
int netem_init()
{
/* Allocate and initialize a new netlink handle */
if (!(sock = nl_socket_alloc())) {
fprintf(stderr, "Failed to alloc netlink socket\n");
return -EOPNOTSUPP;
}
/* Bind and connect socket to protocol, NETLINK_ROUTE in our case. */
if (nl_connect(sock, NETLINK_ROUTE) < 0) {
fprintf(stderr, "Failed to connect to kernel\n");
return -EOPNOTSUPP;
}
/* Retrieve a list of all available interfaces and populate cache. */
if (rtnl_link_alloc_cache(sock, AF_UNSPEC, &link_cache) < 0) {
fprintf(stderr, "Error creating link cache\n");
return -EOPNOTSUPP;
}
/* Retrieve a list of all available qdiscs and populate cache. */
if (rtnl_qdisc_alloc_cache(sock, &qdisc_cache) < 0) {
fprintf(stderr, "Error creating qdisc cache\n");
return -EOPNOTSUPP;
}
return 0;
}
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;
}
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 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;
}
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 int unl_init(struct unl *unl)
{
unl->sock = nl_socket_alloc();
if (!unl->sock)
return -1;
return 0;
}
struct nl_sock *match_nl_get_socket(void)
{
struct nl_sock *nsd = nl_socket_alloc();
nl_connect(nsd, NETLINK_GENERIC);
return nsd;
}
struct nl_sock *nl_cli_alloc_socket(void)
{
struct nl_sock *sock;
if (!(sock = nl_socket_alloc()))
nl_cli_fatal(ENOBUFS, "Unable to allocate netlink socket");
return sock;
}
int netlink_request(void *request, __u16 request_len, int (*cb)(struct nl_msg *, void *),
void *cb_arg)
{
struct nl_sock *sk;
enum nl_cb_type callbacks[] = { NL_CB_VALID, NL_CB_FINISH, NL_CB_ACK };
int i;
int error;
sk = nl_socket_alloc();
if (!sk) {
log_err(ERR_ALLOC_FAILED, "Could not allocate a socket; cannot speak to the NAT64.");
return -ENOMEM;
}
for (i = 0; i < (sizeof(callbacks) / sizeof(callbacks[0])); i++) {
error = nl_socket_modify_cb(sk, callbacks[i], NL_CB_CUSTOM, cb, cb_arg);
if (error < 0) {
log_err(ERR_NETLINK, "Could not register response handler. "
"I won't be able to parse the NAT64's response, so I won't send the request.\n"
"Netlink error message: %s (Code %d)", nl_geterror(error), error);
goto fail_free;
}
}
error = nl_connect(sk, NETLINK_USERSOCK);
if (error < 0) {
log_err(ERR_NETLINK, "Could not bind the socket to the NAT64.\n"
"Netlink error message: %s (Code %d)", nl_geterror(error), error);
goto fail_free;
}
error = nl_send_simple(sk, MSG_TYPE_NAT64, 0, request, request_len);
if (error < 0) {
log_err(ERR_NETLINK, "Could not send the request to the NAT64 (is it really up?).\n"
"Netlink error message: %s (Code %d)", nl_geterror(error), error);
goto fail_close;
}
error = nl_recvmsgs_default(sk);
if (error < 0) {
log_err(ERR_NETLINK, "%s (System error %d)", nl_geterror(error), error);
goto fail_close;
}
nl_close(sk);
nl_socket_free(sk);
return 0;
fail_close:
nl_close(sk);
/* Fall through. */
fail_free:
nl_socket_free(sk);
return -EINVAL;
}
static int nl80211_init(void)
{
int err, fd;
if (!nls)
{
nls = malloc(sizeof(struct nl80211_state));
if (!nls) {
err = -ENOMEM;
goto err;
}
memset(nls, 0, sizeof(*nls));
nls->nl_sock = nl_socket_alloc();
if (!nls->nl_sock) {
err = -ENOMEM;
goto err;
}
if (genl_connect(nls->nl_sock)) {
err = -ENOLINK;
goto err;
}
fd = nl_socket_get_fd(nls->nl_sock);
if (fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC) < 0) {
err = -EINVAL;
goto err;
}
if (genl_ctrl_alloc_cache(nls->nl_sock, &nls->nl_cache)) {
err = -ENOMEM;
goto err;
}
nls->nl80211 = genl_ctrl_search_by_name(nls->nl_cache, "nl80211");
if (!nls->nl80211) {
err = -ENOENT;
goto err;
}
nls->nlctrl = genl_ctrl_search_by_name(nls->nl_cache, "nlctrl");
if (!nls->nlctrl) {
err = -ENOENT;
goto err;
}
}
return 0;
err:
nl80211_close();
return err;
}
LinuxPlatformBackend::LinuxPlatformBackend (QObject *parent)
: PlatformBackend (parent)
, Rtsock_ (nl_socket_alloc ())
{
if (nl_connect (Rtsock_, NETLINK_ROUTE) >= 0)
rtnl_link_alloc_cache (Rtsock_, AF_UNSPEC, &LinkCache_);
else
qWarning () << Q_FUNC_INFO
<< "unable to establish netlink conn";
}
int main(int argc, char *argv[])
{
struct nl_cache *link_cache;
struct rtnl_link *link, *link2;
struct nl_sock *sk;
uint32_t tb_id;
int err;
sk = nl_socket_alloc();
if ((err = nl_connect(sk, NETLINK_ROUTE)) < 0) {
nl_perror(err, "Unable to connect socket");
return err;
}
if (!(link = rtnl_link_vrf_alloc())) {
fprintf(stderr, "Unable to allocate link");
return -1;
}
rtnl_link_set_name(link, "vrf-red");
if ((err = rtnl_link_vrf_set_tableid(link, 10)) < 0) {
nl_perror(err, "Unable to set VRF table id");
return err;
}
if ((err = rtnl_link_add(sk, link, NLM_F_CREATE)) < 0) {
nl_perror(err, "Unable to add link");
return err;
}
if ((err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache)) < 0) {
nl_perror(err, "Unable to allocate cache");
return err;
}
if (!(link2 = rtnl_link_get_by_name(link_cache, "vrf-red"))) {
fprintf(stderr, "Unable to lookup vrf-red");
return -1;
}
if ((err = rtnl_link_vrf_get_tableid(link2, &tb_id)) < 0) {
nl_perror(err, "Unable to get VRF table id");
return err;
}
if (tb_id != 10) {
fprintf(stderr, "Mismatch with VRF table id\n");
}
rtnl_link_put(link);
nl_close(sk);
return 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;
}
int main(int argc, char *argv[])
{
struct nl_cache *link_cache;
struct rtnl_link *link;
struct in_addr addr;
struct nl_sock *sk;
int err, if_index;
sk = nl_socket_alloc();
if ((err = nl_connect(sk, NETLINK_ROUTE)) < 0) {
nl_perror(err, "Unable to connect socket");
return err;
}
err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache);
if ( err < 0) {
nl_perror(err, "Unable to allocate cache");
return err;
}
if_index = rtnl_link_name2i(link_cache, "eno16777736");
if (!if_index) {
fprintf(stderr, "Unable to lookup eno16777736");
return -1;
}
link = rtnl_link_sit_alloc();
if(!link) {
nl_perror(err, "Unable to allocate link");
return -1;
}
rtnl_link_set_name(link, "sit-tun");
rtnl_link_sit_set_link(link, if_index);
inet_pton(AF_INET, "192.168.254.12", &addr.s_addr);
rtnl_link_sit_set_local(link, addr.s_addr);
inet_pton(AF_INET, "192.168.254.13", &addr.s_addr);
rtnl_link_sit_set_remote(link, addr.s_addr);
rtnl_link_sit_set_ttl(link, 64);
err = rtnl_link_add(sk, link, NLM_F_CREATE);
if (err < 0) {
nl_perror(err, "Unable to add link");
return err;
}
rtnl_link_put(link);
nl_close(sk);
return 0;
}
int main(int argc, char *argv[])
{
struct nl_cache *link_cache;
struct rtnl_link *link;
struct in6_addr addr;
struct nl_sock *sk;
int err, if_index;
sk = nl_socket_alloc();
if ((err = nl_connect(sk, NETLINK_ROUTE)) < 0) {
nl_perror(err, "Unable to connect socket");
return err;
}
err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache);
if ( err < 0) {
nl_perror(err, "Unable to allocate cache");
return err;
}
if_index = rtnl_link_name2i(link_cache, "ens33");
if (!if_index) {
fprintf(stderr, "Unable to lookup ens33");
return -1;
}
link = rtnl_link_ip6_tnl_alloc();
if(!link) {
nl_perror(err, "Unable to allocate link");
return -1;
}
rtnl_link_set_name(link, "ip6tnl-tun");
rtnl_link_ip6_tnl_set_link(link, if_index);
inet_pton(AF_INET6, "2607:f0d0:1002:51::4", &addr);
rtnl_link_ip6_tnl_set_local(link, &addr);
inet_pton(AF_INET6, "2607:f0d0:1002:52::5", &addr);
rtnl_link_ip6_tnl_set_remote(link, &addr);
err = rtnl_link_add(sk, link, NLM_F_CREATE);
if (err < 0) {
nl_perror(err, "Unable to add link");
return err;
}
rtnl_link_put(link);
nl_close(sk);
return 0;
}
