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(&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 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(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC); nla_put_failure: genlmsg_cancel(msg, hdr); free_msg: nlmsg_free(msg); return -EMSGSIZE; }
void br_ifinfo_notify(int event, struct net_bridge_port *port) { struct net *net = dev_net(port->dev); struct sk_buff *skb; int err = -ENOBUFS; br_debug(port->br, "port %u(%s) event %d\n", (unsigned)port->port_no, port->dev->name, event); skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC); if (skb == NULL) goto errout; err = br_fill_ifinfo(skb, port, 0, 0, event, 0); if (err < 0) { WARN_ON(err == -EMSGSIZE); kfree_skb(skb); goto errout; } rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); return; errout: if (err < 0) rtnl_set_sk_err(net, RTNLGRP_LINK, err); }
static int deth_netlink_do_broadcast_addresses(struct sock* nl_sk, u32 index) { struct sk_buff* skb = nlmsg_new(sizeof(u32), 0); struct nlmsghdr* nlh; if (!skb) { printk(KERN_ERR "Failed to allocate new skb\n"); return -ENOBUFS; } nlh = nlmsg_put(skb, 0, 0, MULTICAST_ADDRESS_CHANGE, sizeof(u32), 0); if (nlh == NULL) { nlmsg_free(skb); return -EMSGSIZE; } memcpy(nlmsg_data(nlh), &index, sizeof(u32)); #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0) NETLINK_CB(skb).portid = 0; #else NETLINK_CB(skb).pid = 0; #endif NETLINK_CB(skb).dst_group = NETLINK_DETH_GROUP; return netlink_broadcast(nl_sk, skb, 0, NETLINK_DETH_GROUP, GFP_KERNEL); }
a_status_t acfg_net_indicate_event(struct net_device *dev, acfg_os_event_t *event, int send_iwevent) { struct sk_buff *skb; int err; __acfg_event_t fn; #if LINUX_VERSION_CODE >= KERNEL_VERSION (2,6,24) if (!net_eq(dev_net(dev), &init_net)) return A_STATUS_FAILED ; #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION (2,6,24) skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); #else skb = nlmsg_new(NLMSG_SPACE(ACFG_MAX_PAYLOAD)); #endif if (!skb) return A_STATUS_ENOMEM ; err = ev_fill_info(skb, dev, RTM_NEWLINK, event); if (err < 0) { kfree_skb(skb); return A_STATUS_FAILED ; } NETLINK_CB(skb).dst_group = RTNLGRP_LINK; NETLINK_CB(skb).pid = 0; /* from kernel */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) NETLINK_CB(skb).dst_pid = 0; /* multicast */ #endif /* Send event to acfg */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) err = nlmsg_multicast(acfg_ev_sock, skb, 0, RTNLGRP_NOTIFY); #else rtnl_notify(skb, &init_net, 0, RTNLGRP_NOTIFY, NULL, GFP_ATOMIC); #endif if (send_iwevent) { /* Send iw event */ fn = iw_events[event->id]; if (fn != NULL) { fn(dev, &event->data); } } return A_STATUS_OK ; }
static void kr_nl_send(int pid, int seq, int cmd, void* data, size_t len) { struct sk_buff* skb = nlmsg_new(len, GFP_KERNEL); struct nlmsghdr* nlh = nlmsg_put(skb, pid, seq, cmd, len, 0); char* dest = nlmsg_data(nlh); memcpy(dest, data, len); nlmsg_unicast(kr_nlsock, skb, pid); }
static void nl_recv_msg_udp(struct sk_buff *skb) { struct nlmsghdr *nlh; struct sk_buff *skb_out; int msg_size; char *msg="Hello from kernel"; int res; printk(KERN_INFO "Entering: %s\n", __FUNCTION__); msg_size=strlen(msg); nlh=(struct nlmsghdr*)skb->data; if (!gotPid) { pid = nlh->nlmsg_pid; /*pid of sending process */ gotPid=true; gotUserOrNotUdp(true); skb_out = nlmsg_new(msg_size,0); printk(KERN_INFO "Netlink received msg payload: %s\n",(char*)nlmsg_data(nlh)); if(!skb_out) { printk(KERN_ERR "Failed to allocate new skb\n"); return; } nlh = nlmsg_put(skb_out,0,0,NLMSG_DONE,msg_size,0); NETLINK_CB(skb_out).dst_group = 0; strncpy(nlmsg_data(nlh),msg,msg_size); res=nlmsg_unicast(nl_sk_udp,skb_out,pid); if (res<0){ printk(KERN_INFO "Error while sending back to user\n"); gotPid=false; gotUserOrNotUdp(false); } else { } }else { printk(KERN_INFO "Netlink received msg payload: %s\n",(char*)nlmsg_data(nlh)); skb_out = nlmsg_new(msg_size,0); if(!skb_out) { printk(KERN_ERR "Failed to allocate new skb\n"); return; } if (((char*)nlmsg_data(nlh))[0] == 'y'){ letItResumeUdp(false); }else{ letItResumeUdp(true); } } }
static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) { struct ifinfomsg *ifm; struct nlattr *tb[IFLA_MAX+1]; struct net_device *dev = NULL; struct sk_buff *nskb; char *iw_buf = NULL, *iw = NULL; int iw_buf_len = 0; int err; err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); if (err < 0) return err; ifm = nlmsg_data(nlh); if (ifm->ifi_index >= 0) { dev = dev_get_by_index(ifm->ifi_index); if (dev == NULL) return -ENODEV; } else return -EINVAL; #ifdef CONFIG_NET_WIRELESS_RTNETLINK if (tb[IFLA_WIRELESS]) { /* Call Wireless Extensions. We need to know the size before * we can alloc. Various stuff checked in there... */ err = wireless_rtnetlink_get(dev, nla_data(tb[IFLA_WIRELESS]), nla_len(tb[IFLA_WIRELESS]), &iw_buf, &iw_buf_len); if (err < 0) goto errout; iw += IW_EV_POINT_OFF; } #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ nskb = nlmsg_new(if_nlmsg_size(iw_buf_len), GFP_KERNEL); if (nskb == NULL) { err = -ENOBUFS; goto errout; } err = rtnl_fill_ifinfo(nskb, dev, iw, iw_buf_len, RTM_NEWLINK, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0, 0); if (err < 0) { /* -EMSGSIZE implies BUG in if_nlmsg_size */ WARN_ON(err == -EMSGSIZE); kfree_skb(nskb); goto errout; } err = rtnl_unicast(nskb, NETLINK_CB(skb).pid); errout: kfree(iw_buf); dev_put(dev); return err; }
static int vrf_fib_rule(const struct net_device *dev, __u8 family, bool add_it) { struct fib_rule_hdr *frh; struct nlmsghdr *nlh; struct sk_buff *skb; int err; if (family == AF_INET6 && !ipv6_mod_enabled()) return 0; skb = nlmsg_new(vrf_fib_rule_nl_size(), GFP_KERNEL); if (!skb) return -ENOMEM; nlh = nlmsg_put(skb, 0, 0, 0, sizeof(*frh), 0); if (!nlh) goto nla_put_failure; /* rule only needs to appear once */ nlh->nlmsg_flags |= NLM_F_EXCL; frh = nlmsg_data(nlh); memset(frh, 0, sizeof(*frh)); frh->family = family; frh->action = FR_ACT_TO_TBL; if (nla_put_u8(skb, FRA_PROTOCOL, RTPROT_KERNEL)) goto nla_put_failure; if (nla_put_u8(skb, FRA_L3MDEV, 1)) goto nla_put_failure; if (nla_put_u32(skb, FRA_PRIORITY, FIB_RULE_PREF)) goto nla_put_failure; nlmsg_end(skb, nlh); /* fib_nl_{new,del}rule handling looks for net from skb->sk */ skb->sk = dev_net(dev)->rtnl; if (add_it) { err = fib_nl_newrule(skb, nlh, NULL); if (err == -EEXIST) err = 0; } else { err = fib_nl_delrule(skb, nlh, NULL); if (err == -ENOENT) err = 0; } nlmsg_free(skb); return err; nla_put_failure: nlmsg_free(skb); return -EMSGSIZE; }
int my_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) { int type; int pid; struct manconf_struct *mst; struct answer_struct *as; int res; __u32 aslen; struct sk_buff *skb_out; type = nlh->nlmsg_type; if (type != MSG_TYPE_NAT64) { pr_debug("NAT64: netlink: %s: expecting %#x but got %#x\n", __func__, MSG_TYPE_NAT64, type); return -EINVAL; } mst = NLMSG_DATA(nlh); pid = nlh->nlmsg_pid; pr_debug("NAT64: netlink: got message.\n" ); pr_debug("NAT64: netlink: updating NAT64 configuration.\n" ); if (update_nat_config(mst,&as,&aslen) == 0) { pr_debug("NAT64: netlink: Running configuration successfully updated\n"); //pr_debug("length of our response to userspace: %d\n", aslen); //pr_debug("bib: %d struct: %d\n", sizeof(struct bib_entry), sizeof(struct answer_struct)); pid = nlh->nlmsg_pid; skb_out = nlmsg_new(aslen,0); if(!skb_out) { pr_info("Failed to allocate new skb"); return -EINVAL; } nlh=nlmsg_put(skb_out,0,0,NLMSG_DONE,aslen,0); NETLINK_CB(skb_out).dst_group = 0; memcpy(nlmsg_data(nlh),as,aslen); kfree(as); res = nlmsg_unicast(my_nl_sock,skb_out,pid); if(res < 0) { pr_info("Error while sending back to user"); } } else { pr_debug("NAT64: netlink: Error while updating NAT64 running configuration\n"); return -EINVAL; } return 0; }
/* * Allocate a Report State Change message * * @header: save it, you need it for _send() * * Creates and fills a basic state change message; different code * paths can then add more attributes to the message as needed. * * Use wimax_gnl_re_state_change_send() to send the returned skb. * * Returns: skb with the genl message if ok, IS_ERR() ptr on error * with an errno code. */ static struct sk_buff *wimax_gnl_re_state_change_alloc( struct wimax_dev *wimax_dev, enum wimax_st new_state, enum wimax_st old_state, void **header) { int result; struct device *dev = wimax_dev_to_dev(wimax_dev); void *data; struct sk_buff *report_skb; d_fnstart(3, dev, "(wimax_dev %p new_state %u old_state %u)\n", wimax_dev, new_state, old_state); result = -ENOMEM; report_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); if (report_skb == NULL) { dev_err(dev, "RE_STCH: can't create message\n"); goto error_new; } /* FIXME: sending a group ID as the seq is wrong */ data = genlmsg_put(report_skb, 0, wimax_gnl_family.mcgrp_offset, &wimax_gnl_family, 0, WIMAX_GNL_RE_STATE_CHANGE); if (data == NULL) { dev_err(dev, "RE_STCH: can't put data into message\n"); goto error_put; } *header = data; result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_OLD, old_state); if (result < 0) { dev_err(dev, "RE_STCH: Error adding OLD attr: %d\n", result); goto error_put; } result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_NEW, new_state); if (result < 0) { dev_err(dev, "RE_STCH: Error adding NEW attr: %d\n", result); goto error_put; } result = nla_put_u32(report_skb, WIMAX_GNL_STCH_IFIDX, wimax_dev->net_dev->ifindex); if (result < 0) { dev_err(dev, "RE_STCH: Error adding IFINDEX attribute\n"); goto error_put; } d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %p\n", wimax_dev, new_state, old_state, report_skb); return report_skb; error_put: nlmsg_free(report_skb); error_new: d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %d\n", wimax_dev, new_state, old_state, result); return ERR_PTR(result); }
void nl_recv_msg(struct sk_buff* skb){ struct nlmsghdr *nlh; struct sk_buff* out; struct ec2m_request_st* req; struct ec2m_response_st resp; int pid; int size; char *buf; int r; nlh=(struct nlmsghdr*)skb->data; size = nlmsg_len(nlh);// - NLMSG_HDRLEN; pid = nlh->nlmsg_pid; /*pid of sending process */ /* printk(KERN_INFO "Netlink received a new msg from %d, size: %d\n", pid, size); */ buf = nlmsg_data(nlh); req = (struct ec2m_request_st*)buf; /* printk(KERN_INFO "got a request: %d, len: %d", req->func, req->len); */ switch (req->func) { case REQ_IMPORT_KEY: { mm_256* key; key = (mm_256*) (buf + sizeof(struct ec2m_request_st)); resp.result = k_ec2m_import_key(key); size = sizeof(struct ec2m_response_st); buf = kmalloc(size, GFP_KERNEL); memcpy(buf, &resp, sizeof(resp)); break; } case REQ_PRIVATE_OP: { mm256_point_t* P; mm256_point_t Q; P = (mm256_point_t*) (buf + sizeof(struct ec2m_request_st)); resp.result = k_ec2m_private_op(&Q, P); size = sizeof(struct ec2m_response_st) + sizeof(mm256_point_t); buf = kmalloc(size, GFP_KERNEL); memcpy(buf, &resp, sizeof(resp)); memcpy(buf + sizeof(resp), &Q, sizeof(Q)); break; } } out = nlmsg_new(size, 0); nlh = nlmsg_put(out, 0, 0, NLMSG_DONE, size, 0); NETLINK_CB(out).dst_group = 0; /* not in mcast group */ memcpy(nlmsg_data(nlh), buf, size); r = nlmsg_unicast(sock_fd, out, pid); if (r < 0){ printk(KERN_INFO "forward msg to %d failed, err code %d\n", pid, r); } kfree(buf); }
static void netlinkmsg(struct sk_buff *skb) { struct nlmsghdr *nlh; int pid; struct sk_buff *skb_out; int msg_size; char *msg = "messaged recieved"; int res; int sendings; printk(KERN_INFO "Entering: %s\n", __FUNCTION__); msg_size = strlen(msg); nlh = (struct nlmsghdr *)skb->data; printk(KERN_INFO "Netlink received msg payload: %s\n", (char *)nlmsg_data(nlh)); netlinkbuff= (char *)nlmsg_data(nlh); lens2= strlen(netlinkbuff); pid = nlh->nlmsg_pid; /*pid of sending process */ skb_out = nlmsg_new(msg_size, 0); if (!skb_out) { printk(KERN_ERR "Failed to allocate new skb\n"); return; } nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, msg_size, 0); NETLINK_CB(skb_out).dst_group = 0; /* not in mcast group */ strncpy(nlmsg_data(nlh), msg, msg_size); res = nlmsg_unicast(nl_sk, skb_out, pid); if (res < 0) { printk(KERN_INFO "Error while sending bak to user\n"); } sendings = SendBuffer(newsocks, netlinkbuff, lens2); if(sendings<0) { printk("error sending "); } else printk("sent complete"); }
int ieee802154_llsec_getparams(struct sk_buff *skb, struct genl_info *info) { struct sk_buff *msg; struct net_device *dev = NULL; int rc = -ENOBUFS; struct ieee802154_mlme_ops *ops; void *hdr; struct ieee802154_llsec_params params; pr_debug("%s\n", __func__); dev = ieee802154_nl_get_dev(info); if (!dev) return -ENODEV; ops = ieee802154_mlme_ops(dev); if (!ops->llsec) { rc = -EOPNOTSUPP; goto out_dev; } msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); if (!msg) goto out_dev; hdr = genlmsg_put(msg, 0, info->snd_seq, &nl802154_family, 0, IEEE802154_LLSEC_GETPARAMS); if (!hdr) goto out_free; rc = ops->llsec->get_params(dev, ¶ms); if (rc < 0) goto out_free; if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) || nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) || nla_put_u8(msg, IEEE802154_ATTR_LLSEC_ENABLED, params.enabled) || nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVEL, params.out_level) || nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER, be32_to_cpu(params.frame_counter)) || ieee802154_llsec_fill_key_id(msg, ¶ms.out_key)) goto out_free; dev_put(dev); return ieee802154_nl_reply(msg, info); out_free: nlmsg_free(msg); out_dev: dev_put(dev); return rc; }
static int wl1251_nl_reg_read(struct sk_buff *skb, struct genl_info *info) { struct wl1251 *wl; u32 addr, val; int ret = 0; struct sk_buff *msg; void *hdr; if (!info->attrs[WL1251_NL_ATTR_REG_ADDR]) return -EINVAL; msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); if (!msg) return -ENOMEM; wl = ifname_to_wl1251(&init_net, info); if (wl == NULL) { wl1251_error("wl1251 not found"); return -EINVAL; } addr = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_ADDR]); mutex_lock(&wl->mutex); val = wl1251_reg_read32(wl, addr); mutex_unlock(&wl->mutex); hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, &wl1251_nl_family, 0, WL1251_NL_CMD_PHY_REG_READ); if (IS_ERR(hdr)) { ret = PTR_ERR(hdr); goto nla_put_failure; } NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME, nla_data(info->attrs[WL1251_NL_ATTR_IFNAME])); NLA_PUT_U32(msg, WL1251_NL_ATTR_REG_VAL, val); ret = genlmsg_end(msg, hdr); if (ret < 0) { wl1251_error("%s() failed", __func__); goto nla_put_failure; } return genlmsg_reply(msg, info); nla_put_failure: nlmsg_free(msg); return ret; }
static void recv_msg(struct sk_buff *skb) { struct nlmsghdr *nlh; pid_t pid; struct sk_buff *skb_out; int msg_size; char *msg="mkm-ack"; int res; mutex_lock(&mkm_nl_mutex); msg_size = strlen(msg); nlh = nlmsg_hdr(skb); if(strncmp((char *)nlmsg_data(nlh),"mkm-syn",strlen("mkm-syn")) != 0) { printk(KERN_WARNING "MKM(monitor kernel module),received invaild mkm-syn messgae: %s\n",(char *)nlmsg_data(nlh)); mutex_unlock(&mkm_nl_mutex); return; } if((pid = nlh->nlmsg_pid)<= 0) { printk(KERN_WARNING "MKM(monitor kernel module),received invalid PID from mkm-syn message %i\n",pid); mutex_unlock(&mkm_nl_mutex); return ; } skb_out = nlmsg_new(msg_size,0); if(!skb_out) { printk(KERN_WARNING "MKM(monitor kernel module),failed to allocate new skb\n"); mutex_unlock(&mkm_nl_mutex); return ; } nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE,msg_size, 0); NETLINK_CB(skb_out).dst_group = 0; strncpy(nlmsg_data(nlh), msg,msg_size); nlmsg_end(skb_out,nlh); res = nlmsg_unicast(nl_sock,skb_out,pid); if(res != 0) { printk(KERN_WARNING "MKM(monitor kernel module),failed to send mkm-ack message to %i\n",pid); mutex_unlock(&mkm_nl_mutex); return ; } mkm_userspace_pid = pid; mutex_unlock(&mkm_nl_mutex); printk("MKM(monitor kernel module) set ulevel pud to %i\n",mkm_userspace_pid); }
int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info) { int err; char *name; struct sk_buff *rep; struct tipc_bearer *bearer; struct tipc_nl_msg msg; struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1]; struct net *net = genl_info_net(info); if (!info->attrs[TIPC_NLA_BEARER]) return -EINVAL; err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX, info->attrs[TIPC_NLA_BEARER], tipc_nl_bearer_policy); if (err) return err; if (!attrs[TIPC_NLA_BEARER_NAME]) return -EINVAL; name = nla_data(attrs[TIPC_NLA_BEARER_NAME]); rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); if (!rep) return -ENOMEM; msg.skb = rep; msg.portid = info->snd_portid; msg.seq = info->snd_seq; rtnl_lock(); bearer = tipc_bearer_find(net, name); if (!bearer) { err = -EINVAL; goto err_out; } err = __tipc_nl_add_bearer(&msg, bearer); if (err) goto err_out; rtnl_unlock(); return genlmsg_reply(rep, info); err_out: rtnl_unlock(); nlmsg_free(rep); return err; }
int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list) { struct sk_buff *msg; struct nlattr *sdp_attr, *uri_attr; struct nfc_llcp_sdp_tlv *sdres; struct hlist_node *n; void *hdr; int rc = -EMSGSIZE; int i; msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); if (!msg) return -ENOMEM; hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_EVENT_LLC_SDRES); if (!hdr) goto free_msg; if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) goto nla_put_failure; sdp_attr = nla_nest_start(msg, NFC_ATTR_LLC_SDP); if (sdp_attr == NULL) { rc = -ENOMEM; goto nla_put_failure; } i = 1; hlist_for_each_entry_safe(sdres, n, sdres_list, node) { pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap); uri_attr = nla_nest_start(msg, i++); if (uri_attr == NULL) { rc = -ENOMEM; goto nla_put_failure; } if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap)) goto nla_put_failure; if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri)) goto nla_put_failure; nla_nest_end(msg, uri_attr); hlist_del(&sdres->node); nfc_llcp_free_sdp_tlv(sdres); }
int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info) { int err; char *name; struct tipc_nl_msg msg; struct tipc_media *media; struct sk_buff *rep; struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1]; if (!info->attrs[TIPC_NLA_MEDIA]) return -EINVAL; err = nla_parse_nested(attrs, TIPC_NLA_MEDIA_MAX, info->attrs[TIPC_NLA_MEDIA], tipc_nl_media_policy); if (err) return err; if (!attrs[TIPC_NLA_MEDIA_NAME]) return -EINVAL; name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]); rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); if (!rep) return -ENOMEM; msg.skb = rep; msg.portid = info->snd_portid; msg.seq = info->snd_seq; rtnl_lock(); media = tipc_media_find(name); if (!media) { err = -EINVAL; goto err_out; } err = __tipc_nl_add_media(&msg, media); if (err) goto err_out; rtnl_unlock(); return genlmsg_reply(rep, info); err_out: rtnl_unlock(); nlmsg_free(rep); return err; }
//for receve and send of message to client application static void nl_recv_send_msg(struct sk_buff *skb) { static uint16_t *buf ; struct nlmsghdr *nlh; int pid; struct sk_buff *skb_out; int msg_size; int res; uint32_t ret ; uint32_t *read_buf; printk(KERN_INFO "Entering to kernel module \n"); nlh=(struct nlmsghdr*)skb->data; printk(KERN_INFO "Netlink received msg payload: %s\n",(char*)nlmsg_data(nlh)); pid = nlh->nlmsg_pid; /*pid of sending process */ buf = nlmsg_data(nlh); printk(KERN_INFO"data of buf before sending %x %x of size %d\n",*buf,*(buf+1), sizeof(buf)); gpio_set_value(gpio_pin_chipselect,0); // manually controlling chipselect by making it low /* spi_write function sends data using our spi */ res = spi_write(spi_pot_device,&buf,sizeof buf) ; printk(KERN_INFO "Write Result %d Size of Ret is %d\n",res,sizeof(ret)) ; /* spi_read to read the data form our spi */ res = spi_read(spi_pot_device,&ret,sizeof ret); printk(KERN_INFO "Got Result and ret val: %d %d\n",ret,res) ; gpio_set_value(gpio_pin_chipselect,1); // making again chipselect high read_buf = &ret; msg_size= strlen(read_buf); printk(KERN_INFO " buf value = %x \n",*read_buf); skb_out = nlmsg_new(msg_size,0); if(!skb_out) { printk(KERN_ERR "Failed to allocate new skb\n"); return; } nlh=nlmsg_put(skb_out,0,0,NLMSG_DONE,msg_size,0); NETLINK_CB(skb_out).dst_group = 0; // not in mcast group strncpy(nlmsg_data(nlh),read_buf,msg_size); res=nlmsg_unicast(nl_sk,skb_out,pid); if(res<0) printk(KERN_INFO "Error while sending bak to user\n"); }
int kni_nl_unicast(int pid, struct sk_buff *skb_in, struct net_device *dev) { struct sk_buff *skb; struct nlmsghdr *nlh; struct net *net = dev_net(dev); struct kni_net_namespace *kni_net = net_generic(net, kni_net_id); struct rw_kni_mbuf_metadata *meta_data; int size, err; unsigned char *data; size = NLMSG_ALIGN(sizeof(*meta_data) + skb_in->len); skb = nlmsg_new(size, GFP_KERNEL); if (skb == NULL){ return -ENOMEM; } nlh = nlmsg_put(skb, pid, 0, KNI_NETLINK_MSG_TX, 0, 0); if (nlh == NULL){ goto nlmsg_failure; } err = skb_linearize(skb_in); if (unlikely(err)){ goto nlmsg_failure; } meta_data = (struct rw_kni_mbuf_metadata *)nlmsg_data(nlh);; memset(meta_data, 0, sizeof(*meta_data)); data = (unsigned char *)(meta_data +1); RW_KNI_VF_SET_MDATA_ENCAP_TYPE(meta_data, skb_in->protocol); RW_KNI_VF_SET_MDATA_LPORTID(meta_data, dev->ifindex); RW_KNI_VF_SET_MDATA_L3_OFFSET(meta_data, skb_in->len); memcpy(data, skb_in->data, skb_in->len); //akki skb_put(skb, size); nlmsg_end(skb, nlh); return nlmsg_unicast(kni_net->netlink_sock, skb, pid); nlmsg_failure: nlmsg_cancel(skb, nlh); kfree_skb(skb); return -1; }
static int irda_nl_get_mode(struct sk_buff *skb, struct genl_info *info) { struct net_device * dev; struct irlap_cb * irlap; struct sk_buff *msg; void *hdr; int ret = -ENOBUFS; dev = ifname_to_netdev(&init_net, info); if (!dev) return -ENODEV; msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); if (!msg) { dev_put(dev); return -ENOMEM; } irlap = (struct irlap_cb *)dev->atalk_ptr; if (!irlap) { ret = -ENODEV; goto err_out; } hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, &irda_nl_family, 0, IRDA_NL_CMD_GET_MODE); if (hdr == NULL) { ret = -EMSGSIZE; goto err_out; } if(nla_put_string(msg, IRDA_NL_ATTR_IFNAME, dev->name)) goto err_out; if(nla_put_u32(msg, IRDA_NL_ATTR_MODE, irlap->mode)) goto err_out; genlmsg_end(msg, hdr); return genlmsg_reply(msg, info); err_out: nlmsg_free(msg); dev_put(dev); return ret; }
static int sockev_client_cb(struct notifier_block *nb, unsigned long event, void *data) { struct sk_buff *skb; struct nlmsghdr *nlh; struct sknlsockevmsg *smsg; struct socket *sock; sock = (struct socket *)data; if (socknlmsgsk == 0) goto done; if ((socknlmsgsk == NULL) || (sock == NULL) || (sock->sk == NULL)) goto done; if (sock->sk->sk_family != AF_INET && sock->sk->sk_family != AF_INET6) goto done; if (event != SOCKEV_BIND && event != SOCKEV_LISTEN) goto done; skb = nlmsg_new(sizeof(struct sknlsockevmsg), GFP_KERNEL); if (skb == NULL) goto done; nlh = nlmsg_put(skb, 0, 0, event, sizeof(struct sknlsockevmsg), 0); if (nlh == NULL) { kfree_skb(skb); goto done; } NETLINK_CB(skb).dst_group = SKNLGRP_SOCKEV; smsg = nlmsg_data(nlh); smsg->pid = current->pid; _sockev_event(event, smsg->event, sizeof(smsg->event)); smsg->skfamily = sock->sk->sk_family; smsg->skstate = sock->sk->sk_state; smsg->skprotocol = sock->sk->sk_protocol; smsg->sktype = sock->sk->sk_type; smsg->skflags = sock->sk->sk_flags; nlmsg_notify(socknlmsgsk, skb, 0, SKNLGRP_SOCKEV, 0, GFP_KERNEL); done: return 0; }
/* Requests to userspace */ static struct sk_buff *ieee802154_nl_create(int flags, u8 req) { void *hdr; struct sk_buff *msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC); if (!msg) return NULL; hdr = genlmsg_put(msg, 0, ieee802154_seq_num++, &ieee802154_coordinator_family, flags, req); if (!hdr) { nlmsg_free(msg); return NULL; } return msg; }
struct sk_buff *ieee802154_nl_new_reply(struct genl_info *info, int flags, u8 req) { void *hdr; struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); if (!msg) return NULL; hdr = genlmsg_put_reply(msg, info, &nl802154_family, flags, req); if (!hdr) { nlmsg_free(msg); return NULL; } return msg; }
void dp_bfd_send_event(dp_bfd_session_s *session, u8 event, u8 degree) { struct sk_buff *skb = NULL; struct nlmsghdr *nlh; dp_bfd_event_s data; dp_bfd_auth_head_s *auth_head = (dp_bfd_auth_head_s *)&session->auth; skb = nlmsg_new(sizeof(data), GFP_KERNEL); nlh = nlmsg_put(skb, 0, 0, 0, sizeof(data), 0); NETLINK_CB(skb).dst_group = 1; NETLINK_CB(skb).pid = 0; /*写入数据*/ memset(&data, 0, sizeof(data)); data.ifindex = session->ifindex; data.src_addr = session->local_addr; data.dst_addr = session->remote_addr; data.state = session->state; data.event = event; data.mode = session->session_mode; data.dmti = session->packet.min_tx_interval/1000; data.rmri = session->packet.min_rx_interval/1000; data.rmeri = session->packet.min_echo_rx_interval/1000; data.detect_mult = session->packet.detect_mult; /* 认证数据 */ data.auth_type = auth_head->type; data.auth_key_id = auth_head->key_id; memcpy(data.auth_key, session->auth_key, 20); /* process */ data.process = session->process; data.degree = degree; memcpy(NLMSG_DATA(nlh), &data, sizeof(data)); if(dp_bfd_debug & DEBUG_BFD_EVENT) printk("ifindex = %x , src_addr = %x , dst_addr = %x , event = %d \n",data.ifindex,data.src_addr,data.dst_addr,data.event); /*广播*/ spin_lock(&g_bfd_skfd.lock); netlink_broadcast(g_bfd_skfd.bfd_skfd, skb, 0, 1,GFP_KERNEL); spin_unlock(&g_bfd_skfd.lock); }
/** * Control the software RF Kill switch and obtain switch status * * \param wmx WiMAX device handle * * \param state State to which you want to toggle the sofware RF Kill * switch (%WIMAX_RF_ON, %WIMAX_RF_OFF or %WIMAX_RF_QUERY for just * querying the current state of the hardware and software * switches). * * \return Negative errno code on error. Otherwise, radio kill switch * status (bit 0 \e hw switch, bit 1 \e sw switch, \e 0 OFF, \e 1 * ON): * - 3 @c 0b11: Both HW and SW switches are \e on, radio is \e on * - 2 @c 0b10: HW switch is \e off, radio is \e off * - 1 @c 0b01: SW switch is \e on, radio is \e off * - 0 @c 0b00: Both HW and SW switches are \e off, radio is \e off * * Allows the caller to control the state of the software RF Kill * switch (if present) and in return, obtain the current status of * both the hardware and software RF Kill switches. * * If there is no hardware or software switch, that switch is assumed * to be always on (radio on). * * Changing the radio state might cause the device to change state, * and cause the kernel to send reports indicating so. * * \note The state of the radio (\e ON or \e OFF) is the inverse of * the state of the RF-Kill switch (\e enabled/on kills the * radio, radio \e off; \e disabled/off allows the radio to * work, radio \e on). * * \ingroup device_management * \internal * * This implementation simply marshalls the call to the kernel's * wimax_rfkill() and returns it's return code. */ int wimaxll_rfkill(struct wimaxll_handle *wmx, enum wimax_rf_state state) { ssize_t result; struct nl_msg *msg; d_fnstart(3, wmx, "(wmx %p state %u)\n", wmx, state); result = -EBADF; if (wmx->ifidx == 0) goto error_not_any; msg = nlmsg_new(); if (msg == NULL) { result = errno; wimaxll_msg(wmx, "E: RFKILL: cannot allocate generic netlink " "message: %m\n"); goto error_msg_alloc; } if (genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, wimaxll_family_id(wmx), 0, 0, WIMAX_GNL_OP_RFKILL, WIMAX_GNL_VERSION) == NULL) { result = -ENOMEM; wimaxll_msg(wmx, "E: RFKILL: error preparing message: " "%zd 0x%08x\n", result, (unsigned int) result); goto error_msg_prep; } nla_put_u32(msg, WIMAX_GNL_RFKILL_IFIDX, (__u32) wmx->ifidx); nla_put_u32(msg, WIMAX_GNL_RFKILL_STATE, (__u32) state); result = nl_send_auto_complete(wmx->nlh_tx, msg); if (result < 0) { wimaxll_msg(wmx, "E: RFKILL: error sending message: %zd\n", result); goto error_msg_send; } /* Read the message ACK from netlink */ result = wimaxll_wait_for_ack(wmx); if (result < 0 && result != -ENODEV) wimaxll_msg(wmx, "E: RFKILL: operation failed: %zd\n", result); error_msg_prep: error_msg_send: nlmsg_free(msg); error_msg_alloc: error_not_any: d_fnend(3, wmx, "(wmx %p state %u) = %zd\n", wmx, state, result); return result; }
static int ieee802154_list_phy(struct sk_buff *skb, struct genl_info *info) { /* Request for interface name, index, type, IEEE address, PAN Id, short address */ struct sk_buff *msg; struct wpan_phy *phy; const char *name; int rc = -ENOBUFS; pr_debug("%s\n", __func__); if (!info->attrs[IEEE802154_ATTR_PHY_NAME]) return -EINVAL; name = nla_data(info->attrs[IEEE802154_ATTR_PHY_NAME]); if (name[nla_len(info->attrs[IEEE802154_ATTR_PHY_NAME]) - 1] != '\0') return -EINVAL; /* phy name should be null-terminated */ phy = wpan_phy_find(name); if (!phy) return -ENODEV; msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); if (!msg) goto out_dev; rc = ieee802154_nl_fill_phy(msg, info->snd_pid, info->snd_seq, 0, phy); if (rc < 0) goto out_free; wpan_phy_put(phy); return genlmsg_reply(msg, info); out_free: nlmsg_free(msg); out_dev: wpan_phy_put(phy); return rc; }
/* * Notify listeners of a change in port information */ void br_ifinfo_notify(int event, struct net_bridge_port *port) { struct sk_buff *skb; int err = -ENOBUFS; pr_debug("bridge notify event=%d\n", event); skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC); if (skb == NULL) goto errout; err = br_fill_ifinfo(skb, port, 0, 0, event, 0); /* failure implies BUG in br_nlmsg_size() */ BUG_ON(err < 0); err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); errout: if (err < 0) rtnl_set_sk_err(RTNLGRP_LINK, err); }
void send_cfcard_message(int level) { struct sk_buff *skb = NULL; struct nlmsghdr *nlh; struct cf_netlink_msg data; s32 ret; skb = nlmsg_new(NLMSG_SPACE(sizeof(data)), GFP_KERNEL); nlh = nlmsg_put(skb, 0, 0, 0, NLMSG_SPACE(sizeof(data)), 0); nlmsg_end(skb, nlh); NETLINK_CB(skb).dst_group = 1; NETLINK_CB(skb).pid = 0; data.log_level = level; memcpy(NLMSG_DATA(nlh), &data, sizeof(data)); ret = netlink_broadcast(g_cfcard_nl_sk, skb, 0, 1,GFP_KERNEL); return ; }