static struct nl_msg *gen_msg(int iface, char* ssid, int chan) {
struct nl_msg *msg, *ssids, *freqs;
msg = nlmsg_alloc();
ssids = nlmsg_alloc();
freqs = nlmsg_alloc();
if (!msg || !ssids || !freqs) {
fprintf(stderr, "Failed to allocate netlink message");
if(msg)
nlmsg_free(msg);
if(ssids)
nlmsg_free(ssids);
if(freqs)
nlmsg_free(freqs);
return NULL;
}
genlmsg_put(msg, 0, 0, handle_id, 0, 0, NL80211_CMD_TRIGGER_SCAN, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, iface);
NLA_PUT(ssids, 1, strlen(ssid), ssid);
nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids);
NLA_PUT_U32(freqs, 1, chan*5 + 2407);
nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs);
return msg;
nla_put_failure:
nlmsg_free(msg);
return NULL;
}
int lxc_netdev_delete_by_index(int ifindex)
{
struct nl_handler nlh;
struct nlmsg *nlmsg = NULL, *answer = NULL;
struct link_req *link_req;
int err;
err = netlink_open(&nlh, NETLINK_ROUTE);
if (err)
return err;
err = -ENOMEM;
nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!nlmsg)
goto out;
answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!answer)
goto out;
link_req = (struct link_req *)nlmsg;
link_req->ifinfomsg.ifi_family = AF_UNSPEC;
link_req->ifinfomsg.ifi_index = ifindex;
nlmsg->nlmsghdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
nlmsg->nlmsghdr.nlmsg_flags = NLM_F_ACK|NLM_F_REQUEST;
nlmsg->nlmsghdr.nlmsg_type = RTM_DELLINK;
err = netlink_transaction(&nlh, nlmsg, answer);
out:
netlink_close(&nlh);
nlmsg_free(answer);
nlmsg_free(nlmsg);
return err;
}
static int
ip_addr_add(int family, int ifindex,
void *addr, void *bcast, void *acast, int prefix) {
struct nl_handler nlh;
struct nlmsg *nlmsg = NULL, *answer = NULL;
struct ip_req *ip_req;
int addrlen;
int err;
addrlen = family == AF_INET ? sizeof(struct in_addr) :
sizeof(struct in6_addr);
err = netlink_open(&nlh, NETLINK_ROUTE);
if (err)
return err;
err = -ENOMEM;
nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!nlmsg)
goto out;
answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!answer)
goto out;
ip_req = (struct ip_req *)nlmsg;
ip_req->nlmsg.nlmsghdr.nlmsg_len =
NLMSG_LENGTH(sizeof(struct ifaddrmsg));
ip_req->nlmsg.nlmsghdr.nlmsg_flags =
NLM_F_ACK|NLM_F_REQUEST|NLM_F_CREATE|NLM_F_EXCL;
ip_req->nlmsg.nlmsghdr.nlmsg_type = RTM_NEWADDR;
ip_req->ifa.ifa_prefixlen = prefix;
ip_req->ifa.ifa_index = ifindex;
ip_req->ifa.ifa_family = family;
ip_req->ifa.ifa_scope = 0;
err = -EINVAL;
if (nla_put_buffer(nlmsg, IFA_LOCAL, addr, addrlen))
goto out;
if (nla_put_buffer(nlmsg, IFA_ADDRESS, addr, addrlen))
goto out;
if (nla_put_buffer(nlmsg, IFA_BROADCAST, bcast, addrlen))
goto out;
/* TODO : multicast, anycast with ipv6 */
err = -EPROTONOSUPPORT;
if (family == AF_INET6 &&
(memcmp(bcast, &in6addr_any, sizeof(in6addr_any)) ||
memcmp(acast, &in6addr_any, sizeof(in6addr_any))))
goto out;
err = netlink_transaction(&nlh, nlmsg, answer);
out:
netlink_close(&nlh);
nlmsg_free(answer);
nlmsg_free(nlmsg);
return err;
}
static int
ip_gateway_add(int family, int ifindex, void *gw) {
struct nl_handler nlh;
struct nlmsg *nlmsg = NULL, *answer = NULL;
struct rt_req *rt_req;
int addrlen;
int err;
addrlen = family == AF_INET ? sizeof(struct in_addr) :
sizeof(struct in6_addr);
err = netlink_open(&nlh, NETLINK_ROUTE);
if (err)
return err;
err = -ENOMEM;
nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!nlmsg)
goto out;
answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!answer)
goto out;
rt_req = (struct rt_req *)nlmsg;
rt_req->nlmsg.nlmsghdr.nlmsg_len =
NLMSG_LENGTH(sizeof(struct rtmsg));
rt_req->nlmsg.nlmsghdr.nlmsg_flags =
NLM_F_ACK|NLM_F_REQUEST|NLM_F_CREATE|NLM_F_EXCL;
rt_req->nlmsg.nlmsghdr.nlmsg_type = RTM_NEWROUTE;
rt_req->rt.rtm_family = family;
rt_req->rt.rtm_table = RT_TABLE_MAIN;
rt_req->rt.rtm_scope = RT_SCOPE_UNIVERSE;
rt_req->rt.rtm_protocol = RTPROT_BOOT;
rt_req->rt.rtm_type = RTN_UNICAST;
/* "default" destination */
rt_req->rt.rtm_dst_len = 0;
err = -EINVAL;
if (nla_put_buffer(nlmsg, RTA_GATEWAY, gw, addrlen))
goto out;
/* Adding the interface index enables the use of link-local
* addresses for the gateway */
if (nla_put_u32(nlmsg, RTA_OIF, ifindex))
goto out;
err = netlink_transaction(&nlh, nlmsg, answer);
out:
netlink_close(&nlh);
nlmsg_free(answer);
nlmsg_free(nlmsg);
return err;
}
int lxc_device_rename(const char *oldname, const char *newname)
{
struct nl_handler nlh;
struct nlmsg *nlmsg = NULL, *answer = NULL;
struct link_req *link_req;
int index, len, err = -1;
if (netlink_open(&nlh, NETLINK_ROUTE))
return -1;
len = strlen(oldname);
if (len == 1 || len > IFNAMSIZ)
goto out;
len = strlen(newname);
if (len == 1 || len > IFNAMSIZ)
goto out;
nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!nlmsg)
goto out;
answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
if (!answer)
goto out;
index = if_nametoindex(oldname);
if (!index)
goto out;
link_req = (struct link_req *)nlmsg;
link_req->ifinfomsg.ifi_family = AF_UNSPEC;
link_req->ifinfomsg.ifi_index = index;
nlmsg->nlmsghdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
nlmsg->nlmsghdr.nlmsg_flags = NLM_F_ACK|NLM_F_REQUEST;
nlmsg->nlmsghdr.nlmsg_type = RTM_NEWLINK;
if (nla_put_string(nlmsg, IFLA_IFNAME, newname))
goto out;
if (netlink_transaction(&nlh, nlmsg, answer))
goto out;
err = 0;
out:
netlink_close(&nlh);
nlmsg_free(answer);
nlmsg_free(nlmsg);
return err;
}
static int wpa_driver_set_power_save(void *priv, int state)
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct nl_msg *msg;
int ret = -1;
enum nl80211_ps_state ps_state;
msg = nlmsg_alloc();
if (!msg)
return -1;
genlmsg_put(msg, 0, 0, drv->global->nl80211_id, 0, 0,
NL80211_CMD_SET_POWER_SAVE, 0);
if (state == WPA_PS_ENABLED)
ps_state = NL80211_PS_ENABLED;
else
ps_state = NL80211_PS_DISABLED;
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
NLA_PUT_U32(msg, NL80211_ATTR_PS_STATE, ps_state);
ret = send_and_recv_msgs(drv, msg, NULL, NULL);
msg = NULL;
if (ret < 0)
wpa_printf(MSG_ERROR, "nl80211: Set power mode fail: %d", ret);
nla_put_failure:
nlmsg_free(msg);
return ret;
}
int reroute_path_selection_frames(char* ifname)
{
struct nl_msg *msg;
uint8_t cmd = NL80211_CMD_REGISTER_FRAME;
int ret;
char *pret;
char action_code[2] = { 0x20, 0x00 };
int ifindex = if_nametoindex(ifname);
msg = nlmsg_alloc();
if (!msg)
return -ENOMEM;
pret = genlmsg_put(msg, 0, 0,
genl_family_get_id(nlcfg.nl80211), 0, 0, cmd, 0);
if (pret == NULL)
goto nla_put_failure;
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
NLA_PUT(msg, NL80211_ATTR_FRAME_MATCH, sizeof(action_code), action_code);
ret = send_and_recv_msgs(msg, receive_ps_frames, NULL);
if (ret)
printf("Registering for path selection frames failed: %d (%s)\n", ret,
strerror(-ret));
else
printf("Registering for path selection frames succeeded. Yay!\n");
return ret;
nla_put_failure:
return -ENOBUFS;
}
static struct nl80211_msg_conveyor * nl80211_new(struct genl_family *family,
int cmd, int flags)
{
static struct nl80211_msg_conveyor cv;
struct nl_msg *req = NULL;
struct nl_cb *cb = NULL;
req = nlmsg_alloc();
if (!req)
goto err;
cb = nl_cb_alloc(NL_CB_DEFAULT);
if (!cb)
goto err;
genlmsg_put(req, 0, 0, genl_family_get_id(family), 0, flags, cmd, 0);
cv.msg = req;
cv.cb = cb;
return &cv;
err:
nla_put_failure:
if (cb)
nl_cb_put(cb);
if (req)
nlmsg_free(req);
return NULL;
}
int ac_kmod_deauthorize_station(struct capwap_sessionid_element* sessionid, const uint8_t* macaddress) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
ASSERT(macaddress != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_DEAUTH_STATION, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
nla_put(msg, NLSMARTCAPWAP_ATTR_MACADDRESS, MACADDRESS_EUI48_LENGTH, macaddress);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result) {
log_printf(LOG_ERR, "Unable to deauthorize station: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
static void
add_internal_port(const char *datapath, const char *interface)
{
if (strlen(interface) > IFNAMSIZ) {
fprintf(stderr, "Failed: Interface name too long\n");
exit(1);
}
unsigned int dp_ifindex = if_nametoindex(datapath);
if (dp_ifindex == 0) {
fprintf(stderr, "Failed: no such datapath '%s'\n", datapath);
exit(1);
}
struct nl_msg *msg = nlmsg_alloc();
struct ovs_header *hdr = genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ,
ovs_vport_family, sizeof(*hdr),
NLM_F_ACK, OVS_VPORT_CMD_NEW,
OVS_VPORT_VERSION);
hdr->dp_ifindex = dp_ifindex;
nla_put_u32(msg, OVS_VPORT_ATTR_TYPE, OVS_VPORT_TYPE_INTERNAL);
nla_put_string(msg, OVS_VPORT_ATTR_NAME, interface);
nla_put_u32(msg, OVS_VPORT_ATTR_UPCALL_PID, 0);
int err = transact(sk, msg);
if (err) {
fprintf(stderr, "Failed: %s\n", strerror(-err));
exit(1);
}
}
int __near_netlink_dep_link_down(uint32_t idx)
{
struct nl_msg *msg;
void *hdr;
int err;
DBG("");
msg = nlmsg_alloc();
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, nfc_state->nfc_id, 0,
NLM_F_REQUEST, NFC_CMD_DEP_LINK_DOWN, NFC_GENL_VERSION);
if (!hdr) {
err = -EINVAL;
goto nla_put_failure;
}
err = -EMSGSIZE;
NLA_PUT_U32(msg, NFC_ATTR_DEVICE_INDEX, idx);
err = nl_send_msg(nfc_state->cmd_sock, msg, NULL, NULL);
nla_put_failure:
nlmsg_free(msg);
return err;
}
int __near_netlink_dep_link_up(uint32_t idx, uint32_t target_idx,
uint8_t comm_mode, uint8_t rf_mode)
{
struct nl_msg *msg;
void *hdr;
int err;
DBG("");
msg = nlmsg_alloc();
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, nfc_state->nfc_id, 0,
NLM_F_REQUEST, NFC_CMD_DEP_LINK_UP, NFC_GENL_VERSION);
if (!hdr) {
err = -EINVAL;
goto nla_put_failure;
}
err = -EMSGSIZE;
NLA_PUT_U32(msg, NFC_ATTR_DEVICE_INDEX, idx);
NLA_PUT_U32(msg, NFC_ATTR_TARGET_INDEX, target_idx);
NLA_PUT_U8(msg, NFC_ATTR_COMM_MODE, comm_mode);
NLA_PUT_U8(msg, NFC_ATTR_RF_MODE, rf_mode);
err = nl_send_msg(nfc_state->cmd_sock, msg, NULL, NULL);
nla_put_failure:
nlmsg_free(msg);
return err;
}
int __near_netlink_activate_target(uint32_t idx, uint32_t target_idx,
uint32_t protocol)
{
struct nl_msg *msg;
void *hdr;
int err;
DBG("");
msg = nlmsg_alloc();
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, nfc_state->nfc_id, 0,
NLM_F_REQUEST, NFC_CMD_ACTIVATE_TARGET,
NFC_GENL_VERSION);
if (!hdr) {
err = -EINVAL;
goto nla_put_failure;
}
err = -EMSGSIZE;
NLA_PUT_U32(msg, NFC_ATTR_DEVICE_INDEX, idx);
NLA_PUT_U32(msg, NFC_ATTR_TARGET_INDEX, target_idx);
NLA_PUT_U32(msg, NFC_ATTR_PROTOCOLS, protocol);
err = nl_send_msg(nfc_state->cmd_sock, msg, NULL, NULL);
nla_put_failure:
nlmsg_free(msg);
return err;
}
int __near_netlink_get_adapters(void)
{
struct nl_msg *msg;
void *hdr;
int err;
DBG("");
if (!nfc_state || nfc_state->nfc_id < 0)
return -ENODEV;
msg = nlmsg_alloc();
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, nfc_state->nfc_id, 0,
NLM_F_DUMP, NFC_CMD_GET_DEVICE, NFC_GENL_VERSION);
if (!hdr) {
err = -EINVAL;
goto out;
}
err = nl_send_msg(nfc_state->cmd_sock, msg, get_devices_handler, NULL);
out:
nlmsg_free(msg);
return err;
}
static bool nl80211_msg_prepare(struct nl_msg **const msgp,
const enum nl80211_commands cmd,
const char *const interface)
{
struct nl_msg *msg = nlmsg_alloc();
if (!msg) {
fprintf(stderr, "failed to allocate netlink message\n");
return false;
}
if (!genlmsg_put(msg, 0, 0, genl_family_get_id(family), 0, 0 /*flags*/, cmd, 0)) {
fprintf(stderr, "failed to add generic netlink headers\n");
goto nla_put_failure;
}
if (interface) { //TODO: PHY commands don't need interface name but wiphy index
unsigned int if_index = if_nametoindex(interface);
if (!if_index) {
fprintf(stderr, "interface %s does not exist\n", interface);
goto nla_put_failure;
}
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_index);
}
*msgp = msg;
return true;
nla_put_failure:
nlmsg_free(msg);
return false;
}
int ac_kmod_create_iface(const char* ifname, uint16_t mtu) {
int result;
struct nl_msg* msg;
uint32_t ifindex = 0;
ASSERT(ifname != NULL);
ASSERT(mtu > 0);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_ADD_IFACE, 0);
nla_put_string(msg, NLSMARTCAPWAP_ATTR_IFPHY_NAME, ifname);
nla_put_u16(msg, NLSMARTCAPWAP_ATTR_MTU, mtu);
/* */
result = ac_kmod_send_and_recv_msg(msg, cb_kmod_create_iface, &ifindex);
if (!result) {
result = (ifindex ? (int)ifindex : -1);
} else {
log_printf(LOG_ERR, "Unable to create data session: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
int ac_kmod_delete_iface(int ifindex) {
int result;
struct nl_msg* msg;
ASSERT(ifindex > 0);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_DELETE_IFACE, 0);
nla_put_u32(msg, NLSMARTCAPWAP_ATTR_IFPHY_INDEX, (uint32_t)ifindex);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result && (result != ENOENT)) {
log_printf(LOG_ERR, "Unable to delete interface: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
static struct nl_msg *fifo_get_opts(struct rtnl_qdisc *qdisc)
{
struct rtnl_fifo *fifo;
struct tc_fifo_qopt opts;
struct nl_msg *msg;
fifo = fifo_qdisc(qdisc);
if (!fifo || !(fifo->qf_mask & SCH_FIFO_ATTR_LIMIT))
return NULL;
msg = nlmsg_alloc();
if (!msg)
goto errout;
memset(&opts, 0, sizeof(opts));
opts.limit = fifo->qf_limit;
if (nlmsg_append(msg, &opts, sizeof(opts), NL_DONTPAD) < 0)
goto errout;
return msg;
errout:
nlmsg_free(msg);
return NULL;
}
static void
del_port(const char *datapath, const char *interface)
{
unsigned int dp_ifindex = if_nametoindex(datapath);
if (dp_ifindex == 0) {
fprintf(stderr, "Failed: no such datapath '%s'\n", datapath);
exit(1);
}
struct nl_msg *msg = nlmsg_alloc();
struct ovs_header *hdr = genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ,
ovs_vport_family, sizeof(*hdr),
NLM_F_ACK, OVS_VPORT_CMD_DEL,
OVS_VPORT_VERSION);
hdr->dp_ifindex = dp_ifindex;
nla_put_string(msg, OVS_VPORT_ATTR_NAME, interface);
int err = transact(sk, msg);
/*
* HACK the OVS kernel module had a bug (fixed by rlane in d5c9288d) which
* returned random values on success. Work around this by assuming the
* operation was successful if the kernel returned an invalid errno.
*/
if (err > 0 || err < -1024) {
err = 0;
}
if (err) {
fprintf(stderr, "Failed: %s\n", strerror(-err));
exit(1);
}
}
static int ac_kmod_link(void) {
int result;
struct nl_msg* msg;
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_LINK, 0);
/* */
result = ac_kmod_send_and_recv(g_ac.kmodhandle.nl, g_ac.kmodhandle.nl_cb, msg, NULL, NULL);
if (result) {
if (result == -EALREADY) {
result = 0;
} else {
log_printf(LOG_WARNING, "Unable to connect kernel module, error code: %d", result);
}
}
/* */
nlmsg_free(msg);
return result;
}
static int iw_cqm_rssi(struct nl80211_state *state, struct nl_cb *cb,
struct nl_msg *msg, int argc, char **argv)
{
struct nl_msg *cqm = NULL;
int thold = 0;
int hyst = 0;
int ret = -ENOSPC;
/* get the required args */
if (argc < 1 || argc > 2)
return 1;
if (strcmp(argv[0], "off")) {
thold = atoi(argv[0]);
if (thold == 0)
return -EINVAL;
if (argc == 2)
hyst = atoi(argv[1]);
}
/* connection quality monitor attributes */
cqm = nlmsg_alloc();
NLA_PUT_U32(cqm, NL80211_ATTR_CQM_RSSI_THOLD, thold);
NLA_PUT_U32(cqm, NL80211_ATTR_CQM_RSSI_HYST, hyst);
nla_put_nested(msg, NL80211_ATTR_CQM, cqm);
ret = 0;
nla_put_failure:
nlmsg_free(cqm);
return ret;
}
int ac_kmod_send_keepalive(struct capwap_sessionid_element* sessionid) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_SEND_KEEPALIVE, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
/* */
log_printf(LOG_DEBUG, "Prepare to send keep-alive");
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result) {
log_printf(LOG_ERR, "Unable to send keep-alive: %d", result);
}
log_printf(LOG_DEBUG, "Sent keep-alive");
/* */
nlmsg_free(msg);
return result;
}
static struct nl_msg *sfq_get_opts(struct rtnl_qdisc *qdisc)
{
struct rtnl_sfq *sfq;
struct tc_sfq_qopt opts;
struct nl_msg *msg;
sfq = sfq_qdisc(qdisc);
if (!sfq)
return NULL;
msg = nlmsg_alloc();
if (!msg)
goto errout;
memset(&opts, 0, sizeof(opts));
opts.quantum = sfq->qs_quantum;
opts.perturb_period = sfq->qs_perturb;
opts.limit = sfq->qs_limit;
if (nlmsg_append(msg, &opts, sizeof(opts), NL_DONTPAD) < 0)
goto errout;
return msg;
errout:
nlmsg_free(msg);
return NULL;
}
int ac_kmod_send_data(struct capwap_sessionid_element* sessionid, uint8_t radioid, uint8_t binding, const uint8_t* data, int length) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
ASSERT(data != NULL);
ASSERT(length > 0);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_SEND_DATA, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_RADIOID, radioid);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_BINDING, binding);
nla_put(msg, NLSMARTCAPWAP_ATTR_DATA_FRAME, length, data);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result) {
log_printf(LOG_ERR, "Unable to send data: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
static inline struct nl_msg *nl80211_nlmsg_xalloc(void)
{
struct nl_msg *ret = nlmsg_alloc();
if (!ret)
panic("Cannot allocate nlmsg memory!\n");
return ret;
}
int ac_kmod_new_datasession(struct capwap_sessionid_element* sessionid, uint8_t binding, uint16_t mtu) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_NEW_SESSION, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
nla_put_u16(msg, NLSMARTCAPWAP_ATTR_BINDING, binding);
nla_put_u16(msg, NLSMARTCAPWAP_ATTR_MTU, mtu);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result) {
log_printf(LOG_ERR, "Unable to create data session: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
void encoder::send_encoded_packet(uint8_t type)
{
struct nl_msg *msg;
struct nlattr *attr;
uint8_t *data;
size_t symbols = this->symbols();
VLOG(LOG_PKT) << "Encoder " << m_coder << ": Send "
<< (m_enc_pkt_count < symbols ? "systematic" : "encoded");
msg = nlmsg_alloc();
genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, m_io->genl_family(),
0, 0, BATADV_HLP_C_FRAME, 1);
nla_put_u32(msg, BATADV_HLP_A_IFINDEX, m_io->ifindex());
nla_put(msg, BATADV_HLP_A_SRC, ETH_ALEN, _key.src);
nla_put(msg, BATADV_HLP_A_DST, ETH_ALEN, _key.dst);
nla_put_u16(msg, BATADV_HLP_A_BLOCK, _key.block);
nla_put_u8(msg, BATADV_HLP_A_TYPE, type);
attr = nla_reserve(msg, BATADV_HLP_A_FRAME, this->payload_size());
data = reinterpret_cast<uint8_t *>(nla_data(attr));
this->encode(data);
m_io->send_msg(msg);
nlmsg_free(msg);
m_enc_pkt_count++;
inc("encoded sent");
m_budget--;
}
int ac_kmod_addwlan(struct capwap_sessionid_element* sessionid, uint8_t radioid, uint8_t wlanid, const uint8_t* bssid, uint8_t macmode, uint8_t tunnelmode) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
ASSERT(IS_VALID_RADIOID(radioid));
ASSERT(IS_VALID_WLANID(wlanid));
ASSERT(bssid != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_ADD_WLAN, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_RADIOID, radioid);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_WLANID, wlanid);
nla_put(msg, NLSMARTCAPWAP_ATTR_MACADDRESS, MACADDRESS_EUI48_LENGTH, bssid);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_MACMODE, macmode);
nla_put_u8(msg, NLSMARTCAPWAP_ATTR_TUNNELMODE, tunnelmode);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result) {
log_printf(LOG_ERR, "Unable to add wlan: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
static int wpa_driver_get_power_save(void *priv, int *state)
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct nl_msg *msg;
int ret = -1;
enum nl80211_ps_state ps_state;
msg = nlmsg_alloc();
if (!msg)
return -1;
genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
NL80211_CMD_GET_POWER_SAVE, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
ret = send_and_recv_msgs(drv, msg, get_power_mode_handler, state);
msg = NULL;
if (ret < 0)
wpa_printf(MSG_ERROR, "nl80211: Get power mode fail: %d", ret);
nla_put_failure:
nlmsg_free(msg);
return ret;
}
int ac_kmod_removewlan(struct capwap_sessionid_element* sessionid) {
int result;
struct nl_msg* msg;
ASSERT(sessionid != NULL);
/* */
msg = nlmsg_alloc();
if (!msg) {
return -1;
}
/* */
genlmsg_put(msg, 0, 0, g_ac.kmodhandle.nlsmartcapwap_id, 0, 0, NLSMARTCAPWAP_CMD_REMOVE_WLAN, 0);
nla_put(msg, NLSMARTCAPWAP_ATTR_SESSION_ID, sizeof(struct capwap_sessionid_element), sessionid);
/* */
result = ac_kmod_send_and_recv_msg(msg, NULL, NULL);
if (result && (result != ENOENT)) {
log_printf(LOG_ERR, "Unable to remove wlan: %d", result);
}
/* */
nlmsg_free(msg);
return result;
}
