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>
106 struct sockaddr_nl local = { 0 };
110 flags |= SOCK_CLOEXEC;
114 return -NLE_BAD_SOCK;
116 sk->s_fd = socket(AF_NETLINK, SOCK_RAW | flags, protocol);
119 NL_DBG(4,
"nl_connect(%p): socket() failed with %d (%s)\n", sk, errsv,
120 strerror_r(errsv, buf,
sizeof(buf)));
121 err = -nl_syserr2nlerr(errsv);
129 if (_nl_socket_is_local_port_unspecified (sk)) {
131 uint32_t used_ports[32] = { 0 };
134 port = _nl_socket_generate_local_port_no_release(sk);
136 if (port == UINT32_MAX) {
137 NL_DBG(4,
"nl_connect(%p): no more unused local ports.\n", sk);
138 _nl_socket_used_ports_release_all(used_ports);
142 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
143 sizeof(sk->s_local));
148 if (errsv == EADDRINUSE) {
149 NL_DBG(4,
"nl_connect(%p): local port %u already in use. Retry.\n", sk, (
unsigned) port);
150 _nl_socket_used_ports_set(used_ports, port);
152 NL_DBG(4,
"nl_connect(%p): bind() for port %u failed with %d (%s)\n",
153 sk, (
unsigned) port, errsv, strerror_r(errsv, buf,
sizeof(buf)));
154 _nl_socket_used_ports_release_all(used_ports);
155 err = -nl_syserr2nlerr(errsv);
159 _nl_socket_used_ports_release_all(used_ports);
161 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
162 sizeof(sk->s_local));
165 NL_DBG(4,
"nl_connect(%p): bind() failed with %d (%s)\n",
166 sk, errsv, strerror_r(errsv, buf,
sizeof(buf)));
167 err = -nl_syserr2nlerr(errsv);
172 addrlen =
sizeof(local);
173 err = getsockname(sk->s_fd, (
struct sockaddr *) &local,
176 NL_DBG(4,
"nl_connect(%p): getsockname() failed with %d (%s)\n",
177 sk, errno, strerror_r(errno, buf,
sizeof(buf)));
178 err = -nl_syserr2nlerr(errno);
182 if (addrlen !=
sizeof(local)) {
187 if (local.nl_family != AF_NETLINK) {
188 err = -NLE_AF_NOSUPPORT;
192 if (sk->s_local.nl_pid != local.nl_pid) {
199 sk->s_proto = protocol;
203 if (sk->s_fd != -1) {
262 int nl_sendto(
struct nl_sock *sk,
void *buf,
size_t size)
270 return -NLE_BAD_SOCK;
272 ret = sendto(sk->s_fd, buf, size, 0, (
struct sockaddr *)
273 &sk->s_peer,
sizeof(sk->s_peer));
277 NL_DBG(4,
"nl_sendto(%p): sendto() failed with %d (%s)\n",
278 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
279 return -nl_syserr2nlerr(errno);
321 int nl_sendmsg(
struct nl_sock *sk,
struct nl_msg *msg,
struct msghdr *hdr)
327 return -NLE_BAD_SOCK;
329 nlmsg_set_src(msg, &sk->s_local);
336 ret = sendmsg(sk->s_fd, hdr, 0);
340 NL_DBG(4,
"nl_sendmsg(%p): sendmsg() failed with %d (%s)\n",
341 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
342 return -nl_syserr2nlerr(errno);
345 NL_DBG(4,
"sent %d bytes\n", ret);
369 int nl_send_iovec(
struct nl_sock *sk,
struct nl_msg *msg,
struct iovec *iov,
unsigned iovlen)
371 struct sockaddr_nl *dst;
373 struct msghdr hdr = {
374 .msg_name = (
void *) &sk->s_peer,
375 .msg_namelen =
sizeof(
struct sockaddr_nl),
377 .msg_iovlen = iovlen,
383 dst = nlmsg_get_dst(msg);
384 if (dst->nl_family == AF_NETLINK)
388 creds = nlmsg_get_creds(msg);
390 char buf[CMSG_SPACE(
sizeof(
struct ucred))];
391 struct cmsghdr *cmsg;
393 hdr.msg_control = buf;
394 hdr.msg_controllen =
sizeof(buf);
396 cmsg = CMSG_FIRSTHDR(&hdr);
397 cmsg->cmsg_level = SOL_SOCKET;
398 cmsg->cmsg_type = SCM_CREDENTIALS;
399 cmsg->cmsg_len = CMSG_LEN(
sizeof(
struct ucred));
400 memcpy(CMSG_DATA(cmsg), creds,
sizeof(
struct ucred));
443 int nl_send(
struct nl_sock *sk,
struct nl_msg *msg)
445 struct nl_cb *cb = sk->s_cb;
448 return cb->cb_send_ow(sk, msg);
479 struct nlmsghdr *nlh;
483 nlh->nlmsg_pid = nl_socket_get_local_port(sk);
486 nlh->nlmsg_seq = sk->s_seq_next++;
488 if (msg->nm_protocol == -1)
489 msg->nm_protocol = sk->s_proto;
491 nlh->nlmsg_flags |= NLM_F_REQUEST;
493 if (!(sk->s_flags & NL_NO_AUTO_ACK))
494 nlh->nlmsg_flags |= NLM_F_ACK;
553 return wait_for_ack(sk);
652 int nl_recv(
struct nl_sock *sk,
struct sockaddr_nl *nla,
653 unsigned char **buf,
struct ucred **creds)
657 static int page_size = 0;
659 struct msghdr msg = {
660 .msg_name = (
void *) nla,
661 .msg_namelen =
sizeof(
struct sockaddr_nl),
665 struct ucred* tmpcreds = NULL;
671 if (sk->s_flags & NL_MSG_PEEK)
672 flags |= MSG_PEEK | MSG_TRUNC;
675 page_size = getpagesize() * 4;
677 iov.iov_len = sk->s_bufsize ? : page_size;
678 iov.iov_base = malloc(iov.iov_len);
685 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
686 msg.msg_controllen = CMSG_SPACE(
sizeof(
struct ucred));
687 msg.msg_control = malloc(msg.msg_controllen);
688 if (!msg.msg_control) {
695 n = recvmsg(sk->s_fd, &msg, flags);
703 if (errno == EINTR) {
704 NL_DBG(3,
"recvmsg() returned EINTR, retrying\n");
708 NL_DBG(4,
"nl_sendmsg(%p): nl_recv() failed with %d (%s)\n",
709 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
710 retval = -nl_syserr2nlerr(errno);
714 if (msg.msg_flags & MSG_CTRUNC) {
716 msg.msg_controllen *= 2;
717 tmp = realloc(msg.msg_control, msg.msg_controllen);
722 msg.msg_control = tmp;
726 if (iov.iov_len < n || (msg.msg_flags & MSG_TRUNC)) {
732 tmp = realloc(iov.iov_base, iov.iov_len);
748 if (msg.msg_namelen !=
sizeof(
struct sockaddr_nl)) {
749 retval = -NLE_NOADDR;
753 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
754 struct cmsghdr *cmsg;
756 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
757 if (cmsg->cmsg_level != SOL_SOCKET)
759 if (cmsg->cmsg_type != SCM_CREDENTIALS)
761 tmpcreds = malloc(
sizeof(*tmpcreds));
766 memcpy(tmpcreds, CMSG_DATA(cmsg),
sizeof(*tmpcreds));
773 free(msg.msg_control);
790 #define NL_CB_CALL(cb, type, msg) \
792 err = nl_cb_call(cb, type, msg); \
807 static int recvmsgs(
struct nl_sock *sk,
struct nl_cb *cb)
809 int n, err = 0, multipart = 0, interrupted = 0, nrecv = 0;
810 unsigned char *buf = NULL;
811 struct nlmsghdr *hdr;
818 struct sockaddr_nl nla = {0};
819 struct nl_msg *msg = NULL;
820 struct ucred *creds = NULL;
823 NL_DBG(3,
"Attempting to read from %p\n", sk);
825 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
827 n =
nl_recv(sk, &nla, &buf, &creds);
832 NL_DBG(3,
"recvmsgs(%p): Read %d bytes\n", sk, n);
834 hdr = (
struct nlmsghdr *) buf;
836 NL_DBG(3,
"recvmsgs(%p): Processing valid message...\n", sk);
845 nlmsg_set_proto(msg, sk->s_proto);
846 nlmsg_set_src(msg, &nla);
848 nlmsg_set_creds(msg, creds);
864 }
else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
865 if (hdr->nlmsg_seq != sk->s_seq_expect) {
869 err = -NLE_SEQ_MISMATCH;
875 if (hdr->nlmsg_type == NLMSG_DONE ||
876 hdr->nlmsg_type == NLMSG_ERROR ||
877 hdr->nlmsg_type == NLMSG_NOOP ||
878 hdr->nlmsg_type == NLMSG_OVERRUN) {
882 NL_DBG(3,
"recvmsgs(%p): Increased expected " \
883 "sequence number to %d\n",
884 sk, sk->s_seq_expect);
887 if (hdr->nlmsg_flags & NLM_F_MULTI)
890 if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
904 if (hdr->nlmsg_flags & NLM_F_ACK) {
916 if (hdr->nlmsg_type == NLMSG_DONE) {
926 else if (hdr->nlmsg_type == NLMSG_NOOP) {
936 else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
940 err = -NLE_MSG_OVERFLOW;
946 else if (hdr->nlmsg_type == NLMSG_ERROR) {
949 if (hdr->nlmsg_len <
nlmsg_size(
sizeof(*e))) {
957 err = -NLE_MSG_TRUNC;
960 }
else if (e->error) {
963 NL_DBG(4,
"recvmsgs(%p): RTNETLINK responded with %d (%s)\n",
964 sk, -e->error, strerror_r(-e->error, buf,
sizeof(buf)));
968 err = cb->cb_err(&nla, e,
975 err = -nl_syserr2nlerr(e->error);
979 err = -nl_syserr2nlerr(e->error);
1005 goto continue_reading;
1015 err = -NLE_DUMP_INTR;
1037 if (cb->cb_recvmsgs_ow)
1038 return cb->cb_recvmsgs_ow(sk, cb);
1040 return recvmsgs(sk, cb);
1082 static int ack_wait_handler(
struct nl_msg *msg,
void *arg)
1114 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1115 struct nlmsghdr *,
struct nl_parser_param *);
1116 struct nl_object *result;
1120 static int __store_answer(
struct nl_object *obj,
struct nl_parser_param *p)
1122 struct pickup_param *pp = p->pp_arg;
1133 static int __pickup_answer(
struct nl_msg *msg,
void *arg)
1135 struct pickup_param *pp = arg;
1136 struct nl_parser_param parse_arg = {
1137 .pp_cb = __store_answer,
1141 return pp->parser(NULL, &msg->nm_src, msg->nm_nlh, &parse_arg);
1144 static int __pickup_answer_syserr(
struct sockaddr_nl *nla,
struct nlmsgerr *nlerr,
void *arg)
1146 *(((
struct pickup_param *) arg)->syserror) = nlerr->error;
1148 return -nl_syserr2nlerr(nlerr->error);
1162 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1163 struct nlmsghdr *,
struct nl_parser_param *),
1164 struct nl_object **result)
1179 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1180 struct nlmsghdr *,
struct nl_parser_param *),
1181 struct nl_object **result,
1186 struct pickup_param pp = {
1197 pp.syserror = syserror;
1205 *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 nl_pickup_keep_syserr(struct nl_sock *sk, int(*parser)(struct nl_cache_ops *, struct sockaddr_nl *, struct nlmsghdr *, struct nl_parser_param *), struct nl_object **result, int *syserror)
Pickup netlink answer, parse is and return object with preserving system error.
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.
void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
Set local port of socket.
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_cb_err(struct nl_cb *cb, enum nl_cb_kind kind, nl_recvmsg_err_cb_t func, void *arg)
Set up an error callback.
int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
Transmit Netlink message using sendmsg()