29 #include <netlink-private/netlink.h> 30 #include <netlink-private/socket.h> 31 #include <netlink-private/utils.h> 32 #include <netlink/netlink.h> 33 #include <netlink/utils.h> 34 #include <netlink/handlers.h> 35 #include <netlink/msg.h> 36 #include <netlink/attr.h> 37 #include <linux/socket.h> 109 struct sockaddr_nl local = { 0 };
113 flags |= SOCK_CLOEXEC;
117 return -NLE_BAD_SOCK;
119 sk->s_fd = socket(AF_NETLINK, SOCK_RAW | flags, protocol);
122 NL_DBG(4,
"nl_connect(%p): socket() failed with %d (%s)\n", sk, errsv,
123 nl_strerror_l(errsv));
124 err = -nl_syserr2nlerr(errsv);
132 if (_nl_socket_is_local_port_unspecified (sk)) {
134 uint32_t used_ports[32] = { 0 };
141 _nl_socket_set_local_port_no_release (sk, 0);
145 port = _nl_socket_set_local_port_no_release(sk, 1);
149 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
150 sizeof(sk->s_local));
157 if (errsv == EADDRINUSE) {
158 NL_DBG(4,
"nl_connect(%p): local port %u already in use. Retry.\n", sk, (
unsigned) port);
159 _nl_socket_used_ports_set(used_ports, port);
161 NL_DBG(4,
"nl_connect(%p): bind() for port %u failed with %d (%s)\n",
162 sk, (
unsigned) port, errsv, nl_strerror_l(errsv));
163 _nl_socket_used_ports_release_all(used_ports);
164 err = -nl_syserr2nlerr(errsv);
168 _nl_socket_used_ports_release_all(used_ports);
171 err = bind(sk->s_fd, (
struct sockaddr*) &sk->s_local,
172 sizeof(sk->s_local));
175 NL_DBG(4,
"nl_connect(%p): bind() failed with %d (%s)\n",
176 sk, errsv, nl_strerror_l(errsv));
177 err = -nl_syserr2nlerr(errsv);
182 addrlen =
sizeof(local);
183 err = getsockname(sk->s_fd, (
struct sockaddr *) &local,
186 NL_DBG(4,
"nl_connect(%p): getsockname() failed with %d (%s)\n",
187 sk, errno, nl_strerror_l(errno));
188 err = -nl_syserr2nlerr(errno);
192 if (addrlen !=
sizeof(local)) {
197 if (local.nl_family != AF_NETLINK) {
198 err = -NLE_AF_NOSUPPORT;
202 if (sk->s_local.nl_pid != local.nl_pid) {
208 sk->s_proto = protocol;
212 if (sk->s_fd != -1) {
271 int nl_sendto(
struct nl_sock *sk,
void *buf,
size_t size)
279 return -NLE_BAD_SOCK;
281 ret = sendto(sk->s_fd, buf, size, 0, (
struct sockaddr *)
282 &sk->s_peer,
sizeof(sk->s_peer));
284 NL_DBG(4,
"nl_sendto(%p): sendto() failed with %d (%s)\n",
285 sk, errno, nl_strerror_l(errno));
286 return -nl_syserr2nlerr(errno);
328 int nl_sendmsg(
struct nl_sock *sk,
struct nl_msg *msg,
struct msghdr *hdr)
334 return -NLE_BAD_SOCK;
336 nlmsg_set_src(msg, &sk->s_local);
343 ret = sendmsg(sk->s_fd, hdr, 0);
345 NL_DBG(4,
"nl_sendmsg(%p): sendmsg() failed with %d (%s)\n",
346 sk, errno, nl_strerror_l(errno));
347 return -nl_syserr2nlerr(errno);
350 NL_DBG(4,
"sent %d bytes\n", ret);
374 int nl_send_iovec(
struct nl_sock *sk,
struct nl_msg *msg,
struct iovec *iov,
unsigned iovlen)
376 struct sockaddr_nl *dst;
378 struct msghdr hdr = {
379 .msg_name = (
void *) &sk->s_peer,
380 .msg_namelen =
sizeof(
struct sockaddr_nl),
382 .msg_iovlen = iovlen,
384 char buf[CMSG_SPACE(
sizeof(
struct ucred))];
389 dst = nlmsg_get_dst(msg);
390 if (dst->nl_family == AF_NETLINK)
394 creds = nlmsg_get_creds(msg);
396 struct cmsghdr *cmsg;
398 hdr.msg_control = buf;
399 hdr.msg_controllen =
sizeof(buf);
401 cmsg = CMSG_FIRSTHDR(&hdr);
402 cmsg->cmsg_level = SOL_SOCKET;
403 cmsg->cmsg_type = SCM_CREDENTIALS;
404 cmsg->cmsg_len = CMSG_LEN(
sizeof(
struct ucred));
405 memcpy(CMSG_DATA(cmsg), creds,
sizeof(
struct ucred));
448 int nl_send(
struct nl_sock *sk,
struct nl_msg *msg)
450 struct nl_cb *cb = sk->s_cb;
453 return cb->cb_send_ow(sk, msg);
484 struct nlmsghdr *nlh;
488 nlh->nlmsg_pid = nl_socket_get_local_port(sk);
491 nlh->nlmsg_seq = sk->s_seq_next++;
493 if (msg->nm_protocol == -1)
494 msg->nm_protocol = sk->s_proto;
496 nlh->nlmsg_flags |= NLM_F_REQUEST;
498 if (!(sk->s_flags & NL_NO_AUTO_ACK))
499 nlh->nlmsg_flags |= NLM_F_ACK;
558 return wait_for_ack(sk);
659 int nl_recv(
struct nl_sock *sk,
struct sockaddr_nl *nla,
660 unsigned char **buf,
struct ucred **creds)
664 static int page_size = 0;
666 struct msghdr msg = {
667 .msg_name = (
void *) nla,
668 .msg_namelen =
sizeof(
struct sockaddr_nl),
672 struct ucred* tmpcreds = NULL;
678 if ( (sk->s_flags & NL_MSG_PEEK)
679 || (!(sk->s_flags & NL_MSG_PEEK_EXPLICIT) && sk->s_bufsize == 0))
680 flags |= MSG_PEEK | MSG_TRUNC;
683 page_size = getpagesize() * 4;
685 iov.iov_len = sk->s_bufsize ? 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);
709 if (errno == EINTR) {
710 NL_DBG(3,
"recvmsg() returned EINTR, retrying\n");
714 NL_DBG(4,
"recvmsg(%p): nl_recv() failed with %d (%s)\n",
715 sk, errno, nl_strerror_l(errno));
716 retval = -nl_syserr2nlerr(errno);
720 if (msg.msg_flags & MSG_CTRUNC) {
723 if (msg.msg_controllen == 0) {
724 retval = -NLE_MSG_TRUNC;
725 NL_DBG(4,
"recvmsg(%p): Received unexpected control data", sk);
729 msg.msg_controllen *= 2;
730 tmp = realloc(msg.msg_control, msg.msg_controllen);
735 msg.msg_control = tmp;
739 if (iov.iov_len < n || (msg.msg_flags & MSG_TRUNC)) {
744 retval = -NLE_MSG_TRUNC;
752 tmp = realloc(iov.iov_base, iov.iov_len);
768 if (msg.msg_namelen !=
sizeof(
struct sockaddr_nl)) {
769 retval = -NLE_NOADDR;
773 if (creds && (sk->s_flags & NL_SOCK_PASSCRED)) {
774 struct cmsghdr *cmsg;
776 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
777 if (cmsg->cmsg_level != SOL_SOCKET)
779 if (cmsg->cmsg_type != SCM_CREDENTIALS)
781 tmpcreds = malloc(
sizeof(*tmpcreds));
786 memcpy(tmpcreds, CMSG_DATA(cmsg),
sizeof(*tmpcreds));
793 free(msg.msg_control);
810 #define NL_CB_CALL(cb, type, msg) \ 812 err = nl_cb_call(cb, type, msg); \ 827 static int recvmsgs(
struct nl_sock *sk,
struct nl_cb *cb)
829 int n, err = 0, multipart = 0, interrupted = 0, nrecv = 0;
830 unsigned char *buf = NULL;
831 struct nlmsghdr *hdr;
838 struct sockaddr_nl nla = {0};
839 struct nl_msg *msg = NULL;
840 struct ucred *creds = NULL;
843 NL_DBG(3,
"Attempting to read from %p\n", sk);
845 n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
847 n =
nl_recv(sk, &nla, &buf, &creds);
852 NL_DBG(3,
"recvmsgs(%p): Read %d bytes\n", sk, n);
854 hdr = (
struct nlmsghdr *) buf;
856 NL_DBG(3,
"recvmsgs(%p): Processing valid message...\n", sk);
865 nlmsg_set_proto(msg, sk->s_proto);
866 nlmsg_set_src(msg, &nla);
868 nlmsg_set_creds(msg, creds);
884 }
else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
885 if (hdr->nlmsg_seq != sk->s_seq_expect) {
889 err = -NLE_SEQ_MISMATCH;
895 if (hdr->nlmsg_type == NLMSG_DONE ||
896 hdr->nlmsg_type == NLMSG_ERROR ||
897 hdr->nlmsg_type == NLMSG_NOOP ||
898 hdr->nlmsg_type == NLMSG_OVERRUN) {
902 NL_DBG(3,
"recvmsgs(%p): Increased expected " \
903 "sequence number to %d\n",
904 sk, sk->s_seq_expect);
907 if (hdr->nlmsg_flags & NLM_F_MULTI)
910 if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
924 if (hdr->nlmsg_flags & NLM_F_ACK) {
936 if (hdr->nlmsg_type == NLMSG_DONE) {
946 else if (hdr->nlmsg_type == NLMSG_NOOP) {
956 else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
960 err = -NLE_MSG_OVERFLOW;
966 else if (hdr->nlmsg_type == NLMSG_ERROR) {
969 if (hdr->nlmsg_len <
nlmsg_size(
sizeof(*e))) {
977 err = -NLE_MSG_TRUNC;
980 }
else if (e->error) {
981 NL_DBG(4,
"recvmsgs(%p): RTNETLINK responded with %d (%s)\n",
982 sk, -e->error, nl_strerror_l(-e->error));
986 err = cb->cb_err(&nla, e,
993 err = -nl_syserr2nlerr(e->error);
997 err = -nl_syserr2nlerr(e->error);
1023 goto continue_reading;
1033 err = -NLE_DUMP_INTR;
1055 if (cb->cb_recvmsgs_ow)
1056 return cb->cb_recvmsgs_ow(sk, cb);
1058 return recvmsgs(sk, cb);
1100 static int ack_wait_handler(
struct nl_msg *msg,
void *arg)
1132 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1133 struct nlmsghdr *,
struct nl_parser_param *);
1134 struct nl_object *result;
1138 static int __store_answer(
struct nl_object *obj,
struct nl_parser_param *p)
1140 struct pickup_param *pp = p->pp_arg;
1151 static int __pickup_answer(
struct nl_msg *msg,
void *arg)
1153 struct pickup_param *pp = arg;
1154 struct nl_parser_param parse_arg = {
1155 .pp_cb = __store_answer,
1159 return pp->parser(NULL, &msg->nm_src, msg->nm_nlh, &parse_arg);
1162 static int __pickup_answer_syserr(
struct sockaddr_nl *nla,
struct nlmsgerr *nlerr,
void *arg)
1164 *(((
struct pickup_param *) arg)->syserror) = nlerr->error;
1166 return -nl_syserr2nlerr(nlerr->error);
1180 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1181 struct nlmsghdr *,
struct nl_parser_param *),
1182 struct nl_object **result)
1197 int (*parser)(
struct nl_cache_ops *,
struct sockaddr_nl *,
1198 struct nlmsghdr *,
struct nl_parser_param *),
1199 struct nl_object **result,
1204 struct pickup_param pp = {
1215 pp.syserror = syserror;
1223 *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()