int ieee802154_nl_scan_confirm(struct net_device *dev, u8 status, u8 scan_type, u32 unscanned, u8 page, u8 *edl/* */) { struct sk_buff *msg; pr_debug("%s\n", __func__); msg = ieee802154_nl_create(0, IEEE802154_SCAN_CONF); if (!msg) return -ENOBUFS; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name); 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_U8(msg, IEEE802154_ATTR_STATUS, status); NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, scan_type); NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, unscanned); NLA_PUT_U8(msg, IEEE802154_ATTR_PAGE, page); if (edl) NLA_PUT(msg, IEEE802154_ATTR_ED_LIST, 27, edl); return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id); nla_put_failure: nlmsg_free(msg); return -ENOBUFS; }
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 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; }
static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 pid, u32 seq, int flags, struct l2tp_tunnel *tunnel) { void *hdr; struct nlattr *nest; struct sock *sk = NULL; struct inet_sock *inet; hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags, L2TP_CMD_TUNNEL_GET); if (IS_ERR(hdr)) return PTR_ERR(hdr); NLA_PUT_U8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version); NLA_PUT_U32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id); NLA_PUT_U32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id); NLA_PUT_U32(skb, L2TP_ATTR_DEBUG, tunnel->debug); NLA_PUT_U16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap); nest = nla_nest_start(skb, L2TP_ATTR_STATS); if (nest == NULL) goto nla_put_failure; NLA_PUT_U64(skb, L2TP_ATTR_TX_PACKETS, tunnel->stats.tx_packets); NLA_PUT_U64(skb, L2TP_ATTR_TX_BYTES, tunnel->stats.tx_bytes); NLA_PUT_U64(skb, L2TP_ATTR_TX_ERRORS, tunnel->stats.tx_errors); NLA_PUT_U64(skb, L2TP_ATTR_RX_PACKETS, tunnel->stats.rx_packets); NLA_PUT_U64(skb, L2TP_ATTR_RX_BYTES, tunnel->stats.rx_bytes); NLA_PUT_U64(skb, L2TP_ATTR_RX_SEQ_DISCARDS, tunnel->stats.rx_seq_discards); NLA_PUT_U64(skb, L2TP_ATTR_RX_OOS_PACKETS, tunnel->stats.rx_oos_packets); NLA_PUT_U64(skb, L2TP_ATTR_RX_ERRORS, tunnel->stats.rx_errors); nla_nest_end(skb, nest); sk = tunnel->sock; if (!sk) goto out; inet = inet_sk(sk); switch (tunnel->encap) { case L2TP_ENCAPTYPE_UDP: NLA_PUT_U16(skb, L2TP_ATTR_UDP_SPORT, ntohs(inet->inet_sport)); NLA_PUT_U16(skb, L2TP_ATTR_UDP_DPORT, ntohs(inet->inet_dport)); NLA_PUT_U8(skb, L2TP_ATTR_UDP_CSUM, (sk->sk_no_check != UDP_CSUM_NOXMIT)); /* NOBREAK */ case L2TP_ENCAPTYPE_IP: NLA_PUT_BE32(skb, L2TP_ATTR_IP_SADDR, inet->inet_saddr); NLA_PUT_BE32(skb, L2TP_ATTR_IP_DADDR, inet->inet_daddr); break; } out: return genlmsg_end(skb, hdr); nla_put_failure: genlmsg_cancel(skb, hdr); return -1; }
static iz_res_t scan_request(struct iz_cmd *cmd, struct nl_msg *msg) { int type; int duration; char *dummy; int channels; if (cmd->argc != 5) { printf("Incorrect number of arguments!\n"); return IZ_STOP_ERR; } if (!cmd->argv[1]) return IZ_STOP_ERR; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, cmd->argv[1]); if (!cmd->argv[2]) return IZ_STOP_ERR; if (!strcmp(cmd->argv[2], "ed")) { type = IEEE802154_MAC_SCAN_ED; } else if (!strcmp(cmd->argv[2], "active")) { type = IEEE802154_MAC_SCAN_ACTIVE; } else if (!strcmp(cmd->argv[2], "passive")) { type = IEEE802154_MAC_SCAN_PASSIVE; } else if (!strcmp(cmd->argv[2], "orphan")) { type = IEEE802154_MAC_SCAN_ORPHAN; } else { printf("Unknown scan type %s!\n", cmd->argv[2]); return IZ_STOP_ERR; } if (!cmd->argv[3]) return IZ_STOP_ERR; channels = strtol(cmd->argv[3], &dummy, 16); if (*dummy) { printf("Bad channels %s!\n", cmd->argv[3]); return IZ_STOP_ERR; } if (!cmd->argv[4]) return IZ_STOP_ERR; duration = strtol(cmd->argv[4], &dummy, 10); if (*dummy) { printf("Bad duration %s!\n", cmd->argv[4]); return IZ_STOP_ERR; } NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, type); NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, channels); NLA_PUT_U8(msg, IEEE802154_ATTR_DURATION, duration); return IZ_CONT_OK; nla_put_failure: return IZ_STOP_ERR; }
static int icmpv6_tuple_to_nlattr(struct sk_buff *skb, const struct nf_conntrack_tuple *t) { NLA_PUT_BE16(skb, CTA_PROTO_ICMPV6_ID, t->src.u.icmp.id); NLA_PUT_U8(skb, CTA_PROTO_ICMPV6_TYPE, t->dst.u.icmp.type); NLA_PUT_U8(skb, CTA_PROTO_ICMPV6_CODE, t->dst.u.icmp.code); return 0; nla_put_failure: return -1; }
static int parse_4addr_flag(const char *value, struct nl_msg *msg) { if (strcmp(value, "on") == 0) NLA_PUT_U8(msg, NL80211_ATTR_4ADDR, 1); else if (strcmp(value, "off") == 0) NLA_PUT_U8(msg, NL80211_ATTR_4ADDR, 0); else return 1; return 0; nla_put_failure: return 1; }
int join_mesh(char* ifname, char *mesh_id, int mesh_id_len, char *vendor_ie, int vendor_ie_len) { struct nl_msg *msg; uint8_t cmd = NL80211_CMD_JOIN_MESH; int ret; char *pret; int ifindex = if_nametoindex(ifname); msg = nlmsg_alloc(); if (!msg) return -ENOMEM; if (!mesh_id || !mesh_id_len) return -EINVAL; printf("o11s-pathseld: Staring mesh with mesh id = %s\n", mesh_id); pret = genlmsg_put(msg, 0, 0, genl_family_get_id(nlcfg.nl80211), 0, 0, cmd, 0); if (pret == NULL) goto nla_put_failure; if (vendor_ie) { struct nlattr *container = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS); if (!container) return -ENOBUFS; NLA_PUT(msg, NL80211_MESHCONF_VENDOR_PATH_SEL_IE, vendor_ie_len, vendor_ie); NLA_PUT_U8(msg, NL80211_MESHCONF_ENABLE_VENDOR_PATH_SEL, 1); NLA_PUT_U8(msg, NL80211_MESHCONF_ENABLE_VENDOR_METRIC, 1); nla_nest_end(msg, container); } NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex); NLA_PUT(msg, NL80211_ATTR_MESH_ID, mesh_id_len, mesh_id); ret = send_and_recv_msgs(msg, NULL, NULL); if (ret) printf("Mesh start failed: %d (%s)\n", ret, strerror(-ret)); else printf("Mesh start succeeded. Yay!\n"); return ret; nla_put_failure: return -ENOBUFS; }
static int plt_get_rx_statcs(struct nl80211_state *state, struct nl_cb *cb, struct nl_msg *msg, int argc, char **argv) { struct nlattr *key; struct wl1271_radio_rx_statcs prms; prms.test.id = TEST_CMD_RX_STAT_GET; key = nla_nest_start(msg, NL80211_ATTR_TESTDATA); if (!key) { fprintf(stderr, "%s> fail to nla_nest_start()\n", __func__); return 1; } NLA_PUT_U32(msg, WL1271_TM_ATTR_CMD_ID, WL1271_TM_CMD_TEST); NLA_PUT(msg, WL1271_TM_ATTR_DATA, sizeof(prms), &prms); NLA_PUT_U8(msg, WL1271_TM_ATTR_ANSWER, 1); nla_nest_end(msg, key); nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, display_rx_statcs, NULL); /* Important: needed gap between tx_start and tx_get */ sleep(2); return 0; nla_put_failure: fprintf(stderr, "%s> building message failed\n", __func__); return 2; }
static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target, struct netlink_callback *cb, int flags) { void *hdr; hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, &nfc_genl_family, flags, NFC_CMD_GET_TARGET); if (!hdr) return -EMSGSIZE; genl_dump_check_consistent(cb, hdr, &nfc_genl_family); NLA_PUT_U32(msg, NFC_ATTR_TARGET_INDEX, target->idx); NLA_PUT_U32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols); NLA_PUT_U16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res); NLA_PUT_U8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res); if (target->nfcid1_len > 0) NLA_PUT(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len, target->nfcid1); if (target->sensb_res_len > 0) NLA_PUT(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len, target->sensb_res); if (target->sensf_res_len > 0) NLA_PUT(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len, target->sensf_res); return genlmsg_end(msg, hdr); nla_put_failure: genlmsg_cancel(msg, hdr); return -EMSGSIZE; }
int ieee802154_nl_disassoc_indic(struct net_device *dev, struct ieee802154_addr *addr, u8 reason) { struct sk_buff *msg; pr_debug("%s\n", __func__); msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_INDIC); if (!msg) return -ENOBUFS; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name); NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex); NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN, dev->dev_addr); if (addr->addr_type == IEEE802154_ADDR_LONG) NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN, addr->hwaddr); else NLA_PUT_U16(msg, IEEE802154_ATTR_SRC_SHORT_ADDR, addr->short_addr); NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason); return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id); nla_put_failure: nlmsg_free(msg); return -ENOBUFS; }
static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev, u32 pid, u32 seq, struct netlink_callback *cb, int flags) { void *hdr; hdr = genlmsg_put(msg, pid, seq, &nfc_genl_family, flags, NFC_CMD_GET_DEVICE); if (!hdr) return -EMSGSIZE; if (cb) genl_dump_check_consistent(cb, hdr, &nfc_genl_family); 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); return genlmsg_end(msg, hdr); nla_put_failure: genlmsg_cancel(msg, hdr); return -EMSGSIZE; }
int nfc_genl_device_added(struct nfc_dev *dev) { struct sk_buff *msg; void *hdr; msg = nlmsg_new(NLMSG_GOODSIZE, 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; 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); 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 ieee802154_nl_assoc_indic(struct net_device *dev, struct ieee802154_addr *addr, u8 cap) { struct sk_buff *msg; pr_debug("%s\n", __func__); if (addr->addr_type != IEEE802154_ADDR_LONG) { pr_err("%s: received non-long source address!\n", __func__); return -EINVAL; } msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_INDIC); if (!msg) return -ENOBUFS; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name); 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(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN, addr->hwaddr); NLA_PUT_U8(msg, IEEE802154_ATTR_CAPABILITY, cap); return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id); nla_put_failure: nlmsg_free(msg); return -ENOBUFS; }
int ieee802154_nl_assoc_confirm(struct net_device *dev, u16 short_addr, u8 status) { struct sk_buff *msg; pr_debug("%s\n", __func__); msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_CONF); if (!msg) return -ENOBUFS; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name); 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, short_addr); NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status); return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id); nla_put_failure: nlmsg_free(msg); return -ENOBUFS; }
/* * Create one netlink message for one interface * Contains port and master info as well as carrier and bridge state. */ static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *port, u32 pid, u32 seq, int event, unsigned int flags) { const struct net_bridge *br = port->br; const struct net_device *dev = port->dev; struct ifinfomsg *hdr; struct nlmsghdr *nlh; u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN; br_debug(br, "br_fill_info event %d port %s master %s\n", event, dev->name, br->dev->name); nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags); if (nlh == NULL) return -EMSGSIZE; hdr = nlmsg_data(nlh); hdr->ifi_family = AF_BRIDGE; hdr->__ifi_pad = 0; hdr->ifi_type = dev->type; hdr->ifi_index = dev->ifindex; hdr->ifi_flags = dev_get_flags(dev); hdr->ifi_change = 0; NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name); NLA_PUT_U32(skb, IFLA_MASTER, br->dev->ifindex); NLA_PUT_U32(skb, IFLA_MTU, dev->mtu); NLA_PUT_U8(skb, IFLA_OPERSTATE, operstate); if (dev->addr_len) NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); if (dev->ifindex != dev->iflink) NLA_PUT_U32(skb, IFLA_LINK, dev->iflink); if (event == RTM_NEWLINK) NLA_PUT_U8(skb, IFLA_PROTINFO, port->state); return nlmsg_end(skb, nlh); nla_put_failure: nlmsg_cancel(skb, nlh); return -EMSGSIZE; }
static bool hash_net4_data_list(struct sk_buff *skb, const struct hash_net4_elem *data) { NLA_PUT_IPADDR4(skb, IPSET_ATTR_IP, data->ip); NLA_PUT_U8(skb, IPSET_ATTR_CIDR, data->cidr); return 0; nla_put_failure: return 1; }
static int dccp_to_nlattr(struct sk_buff *skb, struct nlattr *nla, const struct nf_conn *ct) { struct nlattr *nest_parms; read_lock_bh(&dccp_lock); nest_parms = nla_nest_start(skb, CTA_PROTOINFO_DCCP | NLA_F_NESTED); if (!nest_parms) goto nla_put_failure; NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_STATE, ct->proto.dccp.state); NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_ROLE, ct->proto.dccp.role[IP_CT_DIR_ORIGINAL]); nla_nest_end(skb, nest_parms); read_unlock_bh(&dccp_lock); return 0; nla_put_failure: read_unlock_bh(&dccp_lock); return -1; }
static int ieee802154_nl_fill_phy(struct sk_buff *msg, u32 pid, u32 seq, int flags, struct wpan_phy *phy) { void *hdr; int i, pages = 0; uint32_t *buf = kzalloc(32 * sizeof(uint32_t), GFP_KERNEL); pr_debug("%s\n", __func__); if (!buf) return -EMSGSIZE; hdr = genlmsg_put(msg, 0, seq, &nl802154_family, flags, IEEE802154_LIST_PHY); if (!hdr) goto out; mutex_lock(&phy->pib_lock); NLA_PUT_STRING(msg, IEEE802154_ATTR_PHY_NAME, wpan_phy_name(phy)); NLA_PUT_U8(msg, IEEE802154_ATTR_PAGE, phy->current_page); NLA_PUT_U8(msg, IEEE802154_ATTR_CHANNEL, phy->current_channel); for (i = 0; i < 32; i++) { if (phy->channels_supported[i]) buf[pages++] = phy->channels_supported[i] | (i << 27); } if (pages) NLA_PUT(msg, IEEE802154_ATTR_CHANNEL_PAGE_LIST, pages * sizeof(uint32_t), buf); mutex_unlock(&phy->pib_lock); kfree(buf); return genlmsg_end(msg, hdr); nla_put_failure: mutex_unlock(&phy->pib_lock); genlmsg_cancel(msg, hdr); out: kfree(buf); return -EMSGSIZE; }
static bool hash_ipport4_data_list(struct sk_buff *skb, const struct hash_ipport4_elem *data) { NLA_PUT_IPADDR4(skb, IPSET_ATTR_IP, data->ip); NLA_PUT_NET16(skb, IPSET_ATTR_PORT, data->port); NLA_PUT_U8(skb, IPSET_ATTR_PROTO, data->proto); return 0; nla_put_failure: return 1; }
static int inet6_fill_af(struct rtnl_link *link, struct nl_msg *msg, void *data) { struct inet6_data *id = data; if (id->i6_addr_gen_mode != I6_ADDR_GEN_MODE_UNKNOWN) NLA_PUT_U8(msg, IFLA_INET6_ADDR_GEN_MODE, id->i6_addr_gen_mode); return 0; nla_put_failure: return -NLE_MSGSIZE; }
static int dccp_to_nlattr(struct sk_buff *skb, struct nlattr *nla, struct nf_conn *ct) { struct nlattr *nest_parms; spin_lock_bh(&ct->lock); nest_parms = nla_nest_start(skb, CTA_PROTOINFO_DCCP | NLA_F_NESTED); if (!nest_parms) goto nla_put_failure; NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_STATE, ct->proto.dccp.state); NLA_PUT_U8(skb, CTA_PROTOINFO_DCCP_ROLE, ct->proto.dccp.role[IP_CT_DIR_ORIGINAL]); NLA_PUT_BE64(skb, CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ, cpu_to_be64(ct->proto.dccp.handshake_seq)); nla_nest_end(skb, nest_parms); spin_unlock_bh(&ct->lock); return 0; nla_put_failure: spin_unlock_bh(&ct->lock); return -1; }
int ipvs_start_daemon(ipvs_daemon_t *dm) { struct ip_vs_daemon_kern dmk; ipvs_func = ipvs_start_daemon; #ifdef LIBIPVS_USE_NL if (try_nl) { struct nlattr *nl_daemon; struct nl_msg *msg = ipvs_nl_message(IPVS_CMD_NEW_DAEMON, 0); if (!msg) return -1; nl_daemon = nla_nest_start(msg, IPVS_CMD_ATTR_DAEMON); if (!nl_daemon) goto nla_put_failure; NLA_PUT_U32(msg, IPVS_DAEMON_ATTR_STATE, dm->state); NLA_PUT_STRING(msg, IPVS_DAEMON_ATTR_MCAST_IFN, dm->mcast_ifn); NLA_PUT_U32(msg, IPVS_DAEMON_ATTR_SYNC_ID, dm->syncid); if (dm->sync_maxlen) NLA_PUT_U16(msg, IPVS_DAEMON_ATTR_SYNC_MAXLEN, dm->sync_maxlen); if (dm->mcast_port) NLA_PUT_U16(msg, IPVS_DAEMON_ATTR_MCAST_PORT, dm->mcast_port); if (dm->mcast_ttl) NLA_PUT_U8(msg, IPVS_DAEMON_ATTR_MCAST_TTL, dm->mcast_ttl); if (AF_INET6 == dm->mcast_af) NLA_PUT(msg, IPVS_DAEMON_ATTR_MCAST_GROUP6, sizeof(dm->mcast_group.in6), &dm->mcast_group.in6); else if (AF_INET == dm->mcast_af) NLA_PUT_U32(msg, IPVS_DAEMON_ATTR_MCAST_GROUP, dm->mcast_group.ip); nla_nest_end(msg, nl_daemon); return ipvs_nl_send_message(msg, ipvs_nl_noop_cb, NULL); nla_put_failure: nlmsg_free(msg); return -1; } #endif memset(&dmk, 0, sizeof(dmk)); dmk.state = dm->state; strcpy(dmk.mcast_ifn, dm->mcast_ifn); dmk.syncid = dm->syncid; return setsockopt(sockfd, IPPROTO_IP, IP_VS_SO_SET_STARTDAEMON, (char *)&dmk, sizeof(dmk)); }
static iz_res_t disassoc_request(struct iz_cmd *cmd, struct nl_msg *msg) { char *dummy; uint8_t reason; unsigned char hwa[IEEE802154_ADDR_LEN]; uint16_t short_addr; int ret; if (!cmd->argv[1]) return IZ_STOP_ERR; NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, cmd->argv[1]); if (!cmd->argv[2]) return IZ_STOP_ERR; if (cmd->argv[2][0] == 'H' || cmd->argv[2][0] == 'h') { ret = parse_hw_addr(cmd->argv[2]+1, hwa); if (ret) { printf("Bad destination address!\n"); return IZ_STOP_ERR; } NLA_PUT(msg, IEEE802154_ATTR_DEST_HW_ADDR, IEEE802154_ADDR_LEN, hwa); } else { short_addr = strtol(cmd->argv[2], &dummy, 16); if (*dummy) { printf("Bad destination address!\n"); return IZ_STOP_ERR; } NLA_PUT_U16(msg, IEEE802154_ATTR_DEST_SHORT_ADDR, short_addr); } if (!cmd->argv[3]) return IZ_STOP_ERR; reason = strtol(cmd->argv[3], &dummy, 16); if (*dummy) { printf("Bad disassociation reason!\n"); return IZ_STOP_ERR; } if (cmd->argv[4]) return IZ_STOP_ERR; NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason); return IZ_CONT_OK; nla_put_failure: return IZ_STOP_ERR; }
static int tcp_to_nlattr(struct sk_buff *skb, struct nlattr *nla, struct nf_conn *ct) { struct nlattr *nest_parms; struct nf_ct_tcp_flags tmp = {}; spin_lock_bh(&ct->lock); nest_parms = nla_nest_start(skb, CTA_PROTOINFO_TCP | NLA_F_NESTED); if (!nest_parms) goto nla_put_failure; NLA_PUT_U8(skb, CTA_PROTOINFO_TCP_STATE, ct->proto.tcp.state); NLA_PUT_U8(skb, CTA_PROTOINFO_TCP_WSCALE_ORIGINAL, ct->proto.tcp.seen[0].td_scale); NLA_PUT_U8(skb, CTA_PROTOINFO_TCP_WSCALE_REPLY, ct->proto.tcp.seen[1].td_scale); tmp.flags = ct->proto.tcp.seen[0].flags; NLA_PUT(skb, CTA_PROTOINFO_TCP_FLAGS_ORIGINAL, sizeof(struct nf_ct_tcp_flags), &tmp); tmp.flags = ct->proto.tcp.seen[1].flags; NLA_PUT(skb, CTA_PROTOINFO_TCP_FLAGS_REPLY, sizeof(struct nf_ct_tcp_flags), &tmp); spin_unlock_bh(&ct->lock); nla_nest_end(skb, nest_parms); return 0; nla_put_failure: spin_unlock_bh(&ct->lock); return -1; }
static bool hash_net6_data_tlist(struct sk_buff *skb, const struct hash_net6_elem *data) { const struct hash_net6_telem *e = (const struct hash_net6_telem *)data; NLA_PUT_IPADDR6(skb, IPSET_ATTR_IP, &e->ip); NLA_PUT_U8(skb, IPSET_ATTR_CIDR, e->cidr); NLA_PUT_NET32(skb, IPSET_ATTR_TIMEOUT, htonl(ip_set_timeout_get(e->timeout))); return 0; nla_put_failure: return 1; }
int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx, u8 comm_mode, u8 rf_mode) { struct sk_buff *msg; void *hdr; pr_debug("DEP link is up\n"); msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC); if (!msg) return -ENOMEM; hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP); if (!hdr) goto free_msg; NLA_PUT_U32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx); if (rf_mode == NFC_RF_INITIATOR) 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); genlmsg_end(msg, hdr); dev->dep_link_up = true; genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC); return 0; nla_put_failure: genlmsg_cancel(msg, hdr); free_msg: nlmsg_free(msg); return -EMSGSIZE; }
static bool hash_ipport6_data_tlist(struct sk_buff *skb, const struct hash_ipport6_elem *data) { const struct hash_ipport6_telem *e = (const struct hash_ipport6_telem *)data; NLA_PUT_IPADDR6(skb, IPSET_ATTR_IP, &e->ip); NLA_PUT_NET16(skb, IPSET_ATTR_PORT, data->port); NLA_PUT_U8(skb, IPSET_ATTR_PROTO, data->proto); NLA_PUT_NET32(skb, IPSET_ATTR_TIMEOUT, htonl(ip_set_timeout_get(e->timeout))); return 0; nla_put_failure: return 1; }
int nl_dect_cell_build_msg(struct nl_msg *msg, struct nl_dect_cell *cell) { struct dectmsg dm = { .dm_index = cell->c_index, }; if (nlmsg_append(msg, &dm, sizeof(dm), NLMSG_ALIGNTO) < 0) goto nla_put_failure; if (cell->ce_mask & CELL_ATTR_NAME) NLA_PUT_STRING(msg, DECTA_CELL_NAME, cell->c_name); if (cell->ce_mask & CELL_ATTR_FLAGS) NLA_PUT_U32(msg, DECTA_CELL_FLAGS, cell->c_flags); if (cell->ce_mask & CELL_ATTR_LINK) NLA_PUT_U8(msg, DECTA_CELL_CLUSTER, cell->c_link); return 0; nla_put_failure: return -NLE_MSGSIZE; } static struct trans_tbl cell_flags[] = { __ADD(DECT_CELL_CCP, ccp) __ADD(DECT_CELL_SLAVE, slave) __ADD(DECT_CELL_MONITOR, monitor) }; char *nl_dect_cell_flags2str(uint32_t flags, char *buf, size_t len) { return __flags2str(flags, buf, len, cell_flags, ARRAY_SIZE(cell_flags)); } uint32_t nl_dect_cell_str2flags(const char *str) { return __str2flags(str, cell_flags, ARRAY_SIZE(cell_flags)); } /** @cond SKIP */ struct nl_object_ops nl_dect_cell_obj_ops = { .oo_name = "nl_dect/cell", .oo_size = sizeof(struct nl_dect_cell), .oo_free_data = cell_free_data, .oo_dump = { [NL_DUMP_LINE] = cell_dump, }, .oo_id_attrs = CELL_ATTR_NAME,
static int plt_tx_bip(struct nl80211_state *state, struct nl_cb *cb, struct nl_msg *msg, int argc, char **argv) { struct nlattr *key; struct wl1271_cmd_cal_p2g prms; int i; char nvs_path[PATH_MAX]; if (argc < 8) { fprintf(stderr, "%s> Missing arguments\n", __func__); return 2; } if (argc > 8) strncpy(nvs_path, argv[8], strlen(argv[8])); else nvs_path[0] = '\0'; memset(&prms, 0, sizeof(struct wl1271_cmd_cal_p2g)); prms.test.id = TEST_CMD_P2G_CAL; for (i = 0; i < 8; i++) prms.sub_band_mask |= (atoi(argv[i]) & 0x1)<<i; key = nla_nest_start(msg, NL80211_ATTR_TESTDATA); if (!key) { fprintf(stderr, "fail to nla_nest_start()\n"); return 1; } NLA_PUT_U32(msg, WL1271_TM_ATTR_CMD_ID, WL1271_TM_CMD_TEST); NLA_PUT(msg, WL1271_TM_ATTR_DATA, sizeof(prms), &prms); NLA_PUT_U8(msg, WL1271_TM_ATTR_ANSWER, 1); nla_nest_end(msg, key); nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, calib_valid_handler, nvs_path); return 0; nla_put_failure: fprintf(stderr, "%s> building message failed\n", __func__); return 2; }