/* Opens a socket for a local datapath, initializing 'dp'. If
* 'subscribe_dp_idx' is nonnegative, listens for asynchronous messages
* (packet-in, etc.) from the datapath with that number; otherwise, 'dp' will
* receive only replies to explicitly initiated requests. */
int
dpif_open(int subscribe_dp_idx, struct dpif *dp)
{
struct nl_sock *sock;
int multicast_group = 0;
int retval;
retval = nl_lookup_genl_family(DP_GENL_FAMILY_NAME, &openflow_family);
if (retval) {
return retval;
}
if (subscribe_dp_idx >= 0) {
retval = lookup_openflow_multicast_group(subscribe_dp_idx,
&multicast_group);
if (retval) {
return retval;
}
}
/* Specify a large so_rcvbuf size because we occasionally need to be able
* to retrieve large collections of flow records. */
retval = nl_sock_create(NETLINK_GENERIC, multicast_group, 0,
4 * 1024u * 1024, &sock);
if (retval) {
return retval;
}
dp->sock = sock;
return 0;
}
/* Opens a socket for brcompat notifications. Returns 0 if successful,
* otherwise a positive errno value. */
static int
brc_open(struct nl_sock **sock)
{
int multicast_group = 0;
int retval;
retval = nl_lookup_genl_family(BRC_GENL_FAMILY_NAME, &brc_family);
if (retval) {
return retval;
}
retval = lookup_brc_multicast_group(&multicast_group);
if (retval) {
return retval;
}
retval = nl_sock_create(NETLINK_GENERIC, sock);
if (retval) {
return retval;
}
retval = nl_sock_join_mcgroup(*sock, multicast_group);
if (retval) {
nl_sock_destroy(*sock);
*sock = NULL;
}
return retval;
}
static int
lookup_brc_multicast_group(int *multicast_group)
{
struct nl_sock *sock;
struct ofpbuf request, *reply;
struct nlattr *attrs[ARRAY_SIZE(brc_multicast_policy)];
int retval;
retval = nl_sock_create(NETLINK_GENERIC, &sock);
if (retval) {
return retval;
}
ofpbuf_init(&request, 0);
nl_msg_put_genlmsghdr(&request, 0, brc_family,
NLM_F_REQUEST, BRC_GENL_C_QUERY_MC, 1);
retval = nl_sock_transact(sock, &request, &reply);
ofpbuf_uninit(&request);
if (retval) {
nl_sock_destroy(sock);
return retval;
}
if (!nl_policy_parse(reply, NLMSG_HDRLEN + GENL_HDRLEN,
brc_multicast_policy, attrs,
ARRAY_SIZE(brc_multicast_policy))) {
nl_sock_destroy(sock);
ofpbuf_delete(reply);
return EPROTO;
}
*multicast_group = nl_attr_get_u32(attrs[BRC_GENL_A_MC_GROUP]);
nl_sock_destroy(sock);
ofpbuf_delete(reply);
return 0;
}
/* Looks up the Netlink multicast group and datapath index of a datapath
* by either the datapath index or name. If 'dp_idx' points to a value
* of '-1', then 'dp_name' is used to lookup the datapath. If successful,
* stores the multicast group in '*multicast_group' and the index in
* '*dp_idx' and returns 0. Otherwise, returns a positive errno value. */
static int
query_datapath(int *dp_idx, int *multicast_group, const char *dp_name)
{
struct nl_sock *sock;
struct ofpbuf request, *reply;
struct nlattr *attrs[ARRAY_SIZE(openflow_multicast_policy)];
int retval;
retval = nl_sock_create(NETLINK_GENERIC, 0, 0, 0, &sock);
if (retval) {
return retval;
}
ofpbuf_init(&request, 0);
nl_msg_put_genlmsghdr(&request, sock, 0, openflow_family, NLM_F_REQUEST,
DP_GENL_C_QUERY_DP, 1);
if (*dp_idx != -1) {
nl_msg_put_u32(&request, DP_GENL_A_DP_IDX, *dp_idx);
}
if (dp_name) {
nl_msg_put_string(&request, DP_GENL_A_DP_NAME, dp_name);
}
retval = nl_sock_transact(sock, &request, &reply);
ofpbuf_uninit(&request);
if (retval) {
nl_sock_destroy(sock);
return retval;
}
if (!nl_policy_parse(reply, NLMSG_HDRLEN + GENL_HDRLEN,
openflow_multicast_policy, attrs,
ARRAY_SIZE(openflow_multicast_policy))) {
nl_sock_destroy(sock);
ofpbuf_delete(reply);
return EPROTO;
}
*dp_idx = nl_attr_get_u32(attrs[DP_GENL_A_DP_IDX]);
*multicast_group = nl_attr_get_u32(attrs[DP_GENL_A_MC_GROUP]);
nl_sock_destroy(sock);
ofpbuf_delete(reply);
return 0;
}
static int
netdev_windows_init_(void)
{
int error = 0;
static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
if (ovsthread_once_start(&once)) {
error = nl_lookup_genl_family(OVS_WIN_NETDEV_FAMILY,
&ovs_win_netdev_family);
if (error) {
VLOG_ERR("Generic Netlink family '%s' does not exist. "
"The Open vSwitch kernel module is probably not loaded.",
OVS_WIN_NETDEV_FAMILY);
}
if (!error) {
/* XXX: Where to close this socket? */
error = nl_sock_create(NETLINK_GENERIC, &ovs_win_netdev_sock);
}
ovsthread_once_done(&once);
}
return error;
}
/* Creates a new netlink socket for the same protocol as 'src'. Returns 0 and
* sets '*sockp' to the new socket if successful, otherwise returns a positive
* errno value. */
int
nl_sock_clone(const struct nl_sock *src, struct nl_sock **sockp)
{
return nl_sock_create(src->protocol, sockp);
}
int
main(int argc OVS_UNUSED, char *argv[])
{
uint64_t buf_stub[4096 / 64];
struct nl_sock *sock;
struct ofpbuf buf;
int error;
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_DBG);
error = nl_sock_create(NETLINK_ROUTE, &sock);
if (error) {
ovs_fatal(error, "could not create rtnetlink socket");
}
error = nl_sock_join_mcgroup(sock, RTNLGRP_LINK);
if (error) {
ovs_fatal(error, "could not join RTNLGRP_LINK multicast group");
}
ofpbuf_use_stub(&buf, buf_stub, sizeof buf_stub);
for (;;) {
error = nl_sock_recv(sock, &buf, false);
if (error == EAGAIN) {
/* Nothing to do. */
} else if (error == ENOBUFS) {
ovs_error(0, "network monitor socket overflowed");
} else if (error) {
ovs_fatal(error, "error on network monitor socket");
} else {
struct iff_flag {
unsigned int flag;
const char *name;
};
static const struct iff_flag flags[] = {
{ IFF_UP, "UP", },
{ IFF_BROADCAST, "BROADCAST", },
#ifndef _WIN32
{ IFF_DEBUG, "DEBUG", },
#endif
{ IFF_LOOPBACK, "LOOPBACK", },
#ifndef _WIN32
{ IFF_POINTOPOINT, "POINTOPOINT", },
{ IFF_NOTRAILERS, "NOTRAILERS", },
#endif
{ IFF_RUNNING, "RUNNING", },
#ifndef _WIN32
{ IFF_NOARP, "NOARP", },
#endif
{ IFF_PROMISC, "PROMISC", },
#ifndef _WIN32
{ IFF_ALLMULTI, "ALLMULTI", },
{ IFF_MASTER, "MASTER", },
{ IFF_SLAVE, "SLAVE", },
#endif
{ IFF_MULTICAST, "MULTICAST", },
#ifndef _WIN32
{ IFF_PORTSEL, "PORTSEL", },
{ IFF_AUTOMEDIA, "AUTOMEDIA", },
{ IFF_DYNAMIC, "DYNAMIC", },
#endif
};
struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
struct nlmsghdr *nlh;
struct ifinfomsg *iim;
int i;
nlh = ofpbuf_at(&buf, 0, NLMSG_HDRLEN);
iim = ofpbuf_at(&buf, NLMSG_HDRLEN, sizeof *iim);
if (!iim) {
ovs_error(0, "received bad rtnl message (no ifinfomsg)");
continue;
}
if (!nl_policy_parse(&buf, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
rtnlgrp_link_policy,
attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
ovs_error(0, "received bad rtnl message (policy)");
continue;
}
printf("netdev %s changed (%s):\n",
nl_attr_get_string(attrs[IFLA_IFNAME]),
(nlh->nlmsg_type == RTM_NEWLINK ? "RTM_NEWLINK"
#ifndef _WIN32
: nlh->nlmsg_type == RTM_DELLINK ? "RTM_DELLINK"
#endif
: nlh->nlmsg_type == RTM_GETLINK ? "RTM_GETLINK"
#ifndef _WIN32
: nlh->nlmsg_type == RTM_SETLINK ? "RTM_SETLINK"
#endif
: "other"));
printf("\tflags:");
for (i = 0; i < ARRAY_SIZE(flags); i++) {
if (iim->ifi_flags & flags[i].flag) {
printf(" %s", flags[i].name);
}
}
printf("\n");
if (attrs[IFLA_MASTER]) {
uint32_t idx = nl_attr_get_u32(attrs[IFLA_MASTER]);
char ifname[IFNAMSIZ];
#ifndef _WIN32
if (!if_indextoname(idx, ifname)) {
strcpy(ifname, "unknown");
}
#endif
printf("\tmaster=%"PRIu32" (%s)\n", idx, ifname);
}
}
nl_sock_wait(sock, POLLIN);
poll_block();
}
}