static int send_and_recv(struct nl_sock *nl_sock, struct nl_msg *msg, int (*valid_handler)(struct nl_msg *, void *), void *valid_data) { struct nl_cb *cb; int err = -ENOMEM; cb = nl_cb_clone(nlcfg.nl_cb); if (!cb) goto out; err = nl_send_auto_complete(nl_sock, msg); if (err < 0) goto out; err = 1; nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err); if (valid_handler) nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, valid_data); while (err > 0) nl_recvmsgs(nl_sock, cb); out: nl_cb_put(cb); nlmsg_free(msg); return err; }
/** * Pickup netlink answer, parse is and return object * @arg sk Netlink socket * @arg parser Parser function to parse answer * @arg result Result pointer to return parsed object * * @return 0 on success or a negative error code. */ 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) { struct nl_cb *cb; int err; struct pickup_param pp = { .parser = parser, }; cb = nl_cb_clone(sk->s_cb); if (cb == NULL) return -NLE_NOMEM; nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, __pickup_answer, &pp); err = nl_recvmsgs(sk, cb); if (err < 0) goto errout; *result = pp.result; errout: nl_cb_put(cb); return err; }
/* NOTE: this function consumes 'msg' */ static int _nl80211_send_and_recv (struct nl_sock *nl_sock, struct nl_cb *nl_cb, struct nl_msg *msg, int (*valid_handler) (struct nl_msg *, void *), void *valid_data) { struct nl_cb *cb; int err, done; g_return_val_if_fail (msg != NULL, -ENOMEM); cb = nl_cb_clone (nl_cb); if (!cb) { err = -ENOMEM; goto out; } err = nl_send_auto_complete (nl_sock, msg); if (err < 0) goto out; done = 0; nl_cb_err (cb, NL_CB_CUSTOM, error_handler, &done); nl_cb_set (cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &done); nl_cb_set (cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &done); if (valid_handler) nl_cb_set (cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, valid_data); /* Loop until one of our NL callbacks says we're done; on success * done will be 1, on error it will be < 0. */ while (!done) { err = nl_recvmsgs (nl_sock, cb); if (err && err != -NLE_AGAIN) { /* Kernel scan list can change while we are dumping it, as new scan * results from H/W can arrive. BSS info is assured to be consistent * and we don't need consistent view of whole scan list. Hence do * not warn on DUMP_INTR error for get scan command. */ if (err == -NLE_DUMP_INTR && genlmsg_hdr(nlmsg_hdr(msg))->cmd == NL80211_CMD_GET_SCAN) break; nm_log_warn (LOGD_WIFI, "nl_recvmsgs() error: (%d) %s", err, nl_geterror (err)); break; } } if (err == 0 && done < 0) err = done; out: nl_cb_put (cb); nlmsg_free (msg); return err; }
/** * Wait for ACK. * @arg sk Netlink socket. * @pre The netlink socket must be in blocking state. * * Waits until an ACK is received for the latest not yet acknowledged * netlink message. */ int nl_wait_for_ack(struct nl_sock *sk) { int err; struct nl_cb *cb; cb = nl_cb_clone(sk->s_cb); if (cb == NULL) return -NLE_NOMEM; nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL); err = nl_recvmsgs(sk, cb); nl_cb_put(cb); return err; }
/* NOTE: this function consumes 'msg' */ static int _nl80211_send_and_recv (struct nl_sock *nl_sock, struct nl_cb *nl_cb, struct nl_msg *msg, int (*valid_handler)(struct nl_msg *, void *), void *valid_data) { struct nl_cb *cb; int err, done; g_return_val_if_fail (msg != NULL, -ENOMEM); cb = nl_cb_clone (nl_cb); if (!cb) { err = -ENOMEM; goto out; } err = nl_send_auto_complete (nl_sock, msg); if (err < 0) goto out; done = 0; nl_cb_err (cb, NL_CB_CUSTOM, error_handler, &done); nl_cb_set (cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &done); nl_cb_set (cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &done); if (valid_handler) nl_cb_set (cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, valid_data); /* Loop until one of our NL callbacks says we're done; on success * done will be 1, on error it will be < 0. */ while (!done) { err = nl_recvmsgs (nl_sock, cb); if (err && err != -NLE_AGAIN) { nm_log_warn (LOGD_WIFI, "nl_recvmsgs() error: (%d) %s", err, nl_geterror (err)); break; } } if (err == 0 && done < 0) err = done; out: nl_cb_put (cb); nlmsg_free (msg); return err; }
static int send_and_recv(struct nl_handle* handle, struct nl_msg* msg, struct nl_cb* cb) { int err = -1; struct nl_cb *tmp_cb; tmp_cb = nl_cb_clone(cb); if (!cb) goto out; err = nl_send_auto_complete(handle, msg); if (err < 0) goto out; err = 1; nl_cb_err(tmp_cb, NL_CB_CUSTOM, error_handler, &err); nl_cb_set(tmp_cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err); nl_cb_set(tmp_cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err); while(err > 0) nl_recvmsgs(handle, tmp_cb); out: nlmsg_free(msg); nl_cb_put(tmp_cb); return err; }
static int ac_kmod_send_and_recv(struct nl_sock* nl, struct nl_cb* nl_cb, struct nl_msg* msg, ac_kmod_valid_cb valid_cb, void* data) { int result; struct nl_cb* cb; /* Clone netlink callback */ cb = nl_cb_clone(nl_cb); if (!cb) { return -1; } /* */ capwap_lock_enter(&g_ac.kmodhandle.msglock); /* Complete send message */ result = nl_send_auto_complete(nl, msg); if (result >= 0) { /* Customize message callback */ nl_cb_err(cb, NL_CB_CUSTOM, ac_kmod_error_handler, &result); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, ac_kmod_finish_handler, &result); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ac_kmod_ack_handler, &result); if (valid_cb) { nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_cb, data); } result = 1; while (result > 0) { nl_recvmsgs(nl, cb); } } /* */ capwap_lock_exit(&g_ac.kmodhandle.msglock); nl_cb_put(cb); return result; }
/** * Check for event notifications * @arg mngr Cache Manager * @arg timeout Upper limit poll() will block, in milliseconds. * * Causes poll() to be called to check for new event notifications * being available. Calls nl_cache_mngr_data_ready() to process * available data. * * This functionally is ideally called regularly during an idle * period. * * A timeout can be specified in milliseconds to limit the time the * function will wait for updates. * * @see nl_cache_mngr_data_ready() * * @return The number of messages processed or a negative error code. */ int nl_cache_mngr_poll(struct nl_cache_mngr *mngr, int timeout) { int ret; struct pollfd fds = { .fd = nl_socket_get_fd(mngr->cm_sock), .events = POLLIN, }; NL_DBG(3, "Cache manager %p, poll() fd %d\n", mngr, fds.fd); ret = poll(&fds, 1, timeout); NL_DBG(3, "Cache manager %p, poll() returned %d\n", mngr, ret); if (ret < 0) return -nl_syserr2nlerr(errno); /* No events, return */ if (ret == 0) return 0; return nl_cache_mngr_data_ready(mngr); } /** * Receive available event notifications * @arg mngr Cache manager * * This function can be called if the socket associated to the manager * contains updates to be received. This function should only be used * if nl_cache_mngr_poll() is not used. * * The function will process messages until there is no more data to * be read from the socket. * * @see nl_cache_mngr_poll() * * @return The number of messages processed or a negative error code. */ int nl_cache_mngr_data_ready(struct nl_cache_mngr *mngr) { int err, nread = 0; struct nl_cb *cb; NL_DBG(2, "Cache manager %p, reading new data from fd %d\n", mngr, nl_socket_get_fd(mngr->cm_sock)); cb = nl_cb_clone(mngr->cm_sock->s_cb); if (cb == NULL) return -NLE_NOMEM; nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, event_input, mngr); while ((err = nl_recvmsgs_report(mngr->cm_sock, cb)) > 0) { NL_DBG(2, "Cache manager %p, recvmsgs read %d messages\n", mngr, err); nread += err; } nl_cb_put(cb); if (err < 0 && err != -NLE_AGAIN) return err; return nread; }
/** * Send netlink message with control over sendmsg() message header. * @arg handle Netlink handle. * @arg msg Netlink message to be sent. * @arg hdr Sendmsg() message header. * @return Number of characters sent on sucess or a negative error code. */ int nl_sendmsg(struct nl_handle *handle, struct nl_msg *msg, struct msghdr *hdr) { struct nl_cb *cb; int ret; struct iovec iov = { .iov_base = (void *) nlmsg_hdr(msg), .iov_len = nlmsg_hdr(msg)->nlmsg_len, }; hdr->msg_iov = &iov; hdr->msg_iovlen = 1; nlmsg_set_src(msg, &handle->h_local); cb = nl_handle_get_cb(handle); if (cb->cb_set[NL_CB_MSG_OUT]) if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_PROCEED) return 0; ret = sendmsg(handle->h_fd, hdr, 0); if (ret < 0) return nl_errno(errno); return ret; } /** * Send netlink message. * @arg handle Netlink handle * @arg msg Netlink message to be sent. * @see nl_sendmsg() * @return Number of characters sent on success or a negative error code. */ int nl_send(struct nl_handle *handle, struct nl_msg *msg) { struct sockaddr_nl *dst; struct ucred *creds; struct msghdr hdr = { .msg_name = (void *) &handle->h_peer, .msg_namelen = sizeof(struct sockaddr_nl), }; /* Overwrite destination if specified in the message itself, defaults * to the peer address of the handle. */ dst = nlmsg_get_dst(msg); if (dst->nl_family == AF_NETLINK) hdr.msg_name = dst; /* Add credentials if present. */ creds = nlmsg_get_creds(msg); if (creds != NULL) { char buf[CMSG_SPACE(sizeof(struct ucred))]; struct cmsghdr *cmsg; hdr.msg_control = buf; hdr.msg_controllen = sizeof(buf); cmsg = CMSG_FIRSTHDR(&hdr); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_CREDENTIALS; cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred)); memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred)); } return nl_sendmsg(handle, msg, &hdr); } /** * Send netlink message and check & extend header values as needed. * @arg handle Netlink handle. * @arg msg Netlink message to be sent. * * Checks the netlink message \c nlh for completness and extends it * as required before sending it out. Checked fields include pid, * sequence nr, and flags. * * @see nl_send() * @return Number of characters sent or a negative error code. */ int nl_send_auto_complete(struct nl_handle *handle, struct nl_msg *msg) { struct nlmsghdr *nlh; nlh = nlmsg_hdr(msg); if (nlh->nlmsg_pid == 0) nlh->nlmsg_pid = handle->h_local.nl_pid; if (nlh->nlmsg_seq == 0) nlh->nlmsg_seq = handle->h_seq_next++; nlh->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK); if (handle->h_cb->cb_send_ow) return handle->h_cb->cb_send_ow(handle, msg); else return nl_send(handle, msg); } /** * Send simple netlink message using nl_send_auto_complete() * @arg handle Netlink handle. * @arg type Netlink message type. * @arg flags Netlink message flags. * @arg buf Data buffer. * @arg size Size of data buffer. * * Builds a netlink message with the specified type and flags and * appends the specified data as payload to the message. * * @see nl_send_auto_complete() * @return Number of characters sent on success or a negative error code. */ int nl_send_simple(struct nl_handle *handle, int type, int flags, void *buf, size_t size) { int err; struct nl_msg *msg; struct nlmsghdr nlh = { .nlmsg_len = nlmsg_msg_size(0), .nlmsg_type = type, .nlmsg_flags = flags, }; msg = nlmsg_build(&nlh); if (!msg) return nl_errno(ENOMEM); if (buf && size) nlmsg_append(msg, buf, size, 1); err = nl_send_auto_complete(handle, msg); nlmsg_free(msg); return err; } /** @} */ /** * @name Receive * @{ */ /** * Receive netlink message from netlink socket. * @arg handle Netlink handle. * @arg nla Destination pointer for peer's netlink address. * @arg buf Destination pointer for message content. * @arg creds Destination pointer for credentials. * * Receives a netlink message, allocates a buffer in \c *buf and * stores the message content. The peer's netlink address is stored * in \c *nla. The caller is responsible for freeing the buffer allocated * in \c *buf if a positive value is returned. Interruped system calls * are handled by repeating the read. The input buffer size is determined * by peeking before the actual read is done. * * A non-blocking sockets causes the function to return immediately if * no data is available. * * @return Number of octets read, 0 on EOF or a negative error code. */ int nl_recv(struct nl_handle *handle, struct sockaddr_nl *nla, unsigned char **buf, struct ucred **creds) { int n; int flags = MSG_PEEK; struct iovec iov = { .iov_len = 4096, }; struct msghdr msg = { .msg_name = (void *) nla, .msg_namelen = sizeof(sizeof(struct sockaddr_nl)), .msg_iov = &iov, .msg_iovlen = 1, .msg_control = NULL, .msg_controllen = 0, .msg_flags = 0, }; struct cmsghdr *cmsg; iov.iov_base = *buf = calloc(1, iov.iov_len); if (handle->h_flags & NL_SOCK_PASSCRED) { msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred)); msg.msg_control = calloc(1, msg.msg_controllen); } retry: if ((n = recvmsg(handle->h_fd, &msg, flags)) <= 0) { if (!n) goto abort; else if (n < 0) { if (errno == EINTR) goto retry; else if (errno == EAGAIN) goto abort; else { free(msg.msg_control); free(*buf); return nl_error(errno, "recvmsg failed"); } } } if (iov.iov_len < n) { /* Provided buffer is not long enough, enlarge it * and try again. */ iov.iov_len *= 2; iov.iov_base = *buf = realloc(*buf, iov.iov_len); goto retry; } else if (msg.msg_flags & MSG_CTRUNC) { msg.msg_controllen *= 2; msg.msg_control = realloc(msg.msg_control, msg.msg_controllen); goto retry; } else if (flags != 0) { /* Buffer is big enough, do the actual reading */ flags = 0; goto retry; } if (msg.msg_namelen != sizeof(struct sockaddr_nl)) { free(msg.msg_control); free(*buf); return nl_error(EADDRNOTAVAIL, "socket address size mismatch"); } for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_CREDENTIALS) { *creds = calloc(1, sizeof(struct ucred)); memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred)); break; } } free(msg.msg_control); return n; abort: free(msg.msg_control); free(*buf); return 0; } /** * Receive a set of messages from a netlink socket. * @arg handle netlink handle * @arg cb set of callbacks to control the behaviour. * * Repeatedly calls nl_recv() and parses the messages as netlink * messages. Stops reading if one of the callbacks returns * NL_EXIT or nl_recv returns either 0 or a negative error code. * * A non-blocking sockets causes the function to return immediately if * no data is available. * * @return 0 on success or a negative error code from nl_recv(). */ int nl_recvmsgs(struct nl_handle *handle, struct nl_cb *cb) { int n, err = 0; unsigned char *buf = NULL; struct nlmsghdr *hdr; struct sockaddr_nl nla = {0}; struct nl_msg *msg = NULL; struct ucred *creds = NULL; continue_reading: if (cb->cb_recv_ow) n = cb->cb_recv_ow(handle, &nla, &buf, &creds); else n = nl_recv(handle, &nla, &buf, &creds); if (n <= 0) return n; NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", handle, n); hdr = (struct nlmsghdr *) buf; while (nlmsg_ok(hdr, n)) { NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", handle); nlmsg_free(msg); msg = nlmsg_convert(hdr); if (!msg) { err = nl_errno(ENOMEM); goto out; } nlmsg_set_proto(msg, handle->h_proto); nlmsg_set_src(msg, &nla); if (creds) nlmsg_set_creds(msg, creds); /* Raw callback is the first, it gives the most control * to the user and he can do his very own parsing. */ if (cb->cb_set[NL_CB_MSG_IN]) { err = nl_cb_call(cb, NL_CB_MSG_IN, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } /* Sequence number checking. The check may be done by * the user, otherwise a very simple check is applied * enforcing strict ordering */ if (cb->cb_set[NL_CB_SEQ_CHECK]) { err = nl_cb_call(cb, NL_CB_SEQ_CHECK, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else if (hdr->nlmsg_seq != handle->h_seq_expect) { if (cb->cb_set[NL_CB_INVALID]) { err = nl_cb_call(cb, NL_CB_INVALID, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else goto out; } if (hdr->nlmsg_type == NLMSG_DONE || hdr->nlmsg_type == NLMSG_ERROR || hdr->nlmsg_type == NLMSG_NOOP || hdr->nlmsg_type == NLMSG_OVERRUN) { /* We can't check for !NLM_F_MULTI since some netlink * users in the kernel are broken. */ handle->h_seq_expect++; NL_DBG(3, "recvmsgs(%p): Increased expected " \ "sequence number to %d\n", handle, handle->h_seq_expect); } /* Other side wishes to see an ack for this message */ if (hdr->nlmsg_flags & NLM_F_ACK) { if (cb->cb_set[NL_CB_SEND_ACK]) { err = nl_cb_call(cb, NL_CB_SEND_ACK, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else { /* FIXME: implement */ } } /* messages terminates a multpart message, this is * usually the end of a message and therefore we slip * out of the loop by default. the user may overrule * this action by skipping this packet. */ if (hdr->nlmsg_type == NLMSG_DONE) { if (cb->cb_set[NL_CB_FINISH]) { err = nl_cb_call(cb, NL_CB_FINISH, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } err = 0; goto out; } /* Message to be ignored, the default action is to * skip this message if no callback is specified. The * user may overrule this action by returning * NL_PROCEED. */ else if (hdr->nlmsg_type == NLMSG_NOOP) { if (cb->cb_set[NL_CB_SKIPPED]) { err = nl_cb_call(cb, NL_CB_SKIPPED, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else goto skip; } /* Data got lost, report back to user. The default action is to * quit parsing. The user may overrule this action by retuning * NL_SKIP or NL_PROCEED (dangerous) */ else if (hdr->nlmsg_type == NLMSG_OVERRUN) { if (cb->cb_set[NL_CB_OVERRUN]) { err = nl_cb_call(cb, NL_CB_OVERRUN, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else goto out; } /* Message carries a nlmsgerr */ else if (hdr->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *e = nlmsg_data(hdr); if (hdr->nlmsg_len < nlmsg_msg_size(sizeof(*e))) { /* Truncated error message, the default action * is to stop parsing. The user may overrule * this action by returning NL_SKIP or * NL_PROCEED (dangerous) */ if (cb->cb_set[NL_CB_INVALID]) { err = nl_cb_call(cb, NL_CB_INVALID, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } else goto out; } else if (e->error) { /* Error message reported back from kernel. */ if (cb->cb_err) { err = cb->cb_err(&nla, e, cb->cb_err_arg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) { nl_error(-e->error, "Netlink Error"); err = e->error; goto out; } } else { nl_error(-e->error, "Netlink Error"); err = e->error; goto out; } } else if (cb->cb_set[NL_CB_ACK]) { /* ACK */ err = nl_cb_call(cb, NL_CB_ACK, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } } else { /* Valid message (not checking for MULTIPART bit to * get along with broken kernels. NL_SKIP has no * effect on this. */ if (cb->cb_set[NL_CB_VALID]) { err = nl_cb_call(cb, NL_CB_VALID, msg); if (err == NL_SKIP) goto skip; else if (err == NL_EXIT || err < 0) goto out; } } skip: hdr = nlmsg_next(hdr, &n); } nlmsg_free(msg); free(buf); free(creds); buf = NULL; msg = NULL; creds = NULL; /* Multipart message not yet complete, continue reading */ goto continue_reading; out: nlmsg_free(msg); free(buf); free(creds); return err; } /** * Receive a set of message from a netlink socket using handlers in nl_handle. * @arg handle netlink handle * * Calls nl_recvmsgs() with the handlers configured in the netlink handle. */ int nl_recvmsgs_def(struct nl_handle *handle) { if (handle->h_cb->cb_recvmsgs_ow) return handle->h_cb->cb_recvmsgs_ow(handle, handle->h_cb); else return nl_recvmsgs(handle, handle->h_cb); } static int ack_wait_handler(struct nl_msg *msg, void *arg) { return NL_EXIT; } /** * Wait for ACK. * @arg handle netlink handle * @pre The netlink socket must be in blocking state. * * Waits until an ACK is received for the latest not yet acknowledged * netlink message. */ int nl_wait_for_ack(struct nl_handle *handle) { int err; struct nl_cb *cb = nl_cb_clone(nl_handle_get_cb(handle)); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL); err = nl_recvmsgs(handle, cb); nl_cb_destroy(cb); return err; } /** @} */ /** * @name Netlink Family Translations * @{ */ static struct trans_tbl nlfamilies[] = { __ADD(NETLINK_ROUTE,route) __ADD(NETLINK_W1,w1) __ADD(NETLINK_USERSOCK,usersock) __ADD(NETLINK_FIREWALL,firewall) __ADD(NETLINK_INET_DIAG,inetdiag) __ADD(NETLINK_NFLOG,nflog) __ADD(NETLINK_XFRM,xfrm) __ADD(NETLINK_SELINUX,selinux) __ADD(NETLINK_ISCSI,iscsi) __ADD(NETLINK_AUDIT,audit) __ADD(NETLINK_FIB_LOOKUP,fib_lookup) __ADD(NETLINK_CONNECTOR,connector) __ADD(NETLINK_NETFILTER,netfilter) __ADD(NETLINK_IP6_FW,ip6_fw) __ADD(NETLINK_DNRTMSG,dnrtmsg) __ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent) __ADD(NETLINK_GENERIC,generic) }; /** * Convert netlink family to character string. * @arg family Netlink family. * @arg buf Destination buffer. * @arg size Size of destination buffer. * * Converts a netlink family to a character string and stores it in * the specified destination buffer. * * @return The destination buffer or the family encoded in hexidecimal * form if no match was found. */ char * nl_nlfamily2str(int family, char *buf, size_t size) { return __type2str(family, buf, size, nlfamilies, ARRAY_SIZE(nlfamilies)); } /** * Convert character string to netlink family. * @arg name Name of netlink family. * * Converts the provided character string specifying a netlink * family to the corresponding numeric value. * * @return Numeric netlink family or a negative value if no match was found. */ int nl_str2nlfamily(const char *name) { return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies)); }