/* 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; }