int nl_dect_cell_build_msg(struct nl_msg *msg, struct nl_dect_cell *cell)
{
struct dectmsg dm = {
.dm_index = cell->c_index,
};
if (nlmsg_append(msg, &dm, sizeof(dm), NLMSG_ALIGNTO) < 0)
goto nla_put_failure;
if (cell->ce_mask & CELL_ATTR_NAME)
NLA_PUT_STRING(msg, DECTA_CELL_NAME, cell->c_name);
if (cell->ce_mask & CELL_ATTR_FLAGS)
NLA_PUT_U32(msg, DECTA_CELL_FLAGS, cell->c_flags);
if (cell->ce_mask & CELL_ATTR_LINK)
NLA_PUT_U8(msg, DECTA_CELL_CLUSTER, cell->c_link);
return 0;
nla_put_failure:
return -NLE_MSGSIZE;
}
static struct trans_tbl cell_flags[] = {
__ADD(DECT_CELL_CCP, ccp)
__ADD(DECT_CELL_SLAVE, slave)
__ADD(DECT_CELL_MONITOR, monitor)
};
char *nl_dect_cell_flags2str(uint32_t flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, cell_flags, ARRAY_SIZE(cell_flags));
}
uint32_t nl_dect_cell_str2flags(const char *str)
{
return __str2flags(str, cell_flags, ARRAY_SIZE(cell_flags));
}
/** @cond SKIP */
struct nl_object_ops nl_dect_cell_obj_ops = {
.oo_name = "nl_dect/cell",
.oo_size = sizeof(struct nl_dect_cell),
.oo_free_data = cell_free_data,
.oo_dump = {
[NL_DUMP_LINE] = cell_dump,
},
.oo_id_attrs = CELL_ATTR_NAME,
/**
* Send a netlink message.
* @arg handle netlink handle
* @arg nmsg netlink message
* @return see sendmsg(2)
*/
int nl_send(struct nl_handle *handle, struct nlmsghdr *nmsg)
{
struct nl_cb *cb;
struct iovec iov = {
.iov_base = (void *) nmsg,
.iov_len = nmsg->nlmsg_len,
};
struct msghdr msg = {
.msg_name = (void *) &handle->h_peer,
.msg_namelen = sizeof(struct sockaddr_nl),
.msg_iov = &iov,
.msg_iovlen = 1,
};
cb = &handle->h_cb;
if (cb->cb_msg_out)
if (cb->cb_msg_out(nmsg, cb->cb_msg_out_arg) != NL_PROCEED)
return 0;
return sendmsg(handle->h_fd, &msg, 0);
}
/**
* Send a netlink message and check & extend needed header values
* @arg handle netlink handle
* @arg nmsg netlink message
*
* Checks the netlink message \c nmsg for completness and extends it
* as required before sending it out. Checked fields include pid,
* sequence nr, and flags.
*
* @return see sendmsg(2)
*/
int nl_send_auto_complete(struct nl_handle *handle, struct nlmsghdr *nmsg)
{
if (nmsg->nlmsg_pid == 0)
nmsg->nlmsg_pid = handle->h_local.nl_pid;
if (nmsg->nlmsg_seq == 0)
nmsg->nlmsg_seq = handle->h_seq_next++;
nmsg->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK);
if (handle->h_cb.cb_send_ow)
return handle->h_cb.cb_send_ow(handle, nmsg);
else
return nl_send(handle, nmsg);
}
/**
* Send a netlink request message
* @arg handle netlink handle
* @arg type message type
* @arg flags message flags
*
* Fills out a netlink request message and sends it out using
* nl_send_auto_complete()
*
* @return See sendmsg(2)
*/
int nl_request(struct nl_handle *handle, int type, int flags)
{
struct nlmsghdr n = {
.nlmsg_len = NLMSG_LENGTH(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
return nl_send_auto_complete(handle, &n);
}
/**
* Send a netlink request message with data.
* @arg handle netlink handle
* @arg type message type
* @arg flags message flags
* @arg buf data buffer
* @arg len length of data
*
* Fills out a netlink request message, appends the data to the tail
* and sends it out using nl_send_auto_complete().
*
* @return See sendmsg(2)
*/
int nl_request_with_data(struct nl_handle *handle, int type, int flags,
unsigned char *buf, size_t len)
{
int err = 0;
struct nl_msg *m;
struct nlmsghdr n = {
.nlmsg_len = NLMSG_LENGTH(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
m = nl_msg_build(&n);
nl_msg_append_raw(m, buf, len);
err = nl_send_auto_complete(handle, m->nmsg);
nl_msg_free(m);
return err;
}
/** @} */
/**
* @name Receive
* @{
*/
/**
* Receive a netlink message from netlink socket.
* @arg handle netlink handle
* @arg nla target pointer for peer's netlink address
* @arg buf target pointer for message content.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interruped system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_handle *handle, struct sockaddr_nl *nla, unsigned char **buf)
{
int n;
int flags = MSG_PEEK;
struct iovec iov = {
.iov_len = 4096,
};
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(sizeof(struct sockaddr_nl)),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
iov.iov_base = *buf = calloc(1, iov.iov_len);
retry:
if ((n = recvmsg(handle->h_fd, &msg, flags)) <= 0) {
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR)
goto retry;
else if (errno == EAGAIN)
goto abort;
else {
free(*buf);
return nl_error(errno, "recvmsg failed");
}
}
}
if (iov.iov_len < n) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(*buf);
return nl_error(EADDRNOTAVAIL, "socket address size mismatch");
}
return n;
abort:
free(*buf);
return 0;
}
/**
* Receive a set of messages from a netlink socket.
* @arg handle netlink handle
* @arg cb set of callbacks to control the behaviour.
*
* Repeatedly calls nl_recv() and parses the messages as netlink
* messages. Stops reading if one of the callbacks returns
* NL_EXIT or nl_recv returns either 0 or a negative error code.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return 0 on success or a negative error code from nl_recv().
* @see \ref Handlers
*/
int nl_recvmsgs(struct nl_handle *handle, struct nl_cb *cb)
{
int n, err = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
continue_reading:
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(handle, &nla, &buf);
else
n = nl_recv(handle, &nla, &buf);
if (n <= 0)
return n;
hdr = (struct nlmsghdr *) buf;
while (NLMSG_OK(hdr, n)) {
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_msg_in) {
err = cb->cb_msg_in(&nla, hdr, cb->cb_msg_in_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_seq_check) {
err = cb->cb_seq_check(&nla, hdr, cb->cb_seq_check_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else if (hdr->nlmsg_seq != handle->h_seq_expect) {
if (cb->cb_invalid) {
err = cb->cb_invalid(&nla, hdr,
cb->cb_invalid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
handle->h_seq_expect++;
}
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_send_ack) {
err = cb->cb_send_ack(&nla, hdr,
cb->cb_send_ack_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
if (cb->cb_finish) {
err = cb->cb_finish(&nla, hdr,
cb->cb_finish_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
goto out;
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_skipped) {
err = cb->cb_skipped(&nla, hdr,
cb->cb_skipped_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_overrun) {
err = cb->cb_overrun(&nla, hdr,
cb->cb_overrun_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = (struct nlmsgerr*) NLMSG_DATA(hdr);
if (hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_invalid) {
err = cb->cb_invalid(&nla, hdr,
cb->cb_invalid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_error) {
err = cb->cb_error(&nla, e,
cb->cb_error_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (cb->cb_ack) {
/* ACK */
err = cb->cb_ack(&nla, hdr, cb->cb_ack_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_valid) {
err = cb->cb_valid(&nla, hdr, cb->cb_valid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
}
skip:
hdr = NLMSG_NEXT(hdr, n);
}
if (buf) {
free(buf);
buf = NULL;
}
/* Multipart message not yet complete, continue reading */
goto continue_reading;
out:
if (buf)
free(buf);
return err;
}
/**
* Receive a set of message from a netlink socket using handlers in nl_handle.
* @arg handle netlink handle
*
* Calls nl_recvmsgs() with the handlers configured in the netlink handle.
*
* @see \ref Handlers
*/
int nl_recvmsgs_def(struct nl_handle *handle)
{
if (handle->h_cb.cb_recvmsgs_ow)
return handle->h_cb.cb_recvmsgs_ow(handle, &handle->h_cb);
else
return nl_recvmsgs(handle, &handle->h_cb);
}
static int ack_wait_handler(struct sockaddr_nl *who, struct nlmsghdr *n,
void *arg)
{
return NL_EXIT;
}
/**
* Wait for ACK.
* @arg handle netlink handle
* @pre The netlink socket must be in blocking state.
*
* Waits until an ACK is received for the latest not yet acknoledged
* netlink message.
*/
int nl_wait_for_ack(struct nl_handle *handle)
{
struct nl_cb cb;
memcpy(&cb, &handle->h_cb, sizeof(cb));
cb.cb_ack = ack_wait_handler;
return nl_recvmsgs(handle, &cb);
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_SKIP,skip)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_TCPDIAG,tcpdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ARPD,arpd)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_ROUTE6,route6)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_TAPBASE,tapbase)
};
/**
* Convert a netlink family to a character string (Reentrant).
* @arg family netlink family
* @arg buf destination buffer
* @arg len buffer length
*
* Converts a netlink family to a character string and stores it in
* the specified destination buffer.
*
* @return The destination buffer or the family encoded in hexidecimal
* form if no match was found.
*/
char * nl_nlfamily2str_r(int family, char *buf, size_t len)
{
return __type2str_r(family, buf, len, nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert a netlink family to a character string.
* @arg family netlink family
*
* Converts a netlink family to a character string and stores it in a
* static buffer.
*
* @return A static buffer or the family encoded in hexidecimal
* form if no match was found.
* @attention This funnction is NOT thread safe.
*/
char * nl_nlfamily2str(int family)
{
static char buf[32];
memset(buf, 0, sizeof(buf));
return __type2str_r(family, buf, sizeof(buf), nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert a character string to a netlink family
* @arg name name of netlink family
*
* Converts the provided character string specifying a netlink
* family to the corresponding numeric value.
*
* @return Netlink family negative value if none was found.
*/
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
if (queue->ce_mask & QUEUE_ATTR_MAXLEN)
nl_dump(p, "maxlen=%u ", queue->queue_maxlen);
if (queue->ce_mask & QUEUE_ATTR_COPY_MODE)
nl_dump(p, "copy_mode=%s ",
nfnl_queue_copy_mode2str(queue->queue_copy_mode,
buf, sizeof(buf)));
if (queue->ce_mask & QUEUE_ATTR_COPY_RANGE)
nl_dump(p, "copy_range=%u ", queue->queue_copy_range);
nl_dump(p, "\n");
}
static const struct trans_tbl copy_modes[] = {
__ADD(NFNL_QUEUE_COPY_NONE, none),
__ADD(NFNL_QUEUE_COPY_META, meta),
__ADD(NFNL_QUEUE_COPY_PACKET, packet),
};
char *nfnl_queue_copy_mode2str(enum nfnl_queue_copy_mode copy_mode, char *buf,
size_t len)
{
return __type2str(copy_mode, buf, len, copy_modes,
ARRAY_SIZE(copy_modes));
}
int nfnl_queue_str2copy_mode(const char *name)
{
return __str2type(name, copy_modes, ARRAY_SIZE(copy_modes));
}
diff |= RULE_DIFF(TYPE, a->r_type != b->r_type);
diff |= RULE_DIFF(PRIO, a->r_prio != b->r_prio);
diff |= RULE_DIFF(MARK, a->r_mark != b->r_mark);
diff |= RULE_DIFF(SRC_LEN, a->r_src_len != b->r_src_len);
diff |= RULE_DIFF(DST_LEN, a->r_dst_len != b->r_dst_len);
diff |= RULE_DIFF(SRC, nl_addr_cmp(a->r_src, b->r_src));
diff |= RULE_DIFF(DST, nl_addr_cmp(a->r_dst, b->r_dst));
diff |= RULE_DIFF(IIF, strcmp(a->r_iif, b->r_iif));
#undef RULE_DIFF
return diff;
}
static struct trans_tbl rule_attrs[] = {
__ADD(RULE_ATTR_FAMILY, family)
__ADD(RULE_ATTR_PRIO, prio)
__ADD(RULE_ATTR_MARK, mark)
__ADD(RULE_ATTR_IIF, iif)
__ADD(RULE_ATTR_REALMS, realms)
__ADD(RULE_ATTR_SRC, src)
__ADD(RULE_ATTR_DST, dst)
__ADD(RULE_ATTR_DSFIELD, dsfield)
__ADD(RULE_ATTR_TABLE, table)
__ADD(RULE_ATTR_TYPE, type)
__ADD(RULE_ATTR_SRC_LEN, src_len)
__ADD(RULE_ATTR_DST_LEN, dst_len)
__ADD(RULE_ATTR_SRCMAP, srcmap)
};
static char *rule_attrs2str(int attrs, char *buf, size_t len)
#include <netlink-local.h>
#include <netlink-tc.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <netlink/route/tc.h>
#include <netlink/route/classifier.h>
#include <netlink/route/classifier-modules.h>
#include <netlink/route/cls/police.h>
/**
* @name Policer Type
* @{
*/
static struct trans_tbl police_types[] = {
__ADD(TC_POLICE_UNSPEC,unspec)
__ADD(TC_POLICE_OK,ok)
__ADD(TC_POLICE_RECLASSIFY,reclassify)
__ADD(TC_POLICE_SHOT,shot)
#ifdef TC_POLICE_PIPE
__ADD(TC_POLICE_PIPE,pipe)
#endif
};
/**
* Transform a policer type number into a character string (Reentrant).
* @arg type policer type
* @arg buf destination buffer
* @arg len buffer length
*
* Transforms a policer type number into a character string and stores
if (flags & LOOSE_COMPARISON)
diff |= CT_DIFF(STATUS, (a->ct_status ^ b->ct_status) &
b->ct_status_mask);
else
diff |= CT_DIFF(STATUS, a->ct_status != b->ct_status);
#undef CT_DIFF
#undef CT_DIFF_VAL
#undef CT_DIFF_ADDR
return diff;
}
static const struct trans_tbl ct_attrs[] = {
__ADD(CT_ATTR_FAMILY, family),
__ADD(CT_ATTR_PROTO, proto),
__ADD(CT_ATTR_TCP_STATE, tcpstate),
__ADD(CT_ATTR_STATUS, status),
__ADD(CT_ATTR_TIMEOUT, timeout),
__ADD(CT_ATTR_MARK, mark),
__ADD(CT_ATTR_USE, use),
__ADD(CT_ATTR_ID, id),
__ADD(CT_ATTR_ORIG_SRC, origsrc),
__ADD(CT_ATTR_ORIG_DST, origdst),
__ADD(CT_ATTR_ORIG_SRC_PORT, origsrcport),
__ADD(CT_ATTR_ORIG_DST_PORT, origdstport),
__ADD(CT_ATTR_ORIG_ICMP_ID, origicmpid),
__ADD(CT_ATTR_ORIG_ICMP_TYPE, origicmptype),
__ADD(CT_ATTR_ORIG_ICMP_CODE, origicmpcode),
__ADD(CT_ATTR_ORIG_PACKETS, origpackets),
if ((err = nl_send_auto_complete(handle, nl_msg_get(m))) < 0)
return err;
nl_msg_free(m);
return nl_wait_for_ack(handle);
}
/** @} */
/**
* @name Neighbour States Translations
* @{
*/
static struct trans_tbl neigh_states[] = {
__ADD(NUD_INCOMPLETE, incomplete)
__ADD(NUD_REACHABLE, reachable)
__ADD(NUD_STALE, stale)
__ADD(NUD_DELAY, delay)
__ADD(NUD_PROBE, probe)
__ADD(NUD_FAILED, failed)
__ADD(NUD_NOARP, norarp)
__ADD(NUD_PERMANENT, permanent)
};
/**
* Convert neighbour states to a character string.
* @arg state neighbour state
*
* Converts a neighbour state to a character string separated by
* commas and stores it in a static buffer.
* lib/netfilter/netfilter.c Netfilter Generic Functions
*
* This library 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 version 2.1
* of the License.
*
* Copyright (c) 2008 Patrick McHardy <*****@*****.**>
*/
#include <netlink-local.h>
#include <netlink/netfilter/netfilter.h>
#include <linux/netfilter.h>
static const struct trans_tbl nfnl_verdicts[] = {
__ADD(NF_DROP, NF_DROP)
__ADD(NF_ACCEPT, NF_ACCEPT)
__ADD(NF_STOLEN, NF_STOLEN)
__ADD(NF_QUEUE, NF_QUEUE)
__ADD(NF_REPEAT, NF_REPEAT)
__ADD(NF_STOP, NF_STOP)
};
char *nfnl_verdict2str(unsigned int verdict, char *buf, size_t len)
{
return __type2str(verdict, buf, len, nfnl_verdicts,
ARRAY_SIZE(nfnl_verdicts));
}
unsigned int nfnl_str2verdict(const char *name)
{
v = meta_alloc(TCF_META_TYPE(hdr->right.kind),
TCF_META_ID(hdr->right.kind),
hdr->right.shift, vdata, vlen);
if (!v) {
rtnl_meta_value_put(m->left);
return -NLE_NOMEM;
}
m->right = v;
m->opnd = hdr->left.op;
return 0;
}
static const struct trans_tbl meta_int[] = {
__ADD(TCF_META_ID_RANDOM, random)
__ADD(TCF_META_ID_LOADAVG_0, loadavg_0)
__ADD(TCF_META_ID_LOADAVG_1, loadavg_1)
__ADD(TCF_META_ID_LOADAVG_2, loadavg_2)
__ADD(TCF_META_ID_DEV, dev)
__ADD(TCF_META_ID_PRIORITY, prio)
__ADD(TCF_META_ID_PROTOCOL, proto)
__ADD(TCF_META_ID_PKTTYPE, pkttype)
__ADD(TCF_META_ID_PKTLEN, pktlen)
__ADD(TCF_META_ID_DATALEN, datalen)
__ADD(TCF_META_ID_MACLEN, maclen)
__ADD(TCF_META_ID_NFMARK, mark)
__ADD(TCF_META_ID_TCINDEX, tcindex)
__ADD(TCF_META_ID_RTCLASSID, rtclassid)
__ADD(TCF_META_ID_RTIIF, rtiif)
__ADD(TCF_META_ID_SK_FAMILY, sk_family)
BUG();
if (rtnl_route_ops.co_dump[type])
rtnl_route_ops.co_dump[type](NULL, (struct nl_common *) route,
fd, params);
}
/** @} */
/**
* \name Scope Translations
* @{
*/
static struct trans_tbl scopes[] = {
__ADD(255,nowhere)
__ADD(254,host)
__ADD(253,link)
__ADD(200,site)
__ADD(0,global)
};
/**
* Convert a scope ID to a character string.
* @arg scope scope id
*
* Converts a scope ID o a character string and stores it in a
* static buffer.
*
* \return A static buffer or the type encoded in hexidecimal
* form if no match was found.
diff |= 1;
}
}
}
#undef XFRM_AE_DIFF
return diff;
}
/**
* @name XFRM AE Attribute Translations
* @{
*/
static const struct trans_tbl ae_attrs[] =
{
__ADD(XFRM_AE_ATTR_DADDR, daddr),
__ADD(XFRM_AE_ATTR_SPI, spi),
__ADD(XFRM_AE_ATTR_PROTO, protocol),
__ADD(XFRM_AE_ATTR_SADDR, saddr),
__ADD(XFRM_AE_ATTR_FLAGS, flags),
__ADD(XFRM_AE_ATTR_REQID, reqid),
__ADD(XFRM_AE_ATTR_MARK, mark),
__ADD(XFRM_AE_ATTR_LIFETIME, cur_lifetime),
__ADD(XFRM_AE_ATTR_REPLAY_MAXAGE, replay_maxage),
__ADD(XFRM_AE_ATTR_REPLAY_MAXDIFF, replay_maxdiff),
__ADD(XFRM_AE_ATTR_REPLAY_STATE, replay_state),
};
static char* xfrm_ae_attrs2str (int attrs, char *buf, size_t len)
{
return __flags2str(attrs, buf, len, ae_attrs, ARRAY_SIZE(ae_attrs));
diff |= EXP_DIFF_L4PROTO_PORTS(NAT_L4PROTO_PORTS, exp_nat.proto.l4protodata);
diff |= EXP_DIFF_L4PROTO_ICMP(NAT_L4PROTO_ICMP, exp_nat.proto.l4protodata);
#undef EXP_DIFF
#undef EXP_DIFF_VAL
#undef EXP_DIFF_STRING
#undef EXP_DIFF_ADDR
#undef EXP_DIFF_L4PROTO_PORTS
#undef EXP_DIFF_L4PROTO_ICMP
return diff;
}
// CLI arguments?
static const struct trans_tbl exp_attrs[] = {
__ADD(EXP_ATTR_FAMILY, family),
__ADD(EXP_ATTR_TIMEOUT, timeout),
__ADD(EXP_ATTR_ID, id),
__ADD(EXP_ATTR_HELPER_NAME, helpername),
__ADD(EXP_ATTR_ZONE, zone),
__ADD(EXP_ATTR_CLASS, class),
__ADD(EXP_ATTR_FLAGS, flags),
__ADD(EXP_ATTR_FN, function),
__ADD(EXP_ATTR_EXPECT_IP_SRC, expectipsrc),
__ADD(EXP_ATTR_EXPECT_IP_DST, expectipdst),
__ADD(EXP_ATTR_EXPECT_L4PROTO_NUM, expectprotonum),
__ADD(EXP_ATTR_EXPECT_L4PROTO_PORTS, expectports),
__ADD(EXP_ATTR_EXPECT_L4PROTO_ICMP, expecticmp),
__ADD(EXP_ATTR_MASTER_IP_SRC, masteripsrc),
__ADD(EXP_ATTR_MASTER_IP_DST, masteripdst),
__ADD(EXP_ATTR_MASTER_L4PROTO_NUM, masterprotonum),
if (negress == NULL)
return NULL;
if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
*negress = vi->vi_negress;
return vi->vi_egress_qos;
} else {
*negress = 0;
return NULL;
}
}
/** @} */
static const struct trans_tbl vlan_flags[] = {
__ADD(VLAN_FLAG_REORDER_HDR, reorder_hdr),
__ADD(VLAN_FLAG_GVRP, gvrp),
__ADD(VLAN_FLAG_LOOSE_BINDING, loose_binding),
__ADD(VLAN_FLAG_MVRP, mvrp),
};
/**
* @name Flag Translation
* @{
*/
char *rtnl_link_vlan_flags2str(int flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, vlan_flags, ARRAY_SIZE(vlan_flags));
}
/*
* __env_struct_sig --
* Compute signature of structures.
*
* PUBLIC: u_int32_t __env_struct_sig __P((void));
*/
u_int32_t
__env_struct_sig()
{
u_short t[__STRUCTURE_COUNT + 5];
u_int i;
i = 0;
#define __ADD(s) (t[i++] = sizeof(struct s))
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__db_mutex_stat);
#endif
__ADD(__db_lock_stat);
__ADD(__db_lock_hstat);
__ADD(__db_lock_pstat);
__ADD(__db_ilock);
__ADD(__db_lock_u);
__ADD(__db_lsn);
__ADD(__db_log_stat);
__ADD(__db_mpool_stat);
__ADD(__db_rep_stat);
__ADD(__db_repmgr_stat);
__ADD(__db_seq_stat);
__ADD(__db_bt_stat);
__ADD(__db_h_stat);
__ADD(__db_heap_stat);
__ADD(__db_qam_stat);
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__mutex_state);
#endif
__ADD(__db_thread_info);
__ADD(__env_thread_info);
__ADD(__db_lockregion);
__ADD(__sh_dbt);
__ADD(__db_lockobj);
__ADD(__db_locker);
__ADD(__db_lockpart);
__ADD(__db_lock);
__ADD(__log);
__ADD(__mpool);
__ADD(__db_mpool_fstat_int);
__ADD(__mpoolfile);
__ADD(__bh);
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__db_mutexregion);
#endif
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__mutex_history);
#endif
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__db_mutex_t);
#endif
__ADD(__db_reg_env);
__ADD(__db_region);
__ADD(__rep);
__ADD(__db_txn_stat_int);
__ADD(__db_txnregion);
#ifndef HAVE_MIXED_SIZE_ADDRESSING
__ADD(__db_dbt);
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__db_event_mutex_died_info);
#endif
__ADD(__db_event_failchk_info);
__ADD(__db_lockreq);
__ADD(__db_log_cursor);
__ADD(__log_rec_spec);
__ADD(__db_mpoolfile);
__ADD(__db_mpool_fstat);
__ADD(__db_txn);
__ADD(__kids);
__ADD(__my_cursors);
__ADD(__femfs);
__ADD(__db_preplist);
__ADD(__db_txn_active);
__ADD(__db_txn_stat);
__ADD(__db_txn_token);
__ADD(__db_repmgr_site);
__ADD(__db_repmgr_conn_err);
__ADD(__db_seq_record);
__ADD(__db_sequence);
__ADD(__db);
__ADD(__cq_fq);
__ADD(__cq_aq);
__ADD(__cq_jq);
__ADD(__db_stream);
__ADD(__db_heap_rid);
__ADD(__dbc);
__ADD(__key_range);
__ADD(__db_compact);
__ADD(__db_env);
__ADD(__db_distab);
__ADD(__db_logvrfy_config);
__ADD(__db_channel);
__ADD(__db_site);
__ADD(__fn);
__ADD(__db_msgbuf);
__ADD(__pin_list);
__ADD(__flag_map);
__ADD(__db_backup_handle);
__ADD(__env);
__ADD(__dbc_internal);
__ADD(__dbpginfo);
__ADD(__epg);
__ADD(__cursor);
__ADD(__btree);
__ADD(__db_cipher);
__ADD(__db_foreign_info);
__ADD(__db_txnhead);
__ADD(__db_txnlist);
__ADD(__join_cursor);
__ADD(__pg_chksum);
__ADD(__pg_crypto);
__ADD(__heaphdr);
__ADD(__heaphdrsplt);
__ADD(__pglist);
__ADD(__vrfy_dbinfo);
__ADD(__vrfy_pageinfo);
__ADD(__vrfy_childinfo);
__ADD(__db_globals);
__ADD(__envq);
__ADD(__heap);
__ADD(__heap_cursor);
__ADD(__db_locktab);
__ADD(__db_entry);
__ADD(__fname);
__ADD(__db_log);
__ADD(__hdr);
__ADD(__log_persist);
__ADD(__db_commit);
__ADD(__db_filestart);
__ADD(__log_rec_hdr);
__ADD(__db_log_verify_info);
__ADD(__txn_verify_info);
__ADD(__lv_filereg_info);
__ADD(__lv_filelife);
__ADD(__lv_ckp_info);
__ADD(__lv_timestamp_info);
__ADD(__lv_txnrange);
__ADD(__add_recycle_params);
__ADD(__ckp_verify_params);
__ADD(__db_mpool);
__ADD(__db_mpreg);
__ADD(__db_mpool_hash);
__ADD(__bh_frozen_p);
__ADD(__bh_frozen_a);
#ifdef HAVE_MUTEX_SUPPORT
__ADD(__db_mutexmgr);
#endif
__ADD(__fh_t);
__ADD(__db_partition);
__ADD(__part_internal);
__ADD(__qcursor);
__ADD(__mpfarray);
__ADD(__qmpf);
__ADD(__queue);
__ADD(__qam_filelist);
__ADD(__db_reg_env_ref);
__ADD(__db_region_mem_t);
__ADD(__db_reginfo_t);
__ADD(__rep_waiter);
__ADD(__db_rep);
__ADD(__rep_lease_entry);
__ADD(__txn_detail);
__ADD(__db_txnmgr);
__ADD(__db_commit_info);
__ADD(__txn_logrec);
#endif
return (__ham_func5(NULL, t, i * sizeof(t[0])));
}
buf += l;
len -= l;
}
return buf_orig;
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static const struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route),
__ADD(NETLINK_USERSOCK,usersock),
__ADD(NETLINK_FIREWALL,firewall),
__ADD(NETLINK_INET_DIAG,inetdiag),
__ADD(NETLINK_NFLOG,nflog),
__ADD(NETLINK_XFRM,xfrm),
__ADD(NETLINK_SELINUX,selinux),
__ADD(NETLINK_ISCSI,iscsi),
__ADD(NETLINK_AUDIT,audit),
__ADD(NETLINK_FIB_LOOKUP,fib_lookup),
__ADD(NETLINK_CONNECTOR,connector),
__ADD(NETLINK_NETFILTER,netfilter),
__ADD(NETLINK_IP6_FW,ip6_fw),
__ADD(NETLINK_DNRTMSG,dnrtmsg),
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent),
__ADD(NETLINK_GENERIC,generic),
};
err = nl_send_simple(sk, type, flags, &gmsg, sizeof(gmsg));
return err >= 0 ? 0 : err;
}
/** @} */
/**
* @name Routing Type Translations
* @{
*/
static const struct trans_tbl rtntypes[] = {
__ADD(RTN_UNSPEC,unspec)
__ADD(RTN_UNICAST,unicast)
__ADD(RTN_LOCAL,local)
__ADD(RTN_BROADCAST,broadcast)
__ADD(RTN_ANYCAST,anycast)
__ADD(RTN_MULTICAST,multicast)
__ADD(RTN_BLACKHOLE,blackhole)
__ADD(RTN_UNREACHABLE,unreachable)
__ADD(RTN_PROHIBIT,prohibit)
__ADD(RTN_THROW,throw)
__ADD(RTN_NAT,nat)
__ADD(RTN_XRESOLVE,xresolve)
};
char *nl_rtntype2str(int type, char *buf, size_t size)
{
}
uint32_t rtnl_route_nh_get_realms(struct rtnl_nexthop *nh)
{
return nh->rtnh_realms;
}
/** @} */
/**
* @name Nexthop Flags Translations
* @{
*/
static const struct trans_tbl nh_flags[] = {
__ADD(RTNH_F_DEAD, dead)
__ADD(RTNH_F_PERVASIVE, pervasive)
__ADD(RTNH_F_ONLINK, onlink)
};
char *rtnl_route_nh_flags2str(int flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, nh_flags, ARRAY_SIZE(nh_flags));
}
int rtnl_route_nh_str2flags(const char *name)
{
return __str2flags(name, nh_flags, ARRAY_SIZE(nh_flags));
}
/** @} */
stat);
}
}
return 0;
}
/* These live in include/net/if_inet6.h and should be moved to include/linux */
#define IF_RA_OTHERCONF 0x80
#define IF_RA_MANAGED 0x40
#define IF_RA_RCVD 0x20
#define IF_RS_SENT 0x10
#define IF_READY 0x80000000
static const struct trans_tbl inet6_flags[] = {
__ADD(IF_RA_OTHERCONF, ra_otherconf)
__ADD(IF_RA_MANAGED, ra_managed)
__ADD(IF_RA_RCVD, ra_rcvd)
__ADD(IF_RS_SENT, rs_sent)
__ADD(IF_READY, ready)
};
static char *inet6_flags2str(int flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, inet6_flags,
ARRAY_SIZE(inet6_flags));
}
static const struct trans_tbl inet6_devconf[] = {
__ADD(DEVCONF_FORWARDING, forwarding)
__ADD(DEVCONF_HOPLIMIT, hoplimit)
/**
* Send netlink message with control over sendmsg() message header.
* @arg handle Netlink handle.
* @arg msg Netlink message to be sent.
* @arg hdr Sendmsg() message header.
* @return Number of characters sent on sucess or a negative error code.
*/
int nl_sendmsg(struct nl_handle *handle, struct nl_msg *msg, struct msghdr *hdr)
{
struct nl_cb *cb;
int ret;
struct iovec iov = {
.iov_base = (void *) nlmsg_hdr(msg),
.iov_len = nlmsg_hdr(msg)->nlmsg_len,
};
hdr->msg_iov = &iov;
hdr->msg_iovlen = 1;
nlmsg_set_src(msg, &handle->h_local);
cb = nl_handle_get_cb(handle);
if (cb->cb_set[NL_CB_MSG_OUT])
if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_PROCEED)
return 0;
ret = sendmsg(handle->h_fd, hdr, 0);
if (ret < 0)
return nl_errno(errno);
return ret;
}
/**
* Send netlink message.
* @arg handle Netlink handle
* @arg msg Netlink message to be sent.
* @see nl_sendmsg()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send(struct nl_handle *handle, struct nl_msg *msg)
{
struct sockaddr_nl *dst;
struct ucred *creds;
struct msghdr hdr = {
.msg_name = (void *) &handle->h_peer,
.msg_namelen = sizeof(struct sockaddr_nl),
};
/* Overwrite destination if specified in the message itself, defaults
* to the peer address of the handle.
*/
dst = nlmsg_get_dst(msg);
if (dst->nl_family == AF_NETLINK)
hdr.msg_name = dst;
/* Add credentials if present. */
creds = nlmsg_get_creds(msg);
if (creds != NULL) {
char buf[CMSG_SPACE(sizeof(struct ucred))];
struct cmsghdr *cmsg;
hdr.msg_control = buf;
hdr.msg_controllen = sizeof(buf);
cmsg = CMSG_FIRSTHDR(&hdr);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
}
return nl_sendmsg(handle, msg, &hdr);
}
/**
* Send netlink message and check & extend header values as needed.
* @arg handle Netlink handle.
* @arg msg Netlink message to be sent.
*
* Checks the netlink message \c nlh for completness and extends it
* as required before sending it out. Checked fields include pid,
* sequence nr, and flags.
*
* @see nl_send()
* @return Number of characters sent or a negative error code.
*/
int nl_send_auto_complete(struct nl_handle *handle, struct nl_msg *msg)
{
struct nlmsghdr *nlh;
nlh = nlmsg_hdr(msg);
if (nlh->nlmsg_pid == 0)
nlh->nlmsg_pid = handle->h_local.nl_pid;
if (nlh->nlmsg_seq == 0)
nlh->nlmsg_seq = handle->h_seq_next++;
nlh->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK);
if (handle->h_cb->cb_send_ow)
return handle->h_cb->cb_send_ow(handle, msg);
else
return nl_send(handle, msg);
}
/**
* Send simple netlink message using nl_send_auto_complete()
* @arg handle Netlink handle.
* @arg type Netlink message type.
* @arg flags Netlink message flags.
* @arg buf Data buffer.
* @arg size Size of data buffer.
*
* Builds a netlink message with the specified type and flags and
* appends the specified data as payload to the message.
*
* @see nl_send_auto_complete()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send_simple(struct nl_handle *handle, int type, int flags, void *buf,
size_t size)
{
int err;
struct nl_msg *msg;
struct nlmsghdr nlh = {
.nlmsg_len = nlmsg_msg_size(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
msg = nlmsg_build(&nlh);
if (!msg)
return nl_errno(ENOMEM);
if (buf && size)
nlmsg_append(msg, buf, size, 1);
err = nl_send_auto_complete(handle, msg);
nlmsg_free(msg);
return err;
}
/** @} */
/**
* @name Receive
* @{
*/
/**
* Receive netlink message from netlink socket.
* @arg handle Netlink handle.
* @arg nla Destination pointer for peer's netlink address.
* @arg buf Destination pointer for message content.
* @arg creds Destination pointer for credentials.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interruped system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_handle *handle, struct sockaddr_nl *nla,
unsigned char **buf, struct ucred **creds)
{
int n;
int flags = MSG_PEEK;
struct iovec iov = {
.iov_len = 4096,
};
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(sizeof(struct sockaddr_nl)),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
struct cmsghdr *cmsg;
iov.iov_base = *buf = calloc(1, iov.iov_len);
if (handle->h_flags & NL_SOCK_PASSCRED) {
msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
msg.msg_control = calloc(1, msg.msg_controllen);
}
retry:
if ((n = recvmsg(handle->h_fd, &msg, flags)) <= 0) {
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR)
goto retry;
else if (errno == EAGAIN)
goto abort;
else {
free(msg.msg_control);
free(*buf);
return nl_error(errno, "recvmsg failed");
}
}
}
if (iov.iov_len < n) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (msg.msg_flags & MSG_CTRUNC) {
msg.msg_controllen *= 2;
msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(msg.msg_control);
free(*buf);
return nl_error(EADDRNOTAVAIL, "socket address size mismatch");
}
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_CREDENTIALS) {
*creds = calloc(1, sizeof(struct ucred));
memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
break;
}
}
free(msg.msg_control);
return n;
abort:
free(msg.msg_control);
free(*buf);
return 0;
}
/**
* Receive a set of messages from a netlink socket.
* @arg handle netlink handle
* @arg cb set of callbacks to control the behaviour.
*
* Repeatedly calls nl_recv() and parses the messages as netlink
* messages. Stops reading if one of the callbacks returns
* NL_EXIT or nl_recv returns either 0 or a negative error code.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return 0 on success or a negative error code from nl_recv().
*/
int nl_recvmsgs(struct nl_handle *handle, struct nl_cb *cb)
{
int n, err = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
struct nl_msg *msg = NULL;
struct ucred *creds = NULL;
continue_reading:
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(handle, &nla, &buf, &creds);
else
n = nl_recv(handle, &nla, &buf, &creds);
if (n <= 0)
return n;
NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", handle, n);
hdr = (struct nlmsghdr *) buf;
while (nlmsg_ok(hdr, n)) {
NL_DBG(3, "recgmsgs(%p): Processing valid message...\n",
handle);
nlmsg_free(msg);
msg = nlmsg_convert(hdr);
if (!msg) {
err = nl_errno(ENOMEM);
goto out;
}
nlmsg_set_proto(msg, handle->h_proto);
nlmsg_set_src(msg, &nla);
if (creds)
nlmsg_set_creds(msg, creds);
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_set[NL_CB_MSG_IN]) {
err = nl_cb_call(cb, NL_CB_MSG_IN, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_set[NL_CB_SEQ_CHECK]) {
err = nl_cb_call(cb, NL_CB_SEQ_CHECK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else if (hdr->nlmsg_seq != handle->h_seq_expect) {
if (cb->cb_set[NL_CB_INVALID]) {
err = nl_cb_call(cb, NL_CB_INVALID, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
handle->h_seq_expect++;
NL_DBG(3, "recvmsgs(%p): Increased expected " \
"sequence number to %d\n",
handle, handle->h_seq_expect);
}
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_set[NL_CB_SEND_ACK]) {
err = nl_cb_call(cb, NL_CB_SEND_ACK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
if (cb->cb_set[NL_CB_FINISH]) {
err = nl_cb_call(cb, NL_CB_FINISH, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
err = 0;
goto out;
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_set[NL_CB_SKIPPED]) {
err = nl_cb_call(cb, NL_CB_SKIPPED, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_set[NL_CB_OVERRUN]) {
err = nl_cb_call(cb, NL_CB_OVERRUN, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = nlmsg_data(hdr);
if (hdr->nlmsg_len < nlmsg_msg_size(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_set[NL_CB_INVALID]) {
err = nl_cb_call(cb, NL_CB_INVALID,
msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_err) {
err = cb->cb_err(&nla, e,
cb->cb_err_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0) {
nl_error(-e->error,
"Netlink Error");
err = e->error;
goto out;
}
} else {
nl_error(-e->error, "Netlink Error");
err = e->error;
goto out;
}
} else if (cb->cb_set[NL_CB_ACK]) {
/* ACK */
err = nl_cb_call(cb, NL_CB_ACK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_set[NL_CB_VALID]) {
err = nl_cb_call(cb, NL_CB_VALID, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
}
skip:
hdr = nlmsg_next(hdr, &n);
}
nlmsg_free(msg);
free(buf);
free(creds);
buf = NULL;
msg = NULL;
creds = NULL;
/* Multipart message not yet complete, continue reading */
goto continue_reading;
out:
nlmsg_free(msg);
free(buf);
free(creds);
return err;
}
/**
* Receive a set of message from a netlink socket using handlers in nl_handle.
* @arg handle netlink handle
*
* Calls nl_recvmsgs() with the handlers configured in the netlink handle.
*/
int nl_recvmsgs_def(struct nl_handle *handle)
{
if (handle->h_cb->cb_recvmsgs_ow)
return handle->h_cb->cb_recvmsgs_ow(handle, handle->h_cb);
else
return nl_recvmsgs(handle, handle->h_cb);
}
static int ack_wait_handler(struct nl_msg *msg, void *arg)
{
return NL_EXIT;
}
/**
* Wait for ACK.
* @arg handle netlink handle
* @pre The netlink socket must be in blocking state.
*
* Waits until an ACK is received for the latest not yet acknowledged
* netlink message.
*/
int nl_wait_for_ack(struct nl_handle *handle)
{
int err;
struct nl_cb *cb = nl_cb_clone(nl_handle_get_cb(handle));
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
err = nl_recvmsgs(handle, cb);
nl_cb_destroy(cb);
return err;
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_W1,w1)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_INET_DIAG,inetdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ISCSI,iscsi)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_FIB_LOOKUP,fib_lookup)
__ADD(NETLINK_CONNECTOR,connector)
__ADD(NETLINK_NETFILTER,netfilter)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_GENERIC,generic)
};
/**
* Convert netlink family to character string.
* @arg family Netlink family.
* @arg buf Destination buffer.
* @arg size Size of destination buffer.
*
* Converts a netlink family to a character string and stores it in
* the specified destination buffer.
*
* @return The destination buffer or the family encoded in hexidecimal
* form if no match was found.
*/
char * nl_nlfamily2str(int family, char *buf, size_t size)
{
return __type2str(family, buf, size, nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert character string to netlink family.
* @arg name Name of netlink family.
*
* Converts the provided character string specifying a netlink
* family to the corresponding numeric value.
*
* @return Numeric netlink family or a negative value if no match was found.
*/
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
b->a_multicast));
diff |= ADDR_DIFF(BROADCAST, nl_addr_cmp(a->a_bcast, b->a_bcast));
if (flags & LOOSE_FLAG_COMPARISON)
diff |= ADDR_DIFF(FLAGS,
(a->a_flags ^ b->a_flags) & b->a_flag_mask);
else
diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags);
#undef ADDR_DIFF
return diff;
}
static struct trans_tbl addr_attrs[] = {
__ADD(ADDR_ATTR_FAMILY, family)
__ADD(ADDR_ATTR_PREFIXLEN, prefixlen)
__ADD(ADDR_ATTR_FLAGS, flags)
__ADD(ADDR_ATTR_SCOPE, scope)
__ADD(ADDR_ATTR_IFINDEX, ifindex)
__ADD(ADDR_ATTR_LABEL, label)
__ADD(ADDR_ATTR_CACHEINFO, cacheinfo)
__ADD(ADDR_ATTR_PEER, peer)
__ADD(ADDR_ATTR_LOCAL, local)
__ADD(ADDR_ATTR_BROADCAST, broadcast)
__ADD(ADDR_ATTR_ANYCAST, anycast)
__ADD(ADDR_ATTR_MULTICAST, multicast)
};
static char *addr_attrs2str(int attrs, char *buf, size_t len)
{
nl_dump(p, "copy_range=%u ", log->log_copy_range);
if (log->ce_mask & LOG_ATTR_FLUSH_TIMEOUT)
nl_dump(p, "flush_timeout=%u ", log->log_flush_timeout);
if (log->ce_mask & LOG_ATTR_ALLOC_SIZE)
nl_dump(p, "alloc_size=%u ", log->log_alloc_size);
if (log->ce_mask & LOG_ATTR_QUEUE_THRESHOLD)
nl_dump(p, "queue_threshold=%u ", log->log_queue_threshold);
nl_dump(p, "\n");
}
static struct trans_tbl copy_modes[] = {
__ADD(NFNL_LOG_COPY_NONE, none)
__ADD(NFNL_LOG_COPY_META, meta)
__ADD(NFNL_LOG_COPY_PACKET, packet)
};
char *nfnl_log_copy_mode2str(enum nfnl_log_copy_mode copy_mode, char *buf,
size_t len)
{
return __type2str(copy_mode, buf, len, copy_modes,
ARRAY_SIZE(copy_modes));
}
enum nfnl_log_copy_mode nfnl_log_str2copy_mode(const char *name)
{
return __str2type(name, copy_modes, ARRAY_SIZE(copy_modes));
}
#include <netlink/route/qdisc-modules.h>
#include <netlink/route/class.h>
#include <netlink/route/class-modules.h>
#include <netlink/route/link.h>
#include <netlink/route/sch/cbq.h>
#include <netlink/route/cls/police.h>
/**
* @ingroup qdisc
* @ingroup class
* @defgroup cbq Class Based Queueing (CBQ)
* @{
*/
static struct trans_tbl ovl_strategies[] = {
__ADD(TC_CBQ_OVL_CLASSIC,classic)
__ADD(TC_CBQ_OVL_DELAY,delay)
__ADD(TC_CBQ_OVL_LOWPRIO,lowprio)
__ADD(TC_CBQ_OVL_DROP,drop)
__ADD(TC_CBQ_OVL_RCLASSIC,rclassic)
};
/**
* Convert a CBQ OVL strategy to a character string
* @arg type CBQ OVL strategy
* @arg buf destination buffer
* @arg len length of destination buffer
*
* Converts a CBQ OVL strategy to a character string and stores in the
* provided buffer. Returns the destination buffer or the type
* encoded in hex if no match was found.
buf += l;
len -= l;
}
return buf_orig;
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static const struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_INET_DIAG,inetdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ISCSI,iscsi)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_FIB_LOOKUP,fib_lookup)
__ADD(NETLINK_CONNECTOR,connector)
__ADD(NETLINK_NETFILTER,netfilter)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_GENERIC,generic)
req.idiag_family = family;
req.idiag_states = states;
req.idiag_ext = ext;
return nl_send_simple(sk, TCPDIAG_GETSOCK, flags, &req, sizeof(req));
}
/** @} */
/**
* @name Inet Diag flag and attribute conversions
* @{
*/
static const struct trans_tbl idiag_states[] = {
__ADD(IDIAG_SS_UNKNOWN, unknown),
__ADD(IDIAG_SS_ESTABLISHED, established),
__ADD(IDIAG_SS_SYN_SENT, syn_sent),
__ADD(IDIAG_SS_SYN_RECV, syn_recv),
__ADD(IDIAG_SS_FIN_WAIT1, fin_wait),
__ADD(IDIAG_SS_FIN_WAIT2, fin_wait2),
__ADD(IDIAG_SS_TIME_WAIT, time_wait),
__ADD(IDIAG_SS_CLOSE, close),
__ADD(IDIAG_SS_CLOSE_WAIT, close_wait),
__ADD(IDIAG_SS_LAST_ACK, last_ack),
__ADD(IDIAG_SS_LISTEN, listen),
__ADD(IDIAG_SS_CLOSING, closing),
__ADD(IDIAG_SS_MAX, max),
{ ((1<<IDIAG_SS_MAX)-1), "all" }
};
struct vlan_info
{
uint16_t vi_vlan_id;
uint32_t vi_flags;
uint32_t vi_flags_mask;
uint32_t vi_ingress_qos[VLAN_PRIO_MAX+1];
uint32_t vi_negress;
uint32_t vi_egress_size;
struct vlan_map * vi_egress_qos;
uint32_t vi_mask;
};
/** @endcond */
static struct trans_tbl vlan_flags[] = {
__ADD(VLAN_FLAG_REORDER_HDR, reorder_hdr)
};
char *rtnl_link_vlan_flags2str(int flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, vlan_flags, ARRAY_SIZE(vlan_flags));
}
int rtnl_link_vlan_str2flags(const char *name)
{
return __str2flags(name, vlan_flags, ARRAY_SIZE(vlan_flags));
}
static struct nla_policy vlan_policy[IFLA_VLAN_MAX+1] = {
[IFLA_VLAN_ID] = { .type = NLA_U16 },
[IFLA_VLAN_FLAGS] = { .minlen = sizeof(struct ifla_vlan_flags) },
* @see rtnl_link_bridge_unset_flags()
*
* @return Flags or a negative error code.
* @retval -NLE_OPNOTSUPP Link is not a bridge
*/
int rtnl_link_bridge_get_flags(struct rtnl_link *link)
{
struct bridge_data *bd = bridge_data(link);
IS_BRIDGE_LINK_ASSERT(link);
return bd->b_flags;
}
static const struct trans_tbl bridge_flags[] = {
__ADD(RTNL_BRIDGE_HAIRPIN_MODE, hairpin_mode)
__ADD(RTNL_BRIDGE_BPDU_GUARD, bpdu_guard)
__ADD(RTNL_BRIDGE_ROOT_BLOCK, root_block)
__ADD(RTNL_BRIDGE_FAST_LEAVE, fast_leave)
};
/**
* @name Flag Translation
* @{
*/
char *rtnl_link_bridge_flags2str(int flags, char *buf, size_t len)
{
return __flags2str(flags, buf, len, bridge_flags, ARRAY_SIZE(bridge_flags));
}
