picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Systemd/src/libsystemd/sd-rtnl/test-rtnl.c
Lennart Poettering 151b9b9662 api: in constructor function calls, always put the returned object pointer first (or second) 
Previously the returned object of constructor functions where sometimes
returned as last, sometimes as first and sometimes as second parameter.
Let's clean this up a bit. Here are the new rules:

1. The object the new object is derived from is put first, if there is any

2. The object we are creating will be returned in the next arguments

3. This is followed by any additional arguments

Rationale:

For functions that operate on an object we always put that object first.
Constructors should probably not be too different in this regard. Also,
if the additional parameters might want to use varargs which suggests to
put them last.

Note that this new scheme only applies to constructor functions, not to
all other functions. We do give a lot of freedom for those.

Note that this commit only changes the order of the new functions we
added, for old ones we accept the wrong order and leave it like that.
2014-02-20 00:03:10 +01:00

395 lines
13 KiB
C
Raw Blame History

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2013 Tom Gundersen <teg@jklm.no>
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include <netinet/ether.h>
#include "util.h"
#include "macro.h"
#include "sd-rtnl.h"
#include "socket-util.h"
#include "rtnl-util.h"
#include "event-util.h"
#include "missing.h"
static void test_link_configure(sd_rtnl *rtnl, int ifindex) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *message;
uint16_t type;
const char *mac = "98:fe:94:3f:c6:18", *name = "test";
unsigned int mtu = 1450;
void *data;
/* we'd really like to test NEWLINK, but let's not mess with the running kernel */
assert(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, ifindex) >= 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);
assert(sd_rtnl_call(rtnl, message, 0, NULL) == 1);
assert(sd_rtnl_message_read(message, &type, &data) > 0);
assert(type == IFLA_IFNAME);
assert(streq(name, (char *) data));
assert(sd_rtnl_message_read(message, &type, &data) > 0);
assert(type == IFLA_ADDRESS);
assert(streq(mac, ether_ntoa(data)));
assert(sd_rtnl_message_read(message, &type, &data) > 0);
assert(type == IFLA_MTU);
assert(mtu == *(unsigned int *) data);
}
static void test_link_get(sd_rtnl *rtnl, int ifindex) {
sd_rtnl_message *m;
sd_rtnl_message *r;
unsigned int mtu = 1500;
unsigned int *mtu_reply;
void *data;
uint16_t type;
assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(m);
/* u8 test cases */
assert(sd_rtnl_message_append_u8(m, IFLA_CARRIER, 0) >= 0);
assert(sd_rtnl_message_append_u8(m, IFLA_OPERSTATE, 0) >= 0);
assert(sd_rtnl_message_append_u8(m, IFLA_LINKMODE, 0) >= 0);
/* u32 test cases */
assert(sd_rtnl_message_append_u32(m, IFLA_MTU, mtu) >= 0);
assert(sd_rtnl_message_append_u32(m, IFLA_GROUP, 0) >= 0);
assert(sd_rtnl_message_append_u32(m, IFLA_TXQLEN, 0) >= 0);
assert(sd_rtnl_message_append_u32(m, IFLA_NUM_TX_QUEUES, 0) >= 0);
assert(sd_rtnl_message_append_u32(m, IFLA_NUM_RX_QUEUES, 0) >= 0);
assert(sd_rtnl_call(rtnl, m, -1, &r) == 1);
/* u8 read back */
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_CARRIER);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_OPERSTATE);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_LINKMODE);
/* u32 read back */
assert(sd_rtnl_message_read(m, &type, (void **) &mtu_reply) == 1);
assert(type == IFLA_MTU);
assert(*mtu_reply == mtu);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_GROUP);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_TXQLEN);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_NUM_TX_QUEUES);
assert(sd_rtnl_message_read(m, &type, &data) == 1);
assert(type == IFLA_NUM_RX_QUEUES);
while (sd_rtnl_message_read(r, &type, &data) > 0) {
switch (type) {
// case IFLA_MTU:
// assert(*(unsigned int *) data == 65536);
// break;
// case IFLA_QDISC:
// assert(streq((char *) data, "noqueue"));
// break;
case IFLA_IFNAME:
assert(streq((char *) data, "lo"));
break;
}
}
assert(sd_rtnl_flush(rtnl) >= 0);
assert((m = sd_rtnl_message_unref(m)) == NULL);
}
static void test_route(void) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *req;
struct in_addr addr;
uint32_t index = 2;
uint16_t type;
void *data;
int r;
r = sd_rtnl_message_new_route(NULL, &req, RTM_NEWROUTE, AF_INET);
if (r < 0) {
log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
return;
}
addr.s_addr = htonl(INADDR_LOOPBACK);
r = sd_rtnl_message_append_in_addr(req, RTA_GATEWAY, &addr);
if (r < 0) {
log_error("Could not append RTA_GATEWAY attribute: %s", strerror(-r));
return;
}
r = sd_rtnl_message_append_u32(req, RTA_OIF, index);
if (r < 0) {
log_error("Could not append RTA_OIF attribute: %s", strerror(-r));
return;
}
assert(rtnl_message_seal(NULL, req) >= 0);
assert(sd_rtnl_message_read(req, &type, &data) > 0);
assert(type == RTA_GATEWAY);
assert(((struct in_addr *)data)->s_addr == addr.s_addr);
assert(sd_rtnl_message_read(req, &type, &data) > 0);
assert(type == RTA_OIF);
assert(*(uint32_t *) data == index);
}
static void test_multiple(void) {
sd_rtnl *rtnl1, *rtnl2;
assert(sd_rtnl_open(&rtnl1, 0) >= 0);
assert(sd_rtnl_open(&rtnl2, 0) >= 0);
rtnl1 = sd_rtnl_unref(rtnl1);
rtnl2 = sd_rtnl_unref(rtnl2);
}
static int link_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
void *data;
uint16_t type;
char *ifname = userdata;
assert(rtnl);
assert(m);
log_info("got link info about %s", ifname);
free(ifname);
while (sd_rtnl_message_read(m, &type, &data) > 0) {
switch (type) {
// case IFLA_MTU:
// assert(*(unsigned int *) data == 65536);
// break;
// case IFLA_QDISC:
// assert(streq((char *) data, "noqueue"));
// break;
case IFLA_IFNAME:
assert(streq((char *) data, "lo"));
break;
}
}
return 1;
}
static void test_event_loop(int ifindex) {
_cleanup_event_unref_ sd_event *event = NULL;
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
char *ifname;
ifname = strdup("lo2");
assert(ifname);
assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, NULL) >= 0);
assert(sd_event_default(&event) >= 0);
assert(sd_rtnl_attach_event(rtnl, event, 0) >= 0);
assert(sd_event_run(event, 0) >= 0);
assert(sd_rtnl_detach_event(rtnl) >= 0);
}
static int pipe_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
int *counter = userdata;
(*counter) --;
log_info("got reply, %d left in pipe", *counter);
return sd_rtnl_message_get_errno(m);
}
static void test_async(int ifindex) {
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL, *r = NULL;
uint32_t serial;
char *ifname;
ifname = strdup("lo");
assert(ifname);
assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, &serial) >= 0);
assert(sd_rtnl_wait(rtnl, 0) >= 0);
assert(sd_rtnl_process(rtnl, &r) >= 0);
}
static void test_pipe(int ifindex) {
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
_cleanup_rtnl_message_unref_ sd_rtnl_message *m1 = NULL, *m2 = NULL;
int counter = 0;
assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(sd_rtnl_message_new_link(rtnl, &m1, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_message_new_link(rtnl, &m2, RTM_GETLINK, ifindex) >= 0);
counter ++;
assert(sd_rtnl_call_async(rtnl, m1, &pipe_handler, &counter, 0, NULL) >= 0);
counter ++;
assert(sd_rtnl_call_async(rtnl, m2, &pipe_handler, &counter, 0, NULL) >= 0);
while (counter > 0) {
assert(sd_rtnl_wait(rtnl, 0) >= 0);
assert(sd_rtnl_process(rtnl, NULL) >= 0);
}
}
static void test_container(void) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
uint16_t type;
void *data;
assert(sd_rtnl_message_new_link(NULL, &m, RTM_NEWLINK, 0) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) == -ENOTSUP);
assert(sd_rtnl_message_append_string(m, IFLA_INFO_KIND, "kind") >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_INFO_DATA) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_INFO_DATA) == -ENOTSUP);
assert(sd_rtnl_message_append_u16(m, IFLA_VLAN_ID, 100) >= 0);
assert(sd_rtnl_message_close_container(m) >= 0);
assert(sd_rtnl_message_append_string(m, IFLA_INFO_KIND, "kind") >= 0);
assert(sd_rtnl_message_close_container(m) >= 0);
assert(sd_rtnl_message_close_container(m) == -EINVAL);
assert(rtnl_message_seal(NULL, m) >= 0);
assert(sd_rtnl_message_read(m, &type, &data) >= 0);
assert(type == IFLA_LINKINFO);
assert(data == NULL);
assert(sd_rtnl_message_read(m, &type, &data) >= 0);
assert(type == IFLA_INFO_KIND);
assert(streq("kind", (char *)data));
assert(sd_rtnl_message_read(m, &type, &data) >= 0);
assert(type == IFLA_INFO_DATA);
assert(data == NULL);
assert(sd_rtnl_message_read(m, &type, &data) >= 0);
assert(type == IFLA_VLAN_ID);
assert(*(uint16_t *)data == 100);
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert(sd_rtnl_message_exit_container(m) >= 0);
assert(sd_rtnl_message_read(m, &type, &data) >= 0);
assert(type == IFLA_INFO_KIND);
assert(streq("kind", (char *)data));
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert(sd_rtnl_message_exit_container(m) >= 0);
assert(sd_rtnl_message_exit_container(m) == -EINVAL);
}
static void test_match(void) {
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
assert(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
assert(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
assert(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
assert(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 0);
}
int main(void) {
sd_rtnl *rtnl;
sd_rtnl_message *m;
sd_rtnl_message *r;
void *data;
int if_loopback;
uint16_t type;
test_match();
test_multiple();
test_route();
test_container();
assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(rtnl);
if_loopback = (int) if_nametoindex("lo");
assert(if_loopback > 0);
test_async(if_loopback);
test_pipe(if_loopback);
test_event_loop(if_loopback);
test_link_configure(rtnl, if_loopback);
assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
assert(m);
assert(sd_rtnl_message_get_type(m, &type) >= 0);
assert(type == RTM_GETLINK);
assert(sd_rtnl_message_read(m, &type, &data) == -EPERM);
assert(sd_rtnl_call(rtnl, m, 0, &r) == 1);
assert(sd_rtnl_message_get_type(r, &type) >= 0);
assert(type == RTM_NEWLINK);
assert(sd_rtnl_message_read(m, &type, &data) == 0);
assert((r = sd_rtnl_message_unref(r)) == NULL);
assert(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM);
assert((m = sd_rtnl_message_unref(m)) == NULL);
assert((r = sd_rtnl_message_unref(r)) == NULL);
test_link_get(rtnl, if_loopback);
assert(sd_rtnl_flush(rtnl) >= 0);
assert((m = sd_rtnl_message_unref(m)) == NULL);
assert((r = sd_rtnl_message_unref(r)) == NULL);
assert((rtnl = sd_rtnl_unref(rtnl)) == NULL);
return EXIT_SUCCESS;
}
Reference in a new issue View git blame Copy permalink