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>
35 #include <linux/socket.h>
107 struct sockaddr_nl local = { 0 };
112 flags |= SOCK_CLOEXEC;
116 return -NLE_BAD_SOCK;
118 sk->s_fd = socket(AF_NETLINK, SOCK_RAW | flags, protocol);
121 NL_DBG(4,
"nl_connect(%p): socket() failed with %d (%s)\n", sk, errsv,
122 strerror_r(errsv, buf,
sizeof(buf)));
123 err = -nl_syserr2nlerr(errsv);
131 if (_nl_socket_is_local_port_unspecified (sk)) {
133 uint32_t used_ports[32] = { 0 };
140 _nl_socket_set_local_port_no_release (sk, 0);
144 port = _nl_socket_set_local_port_no_release(sk, 1);
148 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
149 sizeof(sk->s_local));
156 if (errsv == EADDRINUSE) {
157 NL_DBG(4,
"nl_connect(%p): local port %u already in use. Retry.\n", sk, (
unsigned) port);
158 _nl_socket_used_ports_set(used_ports, port);
160 NL_DBG(4,
"nl_connect(%p): bind() for port %u failed with %d (%s)\n",
161 sk, (
unsigned) port, errsv, strerror_r(errsv, buf,
sizeof(buf)));
162 _nl_socket_used_ports_release_all(used_ports);
163 err = -nl_syserr2nlerr(errsv);
167 _nl_socket_used_ports_release_all(used_ports);
170 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
171 sizeof(sk->s_local));
174 NL_DBG(4,
"nl_connect(%p): bind() failed with %d (%s)\n",
175 sk, errsv, strerror_r(errsv, buf,
sizeof(buf)));
176 err = -nl_syserr2nlerr(errsv);
181 addrlen =
sizeof(local);
182 err = getsockname(sk->s_fd, (
struct sockaddr *) &local,
185 NL_DBG(4,
"nl_connect(%p): getsockname() failed with %d (%s)\n",
186 sk, errno, strerror_r(errno, buf,
sizeof(buf)));
187 err = -nl_syserr2nlerr(errno);
191 if (addrlen !=
sizeof(local)) {
196 if (local.nl_family != AF_NETLINK) {
197 err = -NLE_AF_NOSUPPORT;
201 if (sk->s_local.nl_pid != local.nl_pid) {
207 sk->s_proto = protocol;
211 if (sk->s_fd != -1) {
270 int nl_sendto(
struct nl_sock *sk,
void *buf,
size_t size)
278 return -NLE_BAD_SOCK;
280 ret = sendto(sk->s_fd, buf, size, 0, (
struct sockaddr *)
281 &sk->s_peer,
sizeof(sk->s_peer));
285 NL_DBG(4,
"nl_sendto(%p): sendto() failed with %d (%s)\n",
286 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
287 return -nl_syserr2nlerr(errno);
329 int nl_sendmsg(
struct nl_sock *sk,
struct nl_msg *msg,
struct msghdr *hdr)
335 return -NLE_BAD_SOCK;
337 nlmsg_set_src(msg, &sk->s_local);
344 ret = sendmsg(sk->s_fd, hdr, 0);
348 NL_DBG(4,
"nl_sendmsg(%p): sendmsg() failed with %d (%s)\n",
349 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
350 return -nl_syserr2nlerr(errno);
353 NL_DBG(4,
"sent %d bytes\n", ret);
377 int nl_send_iovec(
struct nl_sock *sk,
struct nl_msg *msg,
struct iovec *iov,
unsigned iovlen)
379 struct sockaddr_nl *dst;
381 struct msghdr hdr = {
382 .msg_name = (
void *) &sk->s_peer,
383 .msg_namelen =
sizeof(
struct sockaddr_nl),
385 .msg_iovlen = iovlen,
391 dst = nlmsg_get_dst(msg);
392 if (dst->nl_family == AF_NETLINK)
396 creds = nlmsg_get_creds(msg);
398 char buf[CMSG_SPACE(
sizeof(
struct ucred))];
399 struct cmsghdr *cmsg;
401 hdr.msg_control = buf;
402 hdr.msg_controllen =
sizeof(buf);
404 cmsg = CMSG_FIRSTHDR(&hdr);
405 cmsg->cmsg_level = SOL_SOCKET;
406 cmsg->cmsg_type = SCM_CREDENTIALS;
407 cmsg->cmsg_len = CMSG_LEN(
sizeof(
struct ucred));
408 memcpy(CMSG_DATA(cmsg), creds,
sizeof(
struct ucred));
451 int nl_send(
struct nl_sock *sk,
struct nl_msg *msg)
453 struct nl_cb *cb = sk->s_cb;
456 return cb->cb_send_ow(sk, msg);
487 struct nlmsghdr *nlh;
491 nlh->nlmsg_pid = nl_socket_get_local_port(sk);
494 nlh->nlmsg_seq = sk->s_seq_next++;
496 if (msg->nm_protocol == -1)
497 msg->nm_protocol = sk->s_proto;
499 nlh->nlmsg_flags |= NLM_F_REQUEST;
501 if (!(sk->s_flags & NL_NO_AUTO_ACK))
502 nlh->nlmsg_flags |= NLM_F_ACK;
561 return wait_for_ack(sk);
660 int nl_recv(
struct nl_sock *sk,
struct sockaddr_nl *nla,
661 unsigned char **buf,
struct ucred **creds)
665 static int page_size = 0;
667 struct msghdr msg = {
668 .msg_name = (
void *) nla,
669 .msg_namelen =
sizeof(
struct sockaddr_nl),
673 struct ucred* tmpcreds = NULL;
679 if (sk->s_flags & NL_MSG_PEEK)
680 flags |= MSG_PEEK | MSG_TRUNC;
683 page_size = getpagesize() * 4;
685 iov.iov_len = sk->s_bufsize ? : page_size;
686 iov.iov_base = malloc(iov.iov_len);
693 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
694 msg.msg_controllen = CMSG_SPACE(
sizeof(
struct ucred));
695 msg.msg_control = malloc(msg.msg_controllen);
696 if (!msg.msg_control) {
703 n = recvmsg(sk->s_fd, &msg, flags);
711 if (errno == EINTR) {
712 NL_DBG(3,
"recvmsg() returned EINTR, retrying\n");
716 NL_DBG(4,
"nl_sendmsg(%p): nl_recv() failed with %d (%s)\n",
717 sk, errno, strerror_r(errno, errbuf,
sizeof(errbuf)));
718 retval = -nl_syserr2nlerr(errno);
722 if (msg.msg_flags & MSG_CTRUNC) {
725 if (msg.msg_controllen == 0) {
726 retval = -NLE_MSG_TRUNC;
727 NL_DBG(4,
"recvmsg(%p): Received unexpected control data", sk);
731 msg.msg_controllen *= 2;
732 tmp = realloc(msg.msg_control, msg.msg_controllen);
737 msg.msg_control = tmp;
741 if (iov.iov_len < n || (msg.msg_flags & MSG_TRUNC)) {
745 if (!(sk->s_flags & NL_MSG_PEEK)) {
746 retval = -NLE_MSG_TRUNC;
754 tmp = realloc(iov.iov_base, iov.iov_len);
770 if (msg.msg_namelen !=
sizeof(
struct sockaddr_nl)) {
771 retval = -NLE_NOADDR;
775 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
776 struct cmsghdr *cmsg;
778 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
779 if (cmsg->cmsg_level != SOL_SOCKET)
781 if (cmsg->cmsg_type != SCM_CREDENTIALS)
783 tmpcreds = malloc(
sizeof(*tmpcreds));
788 memcpy(tmpcreds, CMSG_DATA(cmsg),
sizeof(*tmpcreds));
795 free(msg.msg_control);
812 #define NL_CB_CALL(cb, type, msg) \
814 err = nl_cb_call(cb, type, msg); \
829 static int recvmsgs(
struct nl_sock *sk,
struct nl_cb *cb)
831 int n, err = 0, multipart = 0, interrupted = 0, nrecv = 0;
832 unsigned char *buf = NULL;
833 struct nlmsghdr *hdr;
840 struct sockaddr_nl nla = {0};
841 struct nl_msg *msg = NULL;
842 struct ucred *creds = NULL;
845 NL_DBG(3,
"Attempting to read from %p\n", sk);
847 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
849 n =
nl_recv(sk, &nla, &buf, &creds);
854 NL_DBG(3,
"recvmsgs(%p): Read %d bytes\n", sk, n);
856 hdr = (
struct nlmsghdr *) buf;
858 NL_DBG(3,
"recvmsgs(%p): Processing valid message...\n", sk);
867 nlmsg_set_proto(msg, sk->s_proto);
868 nlmsg_set_src(msg, &nla);
870 nlmsg_set_creds(msg, creds);
886 }
else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
887 if (hdr->nlmsg_seq != sk->s_seq_expect) {
891 err = -NLE_SEQ_MISMATCH;
897 if (hdr->nlmsg_type == NLMSG_DONE ||
898 hdr->nlmsg_type == NLMSG_ERROR ||
899 hdr->nlmsg_type == NLMSG_NOOP ||
900 hdr->nlmsg_type == NLMSG_OVERRUN) {
904 NL_DBG(3,
"recvmsgs(%p): Increased expected " \
905 "sequence number to %d\n",
906 sk, sk->s_seq_expect);
909 if (hdr->nlmsg_flags & NLM_F_MULTI)
912 if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
926 if (hdr->nlmsg_flags & NLM_F_ACK) {
938 if (hdr->nlmsg_type == NLMSG_DONE) {
948 else if (hdr->nlmsg_type == NLMSG_NOOP) {
958 else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
962 err = -NLE_MSG_OVERFLOW;
968 else if (hdr->nlmsg_type == NLMSG_ERROR) {
971 if (hdr->nlmsg_len <
nlmsg_size(
sizeof(*e))) {
979 err = -NLE_MSG_TRUNC;
982 }
else if (e->error) {
985 NL_DBG(4,
"recvmsgs(%p): RTNETLINK responded with %d (%s)\n",
986 sk, -e->error, strerror_r(-e->error, buf,
sizeof(buf)));
990 err = cb->cb_err(&nla, e,
997 err = -nl_syserr2nlerr(e->error);
1001 err = -nl_syserr2nlerr(e->error);
1027 goto continue_reading;
1037 err = -NLE_DUMP_INTR;
1059 if (cb->cb_recvmsgs_ow)
1060 return cb->cb_recvmsgs_ow(sk, cb);
1062 return recvmsgs(sk, cb);
1104 static int ack_wait_handler(
struct nl_msg *msg,
void *arg)
1136 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1137 struct nlmsghdr *,
struct nl_parser_param *);
1138 struct nl_object *result;
1142 static int __store_answer(
struct nl_object *obj,
struct nl_parser_param *p)
1144 struct pickup_param *pp = p->pp_arg;
1155 static int __pickup_answer(
struct nl_msg *msg,
void *arg)
1157 struct pickup_param *pp = arg;
1158 struct nl_parser_param parse_arg = {
1159 .pp_cb = __store_answer,
1163 return pp->parser(NULL, &msg->nm_src, msg->nm_nlh, &parse_arg);
1166 static int __pickup_answer_syserr(
struct sockaddr_nl *nla,
struct nlmsgerr *nlerr,
void *arg)
1168 *(((
struct pickup_param *) arg)->syserror) = nlerr->error;
1170 return -nl_syserr2nlerr(nlerr->error);
1184 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1185 struct nlmsghdr *,
struct nl_parser_param *),
1186 struct nl_object **result)
1201 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1202 struct nlmsghdr *,
struct nl_parser_param *),
1203 struct nl_object **result,
1208 struct pickup_param pp = {
1219 pp.syserror = syserror;
1227 *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()