/** * 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; }