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;
}
int unl_genl_request(struct unl *unl, struct nl_msg *msg, unl_cb handler, void *arg)
{
struct nlmsghdr *nlh;
struct nl_cb *cb;
int err;
cb = nl_cb_alloc(NL_CB_CUSTOM);
nlh = nlmsg_hdr(msg);
err = nl_send_auto_complete(unl->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 (handler)
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, handler, arg);
while (err > 0)
nl_recvmsgs(unl->sock, cb);
out:
nlmsg_free(msg);
nl_cb_put(cb);
return err;
}
static int
wprobe_send_msg(struct nl_msg *msg, void *callback, void *arg)
{
struct nl_cb *cb;
int err = 0;
cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb)
goto out_no_cb;
if (callback)
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, callback, arg);
err = nl_send_auto_complete(handle, 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);
while (err > 0)
nl_recvmsgs(handle, cb);
out:
nl_cb_put(cb);
out_no_cb:
nlmsg_free(msg);
return err;
}
static struct nl80211_msg_conveyor * nl80211_send(
struct nl80211_msg_conveyor *cv,
int (*cb_func)(struct nl_msg *, void *), void *cb_arg
) {
static struct nl80211_msg_conveyor rcv;
int err = 1;
if (cb_func)
nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, cb_func, cb_arg);
else
nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, nl80211_msg_response, &rcv);
if (nl_send_auto_complete(nls->nl_sock, cv->msg) < 0)
goto err;
nl_cb_err(cv->cb, NL_CB_CUSTOM, nl80211_msg_error, &err);
nl_cb_set(cv->cb, NL_CB_FINISH, NL_CB_CUSTOM, nl80211_msg_finish, &err);
nl_cb_set(cv->cb, NL_CB_ACK, NL_CB_CUSTOM, nl80211_msg_ack, &err);
while (err > 0)
nl_recvmsgs(nls->nl_sock, cv->cb);
return &rcv;
err:
nl_cb_put(cv->cb);
nlmsg_free(cv->msg);
return NULL;
}
static int internal_pollin_handler(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
struct nl_cb *cb = nl_socket_get_cb(info->event_sock);
int res = nl_recvmsgs(info->event_sock, cb);
nl_cb_put(cb);
return res;
}
static int nl80211_add_mon_if(struct nl80211_state *state, const char *device,
const char *mondevice)
{
int ifindex, ret;
struct nl_msg *msg;
struct nl_cb *cb = NULL;
int finished = 0;
ifindex = device_ifindex(device);
msg = nl80211_nlmsg_xalloc();
genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
0, NL80211_CMD_NEW_INTERFACE, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, mondevice);
NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_MONITOR);
ret = nl_send_auto_complete(state->nl_sock, msg);
if (ret < 0) {
if (ret == -ENFILE) {
nlmsg_free(msg);
return -EBUSY;
}
panic("Cannot send_auto_complete!\n");
}
cb = nl_cb_alloc(NL_CB_CUSTOM);
if (!cb)
panic("Cannot alloc nl_cb!\n");
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, nl80211_wait_handler, &finished);
nl_cb_err(cb, NL_CB_CUSTOM, nl80211_error_handler, NULL);
nl_recvmsgs(state->nl_sock, cb);
if (!finished) {
ret = nl_wait_for_ack(state->nl_sock);
if (ret < 0) {
if (ret == -ENFILE) {
nlmsg_free(msg);
return -EBUSY;
}
panic("Waiting for netlink ack failed!\n");
}
}
nl_cb_put(cb);
nlmsg_free(msg);
return 0;
nla_put_failure:
panic("nla put failure!\n");
return -EIO; /* dummy */
}
int SoftapController::executeScanLinkCmd(const char *iface, int *iface_freq)
{
struct nl_cb *cb;
struct nl_msg *msg;
int devidx = 0;
int err;
// initialize to non-valid freq
*iface_freq = 0;
devidx = if_nametoindex(iface);
if (devidx == 0) {
LOGE("failed to translate ifname to idx");
return -errno;
}
msg = nlmsg_alloc();
if (!msg) {
LOGE("failed to allocate netlink message");
return 2;
}
cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb) {
LOGE("failed to allocate netlink callbacks");
err = 2;
goto out_free_msg;
}
genlmsg_put(msg, 0, 0, genl_family_get_id(nl80211), 0,
NLM_F_DUMP, NL80211_CMD_GET_SCAN, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
// iface_freq will be filled out by the callback
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, linkDumpCbHandler, iface_freq);
err = nl_send_auto_complete(nl_soc, msg);
if (err < 0)
goto out;
err = 1;
nl_cb_err(cb, NL_CB_CUSTOM, NlErrorHandler, &err);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, NlFinishHandler, &err);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, NlAckHandler, &err);
while (err > 0)
nl_recvmsgs(nl_soc, cb);
out:
nl_cb_put(cb);
out_free_msg:
nlmsg_free(msg);
return err;
nla_put_failure:
LOGW("building message failed");
return 2;
}
static int handle_mgmt_dump(struct nl80211_state *state,
struct nl_msg *msg, int argc,
char **argv, enum id_input id)
{
struct nl_cb *mgmt_cb;
char *ndev = argv[0];
int mgmt_argc = 5;
char **mgmt_argv;
unsigned int count = 0;
int err = 0;
int i;
mgmt_argv = calloc(mgmt_argc, sizeof(char*));
if (!mgmt_argv)
return -ENOMEM;
mgmt_argv[0] = ndev;
mgmt_argv[1] = "mgmt";
mgmt_argv[2] = "reg";
for (i = 3; i < argc; i += 3) {
if (strcmp(argv[i], "count") == 0) {
count = 1 + atoi(argv[i + 1]);
break;
}
if (strcmp(argv[i], "frame") != 0) {
err = 1;
goto out;
}
mgmt_argv[3] = argv[i + 1];
mgmt_argv[4] = argv[i + 2];
err = handle_cmd(state, II_NETDEV, mgmt_argc, mgmt_argv);
if (err)
goto out;
}
mgmt_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
if (!mgmt_cb) {
err = 1;
goto out;
}
/* need to turn off sequence number checking */
nl_cb_set(mgmt_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, seq_handler, NULL);
nl_cb_set(mgmt_cb, NL_CB_VALID, NL_CB_CUSTOM, dump_mgmt_frame, NULL);
while (--count)
nl_recvmsgs(state->nl_sock, mgmt_cb);
nl_cb_put(mgmt_cb);
out:
free(mgmt_argv);
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;
}
static int internal_pollin_handler(wifi_handle handle, struct nl_sock *sock)
{
struct nl_cb *cb = nl_socket_get_cb(sock);
int res = nl_recvmsgs(sock, cb);
if(res)
ALOGE("Error :%d while reading nl msg", res);
nl_cb_put(cb);
return res;
}
static int internal_pollin_handler(wifi_handle handle)
{
hal_info *info = getHalInfo(handle);
struct nl_cb *cb = nl_socket_get_cb(info->event_sock);
int res = nl_recvmsgs(info->event_sock, cb);
if(res)
ALOGE("Error :%d while reading nl msg", res);
nl_cb_put(cb);
return res;
}
indigo_error_t
indigo_port_stats_get(
of_port_stats_request_t *port_stats_request,
of_port_stats_reply_t **port_stats_reply_ptr)
{
of_port_no_t req_of_port_num;
of_port_stats_reply_t *port_stats_reply;
indigo_error_t err = INDIGO_ERROR_NONE;
port_stats_reply = of_port_stats_reply_new(port_stats_request->version);
if (port_stats_reply == NULL) {
err = INDIGO_ERROR_RESOURCE;
goto out;
}
of_list_port_stats_entry_t list;
of_port_stats_reply_entries_bind(port_stats_reply, &list);
of_port_stats_request_port_no_get(port_stats_request, &req_of_port_num);
int dump_all = req_of_port_num == OF_PORT_DEST_NONE_BY_VERSION(port_stats_request->version);
/* Refresh statistics */
nl_cache_refill(route_cache_sock, link_cache);
struct nl_msg *msg = ind_ovs_create_nlmsg(ovs_vport_family, OVS_VPORT_CMD_GET);
if (dump_all) {
nlmsg_hdr(msg)->nlmsg_flags |= NLM_F_DUMP;
} else {
nla_put_u32(msg, OVS_VPORT_ATTR_PORT_NO, req_of_port_num);
}
/* Ask kernel to send us one or more OVS_VPORT_CMD_NEW messages */
if (nl_send_auto(ind_ovs_socket, msg) < 0) {
err = INDIGO_ERROR_UNKNOWN;
goto out;
}
ind_ovs_nlmsg_freelist_free(msg);
/* Handle OVS_VPORT_CMD_NEW messages */
nl_cb_set(netlink_callbacks, NL_CB_VALID, NL_CB_CUSTOM,
port_stats_iterator, &list);
if (nl_recvmsgs(ind_ovs_socket, netlink_callbacks) < 0) {
err = INDIGO_ERROR_UNKNOWN;
goto out;
}
out:
if (err != INDIGO_ERROR_NONE) {
of_port_stats_reply_delete(port_stats_reply);
port_stats_reply = NULL;
}
*port_stats_reply_ptr = port_stats_reply;
return err;
}
static int go_offchan_freq(struct nl80211_state *state, int devidx, int freq)
{
struct nl_cb *cb;
struct nl_cb *s_cb;
struct nl_msg *msg;
int err;
msg = nlmsg_alloc();
if (!msg) {
fprintf(stderr, "failed to allocate netlink message\n");
return 2;
}
cb = nl_cb_alloc(nl_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
s_cb = nl_cb_alloc(nl_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
if (!cb || !s_cb) {
fprintf(stderr, "failed to allocate netlink callbacks\n");
err = 2;
goto out_free_msg;
}
genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
0,
NL80211_CMD_REMAIN_ON_CHANNEL, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq);
/* 5 seconds is the max allowed, values passed are in ms */
NLA_PUT_U32(msg, NL80211_ATTR_DURATION, 60);
nl_socket_set_cb(state->nl_sock, s_cb);
err = nl_send_auto_complete(state->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);
while (err > 0)
nl_recvmsgs(state->nl_sock, cb);
out:
nl_cb_put(cb);
out_free_msg:
nlmsg_free(msg);
return err;
nla_put_failure:
fprintf(stderr, "building message failed\n");
return 2;
}
static void ac_kmod_event_receive(int fd, void** params, int paramscount) {
int res;
ASSERT(fd >= 0);
ASSERT(params != NULL);
ASSERT(paramscount == 2);
/* */
res = nl_recvmsgs((struct nl_sock*)params[0], (struct nl_cb*)params[1]);
if (res) {
log_printf(LOG_WARNING, "Receive kernel module message failed: %d", res);
}
}
void CW80211EventReceive(void *cbPtr, void *handlePtr)
{
struct nl_cb *cb = (struct nl_cb *) cbPtr;
struct nl_handle * handle = (struct nl_handle *) handlePtr;
int res;
//CWLog("nl80211: Event message available");
res = nl_recvmsgs(handle, cb);
if (res < 0) {
CWLog("nl80211: %s->nl_recvmsgs failed: %d, %s", __func__, res, strerror(res));
}
}
// Retrieve monitor interface for a given physical interface
int ret_mon_IF(struct nl80211_state *state)
{
struct nl_msg *msg;
struct nl_cb *cb, *s_cb;
int err = 1;
msg = nlmsg_alloc();
if (!msg)
{
fprintf(stderr, "failed to allocate netlink message\n");
return 2;
}
// Allocate a new callback handle.
cb = nl_cb_alloc(NL_CB_DEFAULT);
s_cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb || !s_cb)
{
fprintf(stderr, "failed to allocate netlink callbacks\n");
err = 2;
goto out_free_msg;
}
// Add Generic Netlink header (i.e. NL80211_CMD_GET_INTERFACE) to Netlink message
genlmsg_put(msg, 0, 0, state->nl80211_id, 0, 768, NL80211_CMD_GET_INTERFACE, 0);
// Set up a valid callback function
if (nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, iface_handler, NULL))
goto out;
// Attach the callback function to a netlink socket
nl_socket_set_cb(state->nl_sock, s_cb);
// Finalize and transmit Netlink message
if(nl_send_auto_complete(state->nl_sock, msg) < 0)
goto out;
// Set up error, finish and acknowledgment callback function
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);
while (err > 0)
nl_recvmsgs(state->nl_sock, cb);
out:
nl_cb_put(cb);
out_free_msg:
nlmsg_free(msg);
return err;
}
void unl_genl_loop(struct unl *unl, unl_cb handler, void *arg)
{
struct nl_cb *cb;
cb = nl_cb_alloc(NL_CB_CUSTOM);
unl->loop_done = false;
nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, handler, arg);
while (!unl->loop_done)
nl_recvmsgs(unl->sock, cb);
nl_cb_put(cb);
}
static int call_survey_freq(struct nl80211_state *state, int devidx, int freq)
{
struct nl_cb *cb;
struct nl_cb *s_cb;
struct nl_msg *msg;
int err;
msg = nlmsg_alloc();
if (!msg) {
fprintf(stderr, "failed to allocate netlink message\n");
return 2;
}
cb = nl_cb_alloc(nl_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
s_cb = nl_cb_alloc(nl_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
if (!cb || !s_cb) {
fprintf(stderr, "failed to allocate netlink callbacks\n");
err = 2;
goto out_free_msg;
}
genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
NLM_F_DUMP,
NL80211_CMD_GET_SURVEY, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, handle_survey_dump, (void *) &freq);
nl_socket_set_cb(state->nl_sock, s_cb);
err = nl_send_auto_complete(state->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);
while (err > 0)
nl_recvmsgs(state->nl_sock, cb);
out:
nl_cb_put(cb);
out_free_msg:
nlmsg_free(msg);
return err;
nla_put_failure:
fprintf(stderr, "building message failed\n");
return 2;
}
/**
* 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;
}
int nlt_get_ifinfo(struct nl_sock *sk, struct nlt_ifinfo *ifinfo)
{
struct nl_msg *msg = nlmsg_alloc();
if (!msg)
return -1;
int flags = NLM_F_DUMP;
int family_id = genl_ctrl_resolve(sk, "nl80211");
genlmsg_put(msg, 0, NL_AUTO_SEQ, family_id, 0, flags, NL80211_CMD_GET_INTERFACE, 0);
// NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, 0);
nl_send_auto(sk, msg);
int err;
struct nl_cb *nl_cb = nl_cb_alloc(NL_CB_CUSTOM);
nl_cb_set(nl_cb, NL_CB_VALID, NL_CB_CUSTOM, get_ifinfo_cb, ifinfo);
nl_cb_err(nl_cb, NL_CB_CUSTOM, error_handler, &err);
int nlr;
// do {
nlr = nl_recvmsgs(sk, nl_cb);
// printf("round %d\n",nlr);
// }while(1);;
//int nlr = nl_recvmsgs_default(sk);
// cw_log(LOG_ERR, "iGet if index: Make if %d - %s", nlr, nl_geterror(nlr));
// nla_put_failure:
nlmsg_free(msg);
return 0;
}
static int __nl_send_msg(struct nl_sock *sock, struct nl_msg *msg,
int (*rx_handler)(struct nl_msg *, void *),
int (*finish_handler)(struct nl_msg *, void *),
void *data)
{
struct nl_cb *cb;
int err, done;
struct send_msg_data send_data;
DBG("");
cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb)
return -ENOMEM;
err = nl_send_auto_complete(sock, msg);
if (err < 0) {
nl_cb_put(cb);
near_error("%s", strerror(err));
return err;
}
err = done = 0;
send_data.done = &done;
send_data.data = data;
send_data.finish_handler = finish_handler;
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, __finish_handler, &send_data);
nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &done);
if (rx_handler)
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, rx_handler, data);
while (err == 0 && done == 0)
nl_recvmsgs(sock, cb);
nl_cb_put(cb);
return err;
}
static int do_listen_events(void)
{
struct nl_cb *cb = nl_cb_alloc((log_level > LOG_WARNING) ?
NL_CB_DEBUG : NL_CB_DEFAULT);
if (!cb) {
LOG_ERR_("failed to allocate netlink callbacks\n");
return -ENOMEM;
}
/* no sequence checking for multicast messages */
nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
for (;;)
nl_recvmsgs(state.nl_sock, cb);
nl_cb_put(cb);
return 0;
}
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;
}
/* function: send_netlink_msg
* sends a netlink message, reads a response, and hands the response(s) to the callbacks
* msg - netlink message to send
* callbacks - callbacks to use on responses
*/
void send_netlink_msg(struct nl_msg *msg, struct nl_cb *callbacks) {
struct nl_sock *nl_sk;
nl_sk = nl_socket_alloc();
if(!nl_sk)
goto cleanup;
if(nl_connect(nl_sk, NETLINK_ROUTE) != 0)
goto cleanup;
if(nl_send_auto_complete(nl_sk, msg) < 0)
goto cleanup;
if(netlink_set_kernel_only(nl_sk) < 0)
goto cleanup;
nl_recvmsgs(nl_sk, callbacks);
cleanup:
if(nl_sk)
nl_socket_free(nl_sk);
}
static gboolean __nfc_netlink_event(GIOChannel *channel,
GIOCondition cond, gpointer data)
{
struct nl_cb *cb;
struct nlnfc_state *state = data;
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
return FALSE;
cb = nl_cb_alloc(NL_CB_VERBOSE);
if (!cb)
return TRUE;
nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, nfc_netlink_event, data);
nl_recvmsgs(state->event_sock, cb);
nl_cb_put(cb);
return TRUE;
}
int dhd_nl_do_testmode(struct dhd_netlink_info *dhd_nli, dhd_ioctl_t *ioc)
{
struct nl_msg *msg;
int err;
msg = nlmsg_alloc();
if (msg == NULL)
return -ENOMEM;
/* fill testmode message */
genlmsg_put(msg, 0, 0, dhd_nli->nl_id, 0, 0,
NL80211_CMD_TESTMODE, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dhd_nli->ifidx);
NLA_PUT(msg, NL80211_ATTR_TESTDATA, sizeof(*ioc), ioc);
err = nl_send_auto_complete(dhd_nli->nl, msg);
if (err < 0)
goto out;
err = 1;
nl_cb_err(dhd_nli->cb, NL_CB_CUSTOM, dhd_nl_error_handler, &err);
nl_cb_set(dhd_nli->cb, NL_CB_ACK, NL_CB_CUSTOM,
dhd_nl_ack_handler, &err);
nl_cb_set(dhd_nli->cb, NL_CB_FINISH, NL_CB_CUSTOM,
dhd_nl_finish_handler, &err);
nl_cb_set(dhd_nli->cb, NL_CB_VALID, NL_CB_CUSTOM,
dhd_nl_valid_handler, &err);
while (err > 0)
nl_recvmsgs(dhd_nli->nl, dhd_nli->cb);
out:
nlmsg_free(msg);
return err;
nla_put_failure:
fprintf(stderr, "setting netlink attribute failed\n");
err = -EFAULT;
goto out;
}
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;
}
/**
* Receive a set of message from a netlink socket using handlers in nl_sock.
* @arg sk Netlink socket.
*
* Calls nl_recvmsgs() with the handlers configured in the netlink socket.
*/
int nl_recvmsgs_default(struct nl_sock *sk)
{
return nl_recvmsgs(sk, sk->s_cb);
}
