_cleanup_rtnl_message_unref_ sd_rtnl_message *ipv4 = NULL, *ipv6 = NULL;
int r;
- r = sd_rtnl_message_addr_new(RTM_NEWADDR, if_loopback, AF_INET, &ipv4);
+ r = sd_rtnl_message_new_addr(RTM_NEWADDR, if_loopback, AF_INET, &ipv4);
if (r < 0)
return r;
if (!socket_ipv6_is_supported())
return 0;
- r = sd_rtnl_message_addr_new(RTM_NEWADDR, if_loopback, AF_INET6, &ipv6);
+ r = sd_rtnl_message_new_addr(RTM_NEWADDR, if_loopback, AF_INET6, &ipv6);
if (r < 0)
return r;
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
int r;
- r = sd_rtnl_message_link_new(RTM_SETLINK, if_loopback, &req);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, if_loopback, &req);
if (r < 0)
return r;
return 0;
}
-int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family,
+int sd_rtnl_message_new_route(uint16_t nlmsg_type, unsigned char rtm_family,
sd_rtnl_message **ret) {
struct rtmsg *rtm;
int r;
return 0;
}
-int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, sd_rtnl_message **ret) {
+int sd_rtnl_message_new_link(uint16_t nlmsg_type, int index, sd_rtnl_message **ret) {
struct ifinfomsg *ifi;
int r;
return 0;
}
-int sd_rtnl_message_addr_new(uint16_t nlmsg_type, int index, unsigned char family,
+int sd_rtnl_message_new_addr(uint16_t nlmsg_type, int index, unsigned char family,
sd_rtnl_message **ret) {
struct ifaddrmsg *ifa;
int r;
assert(ifindex > 0);
assert(name);
- r = sd_rtnl_message_link_new(RTM_SETLINK, ifindex, &message);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, ifindex, &message);
if (r < 0)
return r;
if (!alias && !mac && mtu == 0)
return 0;
- r = sd_rtnl_message_link_new(RTM_SETLINK, ifindex, &message);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, ifindex, &message);
if (r < 0)
return r;
void *data;
/* we'd really like to test NEWLINK, but let's not mess with the running kernel */
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &message) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &message) >= 0);
assert(sd_rtnl_message_append_string(message, IFLA_IFNAME, name) >= 0);
assert(sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, ether_aton(mac)) >= 0);
assert(sd_rtnl_message_append_u32(message, IFLA_MTU, mtu) >= 0);
void *data;
uint16_t type;
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &m) >= 0);
assert(m);
/* u8 test cases */
void *data;
int r;
- r = sd_rtnl_message_route_new(RTM_NEWROUTE, AF_INET, &req);
+ r = sd_rtnl_message_new_route(RTM_NEWROUTE, AF_INET, &req);
if (r < 0) {
log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
return;
assert(ifname);
assert(sd_rtnl_open(0, &rtnl) >= 0);
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &m) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, NULL) >= 0);
assert(sd_rtnl_open(0, &rtnl) >= 0);
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &m) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, &serial) >= 0);
assert(sd_rtnl_open(0, &rtnl) >= 0);
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &m1) >= 0);
- assert(sd_rtnl_message_link_new(RTM_GETLINK, ifindex, &m2) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &m1) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, ifindex, &m2) >= 0);
counter ++;
assert(sd_rtnl_call_async(rtnl, m1, &pipe_handler, &counter, 0, NULL) >= 0);
uint16_t type;
void *data;
- assert(sd_rtnl_message_link_new(RTM_NEWLINK, 0, &m) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_NEWLINK, 0, &m) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) == -ENOTSUP);
test_link_configure(rtnl, if_loopback);
- assert(sd_rtnl_message_link_new(RTM_GETLINK, if_loopback, &m) >= 0);
+ assert(sd_rtnl_message_new_link(RTM_GETLINK, if_loopback, &m) >= 0);
assert(m);
assert(sd_rtnl_message_get_type(m, &type) >= 0);
assert(link->manager);
assert(link->manager->rtnl);
- r = sd_rtnl_message_addr_new(RTM_DELADDR, link->ifindex, address->family, &req);
+ r = sd_rtnl_message_new_addr(RTM_DELADDR, link->ifindex, address->family, &req);
if (r < 0) {
log_error("Could not allocate RTM_DELADDR message: %s",
strerror(-r));
assert(link->manager);
assert(link->manager->rtnl);
- r = sd_rtnl_message_addr_new(RTM_NEWADDR, link->ifindex,
+ r = sd_rtnl_message_new_addr(RTM_NEWADDR, link->ifindex,
address->family, &req);
if (r < 0) {
log_error("Could not allocate RTM_NEWADDR message: %s",
log_debug_link(link, "setting MTU: %" PRIu32, mtu);
- r = sd_rtnl_message_link_new(RTM_SETLINK, link->ifindex, &req);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, link->ifindex, &req);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_SETLINK message");
return r;
log_debug_link(link, "bringing link up");
- r = sd_rtnl_message_link_new(RTM_SETLINK, link->ifindex, &req);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, link->ifindex, &req);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_SETLINK message");
return r;
log_debug_link(link, "requesting link status");
- r = sd_rtnl_message_link_new(RTM_GETLINK, link->ifindex, &req);
+ r = sd_rtnl_message_new_link(RTM_GETLINK, link->ifindex, &req);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_GETLINK message");
return r;
assert(link);
assert(callback);
- r = sd_rtnl_message_link_new(RTM_SETLINK, link->ifindex, &req);
+ r = sd_rtnl_message_new_link(RTM_SETLINK, link->ifindex, &req);
if (r < 0) {
log_error_netdev(netdev,
"Could not allocate RTM_SETLINK message: %s",
assert(netdev->manager);
assert(netdev->manager->rtnl);
- r = sd_rtnl_message_link_new(RTM_NEWLINK, 0, &req);
+ r = sd_rtnl_message_new_link(RTM_NEWLINK, 0, &req);
if (r < 0) {
log_error_netdev(netdev,
"Could not allocate RTM_NEWLINK message: %s",
assert(link->ifindex > 0);
assert(route->family == AF_INET || route->family == AF_INET6);
- r = sd_rtnl_message_route_new(RTM_NEWROUTE, route->family, &req);
+ r = sd_rtnl_message_new_route(RTM_NEWROUTE, route->family, &req);
if (r < 0) {
log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
return r;
return -errno;
}
- r = sd_rtnl_message_link_new(RTM_NEWLINK, ifi, &m);
+ r = sd_rtnl_message_new_link(RTM_NEWLINK, ifi, &m);
if (r < 0) {
log_error("Failed to allocate netlink message: %s", strerror(-r));
return r;
int sd_rtnl_detach_event(sd_rtnl *nl);
/* messages */
-int sd_rtnl_message_link_new(uint16_t msg_type, int index, sd_rtnl_message **ret);
-int sd_rtnl_message_addr_new(uint16_t msg_type, int index, unsigned char family,
+int sd_rtnl_message_new_link(uint16_t msg_type, int index, sd_rtnl_message **ret);
+int sd_rtnl_message_new_addr(uint16_t msg_type, int index, unsigned char family,
sd_rtnl_message **ret);
-int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family,
+int sd_rtnl_message_new_route(uint16_t nlmsg_type, unsigned char rtm_family,
sd_rtnl_message **ret);
/*
unsigned char rtm_dst_len, unsigned char rtm_src_len,