TError TNlLink::AddAddress(const TNlAddr &addr) {
struct rtnl_addr *a = rtnl_addr_alloc();
if (!a)
return TError(EError::Unknown, "Cannot allocate address");
rtnl_addr_set_link(a, Link);
rtnl_addr_set_family(a, nl_addr_get_family(addr.Addr));
rtnl_addr_set_flags(a, IFA_F_NODAD);
int ret = rtnl_addr_set_local(a, addr.Addr);
if (ret < 0) {
rtnl_addr_put(a);
return Error(ret, "Cannot set local address");
}
ret = rtnl_addr_add(GetSock(), a, 0);
if (ret < 0) {
rtnl_addr_put(a);
return Error(ret, "Cannot add address");
}
rtnl_addr_put(a);
return TError::Success();
}
/*
* Get the first AF_INET address on 'link'. Returns 0 if successful. Caller
* must release reference to *addr.
*/
static int get_link_inet_addr(struct nl_sock *sk, struct rtnl_link *link,
struct nl_addr **addr)
{
struct nl_cache *addr_cache;
int err;
err = rtnl_addr_alloc_cache(sk, &addr_cache);
if (err < 0) {
warnx("rtnl_addr_alloc_cache() failed: %s", nl_geterror(err));
return 1;
}
/* Retrieve the first AF_INET address on the requested interface. */
struct rtnl_addr *filter;
filter = rtnl_addr_alloc();
assert(filter);
rtnl_addr_set_ifindex(filter, rtnl_link_get_ifindex(link));
rtnl_addr_set_family(filter, AF_INET);
*addr = NULL;
nl_cache_foreach_filter(addr_cache, (struct nl_object *)filter,
match_first_addr, addr);
if (*addr == NULL) {
warnx("No AF_INET address found on veth");
rtnl_addr_put(filter);
nl_cache_free(addr_cache);
return 1;
}
rtnl_addr_put(filter);
nl_cache_free(addr_cache);
return 0;
}
int main(int argc, char *argv[])
{
struct nl_handle *nlh;
struct rtnl_addr *addr;
struct nl_addr *local;
int err = 1;
if (argc < 3 || !strcmp(argv[1], "-h")) {
printf("Usage: nl-addr-delete <addr> <ifindex>\n");
goto errout;
}
if (nltool_init(argc, argv) < 0)
goto errout;
nlh = nltool_alloc_handle();
if (!nlh)
goto errout;
addr = rtnl_addr_alloc();
if (!addr)
goto errout_free_handle;
if (nltool_connect(nlh, NETLINK_ROUTE) < 0)
goto errout_free_addr;
local = nltool_addr_parse(argv[1]);
if (!local)
goto errout_close;
if (rtnl_addr_set_local(addr, local) < 0) {
fprintf(stderr, "Unable to set local address: %s\n",
nl_geterror());
goto errout_addr_put;
}
rtnl_addr_set_ifindex(addr, strtoul(argv[2], NULL, 0));
if (rtnl_addr_delete(nlh, addr, 0) < 0) {
fprintf(stderr, "Unable to delete address: %s\n",
nl_geterror());
goto errout_addr_put;
}
err = 0;
errout_addr_put:
nl_addr_put(local);
errout_close:
nl_close(nlh);
errout_free_addr:
rtnl_addr_put(addr);
errout_free_handle:
nl_handle_destroy(nlh);
errout:
return err;
}
int main(int argc, char *argv[])
{
struct nl_handle *nlh;
struct nl_cache *link_cache, *addr_cache;
struct rtnl_addr *addr;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_BRIEF
};
int err = 1;
if (nltool_init(argc, argv) < 0)
return -1;
nlh = nltool_alloc_handle();
if (!nlh)
return -1;
addr = rtnl_addr_alloc();
if (!addr)
goto errout;
if (argc < 2 || !strcmp(argv[1], "-h"))
print_usage();
if (nltool_connect(nlh, NETLINK_ROUTE) < 0)
goto errout_free;
link_cache = nltool_alloc_link_cache(nlh);
if (!link_cache)
goto errout_close;
addr_cache = nltool_alloc_addr_cache(nlh);
if (!addr_cache)
goto errout_link_cache;
params.dp_type = nltool_parse_dumptype(argv[1]);
if (params.dp_type < 0)
goto errout_addr_cache;
get_filter(addr, argc, argv, 2, link_cache);
nl_cache_dump_filter(addr_cache, ¶ms, (struct nl_object *) addr);
err = 0;
errout_addr_cache:
nl_cache_free(addr_cache);
errout_link_cache:
nl_cache_free(link_cache);
errout_close:
nl_close(nlh);
errout_free:
rtnl_addr_put(addr);
errout:
return err;
}
const std::list<vaddress> NetLinkManager::getAddressList(const vinterface &interface, const vaddress::Family f)
{
ibrcommon::MutexLock l(_call_mutex);
if (_refresh_cache)
{
nl_cache_free(_addr_cache);
nl_cache_free(_link_cache);
_link_cache = rtnl_link_alloc_cache(_handle);
if (_link_cache == NULL)
{
throw ibrcommon::vsocket_exception("netlink cache allocation failed");
}
_addr_cache = rtnl_addr_alloc_cache(_handle);
if (_addr_cache == NULL)
{
nl_cache_free(_link_cache);
throw ibrcommon::vsocket_exception("netlink cache allocation failed");
}
// mark the cache as refreshed
_refresh_cache = false;
}
std::list<vaddress> addresses;
struct rtnl_addr *filter = rtnl_addr_alloc();
const std::string i = interface.toString();
rtnl_addr_set_ifindex(filter, rtnl_link_name2i(_link_cache, i.c_str()));
if (f == vaddress::VADDRESS_UNSPEC)
{
rtnl_addr_set_family(filter, AF_INET6);
nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
add_addr_to_list, &addresses);
rtnl_addr_set_family(filter, AF_INET);
nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
add_addr_to_list, &addresses);
}
else
{
rtnl_addr_set_family(filter, f);
nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
add_addr_to_list, &addresses);
}
rtnl_addr_put(filter);
return addresses;
}
struct rtnl_addr *
nm_ip4_config_to_rtnl_addr (NMIP4Config *config, guint32 i, guint32 flags)
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
NMIP4Address *config_addr;
struct rtnl_addr *addr;
gboolean success = TRUE;
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
config_addr = nm_ip4_config_get_address (config, i);
g_return_val_if_fail (config_addr != NULL, NULL);
if (!(addr = rtnl_addr_alloc()))
return NULL;
if (flags & NM_RTNL_ADDR_ADDR)
success = (ip4_addr_to_rtnl_local (nm_ip4_address_get_address (config_addr), addr) >= 0);
if (flags & NM_RTNL_ADDR_PTP_ADDR)
success = (ip4_addr_to_rtnl_peer (priv->ptp_address, addr) >= 0);
if (flags & NM_RTNL_ADDR_PREFIX)
rtnl_addr_set_prefixlen (addr, nm_ip4_address_get_prefix (config_addr));
if (flags & NM_RTNL_ADDR_BROADCAST) {
guint32 hostmask, network, bcast, netmask;
netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (config_addr));
network = ntohl (nm_ip4_address_get_address (config_addr)) & ntohl (netmask);
hostmask = ~ntohl (netmask);
bcast = htonl (network | hostmask);
success = (ip4_addr_to_rtnl_broadcast (bcast, addr) >= 0);
}
if (!success) {
rtnl_addr_put (addr);
addr = NULL;
}
return addr;
}
int sysnet_interface_set_addr(VPNInterface *i)
{
int err;
struct nl_cache *link_cache;
struct nl_sock *sock;
struct rtnl_addr *addr;
struct rtnl_link *link;
struct nl_addr *local_addr;
sock = nl_socket_alloc();
nl_connect(sock, NETLINK_ROUTE);
rtnl_link_alloc_cache(sock, AF_UNSPEC, &link_cache);
addr = rtnl_addr_alloc();
link = rtnl_link_get_by_name(link_cache, i->name);
local_addr = nl_addr_build(i->address.ip.family, &i->address.ip.ip4, sizeof(i->address.ip.ip4));
rtnl_addr_set_local(addr, local_addr);
rtnl_addr_set_family(addr, i->address.ip.family);
rtnl_addr_set_prefixlen(addr, i->address.prefix);
rtnl_addr_set_link(addr, link);
if ((err = rtnl_addr_add(sock, addr, 0)) < 0) {
tox_trace(i->context->tox, "Unable to add address %s on %s: %s", ip_ntoa(&i->address.ip), rtnl_link_get_name(link), nl_geterror(err));
}
else {
tox_trace(i->context->tox, "Added address %s on \"%s\"", ip_ntoa(&i->address.ip), i->name);
}
rtnl_link_put(link);
rtnl_addr_put(addr);
nl_cache_free(link_cache);
nl_addr_put(local_addr);
nl_socket_free(sock);
return err;
}
/**
* Query NETLINK for ethernet configuration
*
* @param ethinf Pointer to an available struct etherinfo element. The 'device' member
* must contain a valid string to the device to query for information
* @param nlc Pointer to the libnl handle, which is used for the query against NETLINK
* @param query What to query for. Must be NLQRY_LINK or NLQRY_ADDR.
*
* @return Returns 1 on success, otherwise 0.
*/
int get_etherinfo(struct etherinfo_obj_data *data, nlQuery query)
{
struct nl_cache *link_cache;
struct nl_cache *addr_cache;
struct rtnl_addr *addr;
struct rtnl_link *link;
struct etherinfo *ethinf = NULL;
int ret = 0;
if( !data || !data->ethinfo ) {
return 0;
}
ethinf = data->ethinfo;
/* Open a NETLINK connection on-the-fly */
if( !open_netlink(data) ) {
PyErr_Format(PyExc_RuntimeError,
"Could not open a NETLINK connection for %s",
ethinf->device);
return 0;
}
/* Find the interface index we're looking up.
* As we don't expect it to change, we're reusing a "cached"
* interface index if we have that
*/
if( ethinf->index < 0 ) {
link_cache = rtnl_link_alloc_cache(*data->nlc);
ethinf->index = rtnl_link_name2i(link_cache, ethinf->device);
if( ethinf->index < 0 ) {
return 0;
}
nl_cache_free(link_cache);
}
/* Query the for requested info vai NETLINK */
switch( query ) {
case NLQRY_LINK:
/* Extract MAC/hardware address of the interface */
link_cache = rtnl_link_alloc_cache(*data->nlc);
link = rtnl_link_alloc();
rtnl_link_set_ifindex(link, ethinf->index);
nl_cache_foreach_filter(link_cache, (struct nl_object *)link, callback_nl_link, ethinf);
rtnl_link_put(link);
nl_cache_free(link_cache);
ret = 1;
break;
case NLQRY_ADDR:
/* Extract IP address information */
addr_cache = rtnl_addr_alloc_cache(*data->nlc);
addr = rtnl_addr_alloc();
rtnl_addr_set_ifindex(addr, ethinf->index);
/* Make sure we don't have any old IPv6 addresses saved */
if( ethinf->ipv6_addresses ) {
free_ipv6addresses(ethinf->ipv6_addresses);
ethinf->ipv6_addresses = NULL;
}
/* Retrieve all address information */
nl_cache_foreach_filter(addr_cache, (struct nl_object *)addr, callback_nl_address, ethinf);
rtnl_addr_put(addr);
nl_cache_free(addr_cache);
ret = 1;
break;
default:
ret = 0;
}
return ret;
}
static int addr_msg_parser(struct sockaddr_nl *who, struct nlmsghdr *nlh,
void *arg)
{
struct rtnl_addr *addr;
struct nl_parser_param *pp = arg;
struct ifaddrmsg *ifa;
struct nlattr *tb[IFA_MAX+1];
int err = -ENOMEM, peer_prefix = 0;
addr = rtnl_addr_alloc();
if (!addr) {
err = nl_errno(ENOMEM);
goto errout;
}
addr->ce_msgtype = nlh->nlmsg_type;
err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy);
if (err < 0)
goto errout_free;
ifa = nlmsg_data(nlh);
addr->a_family = ifa->ifa_family;
addr->a_prefixlen = ifa->ifa_prefixlen;
addr->a_flags = ifa->ifa_flags;
addr->a_scope = ifa->ifa_scope;
addr->a_ifindex = ifa->ifa_index;
addr->a_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN |
ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX);
if (tb[IFA_LABEL]) {
nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ);
addr->a_mask |= ADDR_ATTR_LABEL;
}
if (tb[IFA_CACHEINFO]) {
struct ifa_cacheinfo *ca;
ca = nla_data(tb[IFA_CACHEINFO]);
addr->a_cacheinfo.aci_prefered = ca->ifa_prefered;
addr->a_cacheinfo.aci_valid = ca->ifa_valid;
addr->a_cacheinfo.aci_cstamp = ca->cstamp;
addr->a_cacheinfo.aci_tstamp = ca->tstamp;
addr->a_mask |= ADDR_ATTR_CACHEINFO;
}
if (tb[IFA_LOCAL]) {
addr->a_local = nla_get_addr(tb[IFA_LOCAL], addr->a_family);
if (!addr->a_local)
goto errout_free;
addr->a_mask |= ADDR_ATTR_LOCAL;
}
if (tb[IFA_ADDRESS]) {
struct nl_addr *a;
a = nla_get_addr(tb[IFA_ADDRESS], addr->a_family);
if (!a)
goto errout_free;
/* IPv6 sends the local address as IFA_ADDRESS with
* no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS
* with IFA_ADDRESS being the peer address if they differ */
if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) {
nl_addr_put(addr->a_local);
addr->a_local = a;
addr->a_mask |= ADDR_ATTR_LOCAL;
} else {
addr->a_peer = a;
addr->a_mask |= ADDR_ATTR_PEER;
peer_prefix = 1;
}
}
nl_addr_set_prefixlen(peer_prefix ? addr->a_peer : addr->a_local,
addr->a_prefixlen);
if (tb[IFA_BROADCAST]) {
addr->a_bcast = nla_get_addr(tb[IFA_BROADCAST], addr->a_family);
if (!addr->a_bcast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_BROADCAST;
}
if (tb[IFA_ANYCAST]) {
addr->a_anycast = nla_get_addr(tb[IFA_ANYCAST], addr->a_family);
if (!addr->a_anycast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_ANYCAST;
}
if (tb[IFA_MULTICAST]) {
addr->a_multicast = nla_get_addr(tb[IFA_MULTICAST],
addr->a_family);
if (!addr->a_multicast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_MULTICAST;
}
err = pp->pp_cb((struct nl_object *) addr, pp);
if (err < 0)
goto errout_free;
return P_ACCEPT;
errout_free:
rtnl_addr_free(addr);
errout:
return err;
}
struct rtnl_addr *rtnl_addr_alloc_from_msg(struct nl_msg *msg)
{
struct nlattr *tb[IFA_MAX+1];
struct rtnl_addr *addr;
struct ifaddrmsg *ifa;
struct nlmsghdr *nlh;
int err, peer_prefix = 0;
nlh = nlmsg_hdr(msg);
addr = rtnl_addr_alloc();
if (!addr)
goto errout;
err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy);
if (err < 0)
goto errout_free;
ifa = nlmsg_data(nlh);
addr->a_family = ifa->ifa_family;
addr->a_prefixlen = ifa->ifa_prefixlen;
addr->a_flags = ifa->ifa_flags;
addr->a_scope = ifa->ifa_scope;
addr->a_ifindex = ifa->ifa_index;
addr->a_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN |
ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX);
if (tb[IFA_LABEL]) {
nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ);
addr->a_mask |= ADDR_ATTR_LABEL;
}
if (tb[IFA_CACHEINFO]) {
struct ifa_cacheinfo *ca;
ca = nla_data(tb[IFA_CACHEINFO]);
addr->a_cacheinfo.aci_prefered = ca->ifa_prefered;
addr->a_cacheinfo.aci_valid = ca->ifa_valid;
addr->a_cacheinfo.aci_cstamp = ca->cstamp;
addr->a_cacheinfo.aci_tstamp = ca->tstamp;
addr->a_mask |= ADDR_ATTR_CACHEINFO;
}
if (tb[IFA_LOCAL]) {
addr->a_local = nla_get_addr(tb[IFA_LOCAL], addr->a_family);
if (!addr->a_local)
goto errout_free;
addr->a_mask |= ADDR_ATTR_LOCAL;
}
if (tb[IFA_ADDRESS]) {
struct nl_addr *a;
a = nla_get_addr(tb[IFA_ADDRESS], addr->a_family);
if (!a)
goto errout_free;
/* IPv6 sends the local address as IFA_ADDRESS with
* no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS
* with IFA_ADDRESS being the peer address if they differ */
if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) {
addr->a_local = a;
addr->a_mask |= ADDR_ATTR_LOCAL;
} else {
addr->a_peer = a;
addr->a_mask |= ADDR_ATTR_PEER;
peer_prefix = 1;
}
}
nl_addr_set_prefixlen(peer_prefix ? addr->a_peer : addr->a_local,
addr->a_prefixlen);
if (tb[IFA_BROADCAST]) {
addr->a_bcast = nla_get_addr(tb[IFA_BROADCAST], addr->a_family);
if (!addr->a_bcast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_BROADCAST;
}
if (tb[IFA_ANYCAST]) {
addr->a_anycast = nla_get_addr(tb[IFA_ANYCAST], addr->a_family);
if (!addr->a_anycast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_ANYCAST;
}
if (tb[IFA_MULTICAST]) {
addr->a_multicast = nla_get_addr(tb[IFA_MULTICAST],
addr->a_family);
if (!addr->a_multicast)
goto errout_free;
addr->a_mask |= ADDR_ATTR_MULTICAST;
}
return addr;
errout_free:
rtnl_addr_free(addr);
errout:
return NULL;
}
static void nl_ihandler_cb(struct incident *i, void *ctx)
{
g_debug("%s i %p ctx %p", __PRETTY_FUNCTION__, i, ctx);
struct connection *con;
incident_value_con_get(i, "con", &con);
char *remote = con->remote.ip_string;
char *local = con->local.ip_string;
char *prefix = "::ffff:";
if( strncmp(local, prefix, strlen(prefix)) == 0)
local += strlen(prefix);
if( strncmp(remote, prefix, strlen(prefix)) == 0)
remote += strlen(prefix);
int ifindex;
int err;
{
g_debug("local addr %s remote addr %s", local, remote);
struct rtnl_addr *addr = rtnl_addr_alloc();
struct nl_addr *a;
if ( ( err = nl_addr_parse(local, AF_UNSPEC, &a)) != 0 )
g_critical("could not parse addr %s (%s)", local, nl_geterror(err));
rtnl_addr_set_local(addr, a);
nl_addr_put(a);
struct rtnl_addr *res = NULL;
nl_cache_foreach_filter(nl_runtime.addr_cache, OBJ_CAST(addr), cache_lookup_cb, &res);
g_critical("LOCAL RTNL_ADDR %p", res);
/* struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
nl_cache_dump_filter(nl_runtime.addr_cache, ¶ms, OBJ_CAST(addr));
*/
ifindex = rtnl_addr_get_ifindex(res);
}
struct rtnl_neigh *res = NULL;
{
struct rtnl_neigh *neigh = rtnl_neigh_alloc();
rtnl_neigh_set_ifindex(neigh, ifindex);
struct nl_addr *a;
if ( ( err = nl_addr_parse(remote, AF_UNSPEC, &a)) != 0 )
g_critical("could not parse addr %s (%s)", remote, nl_geterror(err));
rtnl_neigh_set_dst(neigh, a);
nl_addr_put(a);
nl_cache_foreach_filter(nl_runtime.neigh_cache, OBJ_CAST(neigh), cache_lookup_cb, &res);
}
if( res )
{
g_critical("GOT NEIGH %p", res);
struct nl_addr *lladdr = rtnl_neigh_get_lladdr(res);
char buf[123];
nl_addr2str(lladdr, buf, sizeof(buf));
g_critical("GOT NEIGH %s", buf);
struct incident *i = incident_new("dionaea.module.nl.connection.info.mac");
incident_value_string_set(i, "mac", g_string_new(buf));
incident_value_con_set(i, "con", con);
incident_report(i);
incident_free(i);
}
}
int main(int argc, char *argv[])
{
char *unikernel;
enum {
QEMU,
KVM,
UKVM,
UNIX
} hypervisor;
if (argc < 3) {
fprintf(stderr, "usage: runner HYPERVISOR UNIKERNEL [ ARGS... ]\n");
fprintf(stderr, "HYPERVISOR: qemu | kvm | ukvm | unix\n");
return 1;
}
if (strcmp(argv[1], "qemu") == 0)
hypervisor = QEMU;
else if (strcmp(argv[1], "kvm") == 0)
hypervisor = KVM;
else if (strcmp(argv[1], "ukvm") == 0)
hypervisor = UKVM;
else if (strcmp(argv[1], "unix") == 0)
hypervisor = UNIX;
else {
warnx("error: Invalid hypervisor: %s", argv[1]);
return 1;
}
unikernel = argv[2];
/*
* Remaining arguments are to be passed on to the unikernel.
*/
argv += 3;
argc -= 3;
/*
* Check we have CAP_NET_ADMIN.
*/
if (capng_get_caps_process() != 0) {
warnx("error: capng_get_caps_process() failed");
return 1;
}
if (!capng_have_capability(CAPNG_EFFECTIVE, CAP_NET_ADMIN)) {
warnx("error: CAP_NET_ADMIN is required");
return 1;
}
/*
* Connect to netlink, load link cache from kernel.
*/
struct nl_sock *sk;
struct nl_cache *link_cache;
int err;
sk = nl_socket_alloc();
assert(sk);
err = nl_connect(sk, NETLINK_ROUTE);
if (err < 0) {
warnx("nl_connect() failed: %s", nl_geterror(err));
return 1;
}
err = rtnl_link_alloc_cache(sk, AF_UNSPEC, &link_cache);
if (err < 0) {
warnx("rtnl_link_alloc_cache() failed: %s", nl_geterror(err));
return 1;
}
/*
* Retrieve container network configuration -- IP address and
* default gateway.
*/
struct rtnl_link *l_veth;
l_veth = rtnl_link_get_by_name(link_cache, VETH_LINK_NAME);
if (l_veth == NULL) {
warnx("error: Could not get link information for %s", VETH_LINK_NAME);
return 1;
}
struct nl_addr *veth_addr;
err = get_link_inet_addr(sk, l_veth, &veth_addr);
if (err) {
warnx("error: Unable to determine IP address of %s",
VETH_LINK_NAME);
return 1;
}
struct nl_addr *gw_addr;
err = get_default_gw_inet_addr(sk, &gw_addr);
if (err) {
warnx("error: get_deGfault_gw_inet_addr() failed");
return 1;
}
if (gw_addr == NULL) {
warnx("error: No default gateway found. This is currently "
"not supported");
return 1;
}
/*
* Create bridge and tap interface, enslave veth and tap interfaces to
* bridge.
*/
err = create_bridge_link(sk, BRIDGE_LINK_NAME);
if (err < 0) {
warnx("create_bridge_link(%s) failed: %s", BRIDGE_LINK_NAME,
nl_geterror(err));
return 1;
}
int tap_fd;
if (hypervisor == UKVM)
err = create_tap_link(TAP_LINK_NAME, &tap_fd);
else
err = create_tap_link(TAP_LINK_NAME, NULL);
if (err != 0) {
warnx("create_tap_link(%s) failed: %s", TAP_LINK_NAME, strerror(err));
return 1;
}
/* Refill link cache with newly-created interfaces */
nl_cache_refill(sk, link_cache);
struct rtnl_link *l_bridge;
l_bridge = rtnl_link_get_by_name(link_cache, BRIDGE_LINK_NAME);
if (l_bridge == NULL) {
warnx("error: Could not get link information for %s", BRIDGE_LINK_NAME);
return 1;
}
struct rtnl_link *l_tap;
l_tap = rtnl_link_get_by_name(link_cache, TAP_LINK_NAME);
if (l_tap == NULL) {
warnx("error: Could not get link information for %s", TAP_LINK_NAME);
return 1;
}
err = rtnl_link_enslave(sk, l_bridge, l_veth);
if (err < 0) {
warnx("error: Unable to enslave %s to %s: %s", VETH_LINK_NAME,
BRIDGE_LINK_NAME, nl_geterror(err));
return 1;
}
err = rtnl_link_enslave(sk, l_bridge, l_tap);
if (err < 0) {
warnx("error: Unable to enslave %s to %s: %s", TAP_LINK_NAME,
BRIDGE_LINK_NAME, nl_geterror(err));
return 1;
}
/*
* Flush all IPv4 addresses from the veth interface. This is now safe
* as we are good to commit and have retrieved the existing configuration.
*/
struct rtnl_addr *flush_addr;
flush_addr = rtnl_addr_alloc();
assert(flush_addr);
rtnl_addr_set_ifindex(flush_addr, rtnl_link_get_ifindex(l_veth));
rtnl_addr_set_family(flush_addr, AF_INET);
rtnl_addr_set_local(flush_addr, veth_addr);
err = rtnl_addr_delete(sk, flush_addr, 0);
if (err < 0) {
warnx("error: Could not flush addresses on %s: %s", VETH_LINK_NAME,
nl_geterror(err));
return 1;
}
rtnl_addr_put(flush_addr);
/*
* Bring up the tap and bridge interfaces.
*/
struct rtnl_link *l_up;
l_up = rtnl_link_alloc();
assert(l_up);
/* You'd think set_operstate was the thing to do here. It's not. */
rtnl_link_set_flags(l_up, IFF_UP);
err = rtnl_link_change(sk, l_tap, l_up, 0);
if (err < 0) {
warnx("error: rtnl_link_change(%s, UP) failed: %s", TAP_LINK_NAME,
nl_geterror(err));
return 1;
}
err = rtnl_link_change(sk, l_bridge, l_up, 0);
if (err < 0) {
warnx("error: rtnl_link_change(%s, UP) failed: %s", BRIDGE_LINK_NAME,
nl_geterror(err));
return 1;
}
rtnl_link_put(l_up);
/*
* Collect network configuration data.
*/
char ip[AF_INET_BUFSIZE];
if (inet_ntop(AF_INET, nl_addr_get_binary_addr(veth_addr), ip,
sizeof ip) == NULL) {
perror("inet_ntop()");
return 1;
}
char uarg_ip[AF_INET_BUFSIZE];
unsigned int prefixlen = nl_addr_get_prefixlen(veth_addr);
snprintf(uarg_ip, sizeof uarg_ip, "%s/%u", ip, prefixlen);
char uarg_gw[AF_INET_BUFSIZE];
if (inet_ntop(AF_INET, nl_addr_get_binary_addr(gw_addr), uarg_gw,
sizeof uarg_gw) == NULL) {
perror("inet_ntop()");
return 1;
}
/*
* Build unikernel and hypervisor arguments.
*/
ptrvec* uargpv = pvnew();
char *uarg_buf;
/*
* QEMU/KVM:
* /usr/bin/qemu-system-x86_64 <qemu args> -kernel <unikernel> -append "<unikernel args>"
*/
if (hypervisor == QEMU || hypervisor == KVM) {
pvadd(uargpv, "/usr/bin/qemu-system-x86_64");
pvadd(uargpv, "-nodefaults");
pvadd(uargpv, "-no-acpi");
pvadd(uargpv, "-display");
pvadd(uargpv, "none");
pvadd(uargpv, "-serial");
pvadd(uargpv, "stdio");
pvadd(uargpv, "-m");
pvadd(uargpv, "512");
if (hypervisor == KVM) {
pvadd(uargpv, "-enable-kvm");
pvadd(uargpv, "-cpu");
pvadd(uargpv, "host");
}
else {
/*
* Required for AESNI use in Mirage.
*/
pvadd(uargpv, "-cpu");
pvadd(uargpv, "Westmere");
}
pvadd(uargpv, "-device");
char *guest_mac = generate_mac();
assert(guest_mac);
err = asprintf(&uarg_buf, "virtio-net-pci,netdev=n0,mac=%s", guest_mac);
assert(err != -1);
pvadd(uargpv, uarg_buf);
pvadd(uargpv, "-netdev");
err = asprintf(&uarg_buf, "tap,id=n0,ifname=%s,script=no,downscript=no",
TAP_LINK_NAME);
assert(err != -1);
pvadd(uargpv, uarg_buf);
pvadd(uargpv, "-kernel");
pvadd(uargpv, unikernel);
pvadd(uargpv, "-append");
/*
* TODO: Replace any occurences of ',' with ',,' in -append, because
* QEMU arguments are insane.
*/
char cmdline[1024];
char *cmdline_p = cmdline;
size_t cmdline_free = sizeof cmdline;
for (; *argv; argc--, argv++) {
size_t alen = snprintf(cmdline_p, cmdline_free, "%s%s", *argv,
(argc > 1) ? " " : "");
if (alen >= cmdline_free) {
warnx("error: Command line too long");
return 1;
}
cmdline_free -= alen;
cmdline_p += alen;
}
size_t alen = snprintf(cmdline_p, cmdline_free,
"--ipv4=%s --ipv4-gateway=%s", uarg_ip, uarg_gw);
if (alen >= cmdline_free) {
warnx("error: Command line too long");
return 1;
}
pvadd(uargpv, cmdline);
}
/*
* UKVM:
* /unikernel/ukvm <ukvm args> <unikernel> -- <unikernel args>
*/
else if (hypervisor == UKVM) {
pvadd(uargpv, "/unikernel/ukvm");
err = asprintf(&uarg_buf, "--net=@%d", tap_fd);
assert(err != -1);
pvadd(uargpv, uarg_buf);
pvadd(uargpv, "--");
pvadd(uargpv, unikernel);
for (; *argv; argc--, argv++) {
pvadd(uargpv, *argv);
}
err = asprintf(&uarg_buf, "--ipv4=%s", uarg_ip);
assert(err != -1);
pvadd(uargpv, uarg_buf);
err = asprintf(&uarg_buf, "--ipv4-gateway=%s", uarg_gw);
assert(err != -1);
pvadd(uargpv, uarg_buf);
}
/*
* UNIX:
* <unikernel> <unikernel args>
*/
else if (hypervisor == UNIX) {
pvadd(uargpv, unikernel);
err = asprintf(&uarg_buf, "--interface=%s", TAP_LINK_NAME);
assert(err != -1);
pvadd(uargpv, uarg_buf);
for (; *argv; argc--, argv++) {
pvadd(uargpv, *argv);
}
err = asprintf(&uarg_buf, "--ipv4=%s", uarg_ip);
assert(err != -1);
pvadd(uargpv, uarg_buf);
err = asprintf(&uarg_buf, "--ipv4-gateway=%s", uarg_gw);
assert(err != -1);
pvadd(uargpv, uarg_buf);
}
char **uargv = (char **)pvfinal(uargpv);
/*
* Done with netlink, free all resources and close socket.
*/
rtnl_link_put(l_veth);
rtnl_link_put(l_bridge);
rtnl_link_put(l_tap);
nl_addr_put(veth_addr);
nl_addr_put(gw_addr);
nl_cache_free(link_cache);
nl_close(sk);
nl_socket_free(sk);
/*
* Drop all capabilities except CAP_NET_BIND_SERVICE.
*/
capng_clear(CAPNG_SELECT_BOTH);
capng_update(CAPNG_ADD,
CAPNG_EFFECTIVE | CAPNG_PERMITTED | CAPNG_INHERITABLE,
CAP_NET_BIND_SERVICE);
if (capng_apply(CAPNG_SELECT_BOTH) != 0) {
warnx("error: Could not drop capabilities");
return 1;
}
/*
* Run the unikernel.
*/
err = execv(uargv[0], uargv);
warn("error: execv() of %s failed", uargv[0]);
return 1;
}
int configure_loopback_interface() {
struct nl_sock *sock = NULL;
struct rtnl_addr *addr = NULL;
struct nl_addr* lo_addr = NULL;
struct nl_cache *cache = NULL;
struct rtnl_link *link = NULL, *link2 = NULL;
int err, nlflags = NLM_F_CREATE, ret = 0;
if(!want_cap(CAP_NET_ADMIN)) {
errWarn("Cannot set the CAP_NET_ADMIN effective capability");
return -1;
}
sock = nl_socket_alloc();
if(sock == NULL) {
errWarn("nl_socket_alloc");
return -1;
}
if((err = nl_connect(sock, NETLINK_ROUTE)) < 0) {
fprintf(stderr, "Unable to connect to netlink: %s\n", nl_geterror(err));
ret = -1;
goto out2;
}
if(rtnl_link_alloc_cache(sock, AF_UNSPEC, &cache) < 0) {
ret = -1;
goto out;
}
link = rtnl_link_get_by_name(cache, "lo");
if (link == NULL) {
ret = -1;
goto out;
}
addr = rtnl_addr_alloc();
if(addr == NULL) {
ret = -1;
goto out;
}
rtnl_addr_set_link(addr, link);
rtnl_addr_set_family(addr, AF_INET);
if((err = nl_addr_parse("127.0.0.1/8", AF_INET, &lo_addr)) < 0) {
fprintf(stderr, "Unable to parse address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
if((err = rtnl_addr_set_local(addr, lo_addr)) < 0) {
fprintf(stderr, "Unable to set address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
nl_addr_put(lo_addr);
lo_addr = NULL;
if ((err = rtnl_addr_add(sock, addr, nlflags)) < 0) {
fprintf(stderr, "Unable to add address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
rtnl_addr_set_family(addr, AF_INET6);
if((err = nl_addr_parse("::1/128", AF_INET6, &lo_addr)) < 0) {
fprintf(stderr, "Unable to parse address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
if((err = rtnl_addr_set_local(addr, lo_addr)) < 0) {
fprintf(stderr, "Unable to set address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
nl_addr_put(lo_addr);
lo_addr = NULL;
if ((err = rtnl_addr_add(sock, addr, nlflags)) < 0) {
fprintf(stderr, "Unable to add address: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
link2 = rtnl_link_alloc();
if(link2 == NULL) {
ret = -1;
goto out;
}
rtnl_link_set_flags(link2, IFF_UP);
if((err = rtnl_link_change(sock, link, link2, 0)) < 0) {
fprintf(stderr, "Unable to change link: %s\n", nl_geterror(err));
ret = -1;
goto out;
}
out:
if(lo_addr!=NULL)
nl_addr_put(lo_addr);
if(link2!=NULL)
rtnl_link_put(link2);
if(link!=NULL)
rtnl_link_put(link);
if(cache!=NULL)
nl_cache_put(cache);
if(addr!=NULL)
rtnl_addr_put(addr);
nl_close(sock);
out2:
nl_socket_free(sock);
drop_caps();
return ret;
}
int main(int argc, char *argv[])
{
struct nl_sock *nl_sock;
struct nl_cache *link_cache;
int ifindex;
int ret = 0;
int err = 0;
if (argc < 2)
{
printf("%s ip gw on/off tip\n", argv[0]);
return -1;
}
//link
if (err = rtnl_route_read_table_names(ROUTE_TABLE)) {
printf("failed to read %s. err = %s\n", ROUTE_TABLE, nl_geterror(err));
return -1;;
}
nl_sock = nl_socket_alloc();
if (NULL == nl_sock) {
printf("failed to alloc netlink handler.\n");
return -1;
}
if (err = nl_connect(nl_sock, NETLINK_ROUTE)) {
printf("failed to connect NETLINK_ROUTE. err = %s\n", nl_geterror(err));
ret = -1;
goto release_nl;
}
if (err = rtnl_link_alloc_cache(nl_sock, AF_INET, &link_cache))
{
printf("failed to allocate link cache. err = %s\n", nl_geterror(err));
ret = -1;
goto release_nl;
}
ifindex = rtnl_link_name2i(link_cache, NAME);
if (0 == ifindex) {
printf("%s - failed to find.\n", NAME);
ret = -1;
goto release_link_cache;
}
struct rtnl_link * link = rtnl_link_get(link_cache, ifindex);
if (link == NULL)
{
printf("can't get link.\n");
ret = -1;
goto release_link_cache;
}
//rtnl_link_get_by_name
struct nl_addr *lladdr = rtnl_link_get_addr(link);
if (NULL == lladdr || AF_LLC != nl_addr_get_family(lladdr)) {
printf("failed to get MAC\n");
ret = -1;
goto release_link;
}
uint8_t mac_address[ETHER_ADDR_LEN];
memcpy(mac_address, nl_addr_get_binary_addr(lladdr), ETHER_ADDR_LEN);
printf("%02X:%02X:%02X:%02X:%02X:%02X\n",
mac_address[0],
mac_address[1],
mac_address[2],
mac_address[3],
mac_address[4],
mac_address[5]);
//addr
struct nl_cache * addr_cache;
if (err = rtnl_addr_alloc_cache(nl_sock, &addr_cache))
{
printf("fail to get addr_cache\n");
ret = -1;
goto release_link;
}
struct rtnl_addr *addr = rtnl_addr_alloc();
rtnl_addr_set_ifindex(addr, ifindex);
rtnl_addr_set_family(addr, AF_INET);
int prefixlen = 16;
nl_cache_foreach_filter(addr_cache, (struct nl_object *)addr, get_ip, &prefixlen);
nl_cache_free(addr_cache);
uint32_t ipaddr = inet_addr(argv[1]);
struct nl_addr * local = nl_addr_build(AF_INET, &ipaddr, sizeof(ipaddr));
rtnl_addr_set_local(addr, local);
rtnl_addr_set_ifindex(addr, ifindex);
rtnl_addr_set_family(addr, AF_INET);
rtnl_addr_set_prefixlen(addr, 32);
if (!strcmp(argv[2], "on"))
{
if (err = rtnl_addr_add(nl_sock, addr, 0))
{
printf("fail to add addr %s\n", nl_geterror(err));
ret = -1;
goto release_addr;
}
}
else
{
if (err = rtnl_addr_delete(nl_sock, addr, 0))
{
printf("fail to del addr %s\n", nl_geterror(err));
ret = -1;
goto release_addr;
}
}
//neigh
struct nl_cache * neigh_cache;
if (err = rtnl_neigh_alloc_cache(nl_sock, &neigh_cache))
{
printf("failed to allocate neighbor cache. err = %s\n", nl_geterror(err));
ret = -1;
goto release_neigh_cache;
}
uint32_t gw = inet_addr(argv[3]);
struct nl_addr * gw_addr = nl_addr_build(AF_INET, &gw, sizeof(gw));
struct rtnl_neigh * neigh = rtnl_neigh_get(neigh_cache, ifindex, gw_addr);
if (neigh) {
// It's optional
struct nl_addr * lladdr = rtnl_neigh_get_lladdr(neigh);
if (lladdr) {
uint8_t mac_address[ETHER_ADDR_LEN];
memcpy(mac_address, nl_addr_get_binary_addr(lladdr), ETHER_ADDR_LEN);
printf("gw %02X:%02X:%02X:%02X:%02X:%02X\n",
mac_address[0],
mac_address[1],
mac_address[2],
mac_address[3],
mac_address[4],
mac_address[5]);
}
}
nl_addr_put(gw_addr);
//route
struct nl_cache *route_cache;
if (err = rtnl_route_alloc_cache(nl_sock, AF_INET, 0, &route_cache))
{
printf("failed to allocate route cache. err = %s\n", nl_geterror(err));
ret = -1;
goto release_neigh_cache;
}
struct rtnl_route *route = rtnl_route_alloc();
struct nl_addr * taddr;
err = nl_addr_parse(argv[4], AF_INET, &taddr);
if (err)
{
printf("failed to get taddr. err = %s\n", nl_geterror(err));
ret = -1;
goto release_route_cache;
}
nl_cache_foreach_filter(route_cache, OBJ_CAST(route), get_route, NULL);
/*
struct nl_sock *nl_fib_sock;
nl_fib_sock = nl_socket_alloc();
if (err = nl_connect(nl_fib_sock, NETLINK_FIB_LOOKUP)) {
printf("failed to connect NETLINK_ROUTE. err = %s\n", nl_geterror(err));
ret = -1;
goto release_nl;
}
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_DETAILS,
};
struct nl_cache *route_cache = flnl_result_alloc_cache();
struct flnl_request *req = flnl_request_alloc();
struct nl_addr * taddr;
err = nl_addr_parse(argv[4], AF_INET, &taddr);
if (err)
{
printf("failed to get taddr. err = %s\n", nl_geterror(err));
ret = -1;
goto release_route;
}
int table = RT_TABLE_UNSPEC, scope = RT_SCOPE_UNIVERSE;
flnl_request_set_addr(req, taddr);
flnl_request_set_table(req, table);
flnl_request_set_scope(req, scope);
err = flnl_lookup(nl_fib_sock, req, route_cache);
if (err)
{
printf("failed to fib lookup. err = %s\n", nl_geterror(err));
ret = -1;
goto release_route_addr;
}
nl_cache_dump(route_cache, ¶ms);
release_route_addr:
nl_addr_put(taddr);
release_route:
nl_cache_free(route_cache);
nl_object_put(OBJ_CAST(req));
nl_close(nl_fib_sock);
nl_socket_free(nl_fib_sock);
*/
release_route_cache:
nl_cache_free(route_cache);
release_neigh_cache:
nl_cache_free(neigh_cache);
release_addr:
nl_addr_put(local);
rtnl_addr_put(addr);
release_link:
rtnl_link_put(link);
release_link_cache:
nl_cache_free(link_cache);
release_nl:
nl_close(nl_sock);
nl_socket_free(nl_sock);
return ret;
}
int ip_addr(char *ip4addr, char *interface, cmd_t cmd)
{
struct nl_handle *nlh = NULL;
struct rtnl_addr *addr = NULL;
struct nl_addr *nl_addr = NULL;
uint32_t binaddr = 0;
int iface_idx = -1;
int err,ret = 0;
if (init_handle(&nlh) != 0) {
return -1;
}
iface_idx = if_nametoindex(interface);
if (iface_idx < 0) {
return -1;
}
addr = rtnl_addr_alloc ();
if (!addr) {
return -1;
}
if (inet_pton(AF_INET, ip4addr, &binaddr) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"not valid ip address\n");
ret = -1;
goto out;
}
nl_addr = nl_addr_build (AF_INET, &binaddr, sizeof(binaddr));
if (!nl_addr) {
ret = -1;
goto out;
}
rtnl_addr_set_local (addr, nl_addr);
nl_addr_put (nl_addr);
rtnl_addr_set_ifindex (addr, iface_idx);
switch (cmd) {
case ADD_IP:
err = rtnl_addr_add (nlh, addr, 0);
if ( err == -17 ) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
"%s is already on %s interface\n", ip4addr, interface);
ret = 0;
} else if ( err < 0 ) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"error %d returned from rtnl_addr_add():\n%s\n",
err, nl_geterror());
ret = -1;
} else {
ret = 0;
}
break;
case DEL_IP:
err = rtnl_addr_delete (nlh, addr, 0);
if (err == -99) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
"%s is not present on %s interface\n", ip4addr, interface);
ret = 0;
} else if (err < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
"error %d returned from rtnl_addr_delete():\n%s\n",
err, nl_geterror());
ret = -1;
} else {
ret = 0;
}
break;
}
out:
if (addr) {
rtnl_addr_put (addr);
}
if (nlh) {
nl_close(nlh);
nl_handle_destroy(nlh);
}
return ret;
}
static int _set_ip(nozzle_t nozzle,
int command,
const char *ipaddr, const char *prefix,
int secondary)
{
int fam;
char *broadcast = NULL;
int err = 0;
#ifdef KNET_LINUX
struct rtnl_addr *addr = NULL;
struct nl_addr *local_addr = NULL;
struct nl_addr *bcast_addr = NULL;
struct nl_cache *cache = NULL;
int ifindex;
#endif
#ifdef KNET_BSD
char cmdline[4096];
char proto[6];
char *error_string = NULL;
#endif
if (!strchr(ipaddr, ':')) {
fam = AF_INET;
broadcast = generate_v4_broadcast(ipaddr, prefix);
if (!broadcast) {
errno = EINVAL;
return -1;
}
} else {
fam = AF_INET6;
}
#ifdef KNET_LINUX
addr = rtnl_addr_alloc();
if (!addr) {
errno = ENOMEM;
return -1;
}
if (rtnl_link_alloc_cache(lib_cfg.nlsock, AF_UNSPEC, &cache) < 0) {
errno = ENOMEM;
err = -1;
goto out;
}
ifindex = rtnl_link_name2i(cache, nozzle->name);
if (ifindex == 0) {
errno = ENOENT;
err = -1;
goto out;
}
rtnl_addr_set_ifindex(addr, ifindex);
if (nl_addr_parse(ipaddr, fam, &local_addr) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
if (rtnl_addr_set_local(addr, local_addr) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
if (broadcast) {
if (nl_addr_parse(broadcast, fam, &bcast_addr) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
if (rtnl_addr_set_broadcast(addr, bcast_addr) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
}
rtnl_addr_set_prefixlen(addr, atoi(prefix));
if (command == IP_ADD) {
if (rtnl_addr_add(lib_cfg.nlsock, addr, 0) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
} else {
if (rtnl_addr_delete(lib_cfg.nlsock, addr, 0) < 0) {
errno = EINVAL;
err = -1;
goto out;
}
}
out:
if (addr) {
rtnl_addr_put(addr);
}
if (local_addr) {
nl_addr_put(local_addr);
}
if (bcast_addr) {
nl_addr_put(bcast_addr);
}
if (cache) {
nl_cache_put(cache);
}
if (broadcast) {
free(broadcast);
}
return err;
#endif
#ifdef KNET_BSD
/*
* TODO: port to use ioctl and such, drop shell forking here
*/
memset(cmdline, 0, sizeof(cmdline));
if (fam == AF_INET) {
snprintf(proto, sizeof(proto), "inet");
} else {
snprintf(proto, sizeof(proto), "inet6");
}
if (command == IP_ADD) {
snprintf(cmdline, sizeof(cmdline)-1,
"ifconfig %s %s %s/%s",
nozzle->name, proto, ipaddr, prefix);
if (broadcast) {
snprintf(cmdline + strlen(cmdline),
sizeof(cmdline) - strlen(cmdline) -1,
" broadcast %s", broadcast);
}
if ((secondary) && (fam == AF_INET)) {
snprintf(cmdline + strlen(cmdline),
sizeof(cmdline) - strlen(cmdline) -1,
" alias");
}
} else {
snprintf(cmdline, sizeof(cmdline)-1,
"ifconfig %s %s %s/%s delete",
nozzle->name, proto, ipaddr, prefix);
}
if (broadcast) {
free(broadcast);
}
/*
* temporary workaround as we port libnozzle to BSD ioctl
* for IP address management
*/
err = execute_bin_sh_command(cmdline, &error_string);
if (error_string) {
free(error_string);
error_string = NULL;
}
return err;
#endif
}
