};
/* Next nlmsghdr sequence number.
- *
+ *
* This implementation uses sequence numbers that are unique process-wide, to
* avoid a hypothetical race: send request, close socket, open new socket that
* reuses the old socket's PID value, send request on new socket, receive reply
/* Destroys netlink socket 'sock'. */
void
-nl_sock_destroy(struct nl_sock *sock)
+nl_sock_destroy(struct nl_sock *sock)
{
if (sock) {
close(sock->fd);
* 'wait' is true, then the send will wait until buffer space is ready;
* otherwise, returns EAGAIN if the 'sock' send buffer is full. */
int
-nl_sock_send(struct nl_sock *sock, const struct ofpbuf *msg, bool wait)
+nl_sock_send(struct nl_sock *sock, const struct ofpbuf *msg, bool wait)
{
struct nlmsghdr *nlmsg = nl_msg_nlmsghdr(msg);
int error;
* returns EAGAIN if the 'sock' send buffer is full. */
int
nl_sock_sendv(struct nl_sock *sock, const struct iovec iov[], size_t n_iov,
- bool wait)
+ bool wait)
{
struct msghdr msg;
int error;
* If 'wait' is true, nl_sock_recv waits for a message to be ready; otherwise,
* returns EAGAIN if the 'sock' receive buffer is empty. */
int
-nl_sock_recv(struct nl_sock *sock, struct ofpbuf **bufp, bool wait)
+nl_sock_recv(struct nl_sock *sock, struct ofpbuf **bufp, bool wait)
{
uint8_t tmp;
ssize_t bufsize = 2048;
try_again:
/* Attempt to read the message. We don't know the size of the data
* yet, so we take a guess at 2048. If we're wrong, we keep trying
- * and doubling the buffer size each time.
+ * and doubling the buffer size each time.
*/
nlmsghdr = ofpbuf_put_uninit(buf, bufsize);
iov.iov_base = nlmsghdr;
iov.iov_len = bufsize;
do {
- nbytes = recvmsg(sock->fd, &msg, (wait ? 0 : MSG_DONTWAIT) | MSG_PEEK);
+ nbytes = recvmsg(sock->fd, &msg, (wait ? 0 : MSG_DONTWAIT) | MSG_PEEK);
} while (nbytes < 0 && errno == EINTR);
if (nbytes < 0) {
ofpbuf_delete(buf);
*
* Bare Netlink is an unreliable transport protocol. This function layers
* reliable delivery and reply semantics on top of bare Netlink.
- *
+ *
* In Netlink, sending a request to the kernel is reliable enough, because the
* kernel will tell us if the message cannot be queued (and we will in that
* case put it on the transmit queue and wait until it can be delivered).
- *
+ *
* Receiving the reply is the real problem: if the socket buffer is full when
* the kernel tries to send the reply, the reply will be dropped. However, the
* kernel sets a flag that a reply has been dropped. The next call to recv
*/
int
nl_sock_transact(struct nl_sock *sock,
- const struct ofpbuf *request, struct ofpbuf **replyp)
+ const struct ofpbuf *request, struct ofpbuf **replyp)
{
uint32_t seq = nl_msg_nlmsghdr(request)->nlmsg_seq;
struct nlmsghdr *nlmsghdr;
/* Ensure that we get a reply even if this message doesn't ordinarily call
* for one. */
nl_msg_nlmsghdr(request)->nlmsg_flags |= NLM_F_ACK;
-
+
send:
retval = nl_sock_send(sock, request, true);
if (retval) {
*
* 'msg' must be at least as large as a nlmsghdr. */
struct nlmsghdr *
-nl_msg_nlmsghdr(const struct ofpbuf *msg)
+nl_msg_nlmsghdr(const struct ofpbuf *msg)
{
return ofpbuf_at_assert(msg, 0, NLMSG_HDRLEN);
}
* Returns a null pointer if 'msg' is not large enough to contain an nlmsghdr
* and a genlmsghdr. */
struct genlmsghdr *
-nl_msg_genlmsghdr(const struct ofpbuf *msg)
+nl_msg_genlmsghdr(const struct ofpbuf *msg)
{
return ofpbuf_at(msg, NLMSG_HDRLEN, GENL_HDRLEN);
}
*
* 'msg' must be at least as large as a nlmsghdr. */
bool
-nl_msg_nlmsgerr(const struct ofpbuf *msg, int *errorp)
+nl_msg_nlmsgerr(const struct ofpbuf *msg, int *errorp)
{
if (nl_msg_nlmsghdr(msg)->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *err = ofpbuf_at(msg, NLMSG_HDRLEN, sizeof *err);
/* Ensures that 'b' has room for at least 'size' bytes plus netlink padding at
* its tail end, reallocating and copying its data if necessary. */
void
-nl_msg_reserve(struct ofpbuf *msg, size_t size)
+nl_msg_reserve(struct ofpbuf *msg, size_t size)
{
ofpbuf_prealloc_tailroom(msg, NLMSG_ALIGN(size));
}
* message. */
void
nl_msg_put_nlmsghdr(struct ofpbuf *msg,
- size_t expected_payload, uint32_t type, uint32_t flags)
+ size_t expected_payload, uint32_t type, uint32_t flags)
{
struct nlmsghdr *nlmsghdr;
* the tail end of 'msg'. Data in 'msg' is reallocated and copied if
* necessary. */
void
-nl_msg_put(struct ofpbuf *msg, const void *data, size_t size)
+nl_msg_put(struct ofpbuf *msg, const void *data, size_t size)
{
memcpy(nl_msg_put_uninit(msg, size), data, size);
}
* end of 'msg', reallocating and copying its data if necessary. Returns a
* pointer to the first byte of the new data, which is left uninitialized. */
void *
-nl_msg_put_uninit(struct ofpbuf *msg, size_t size)
+nl_msg_put_uninit(struct ofpbuf *msg, size_t size)
{
size_t pad = NLMSG_ALIGN(size) - size;
char *p = ofpbuf_put_uninit(msg, size + pad);
if (pad) {
- memset(p + size, 0, pad);
+ memset(p + size, 0, pad);
}
return p;
}
* 'msg', reallocating and copying its data if necessary. Returns a pointer to
* the first byte of data in the attribute, which is left uninitialized. */
void *
-nl_msg_put_unspec_uninit(struct ofpbuf *msg, uint16_t type, size_t size)
+nl_msg_put_unspec_uninit(struct ofpbuf *msg, uint16_t type, size_t size)
{
size_t total_size = NLA_HDRLEN + size;
struct nlattr* nla = nl_msg_put_uninit(msg, total_size);
* attribute, which is left uninitialized. */
void
nl_msg_put_unspec(struct ofpbuf *msg, uint16_t type,
- const void *data, size_t size)
+ const void *data, size_t size)
{
memcpy(nl_msg_put_unspec_uninit(msg, type, size), data, size);
}
* (Some Netlink protocols use the presence or absence of an attribute as a
* Boolean flag.) */
void
-nl_msg_put_flag(struct ofpbuf *msg, uint16_t type)
+nl_msg_put_flag(struct ofpbuf *msg, uint16_t type)
{
nl_msg_put_unspec(msg, type, NULL, 0);
}
/* Appends a Netlink attribute of the given 'type' and the given 8-bit 'value'
* to 'msg'. */
void
-nl_msg_put_u8(struct ofpbuf *msg, uint16_t type, uint8_t value)
+nl_msg_put_u8(struct ofpbuf *msg, uint16_t type, uint8_t value)
{
nl_msg_put_unspec(msg, type, &value, sizeof value);
}
/* Returns the first byte in the payload of attribute 'nla'. */
const void *
-nl_attr_get(const struct nlattr *nla)
+nl_attr_get(const struct nlattr *nla)
{
assert(nla->nla_len >= NLA_HDRLEN);
return nla + 1;
/* Returns the number of bytes in the payload of attribute 'nla'. */
size_t
-nl_attr_get_size(const struct nlattr *nla)
+nl_attr_get_size(const struct nlattr *nla)
{
assert(nla->nla_len >= NLA_HDRLEN);
return nla->nla_len - NLA_HDRLEN;
/* Asserts that 'nla''s payload is at least 'size' bytes long, and returns the
* first byte of the payload. */
const void *
-nl_attr_get_unspec(const struct nlattr *nla, size_t size)
+nl_attr_get_unspec(const struct nlattr *nla, size_t size)
{
assert(nla->nla_len >= NLA_HDRLEN + size);
return nla + 1;
/* Returns true if 'nla' is nonnull. (Some Netlink protocols use the presence
* or absence of an attribute as a Boolean flag.) */
bool
-nl_attr_get_flag(const struct nlattr *nla)
+nl_attr_get_flag(const struct nlattr *nla)
{
return nla != NULL;
}
*
* Asserts that 'nla''s payload is at least 1 byte long. */
uint8_t
-nl_attr_get_u8(const struct nlattr *nla)
+nl_attr_get_u8(const struct nlattr *nla)
{
return NL_ATTR_GET_AS(nla, uint8_t);
}
*
* Asserts that 'nla''s payload is at least 2 bytes long. */
uint16_t
-nl_attr_get_u16(const struct nlattr *nla)
+nl_attr_get_u16(const struct nlattr *nla)
{
return NL_ATTR_GET_AS(nla, uint16_t);
}
*
* Asserts that 'nla''s payload is at least 4 bytes long. */
uint32_t
-nl_attr_get_u32(const struct nlattr *nla)
+nl_attr_get_u32(const struct nlattr *nla)
{
return NL_ATTR_GET_AS(nla, uint32_t);
}
*
* Asserts that 'nla''s payload is at least 8 bytes long. */
uint64_t
-nl_attr_get_u64(const struct nlattr *nla)
+nl_attr_get_u64(const struct nlattr *nla)
{
return NL_ATTR_GET_AS(nla, uint64_t);
}
*
* Asserts that 'nla''s payload contains a null-terminated string. */
const char *
-nl_attr_get_string(const struct nlattr *nla)
+nl_attr_get_string(const struct nlattr *nla)
{
assert(nla->nla_len > NLA_HDRLEN);
assert(memchr(nl_attr_get(nla), '\0', nla->nla_len - NLA_HDRLEN) != NULL);
\f
/* Miscellaneous. */
-static const struct nl_policy family_policy[CTRL_ATTR_MAX + 1] = {
+static const struct nl_policy family_policy[CTRL_ATTR_MAX + 1] = {
[CTRL_ATTR_FAMILY_ID] = {.type = NL_A_U16},
};
-static int do_lookup_genl_family(const char *name)
+static int do_lookup_genl_family(const char *name)
{
struct nl_sock *sock;
struct ofpbuf request, *reply;
* may use '*number' as the family number. On failure, returns a positive
* errno value and '*number' caches the errno value. */
int
-nl_lookup_genl_family(const char *name, int *number)
+nl_lookup_genl_family(const char *name, int *number)
{
if (*number == 0) {
*number = do_lookup_genl_family(name);
unsigned int bits;
const char *name;
};
- static const struct nlmsg_flag flags[] = {
+ static const struct nlmsg_flag flags[] = {
{ NLM_F_REQUEST, "REQUEST" },
{ NLM_F_MULTI, "MULTI" },
{ NLM_F_ACK, "ACK" },
git://git.onelab.eu / sliver-openvswitch.git / blobdiff