28 #include <netlink-private/netlink.h>
29 #include <netlink-private/socket.h>
30 #include <netlink/netlink.h>
31 #include <netlink/utils.h>
32 #include <netlink/handlers.h>
33 #include <netlink/msg.h>
34 #include <netlink/attr.h>
103 flags |= SOCK_CLOEXEC;
107 return -NLE_BAD_SOCK;
109 sk->s_fd = socket(AF_NETLINK, SOCK_RAW | flags, protocol);
112 NL_DBG(4,
"nl_connect(%p): socket() failed with %d\n", sk, errsv);
113 err = -nl_syserr2nlerr(errsv);
117 if (!(sk->s_flags & NL_SOCK_BUFSIZE_SET)) {
123 if (_nl_socket_is_local_port_unspecified (sk)) {
125 uint32_t used_ports[32] = { 0 };
128 port = _nl_socket_generate_local_port_no_release(sk);
130 if (port == UINT32_MAX) {
131 NL_DBG(4,
"nl_connect(%p): no more unused local ports.\n", sk);
132 _nl_socket_used_ports_release_all(used_ports);
136 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
137 sizeof(sk->s_local));
142 if (errsv == EADDRINUSE) {
143 NL_DBG(4,
"nl_connect(%p): local port %u already in use. Retry.\n", sk, (
unsigned) port);
144 _nl_socket_used_ports_set(used_ports, port);
146 NL_DBG(4,
"nl_connect(%p): bind() for port %u failed with %d\n", sk, (
unsigned) port, errsv);
147 _nl_socket_used_ports_release_all(used_ports);
148 err = -nl_syserr2nlerr(errsv);
152 _nl_socket_used_ports_release_all(used_ports);
154 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
155 sizeof(sk->s_local));
158 NL_DBG(4,
"nl_connect(%p): bind() failed with %d\n", sk, errsv);
159 err = -nl_syserr2nlerr(errsv);
164 addrlen =
sizeof(sk->s_local);
165 err = getsockname(sk->s_fd, (
struct sockaddr *) &sk->s_local,
168 err = -nl_syserr2nlerr(errno);
172 if (addrlen !=
sizeof(sk->s_local)) {
177 if (sk->s_local.nl_family != AF_NETLINK) {
178 err = -NLE_AF_NOSUPPORT;
182 sk->s_proto = protocol;
186 if (sk->s_fd != -1) {
245 int nl_sendto(
struct nl_sock *sk,
void *buf,
size_t size)
253 return -NLE_BAD_SOCK;
255 ret = sendto(sk->s_fd, buf, size, 0, (
struct sockaddr *)
256 &sk->s_peer,
sizeof(sk->s_peer));
258 return -nl_syserr2nlerr(errno);
299 int nl_sendmsg(
struct nl_sock *sk,
struct nl_msg *msg,
struct msghdr *hdr)
305 return -NLE_BAD_SOCK;
307 nlmsg_set_src(msg, &sk->s_local);
314 ret = sendmsg(sk->s_fd, hdr, 0);
316 return -nl_syserr2nlerr(errno);
318 NL_DBG(4,
"sent %d bytes\n", ret);
342 int nl_send_iovec(
struct nl_sock *sk,
struct nl_msg *msg,
struct iovec *iov,
unsigned iovlen)
344 struct sockaddr_nl *dst;
346 struct msghdr hdr = {
347 .msg_name = (
void *) &sk->s_peer,
348 .msg_namelen =
sizeof(
struct sockaddr_nl),
350 .msg_iovlen = iovlen,
356 dst = nlmsg_get_dst(msg);
357 if (dst->nl_family == AF_NETLINK)
361 creds = nlmsg_get_creds(msg);
363 char buf[CMSG_SPACE(
sizeof(
struct ucred))];
364 struct cmsghdr *cmsg;
366 hdr.msg_control = buf;
367 hdr.msg_controllen =
sizeof(buf);
369 cmsg = CMSG_FIRSTHDR(&hdr);
370 cmsg->cmsg_level = SOL_SOCKET;
371 cmsg->cmsg_type = SCM_CREDENTIALS;
372 cmsg->cmsg_len = CMSG_LEN(
sizeof(
struct ucred));
373 memcpy(CMSG_DATA(cmsg), creds,
sizeof(
struct ucred));
416 int nl_send(
struct nl_sock *sk,
struct nl_msg *msg)
418 struct nl_cb *cb = sk->s_cb;
421 return cb->cb_send_ow(sk, msg);
452 struct nlmsghdr *nlh;
456 nlh->nlmsg_pid = nl_socket_get_local_port(sk);
459 nlh->nlmsg_seq = sk->s_seq_next++;
461 if (msg->nm_protocol == -1)
462 msg->nm_protocol = sk->s_proto;
464 nlh->nlmsg_flags |= NLM_F_REQUEST;
466 if (!(sk->s_flags & NL_NO_AUTO_ACK))
467 nlh->nlmsg_flags |= NLM_F_ACK;
526 return wait_for_ack(sk);
625 int nl_recv(
struct nl_sock *sk,
struct sockaddr_nl *nla,
626 unsigned char **buf,
struct ucred **creds)
630 static int page_size = 0;
632 struct msghdr msg = {
633 .msg_name = (
void *) nla,
634 .msg_namelen =
sizeof(
struct sockaddr_nl),
638 struct ucred* tmpcreds = NULL;
644 if (sk->s_flags & NL_MSG_PEEK)
645 flags |= MSG_PEEK | MSG_TRUNC;
648 page_size = getpagesize() * 4;
650 iov.iov_len = sk->s_bufsize ? : page_size;
651 iov.iov_base = malloc(iov.iov_len);
658 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
659 msg.msg_controllen = CMSG_SPACE(
sizeof(
struct ucred));
660 msg.msg_control = malloc(msg.msg_controllen);
661 if (!msg.msg_control) {
668 n = recvmsg(sk->s_fd, &msg, flags);
674 if (errno == EINTR) {
675 NL_DBG(3,
"recvmsg() returned EINTR, retrying\n");
678 retval = -nl_syserr2nlerr(errno);
682 if (msg.msg_flags & MSG_CTRUNC) {
684 msg.msg_controllen *= 2;
685 tmp = realloc(msg.msg_control, msg.msg_controllen);
690 msg.msg_control = tmp;
694 if (iov.iov_len < n || (msg.msg_flags & MSG_TRUNC)) {
700 tmp = realloc(iov.iov_base, iov.iov_len);
716 if (msg.msg_namelen !=
sizeof(
struct sockaddr_nl)) {
717 retval = -NLE_NOADDR;
721 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
722 struct cmsghdr *cmsg;
724 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
725 if (cmsg->cmsg_level != SOL_SOCKET)
727 if (cmsg->cmsg_type != SCM_CREDENTIALS)
729 tmpcreds = malloc(
sizeof(*tmpcreds));
734 memcpy(tmpcreds, CMSG_DATA(cmsg),
sizeof(*tmpcreds));
741 free(msg.msg_control);
758 #define NL_CB_CALL(cb, type, msg) \
760 err = nl_cb_call(cb, type, msg); \
775 static int recvmsgs(
struct nl_sock *sk,
struct nl_cb *cb)
777 int n, err = 0, multipart = 0, interrupted = 0, nrecv = 0;
778 unsigned char *buf = NULL;
779 struct nlmsghdr *hdr;
786 struct sockaddr_nl nla = {0};
787 struct nl_msg *msg = NULL;
788 struct ucred *creds = NULL;
791 NL_DBG(3,
"Attempting to read from %p\n", sk);
793 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
795 n =
nl_recv(sk, &nla, &buf, &creds);
800 NL_DBG(3,
"recvmsgs(%p): Read %d bytes\n", sk, n);
802 hdr = (
struct nlmsghdr *) buf;
804 NL_DBG(3,
"recvmsgs(%p): Processing valid message...\n", sk);
813 nlmsg_set_proto(msg, sk->s_proto);
814 nlmsg_set_src(msg, &nla);
816 nlmsg_set_creds(msg, creds);
832 }
else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
833 if (hdr->nlmsg_seq != sk->s_seq_expect) {
837 err = -NLE_SEQ_MISMATCH;
843 if (hdr->nlmsg_type == NLMSG_DONE ||
844 hdr->nlmsg_type == NLMSG_ERROR ||
845 hdr->nlmsg_type == NLMSG_NOOP ||
846 hdr->nlmsg_type == NLMSG_OVERRUN) {
850 NL_DBG(3,
"recvmsgs(%p): Increased expected " \
851 "sequence number to %d\n",
852 sk, sk->s_seq_expect);
855 if (hdr->nlmsg_flags & NLM_F_MULTI)
858 if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
872 if (hdr->nlmsg_flags & NLM_F_ACK) {
884 if (hdr->nlmsg_type == NLMSG_DONE) {
894 else if (hdr->nlmsg_type == NLMSG_NOOP) {
904 else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
908 err = -NLE_MSG_OVERFLOW;
914 else if (hdr->nlmsg_type == NLMSG_ERROR) {
917 if (hdr->nlmsg_len <
nlmsg_size(
sizeof(*e))) {
925 err = -NLE_MSG_TRUNC;
928 }
else if (e->error) {
931 err = cb->cb_err(&nla, e,
938 err = -nl_syserr2nlerr(e->error);
942 err = -nl_syserr2nlerr(e->error);
968 goto continue_reading;
978 err = -NLE_DUMP_INTR;
1000 if (cb->cb_recvmsgs_ow)
1001 return cb->cb_recvmsgs_ow(sk, cb);
1003 return recvmsgs(sk, cb);
1045 static int ack_wait_handler(
struct nl_msg *msg,
void *arg)
1077 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1078 struct nlmsghdr *,
struct nl_parser_param *);
1079 struct nl_object *result;
1082 static int __store_answer(
struct nl_object *obj,
struct nl_parser_param *p)
1084 struct pickup_param *pp = p->pp_arg;
1095 static int __pickup_answer(
struct nl_msg *msg,
void *arg)
1097 struct pickup_param *pp = arg;
1098 struct nl_parser_param parse_arg = {
1099 .pp_cb = __store_answer,
1103 return pp->parser(NULL, &msg->nm_src, msg->nm_nlh, &parse_arg);
1117 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1118 struct nlmsghdr *,
struct nl_parser_param *),
1119 struct nl_object **result)
1123 struct pickup_param pp = {
1137 *result = pp.result;
Report received that data was lost.
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
Called for every message sent out except for nl_sendto()
Message is an acknowledge.
void nlmsg_free(struct nl_msg *msg)
Release a reference from an netlink message.
void * nlmsg_data(const struct nlmsghdr *nlh)
Return pointer to message payload.
Sending of an acknowledge message has been requested.
void nl_complete_msg(struct nl_sock *sk, struct nl_msg *msg)
Finalize Netlink message.
#define NL_AUTO_PORT
Will cause the netlink port to be set to the port assigned to the netlink icoket ust before sending t...
int nlmsg_size(int payload)
Calculates size of netlink message based on payload length.
Customized handler specified by the user.
#define NL_AUTO_SEQ
May be used to refer to a sequence number which should be automatically set just before sending the m...
void nl_object_get(struct nl_object *obj)
Acquire a reference on a object.
int nl_send_sync(struct nl_sock *sk, struct nl_msg *msg)
Finalize and transmit Netlink message and wait for ACK or error message.
Message wants to be skipped.
int nl_pickup(struct nl_sock *sk, int(*parser)(struct nl_cache_ops *, struct sockaddr_nl *, struct nlmsghdr *, struct nl_parser_param *), struct nl_object **result)
Pickup netlink answer, parse is and return object.
int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
check if the netlink message fits into the remaining bytes
Stop parsing altogether and discard remaining messages.
Called for every message received.
struct nl_cb * nl_cb_clone(struct nl_cb *orig)
Clone an existing callback handle.
int nl_cb_set(struct nl_cb *cb, enum nl_cb_type type, enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func, void *arg)
Set up a callback.
int nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
Receive a set of messages from a netlink socket.
int nl_connect(struct nl_sock *sk, int protocol)
Create file descriptor and bind socket.
struct nlmsghdr * nlmsg_next(struct nlmsghdr *nlh, int *remaining)
next netlink message in message stream
Message is malformed and invalid.
Flag NLM_F_DUMP_INTR is set in message.
Last message in a series of multi part messages received.
struct nlmsghdr * nlmsg_hdr(struct nl_msg *n)
Return actual netlink message.
int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg, struct iovec *iov, unsigned iovlen)
Transmit Netlink message (taking IO vector)
int nl_recvmsgs_default(struct nl_sock *sk)
Receive a set of message from a netlink socket using handlers in nl_sock.
int nl_send(struct nl_sock *sk, struct nl_msg *msg)
Transmit Netlink message.
int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf, size_t size)
Construct and transmit a Netlink message.
Called instead of internal sequence number checking.
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
int nl_wait_for_ack(struct nl_sock *sk)
Wait for ACK.
Proceed with wathever would come next.
struct nl_msg * nlmsg_alloc_simple(int nlmsgtype, int flags)
Allocate a new netlink message.
void nl_close(struct nl_sock *sk)
Close Netlink socket.
void nl_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
Set socket buffer size of netlink socket.
int nl_recvmsgs_report(struct nl_sock *sk, struct nl_cb *cb)
Receive a set of messages from a netlink socket and report parsed messages.
int nl_sendto(struct nl_sock *sk, void *buf, size_t size)
Transmit raw data over Netlink socket.
struct nl_msg * nlmsg_convert(struct nlmsghdr *hdr)
Convert a netlink message received from a netlink socket to a nl_msg.
int nl_send_auto(struct nl_sock *sk, struct nl_msg *msg)
Finalize and transmit Netlink message.
int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla, unsigned char **buf, struct ucred **creds)
Receive data from netlink socket.
int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
Transmit Netlink message using sendmsg()