/* This is called when we haven't heard from the node with MAC address addr for
* some time (just before the node is removed from the node table/list).
*/
void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
{
struct sk_buff *skb;
void *msg_head;
struct hsr_port *master;
int res;
skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
if (!skb)
goto fail;
msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_NODE_DOWN);
if (!msg_head)
goto nla_put_failure;
res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
if (res < 0)
goto nla_put_failure;
genlmsg_end(skb, msg_head);
genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
return;
nla_put_failure:
kfree_skb(skb);
fail:
rcu_read_lock();
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
netdev_warn(master->dev, "Could not send HSR node down\n");
rcu_read_unlock();
}
int nfc_genl_targets_found(struct nfc_dev *dev)
{
struct sk_buff *msg;
void *hdr;
dev->genl_data.poll_req_portid = 0;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_TARGETS_FOUND);
if (!hdr)
goto free_msg;
if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
goto nla_put_failure;
genlmsg_end(msg, hdr);
return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int nfc_genl_tm_deactivated(struct nfc_dev *dev)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_TM_DEACTIVATED);
if (!hdr)
goto free_msg;
if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
return 0;
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
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;
}
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 < -4095) {
err = 0;
}
if (err) {
fprintf(stderr, "Failed: %s\n", strerror(-err));
exit(1);
}
}
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 __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;
}
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;
}
char
stp_dbg_nl_send(
char * aucMsg,
unsigned char cmd
)
{
struct sk_buff *skb = NULL;
void *msg_head = NULL;
int rc = -1;
int i;
if(num_bind_process == 0)
{
/* no listening process */
STP_DBG_ERR_FUNC("%s(): the process is not invoked\n", __func__);
return 0;
}
for(i = 0 ; i < num_bind_process ; i++)
{
skb = genlmsg_new(2048, GFP_KERNEL);
if(skb)
{
msg_head = genlmsg_put(skb, 0, stp_dbg_seqnum++, &stp_dbg_gnl_family, 0, cmd);
if(msg_head == NULL)
{
nlmsg_free(skb);
STP_DBG_ERR_FUNC("%s(): genlmsg_put fail...\n", __func__);
return -1;
}
rc = nla_put_string(skb, STP_DBG_ATTR_MSG, aucMsg);
if(rc != 0)
{
nlmsg_free(skb);
STP_DBG_ERR_FUNC("%s(): nla_put_string fail...\n", __func__);
return -1;
}
/* finalize the message */
genlmsg_end(skb, msg_head);
/* sending message */
rc = genlmsg_unicast(&init_net, skb, bind_pid[i]);
if(rc != 0)
{
STP_DBG_ERR_FUNC("%s(): genlmsg_unicast fail...\n", __func__);
return -1;
}
}
else
{
STP_DBG_ERR_FUNC("%s(): genlmsg_new fail...\n", __func__);
return -1;
}
}
return 0;
}
static int ieee802154_nl_fill_iface(struct sk_buff *msg, u32 pid,
u32 seq, int flags, struct net_device *dev)
{
void *hdr;
struct wpan_phy *phy;
pr_debug("%s\n", __func__);
hdr = genlmsg_put(msg, 0, seq, &nl802154_family, flags,
IEEE802154_LIST_IFACE);
if (!hdr)
goto out;
phy = ieee802154_mlme_ops(dev)->get_phy(dev);
BUG_ON(!phy);
NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
NLA_PUT_STRING(msg, IEEE802154_ATTR_PHY_NAME, wpan_phy_name(phy));
NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
dev->dev_addr);
NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR,
ieee802154_mlme_ops(dev)->get_short_addr(dev));
NLA_PUT_U16(msg, IEEE802154_ATTR_PAN_ID,
ieee802154_mlme_ops(dev)->get_pan_id(dev));
wpan_phy_put(phy);
return genlmsg_end(msg, hdr);
nla_put_failure:
wpan_phy_put(phy);
genlmsg_cancel(msg, hdr);
out:
return -EMSGSIZE;
}
void CNL80211::scan() {
//Get interface index for device:
unsigned int devidx = if_nametoindex(m_ifname.toAscii().constData());
if (devidx == 0) {
emit message("Could not get interface index");
return;
}
//Allocate a new netlink message
nl_msg * msg;
msg = nlmsg_alloc();
if (!msg) {
emit message("Could not allocate netlink message");
return;
}
//allocate the callback function with default verbosity
// nl_cb * cb = nl_cb_alloc(NL_CB_DEFAULT);
// if (!cb) {
// emit message("Could not allocate netlink callback");
// nlmsg_free(msg);
// return;
// }
nl_socket_modify_cb(m_nlSocket, NL_CB_VALID, NL_CB_CUSTOM, &cbForScanResults, this);
genlmsg_put(msg, 0, 0, genl_family_get_id(m_nlFamily), 0, (NLM_F_REQUEST | NLM_F_DUMP), NL80211_CMD_GET_SCAN, 0);
//Set the interface we want to operate on
nla_put_u32(msg, NL80211_ATTR_IFNAME,devidx);
//hier kommt noch was rein
//Send the message
nl_send_auto_complete(m_nlSocket,msg);
nlmsg_free(msg);
}
int nfc_genl_device_added(struct nfc_dev *dev)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_DEVICE_ADDED);
if (!hdr)
goto free_msg;
if (nfc_genl_setup_device_added(dev, msg))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
return 0;
nla_put_failure:
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_TM_ACTIVATED);
if (!hdr)
goto free_msg;
if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
goto nla_put_failure;
if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
return 0;
nla_put_failure:
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
void decoder::send_decoded_packet(size_t i)
{
struct nl_msg *msg;
uint16_t len;
uint8_t *buf;
/* don't send already decoded packets */
if (m_decoded_symbols[i])
return;
/* Read out length field from decoded data */
buf = this->symbol(i);
len = *reinterpret_cast<uint16_t *>(buf);
/* avoid wrongly decoded packets by checking that the
* length is within expected range
*/
LOG_IF(FATAL, len > RLNC_MAX_PAYLOAD) << "Decoder " << m_coder
<< ": Failed packet " << i;
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_u8(msg, BATADV_HLP_A_TYPE, DEC_PACKET);
nla_put(msg, BATADV_HLP_A_FRAME, len, buf + LEN_SIZE);
m_io->send_msg(msg);
nlmsg_free(msg);
VLOG(LOG_PKT) << "Decoder " << m_coder << ": Send decoded packet " << i;
inc("decoded sent");
m_decoded_symbols[i] = true;
}
int nfc_genl_device_added(struct nfc_dev *dev)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_DEVICE_ADDED);
if (!hdr)
goto free_msg;
if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
return 0;
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_msg *msg;
void *hdr;
int err;
sock = nlt_alloc_socket();
nlt_connect(sock, NETLINK_GENERIC);
msg = nlmsg_alloc();
if (msg == NULL)
fatal(NLE_NOMEM, "Unable to allocate netlink message");
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, GENL_ID_CTRL,
0, 0, CTRL_CMD_GETFAMILY, 1);
if (hdr == NULL)
fatal(ENOMEM, "Unable to write genl header");
if ((err = nla_put_u32(msg, CTRL_ATTR_FAMILY_ID, GENL_ID_CTRL)) < 0)
fatal(err, "Unable to add attribute: %s", nl_geterror(err));
if ((err = nl_send_auto_complete(sock, msg)) < 0)
fatal(err, "Unable to send message: %s", nl_geterror(err));
if ((err = nl_recvmsgs_default(sock)) < 0)
fatal(err, "Unable to receive message: %s", nl_geterror(err));
nlmsg_free(msg);
nl_close(sock);
nl_socket_free(sock);
return 0;
}
int nfc_genl_device_removed(struct nfc_dev *dev)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_DEVICE_REMOVED);
if (!hdr)
goto free_msg;
if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
return 0;
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int netlink_request_simple(void *request, __u32 request_len)
{
struct nl_msg *msg;
int error;
msg = nlmsg_alloc();
if (!msg) {
log_err("Could not allocate the request; it seems we're out of memory.");
return -ENOMEM;
}
if (!genlmsg_put(msg, NL_AUTO_PORT, NL_AUTO_SEQ, family, 0, 0,
JOOL_COMMAND, 1)) {
log_err("Unknown error building the packet to the kernel.");
nlmsg_free(msg);
return -EINVAL;
}
error = nla_put(msg, ATTR_DATA, request_len, request);
if (error) {
log_err("Could not write on the packet to kernelspace.");
nlmsg_free(msg);
return netlink_print_error(error);
}
error = nl_send_auto(sk, msg);
nlmsg_free(msg);
if (error < 0) {
log_err("Could not dispatch the request to kernelspace.");
return netlink_print_error(error);
}
return 0;
}
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;
}
int genl_exec(genl_exec_func_t func, void *data)
{
int ret;
mutex_lock(&genl_exec_lock);
init_completion(&done);
skb_get(genlmsg_skb);
genlmsg_put(genlmsg_skb, 0, 0, &genl_exec_family,
NLM_F_REQUEST, GENL_EXEC_RUN);
genl_exec_function = func;
genl_exec_data = data;
/* There is no need to send msg to current namespace. */
ret = genlmsg_unicast(&init_net, genlmsg_skb, 0);
if (!ret) {
wait_for_completion(&done);
ret = genl_exec_function_ret;
} else {
pr_err("genl_exec send error %d\n", ret);
}
/* Wait for genetlink to kfree skb. */
while (skb_shared(genlmsg_skb))
cpu_relax();
genlmsg_skb->data = genlmsg_skb->head;
skb_reset_tail_pointer(genlmsg_skb);
mutex_unlock(&genl_exec_lock);
return ret;
}
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;
}
static int __tipc_nl_add_net(struct net *net, struct tipc_nl_msg *msg)
{
struct tipc_net *tn = net_generic(net, tipc_net_id);
void *hdr;
struct nlattr *attrs;
hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
NLM_F_MULTI, TIPC_NL_NET_GET);
if (!hdr)
return -EMSGSIZE;
attrs = nla_nest_start(msg->skb, TIPC_NLA_NET);
if (!attrs)
goto msg_full;
if (nla_put_u32(msg->skb, TIPC_NLA_NET_ID, tn->net_id))
goto attr_msg_full;
nla_nest_end(msg->skb, attrs);
genlmsg_end(msg->skb, hdr);
return 0;
attr_msg_full:
nla_nest_cancel(msg->skb, attrs);
msg_full:
genlmsg_cancel(msg->skb, hdr);
return -EMSGSIZE;
}
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);
}
}
static int nl80211_del_mon_if(struct nl80211_state *state, const char *device,
const char *mondevice)
{
int ifindex, ret;
struct nl_msg *msg;
ifindex = device_ifindex(mondevice);
msg = nl80211_nlmsg_xalloc();
genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
0, NL80211_CMD_DEL_INTERFACE, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
ret = nl_send_auto_complete(state->nl_sock, msg);
if (ret < 0)
panic("Cannot send_auto_complete!\n");
ret = nl_wait_for_ack(state->nl_sock);
if (ret < 0)
panic("Waiting for netlink ack failed!\n");
nlmsg_free(msg);
return 0;
nla_put_failure:
panic("nla put failure!\n");
return -EIO; /* dummy */
}
static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
{
struct sk_buff *msg;
void *hdr;
int ret = -ENOBUFS;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg) {
ret = -ENOMEM;
goto out;
}
hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
&l2tp_nl_family, 0, L2TP_CMD_NOOP);
if (!hdr) {
ret = -EMSGSIZE;
goto err_out;
}
genlmsg_end(msg, hdr);
return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid);
err_out:
nlmsg_free(msg);
out:
return ret;
}
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 nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
{
struct sk_buff *msg;
void *hdr;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_TARGET_LOST);
if (!hdr)
goto free_msg;
if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
goto nla_put_failure;
genlmsg_end(msg, hdr);
genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
return 0;
nla_put_failure:
genlmsg_cancel(msg, hdr);
free_msg:
nlmsg_free(msg);
return -EMSGSIZE;
}
int netlink_send_cw(unsigned char ca_num, ca_descr_t *ca_descr) {
struct sk_buff *skb;
void *msg_head;
int ret;
skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!skb)
goto out;
msg_head = genlmsg_put(skb, 0, 0, &ca_family, 0, CMD_SET_CW);
if (!msg_head) {
goto out;
}
ret = nla_put_u16(skb, ATTR_CA_NUM, ca_num);
if (ret)
goto out;
ret = nla_put(skb, ATTR_CA_DESCR, sizeof(ca_descr_t), ca_descr);
if (ret)
goto out;
genlmsg_end(skb, msg_head);
ret = genlmsg_unicast(&init_net, skb, processPid );
if (ret)
goto out;
return 0;
out:
printk("dvbsoftwareca: send_cw error\n");
return 0;
}
void recoder::send_rec_packet()
{
struct nl_msg *msg;
struct nlattr *attr;
uint8_t *data;
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, REC_PACKET);
attr = nla_reserve(msg, BATADV_HLP_A_FRAME, this->payload_size());
data = reinterpret_cast<uint8_t *>(nla_data(attr));
this->recode(data);
m_io->send_msg(msg);
nlmsg_free(msg);
m_rec_pkt_count++;
inc("forward packets written");
}
static int l2tp_nl_session_send(struct sk_buff *skb, u32 pid, u32 seq, int flags,
struct l2tp_session *session)
{
void *hdr;
struct nlattr *nest;
struct l2tp_tunnel *tunnel = session->tunnel;
struct sock *sk = NULL;
sk = tunnel->sock;
hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags, L2TP_CMD_SESSION_GET);
if (IS_ERR(hdr))
return PTR_ERR(hdr);
NLA_PUT_U32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id);
NLA_PUT_U32(skb, L2TP_ATTR_SESSION_ID, session->session_id);
NLA_PUT_U32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id);
NLA_PUT_U32(skb, L2TP_ATTR_PEER_SESSION_ID, session->peer_session_id);
NLA_PUT_U32(skb, L2TP_ATTR_DEBUG, session->debug);
NLA_PUT_U16(skb, L2TP_ATTR_PW_TYPE, session->pwtype);
NLA_PUT_U16(skb, L2TP_ATTR_MTU, session->mtu);
if (session->mru)
NLA_PUT_U16(skb, L2TP_ATTR_MRU, session->mru);
if (session->ifname && session->ifname[0])
NLA_PUT_STRING(skb, L2TP_ATTR_IFNAME, session->ifname);
if (session->cookie_len)
NLA_PUT(skb, L2TP_ATTR_COOKIE, session->cookie_len, &session->cookie[0]);
if (session->peer_cookie_len)
NLA_PUT(skb, L2TP_ATTR_PEER_COOKIE, session->peer_cookie_len, &session->peer_cookie[0]);
NLA_PUT_U8(skb, L2TP_ATTR_RECV_SEQ, session->recv_seq);
NLA_PUT_U8(skb, L2TP_ATTR_SEND_SEQ, session->send_seq);
NLA_PUT_U8(skb, L2TP_ATTR_LNS_MODE, session->lns_mode);
#ifdef CONFIG_XFRM
if ((sk) && (sk->sk_policy[0] || sk->sk_policy[1]))
NLA_PUT_U8(skb, L2TP_ATTR_USING_IPSEC, 1);
#endif
if (session->reorder_timeout)
NLA_PUT_MSECS(skb, L2TP_ATTR_RECV_TIMEOUT, session->reorder_timeout);
nest = nla_nest_start(skb, L2TP_ATTR_STATS);
if (nest == NULL)
goto nla_put_failure;
NLA_PUT_U64(skb, L2TP_ATTR_TX_PACKETS, session->stats.tx_packets);
NLA_PUT_U64(skb, L2TP_ATTR_TX_BYTES, session->stats.tx_bytes);
NLA_PUT_U64(skb, L2TP_ATTR_TX_ERRORS, session->stats.tx_errors);
NLA_PUT_U64(skb, L2TP_ATTR_RX_PACKETS, session->stats.rx_packets);
NLA_PUT_U64(skb, L2TP_ATTR_RX_BYTES, session->stats.rx_bytes);
NLA_PUT_U64(skb, L2TP_ATTR_RX_SEQ_DISCARDS, session->stats.rx_seq_discards);
NLA_PUT_U64(skb, L2TP_ATTR_RX_OOS_PACKETS, session->stats.rx_oos_packets);
NLA_PUT_U64(skb, L2TP_ATTR_RX_ERRORS, session->stats.rx_errors);
nla_nest_end(skb, nest);
return genlmsg_end(skb, hdr);
nla_put_failure:
genlmsg_cancel(skb, hdr);
return -1;
}
