28 #include <netlink-private/netlink.h> 29 #include <netlink-private/socket.h> 30 #include <netlink-private/utils.h> 31 #include <netlink/netlink.h> 32 #include <netlink/utils.h> 33 #include <netlink/handlers.h> 34 #include <netlink/msg.h> 35 #include <netlink/attr.h> 36 #include <linux/socket.h> 108 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 nl_strerror_l(errsv));
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, nl_strerror_l(errsv));
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, nl_strerror_l(errsv));
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, nl_strerror_l(errno));
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));
283 NL_DBG(4,
"nl_sendto(%p): sendto() failed with %d (%s)\n",
284 sk, errno, nl_strerror_l(errno));
285 return -nl_syserr2nlerr(errno);
327 int nl_sendmsg(
struct nl_sock *sk,
struct nl_msg *msg,
struct msghdr *hdr)
333 return -NLE_BAD_SOCK;
335 nlmsg_set_src(msg, &sk->s_local);
342 ret = sendmsg(sk->s_fd, hdr, 0);
344 NL_DBG(4,
"nl_sendmsg(%p): sendmsg() failed with %d (%s)\n",
345 sk, errno, nl_strerror_l(errno));
346 return -nl_syserr2nlerr(errno);
349 NL_DBG(4,
"sent %d bytes\n", ret);
373 int nl_send_iovec(
struct nl_sock *sk,
struct nl_msg *msg,
struct iovec *iov,
unsigned iovlen)
375 struct sockaddr_nl *dst;
377 struct msghdr hdr = {
378 .msg_name = (
void *) &sk->s_peer,
379 .msg_namelen =
sizeof(
struct sockaddr_nl),
381 .msg_iovlen = iovlen,
383 char buf[CMSG_SPACE(
sizeof(
struct ucred))];
388 dst = nlmsg_get_dst(msg);
389 if (dst->nl_family == AF_NETLINK)
393 creds = nlmsg_get_creds(msg);
395 struct cmsghdr *cmsg;
397 hdr.msg_control = buf;
398 hdr.msg_controllen =
sizeof(buf);
400 cmsg = CMSG_FIRSTHDR(&hdr);
401 cmsg->cmsg_level = SOL_SOCKET;
402 cmsg->cmsg_type = SCM_CREDENTIALS;
403 cmsg->cmsg_len = CMSG_LEN(
sizeof(
struct ucred));
404 memcpy(CMSG_DATA(cmsg), creds,
sizeof(
struct ucred));
447 int nl_send(
struct nl_sock *sk,
struct nl_msg *msg)
449 struct nl_cb *cb = sk->s_cb;
452 return cb->cb_send_ow(sk, msg);
483 struct nlmsghdr *nlh;
487 nlh->nlmsg_pid = nl_socket_get_local_port(sk);
490 nlh->nlmsg_seq = sk->s_seq_next++;
492 if (msg->nm_protocol == -1)
493 msg->nm_protocol = sk->s_proto;
495 nlh->nlmsg_flags |= NLM_F_REQUEST;
497 if (!(sk->s_flags & NL_NO_AUTO_ACK))
498 nlh->nlmsg_flags |= NLM_F_ACK;
557 return wait_for_ack(sk);
658 int nl_recv(
struct nl_sock *sk,
struct sockaddr_nl *nla,
659 unsigned char **buf,
struct ucred **creds)
663 static int page_size = 0;
665 struct msghdr msg = {
666 .msg_name = (
void *) nla,
667 .msg_namelen =
sizeof(
struct sockaddr_nl),
671 struct ucred* tmpcreds = NULL;
677 if ( (sk->s_flags & NL_MSG_PEEK)
678 || (!(sk->s_flags & NL_MSG_PEEK_EXPLICIT) && sk->s_bufsize == 0))
679 flags |= MSG_PEEK | MSG_TRUNC;
682 page_size = getpagesize() * 4;
684 iov.iov_len = sk->s_bufsize ? : page_size;
685 iov.iov_base = malloc(iov.iov_len);
692 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
693 msg.msg_controllen = CMSG_SPACE(
sizeof(
struct ucred));
694 msg.msg_control = malloc(msg.msg_controllen);
695 if (!msg.msg_control) {
702 n = recvmsg(sk->s_fd, &msg, flags);
708 if (errno == EINTR) {
709 NL_DBG(3,
"recvmsg() returned EINTR, retrying\n");
713 NL_DBG(4,
"nl_sendmsg(%p): nl_recv() failed with %d (%s)\n",
714 sk, errno, nl_strerror_l(errno));
715 retval = -nl_syserr2nlerr(errno);
719 if (msg.msg_flags & MSG_CTRUNC) {
722 if (msg.msg_controllen == 0) {
723 retval = -NLE_MSG_TRUNC;
724 NL_DBG(4,
"recvmsg(%p): Received unexpected control data", sk);
728 msg.msg_controllen *= 2;
729 tmp = realloc(msg.msg_control, msg.msg_controllen);
734 msg.msg_control = tmp;
738 if (iov.iov_len < n || (msg.msg_flags & MSG_TRUNC)) {
743 retval = -NLE_MSG_TRUNC;
751 tmp = realloc(iov.iov_base, iov.iov_len);
767 if (msg.msg_namelen !=
sizeof(
struct sockaddr_nl)) {
768 retval = -NLE_NOADDR;
772 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
773 struct cmsghdr *cmsg;
775 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
776 if (cmsg->cmsg_level != SOL_SOCKET)
778 if (cmsg->cmsg_type != SCM_CREDENTIALS)
780 tmpcreds = malloc(
sizeof(*tmpcreds));
785 memcpy(tmpcreds, CMSG_DATA(cmsg),
sizeof(*tmpcreds));
792 free(msg.msg_control);
809 #define NL_CB_CALL(cb, type, msg) \ 811 err = nl_cb_call(cb, type, msg); \ 826 static int recvmsgs(
struct nl_sock *sk,
struct nl_cb *cb)
828 int n, err = 0, multipart = 0, interrupted = 0, nrecv = 0;
829 unsigned char *buf = NULL;
830 struct nlmsghdr *hdr;
837 struct sockaddr_nl nla = {0};
838 struct nl_msg *msg = NULL;
839 struct ucred *creds = NULL;
842 NL_DBG(3,
"Attempting to read from %p\n", sk);
844 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
846 n =
nl_recv(sk, &nla, &buf, &creds);
851 NL_DBG(3,
"recvmsgs(%p): Read %d bytes\n", sk, n);
853 hdr = (
struct nlmsghdr *) buf;
855 NL_DBG(3,
"recvmsgs(%p): Processing valid message...\n", sk);
864 nlmsg_set_proto(msg, sk->s_proto);
865 nlmsg_set_src(msg, &nla);
867 nlmsg_set_creds(msg, creds);
883 }
else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
884 if (hdr->nlmsg_seq != sk->s_seq_expect) {
888 err = -NLE_SEQ_MISMATCH;
894 if (hdr->nlmsg_type == NLMSG_DONE ||
895 hdr->nlmsg_type == NLMSG_ERROR ||
896 hdr->nlmsg_type == NLMSG_NOOP ||
897 hdr->nlmsg_type == NLMSG_OVERRUN) {
901 NL_DBG(3,
"recvmsgs(%p): Increased expected " \
902 "sequence number to %d\n",
903 sk, sk->s_seq_expect);
906 if (hdr->nlmsg_flags & NLM_F_MULTI)
909 if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
923 if (hdr->nlmsg_flags & NLM_F_ACK) {
935 if (hdr->nlmsg_type == NLMSG_DONE) {
945 else if (hdr->nlmsg_type == NLMSG_NOOP) {
955 else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
959 err = -NLE_MSG_OVERFLOW;
965 else if (hdr->nlmsg_type == NLMSG_ERROR) {
968 if (hdr->nlmsg_len <
nlmsg_size(
sizeof(*e))) {
976 err = -NLE_MSG_TRUNC;
979 }
else if (e->error) {
980 NL_DBG(4,
"recvmsgs(%p): RTNETLINK responded with %d (%s)\n",
981 sk, -e->error, nl_strerror_l(-e->error));
985 err = cb->cb_err(&nla, e,
992 err = -nl_syserr2nlerr(e->error);
996 err = -nl_syserr2nlerr(e->error);
1022 goto continue_reading;
1032 err = -NLE_DUMP_INTR;
1054 if (cb->cb_recvmsgs_ow)
1055 return cb->cb_recvmsgs_ow(sk, cb);
1057 return recvmsgs(sk, cb);
1099 static int ack_wait_handler(
struct nl_msg *msg,
void *arg)
1131 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1132 struct nlmsghdr *,
struct nl_parser_param *);
1133 struct nl_object *result;
1137 static int __store_answer(
struct nl_object *obj,
struct nl_parser_param *p)
1139 struct pickup_param *pp = p->pp_arg;
1150 static int __pickup_answer(
struct nl_msg *msg,
void *arg)
1152 struct pickup_param *pp = arg;
1153 struct nl_parser_param parse_arg = {
1154 .pp_cb = __store_answer,
1158 return pp->parser(NULL, &msg->nm_src, msg->nm_nlh, &parse_arg);
1161 static int __pickup_answer_syserr(
struct sockaddr_nl *nla,
struct nlmsgerr *nlerr,
void *arg)
1163 *(((
struct pickup_param *) arg)->syserror) = nlerr->error;
1165 return -nl_syserr2nlerr(nlerr->error);
1179 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1180 struct nlmsghdr *,
struct nl_parser_param *),
1181 struct nl_object **result)
1196 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1197 struct nlmsghdr *,
struct nl_parser_param *),
1198 struct nl_object **result,
1203 struct pickup_param pp = {
1214 pp.syserror = syserror;
1222 *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()