开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
af_netlink.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：22k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

af_netlink.c：源码内容
  1. /*
  2.  * NETLINK      Kernel-user communication protocol.
  3.  *
  4.  *  Authors: Alan Cox <alan@redhat.com>
  5.  *  Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  6.  *
  7.  * This program is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License
  9.  * as published by the Free Software Foundation; either version
  10.  * 2 of the License, or (at your option) any later version.
  11.  * 
  12.  * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
  13.  *                               added netlink_proto_exit
  14.  *
  15.  */
  17. #include <linux/config.h>
  18. #include <linux/module.h>
  20. #include <linux/kernel.h>
  21. #include <linux/init.h>
  22. #include <linux/major.h>
  23. #include <linux/signal.h>
  24. #include <linux/sched.h>
  25. #include <linux/errno.h>
  26. #include <linux/string.h>
  27. #include <linux/stat.h>
  28. #include <linux/socket.h>
  29. #include <linux/un.h>
  30. #include <linux/fcntl.h>
  31. #include <linux/termios.h>
  32. #include <linux/sockios.h>
  33. #include <linux/net.h>
  34. #include <linux/fs.h>
  35. #include <linux/slab.h>
  36. #include <asm/uaccess.h>
  37. #include <linux/skbuff.h>
  38. #include <linux/netdevice.h>
  39. #include <linux/rtnetlink.h>
  40. #include <linux/proc_fs.h>
  41. #include <linux/smp_lock.h>
  42. #include <net/sock.h>
  43. #include <net/scm.h>
  45. #define Nprintk(a...)
  47. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  48. #define NL_EMULATE_DEV
  49. #endif
  51. struct netlink_opt
  52. {
  53. u32 pid;
  54. unsigned groups;
  55. u32 dst_pid;
  56. unsigned dst_groups;
  57. unsigned long state;
  58. int (*handler)(int unit, struct sk_buff *skb);
  59. wait_queue_head_t wait;
  60. struct netlink_callback *cb;
  61. spinlock_t cb_lock;
  62. void (*data_ready)(struct sock *sk, int bytes);
  63. };
  65. static struct sock *nl_table[MAX_LINKS];
  66. static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
  68. #ifdef NL_EMULATE_DEV
  69. static struct socket *netlink_kernel[MAX_LINKS];
  70. #endif
  72. static int netlink_dump(struct sock *sk);
  73. static void netlink_destroy_callback(struct netlink_callback *cb);
  75. atomic_t netlink_sock_nr;
  77. static rwlock_t nl_table_lock = RW_LOCK_UNLOCKED;
  78. static atomic_t nl_table_users = ATOMIC_INIT(0);
  80. static void netlink_sock_destruct(struct sock *sk)
  81. {
  82. skb_queue_purge(&sk->receive_queue);
  84. if (!sk->dead) {
  85. printk("Freeing alive netlink socket %pn", sk);
  86. return;
  87. }
  88. BUG_TRAP(atomic_read(&sk->rmem_alloc)==0);
  89. BUG_TRAP(atomic_read(&sk->wmem_alloc)==0);
  90. BUG_TRAP(sk->protinfo.af_netlink->cb==NULL);
  92. kfree(sk->protinfo.af_netlink);
  94. atomic_dec(&netlink_sock_nr);
  95. #ifdef NETLINK_REFCNT_DEBUG
  96. printk(KERN_DEBUG "NETLINK %p released, %d are still aliven", sk, atomic_read(&netlink_sock_nr));
  97. #endif
  98. }
  100. /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on SMP.
  101.  * Look, when several writers sleep and reader wakes them up, all but one
  102.  * immediately hit write lock and grab all the cpus. Exclusive sleep solves
  103.  * this, _but_ remember, it adds useless work on UP machines.
  104.  */
  106. static void netlink_table_grab(void)
  107. {
  108. write_lock_bh(&nl_table_lock);
  110. if (atomic_read(&nl_table_users)) {
  111. DECLARE_WAITQUEUE(wait, current);
  113. add_wait_queue_exclusive(&nl_table_wait, &wait);
  114. for(;;) {
  115. set_current_state(TASK_UNINTERRUPTIBLE);
  116. if (atomic_read(&nl_table_users) == 0)
  117. break;
  118. write_unlock_bh(&nl_table_lock);
  119. schedule();
  120. write_lock_bh(&nl_table_lock);
  121. }
  123. __set_current_state(TASK_RUNNING);
  124. remove_wait_queue(&nl_table_wait, &wait);
  125. }
  126. }
  128. static __inline__ void netlink_table_ungrab(void)
  129. {
  130. write_unlock_bh(&nl_table_lock);
  131. wake_up(&nl_table_wait);
  132. }
  134. static __inline__ void
  135. netlink_lock_table(void)
  136. {
  137. /* read_lock() synchronizes us to netlink_table_grab */
  139. read_lock(&nl_table_lock);
  140. atomic_inc(&nl_table_users);
  141. read_unlock(&nl_table_lock);
  142. }
  144. static __inline__ void
  145. netlink_unlock_table(void)
  146. {
  147. if (atomic_dec_and_test(&nl_table_users))
  148. wake_up(&nl_table_wait);
  149. }
  151. static __inline__ struct sock *netlink_lookup(int protocol, u32 pid)
  152. {
  153. struct sock *sk;
  155. read_lock(&nl_table_lock);
  156. for (sk=nl_table[protocol]; sk; sk=sk->next) {
  157. if (sk->protinfo.af_netlink->pid == pid) {
  158. sock_hold(sk);
  159. read_unlock(&nl_table_lock);
  160. return sk;
  161. }
  162. }
  164. read_unlock(&nl_table_lock);
  165. return NULL;
  166. }
  168. extern struct proto_ops netlink_ops;
  170. static int netlink_insert(struct sock *sk, u32 pid)
  171. {
  172. int err = -EADDRINUSE;
  173. struct sock *osk;
  175. netlink_table_grab();
  176. for (osk=nl_table[sk->protocol]; osk; osk=osk->next) {
  177. if (osk->protinfo.af_netlink->pid == pid)
  178. break;
  179. }
  180. if (osk == NULL) {
  181. err = -EBUSY;
  182. if (sk->protinfo.af_netlink->pid == 0) {
  183. sk->protinfo.af_netlink->pid = pid;
  184. sk->next = nl_table[sk->protocol];
  185. nl_table[sk->protocol] = sk;
  186. sock_hold(sk);
  187. err = 0;
  188. }
  189. }
  190. netlink_table_ungrab();
  191. return err;
  192. }
  194. static void netlink_remove(struct sock *sk)
  195. {
  196. struct sock **skp;
  198. netlink_table_grab();
  199. for (skp = &nl_table[sk->protocol]; *skp; skp = &((*skp)->next)) {
  200. if (*skp == sk) {
  201. *skp = sk->next;
  202. __sock_put(sk);
  203. break;
  204. }
  205. }
  206. netlink_table_ungrab();
  207. }
  209. static int netlink_create(struct socket *sock, int protocol)
  210. {
  211. struct sock *sk;
  213. sock->state = SS_UNCONNECTED;
  215. if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
  216. return -ESOCKTNOSUPPORT;
  218. if (protocol<0 || protocol >= MAX_LINKS)
  219. return -EPROTONOSUPPORT;
  221. sock->ops = &netlink_ops;
  223. sk = sk_alloc(PF_NETLINK, GFP_KERNEL, 1);
  224. if (!sk)
  225. return -ENOMEM;
  227. sock_init_data(sock,sk);
  229. sk->protinfo.af_netlink = kmalloc(sizeof(struct netlink_opt), GFP_KERNEL);
  230. if (sk->protinfo.af_netlink == NULL) {
  231. sk_free(sk);
  232. return -ENOMEM;
  233. }
  234. memset(sk->protinfo.af_netlink, 0, sizeof(struct netlink_opt));
  236. spin_lock_init(&sk->protinfo.af_netlink->cb_lock);
  237. init_waitqueue_head(&sk->protinfo.af_netlink->wait);
  238. sk->destruct = netlink_sock_destruct;
  239. atomic_inc(&netlink_sock_nr);
  241. sk->protocol=protocol;
  242. return 0;
  243. }
  245. static int netlink_release(struct socket *sock)
  246. {
  247. struct sock *sk = sock->sk;
  249. if (!sk)
  250. return 0;
  252. netlink_remove(sk);
  254. spin_lock(&sk->protinfo.af_netlink->cb_lock);
  255. if (sk->protinfo.af_netlink->cb) {
  256. sk->protinfo.af_netlink->cb->done(sk->protinfo.af_netlink->cb);
  257. netlink_destroy_callback(sk->protinfo.af_netlink->cb);
  258. sk->protinfo.af_netlink->cb = NULL;
  259. __sock_put(sk);
  260. }
  261. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  263. /* OK. Socket is unlinked, and, therefore,
  264.    no new packets will arrive */
  266. sock_orphan(sk);
  267. sock->sk = NULL;
  268. wake_up_interruptible_all(&sk->protinfo.af_netlink->wait);
  270. skb_queue_purge(&sk->write_queue);
  272. sock_put(sk);
  273. return 0;
  274. }
  276. static int netlink_autobind(struct socket *sock)
  277. {
  278. struct sock *sk = sock->sk;
  279. struct sock *osk;
  280. s32 pid = current->pid;
  281. int err;
  283. retry:
  284. netlink_table_grab();
  285. for (osk=nl_table[sk->protocol]; osk; osk=osk->next) {
  286. if (osk->protinfo.af_netlink->pid == pid) {
  287. /* Bind collision, search negative pid values. */
  288. if (pid > 0)
  289. pid = -4096;
  290. pid--;
  291. netlink_table_ungrab();
  292. goto retry;
  293. }
  294. }
  295. netlink_table_ungrab();
  297. err = netlink_insert(sk, pid);
  298. if (err == -EADDRINUSE)
  299. goto retry;
  300. sk->protinfo.af_netlink->groups = 0;
  301. return 0;
  302. }
  304. static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
  305. {
  306. struct sock *sk = sock->sk;
  307. int err;
  308. struct sockaddr_nl *nladdr=(struct sockaddr_nl *)addr;
  310. if (nladdr->nl_family != AF_NETLINK)
  311. return -EINVAL;
  313. /* Only superuser is allowed to listen multicasts */
  314. if (nladdr->nl_groups && !capable(CAP_NET_ADMIN))
  315. return -EPERM;
  317. if (sk->protinfo.af_netlink->pid) {
  318. if (nladdr->nl_pid != sk->protinfo.af_netlink->pid)
  319. return -EINVAL;
  320. sk->protinfo.af_netlink->groups = nladdr->nl_groups;
  321. return 0;
  322. }
  324. if (nladdr->nl_pid == 0) {
  325. err = netlink_autobind(sock);
  326. if (err == 0)
  327. sk->protinfo.af_netlink->groups = nladdr->nl_groups;
  328. return err;
  329. }
  331. err = netlink_insert(sk, nladdr->nl_pid);
  332. if (err == 0)
  333. sk->protinfo.af_netlink->groups = nladdr->nl_groups;
  334. return err;
  335. }
  337. static int netlink_connect(struct socket *sock, struct sockaddr *addr,
  338.    int alen, int flags)
  339. {
  340. int err = 0;
  341. struct sock *sk = sock->sk;
  342. struct sockaddr_nl *nladdr=(struct sockaddr_nl*)addr;
  344. if (addr->sa_family == AF_UNSPEC) {
  345. sk->protinfo.af_netlink->dst_pid = 0;
  346. sk->protinfo.af_netlink->dst_groups = 0;
  347. return 0;
  348. }
  349. if (addr->sa_family != AF_NETLINK)
  350. return -EINVAL;
  352. /* Only superuser is allowed to send multicasts */
  353. if (nladdr->nl_groups && !capable(CAP_NET_ADMIN))
  354. return -EPERM;
  356. if (!sk->protinfo.af_netlink->pid)
  357. err = netlink_autobind(sock);
  359. if (err == 0) {
  360. sk->protinfo.af_netlink->dst_pid = nladdr->nl_pid;
  361. sk->protinfo.af_netlink->dst_groups = nladdr->nl_groups;
  362. }
  364. return 0;
  365. }
  367. static int netlink_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
  368. {
  369. struct sock *sk = sock->sk;
  370. struct sockaddr_nl *nladdr=(struct sockaddr_nl *)addr;
  372. nladdr->nl_family = AF_NETLINK;
  373. *addr_len = sizeof(*nladdr);
  375. if (peer) {
  376. nladdr->nl_pid = sk->protinfo.af_netlink->dst_pid;
  377. nladdr->nl_groups = sk->protinfo.af_netlink->dst_groups;
  378. } else {
  379. nladdr->nl_pid = sk->protinfo.af_netlink->pid;
  380. nladdr->nl_groups = sk->protinfo.af_netlink->groups;
  381. }
  382. return 0;
  383. }
  385. static void netlink_overrun(struct sock *sk)
  386. {
  387. if (!test_and_set_bit(0, &sk->protinfo.af_netlink->state)) {
  388. sk->err = ENOBUFS;
  389. sk->error_report(sk);
  390. }
  391. }
  393. int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock)
  394. {
  395. struct sock *sk;
  396. int len = skb->len;
  397. int protocol = ssk->protocol;
  398. long timeo;
  399.         DECLARE_WAITQUEUE(wait, current);
  401. timeo = sock_sndtimeo(ssk, nonblock);
  403. retry:
  404. sk = netlink_lookup(protocol, pid);
  405. if (sk == NULL)
  406. goto no_dst;
  408. #ifdef NL_EMULATE_DEV
  409. if (sk->protinfo.af_netlink->handler) {
  410. skb_orphan(skb);
  411. len = sk->protinfo.af_netlink->handler(protocol, skb);
  412. sock_put(sk);
  413. return len;
  414. }
  415. #endif
  417. if (atomic_read(&sk->rmem_alloc) > sk->rcvbuf ||
  418.     test_bit(0, &sk->protinfo.af_netlink->state)) {
  419. if (!timeo) {
  420. if (ssk->protinfo.af_netlink->pid == 0)
  421. netlink_overrun(sk);
  422. sock_put(sk);
  423. kfree_skb(skb);
  424. return -EAGAIN;
  425. }
  427. __set_current_state(TASK_INTERRUPTIBLE);
  428. add_wait_queue(&sk->protinfo.af_netlink->wait, &wait);
  430. if ((atomic_read(&sk->rmem_alloc) > sk->rcvbuf ||
  431.     test_bit(0, &sk->protinfo.af_netlink->state)) &&
  432.     !sk->dead)
  433. timeo = schedule_timeout(timeo);
  435. __set_current_state(TASK_RUNNING);
  436. remove_wait_queue(&sk->protinfo.af_netlink->wait, &wait);
  437. sock_put(sk);
  439. if (signal_pending(current)) {
  440. kfree_skb(skb);
  441. return sock_intr_errno(timeo);
  442. }
  443. goto retry;
  444. }
  446. skb_orphan(skb);
  447. skb_set_owner_r(skb, sk);
  448. skb_queue_tail(&sk->receive_queue, skb);
  449. sk->data_ready(sk, len);
  450. sock_put(sk);
  451. return len;
  453. no_dst:
  454. kfree_skb(skb);
  455. return -ECONNREFUSED;
  456. }
  458. static __inline__ int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
  459. {
  460. #ifdef NL_EMULATE_DEV
  461. if (sk->protinfo.af_netlink->handler) {
  462. skb_orphan(skb);
  463. sk->protinfo.af_netlink->handler(sk->protocol, skb);
  464. return 0;
  465. } else
  466. #endif
  467. if (atomic_read(&sk->rmem_alloc) <= sk->rcvbuf &&
  468.     !test_bit(0, &sk->protinfo.af_netlink->state)) {
  469.                 skb_orphan(skb);
  470. skb_set_owner_r(skb, sk);
  471. skb_queue_tail(&sk->receive_queue, skb);
  472. sk->data_ready(sk, skb->len);
  473. return 0;
  474. }
  475. return -1;
  476. }
  478. void netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
  479.        u32 group, int allocation)
  480. {
  481. struct sock *sk;
  482. struct sk_buff *skb2 = NULL;
  483. int protocol = ssk->protocol;
  484. int failure = 0;
  486. /* While we sleep in clone, do not allow to change socket list */
  488. netlink_lock_table();
  490. for (sk = nl_table[protocol]; sk; sk = sk->next) {
  491. if (ssk == sk)
  492. continue;
  494. if (sk->protinfo.af_netlink->pid == pid ||
  495.     !(sk->protinfo.af_netlink->groups&group))
  496. continue;
  498. if (failure) {
  499. netlink_overrun(sk);
  500. continue;
  501. }
  503. sock_hold(sk);
  504. if (skb2 == NULL) {
  505. if (atomic_read(&skb->users) != 1) {
  506. skb2 = skb_clone(skb, allocation);
  507. } else {
  508. skb2 = skb;
  509. atomic_inc(&skb->users);
  510. }
  511. }
  512. if (skb2 == NULL) {
  513. netlink_overrun(sk);
  514. /* Clone failed. Notify ALL listeners. */
  515. failure = 1;
  516. } else if (netlink_broadcast_deliver(sk, skb2)) {
  517. netlink_overrun(sk);
  518. } else
  519. skb2 = NULL;
  520. sock_put(sk);
  521. }
  523. netlink_unlock_table();
  525. if (skb2)
  526. kfree_skb(skb2);
  527. kfree_skb(skb);
  528. }
  530. void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
  531. {
  532. struct sock *sk;
  533. int protocol = ssk->protocol;
  535. read_lock(&nl_table_lock);
  536. for (sk = nl_table[protocol]; sk; sk = sk->next) {
  537. if (ssk == sk)
  538. continue;
  540. if (sk->protinfo.af_netlink->pid == pid ||
  541.     !(sk->protinfo.af_netlink->groups&group))
  542. continue;
  544. sk->err = code;
  545. sk->error_report(sk);
  546. }
  547. read_unlock(&nl_table_lock);
  548. }
  550. static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, int len,
  551.    struct scm_cookie *scm)
  552. {
  553. struct sock *sk = sock->sk;
  554. struct sockaddr_nl *addr=msg->msg_name;
  555. u32 dst_pid;
  556. u32 dst_groups;
  557. struct sk_buff *skb;
  558. int err;
  560. if (msg->msg_flags&MSG_OOB)
  561. return -EOPNOTSUPP;
  563. if (msg->msg_namelen) {
  564. if (addr->nl_family != AF_NETLINK)
  565. return -EINVAL;
  566. dst_pid = addr->nl_pid;
  567. dst_groups = addr->nl_groups;
  568. if (dst_groups && !capable(CAP_NET_ADMIN))
  569. return -EPERM;
  570. } else {
  571. dst_pid = sk->protinfo.af_netlink->dst_pid;
  572. dst_groups = sk->protinfo.af_netlink->dst_groups;
  573. }
  575. if (!sk->protinfo.af_netlink->pid) {
  576. err = netlink_autobind(sock);
  577. if (err)
  578. goto out;
  579. }
  581. err = -EMSGSIZE;
  582. if ((unsigned)len > sk->sndbuf-32)
  583. goto out;
  584. err = -ENOBUFS;
  585. skb = alloc_skb(len, GFP_KERNEL);
  586. if (skb==NULL)
  587. goto out;
  589. NETLINK_CB(skb).pid = sk->protinfo.af_netlink->pid;
  590. NETLINK_CB(skb).groups = sk->protinfo.af_netlink->groups;
  591. NETLINK_CB(skb).dst_pid = dst_pid;
  592. NETLINK_CB(skb).dst_groups = dst_groups;
  593. memcpy(NETLINK_CREDS(skb), &scm->creds, sizeof(struct ucred));
  595. /* What can I do? Netlink is asynchronous, so that
  596.    we will have to save current capabilities to
  597.    check them, when this message will be delivered
  598.    to corresponding kernel module.   --ANK (980802)
  599.  */
  600. NETLINK_CB(skb).eff_cap = current->cap_effective;
  602. err = -EFAULT;
  603. if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) {
  604. kfree_skb(skb);
  605. goto out;
  606. }
  608. if (dst_groups) {
  609. atomic_inc(&skb->users);
  610. netlink_broadcast(sk, skb, dst_pid, dst_groups, GFP_KERNEL);
  611. }
  612. err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
  614. out:
  615. return err;
  616. }
  618. static int netlink_recvmsg(struct socket *sock, struct msghdr *msg, int len,
  619.    int flags, struct scm_cookie *scm)
  620. {
  621. struct sock *sk = sock->sk;
  622. int noblock = flags&MSG_DONTWAIT;
  623. int copied;
  624. struct sk_buff *skb;
  625. int err;
  627. if (flags&MSG_OOB)
  628. return -EOPNOTSUPP;
  630. copied = 0;
  632. skb = skb_recv_datagram(sk,flags,noblock,&err);
  633. if (skb==NULL)
  634. goto out;
  636. msg->msg_namelen = 0;
  638. copied = skb->len;
  639. if (len < copied) {
  640. msg->msg_flags |= MSG_TRUNC;
  641. copied = len;
  642. }
  644. skb->h.raw = skb->data;
  645. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  647. if (msg->msg_name) {
  648. struct sockaddr_nl *addr = (struct sockaddr_nl*)msg->msg_name;
  649. addr->nl_family = AF_NETLINK;
  650. addr->nl_pid = NETLINK_CB(skb).pid;
  651. addr->nl_groups = NETLINK_CB(skb).dst_groups;
  652. msg->msg_namelen = sizeof(*addr);
  653. }
  655. scm->creds = *NETLINK_CREDS(skb);
  656. skb_free_datagram(sk, skb);
  658. if (sk->protinfo.af_netlink->cb
  659.     && atomic_read(&sk->rmem_alloc) <= sk->rcvbuf/2)
  660. netlink_dump(sk);
  662. out:
  663. if (skb_queue_len(&sk->receive_queue) <= sk->rcvbuf/2) {
  664. if (skb_queue_len(&sk->receive_queue) == 0)
  665. clear_bit(0, &sk->protinfo.af_netlink->state);
  666. if (!test_bit(0, &sk->protinfo.af_netlink->state))
  667. wake_up_interruptible(&sk->protinfo.af_netlink->wait);
  668. }
  669. return err ? : copied;
  670. }
  672. void netlink_data_ready(struct sock *sk, int len)
  673. {
  674. if (sk->protinfo.af_netlink->data_ready)
  675. sk->protinfo.af_netlink->data_ready(sk, len);
  677. if (skb_queue_len(&sk->receive_queue) <= sk->rcvbuf/2) {
  678. if (skb_queue_len(&sk->receive_queue) == 0)
  679. clear_bit(0, &sk->protinfo.af_netlink->state);
  680. if (!test_bit(0, &sk->protinfo.af_netlink->state))
  681. wake_up_interruptible(&sk->protinfo.af_netlink->wait);
  682. }
  683. }
  685. /*
  686.  * We export these functions to other modules. They provide a 
  687.  * complete set of kernel non-blocking support for message
  688.  * queueing.
  689.  */
  691. struct sock *
  692. netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len))
  693. {
  694. struct socket *sock;
  695. struct sock *sk;
  697. if (unit<0 || unit>=MAX_LINKS)
  698. return NULL;
  700. if (!(sock = sock_alloc())) 
  701. return NULL;
  703. sock->type = SOCK_RAW;
  705. if (netlink_create(sock, unit) < 0) {
  706. sock_release(sock);
  707. return NULL;
  708. }
  709. sk = sock->sk;
  710. sk->data_ready = netlink_data_ready;
  711. if (input)
  712. sk->protinfo.af_netlink->data_ready = input;
  714. netlink_insert(sk, 0);
  715. return sk;
  716. }
  718. static void netlink_destroy_callback(struct netlink_callback *cb)
  719. {
  720. if (cb->skb)
  721. kfree_skb(cb->skb);
  722. kfree(cb);
  723. }
  725. /*
  726.  * It looks a bit ugly.
  727.  * It would be better to create kernel thread.
  728.  */
  730. static int netlink_dump(struct sock *sk)
  731. {
  732. struct netlink_callback *cb;
  733. struct sk_buff *skb;
  734. struct nlmsghdr *nlh;
  735. int len;
  737. skb = sock_rmalloc(sk, NLMSG_GOODSIZE, 0, GFP_KERNEL);
  738. if (!skb)
  739. return -ENOBUFS;
  741. spin_lock(&sk->protinfo.af_netlink->cb_lock);
  743. cb = sk->protinfo.af_netlink->cb;
  744. if (cb == NULL) {
  745. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  746. kfree_skb(skb);
  747. return -EINVAL;
  748. }
  750. len = cb->dump(skb, cb);
  752. if (len > 0) {
  753. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  754. skb_queue_tail(&sk->receive_queue, skb);
  755. sk->data_ready(sk, len);
  756. return 0;
  757. }
  759. nlh = __nlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, NLMSG_DONE, sizeof(int));
  760. nlh->nlmsg_flags |= NLM_F_MULTI;
  761. memcpy(NLMSG_DATA(nlh), &len, sizeof(len));
  762. skb_queue_tail(&sk->receive_queue, skb);
  763. sk->data_ready(sk, skb->len);
  765. cb->done(cb);
  766. sk->protinfo.af_netlink->cb = NULL;
  767. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  769. netlink_destroy_callback(cb);
  770. sock_put(sk);
  771. return 0;
  772. }
  774. int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
  775.        struct nlmsghdr *nlh,
  776.        int (*dump)(struct sk_buff *skb, struct netlink_callback*),
  777.        int (*done)(struct netlink_callback*))
  778. {
  779. struct netlink_callback *cb;
  780. struct sock *sk;
  782. cb = kmalloc(sizeof(*cb), GFP_KERNEL);
  783. if (cb == NULL)
  784. return -ENOBUFS;
  786. memset(cb, 0, sizeof(*cb));
  787. cb->dump = dump;
  788. cb->done = done;
  789. cb->nlh = nlh;
  790. atomic_inc(&skb->users);
  791. cb->skb = skb;
  793. sk = netlink_lookup(ssk->protocol, NETLINK_CB(skb).pid);
  794. if (sk == NULL) {
  795. netlink_destroy_callback(cb);
  796. return -ECONNREFUSED;
  797. }
  798. /* A dump is in progress... */
  799. spin_lock(&sk->protinfo.af_netlink->cb_lock);
  800. if (sk->protinfo.af_netlink->cb) {
  801. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  802. netlink_destroy_callback(cb);
  803. sock_put(sk);
  804. return -EBUSY;
  805. }
  806. sk->protinfo.af_netlink->cb = cb;
  807. spin_unlock(&sk->protinfo.af_netlink->cb_lock);
  809. netlink_dump(sk);
  810. return 0;
  811. }
  813. void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
  814. {
  815. struct sk_buff *skb;
  816. struct nlmsghdr *rep;
  817. struct nlmsgerr *errmsg;
  818. int size;
  820. if (err == 0)
  821. size = NLMSG_SPACE(sizeof(struct nlmsgerr));
  822. else
  823. size = NLMSG_SPACE(4 + NLMSG_ALIGN(nlh->nlmsg_len));
  825. skb = alloc_skb(size, GFP_KERNEL);
  826. if (!skb)
  827. return;
  829. rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
  830.   NLMSG_ERROR, sizeof(struct nlmsgerr));
  831. errmsg = NLMSG_DATA(rep);
  832. errmsg->error = err;
  833. memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(struct nlmsghdr));
  834. netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
  835. }
  838. #ifdef NL_EMULATE_DEV
  840. static rwlock_t nl_emu_lock = RW_LOCK_UNLOCKED;
  842. /*
  843.  * Backward compatibility.
  844.  */
  845.  
  846. int netlink_attach(int unit, int (*function)(int, struct sk_buff *skb))
  847. {
  848. struct sock *sk = netlink_kernel_create(unit, NULL);
  849. if (sk == NULL)
  850. return -ENOBUFS;
  851. sk->protinfo.af_netlink->handler = function;
  852. write_lock_bh(&nl_emu_lock);
  853. netlink_kernel[unit] = sk->socket;
  854. write_unlock_bh(&nl_emu_lock);
  855. return 0;
  856. }
  858. void netlink_detach(int unit)
  859. {
  860. struct socket *sock;
  862. write_lock_bh(&nl_emu_lock);
  863. sock = netlink_kernel[unit];
  864. netlink_kernel[unit] = NULL;
  865. write_unlock_bh(&nl_emu_lock);
  867. sock_release(sock);
  868. }
  870. int netlink_post(int unit, struct sk_buff *skb)
  871. {
  872. struct socket *sock;
  874. read_lock(&nl_emu_lock);
  875. sock = netlink_kernel[unit];
  876. if (sock) {
  877. struct sock *sk = sock->sk;
  878. memset(skb->cb, 0, sizeof(skb->cb));
  879. sock_hold(sk);
  880. read_unlock(&nl_emu_lock);
  882. netlink_broadcast(sk, skb, 0, ~0, GFP_ATOMIC);
  884. sock_put(sk);
  885. return 0;
  886. }
  887. read_unlock(&nl_emu_lock);
  888. return -EUNATCH;
  889. }
  891. #endif
  894. #ifdef CONFIG_PROC_FS
  895. static int netlink_read_proc(char *buffer, char **start, off_t offset,
  896.      int length, int *eof, void *data)
  897. {
  898. off_t pos=0;
  899. off_t begin=0;
  900. int len=0;
  901. int i;
  902. struct sock *s;
  904. len+= sprintf(buffer,"sk       Eth Pid    Groups   "
  905.       "Rmem     Wmem     Dump     Locksn");
  907. for (i=0; i<MAX_LINKS; i++) {
  908. read_lock(&nl_table_lock);
  909. for (s = nl_table[i]; s; s = s->next) {
  910. len+=sprintf(buffer+len,"%p %-3d %-6d %08x %-8d %-8d %p %d",
  911.      s,
  912.      s->protocol,
  913.      s->protinfo.af_netlink->pid,
  914.      s->protinfo.af_netlink->groups,
  915.      atomic_read(&s->rmem_alloc),
  916.      atomic_read(&s->wmem_alloc),
  917.      s->protinfo.af_netlink->cb,
  918.      atomic_read(&s->refcnt)
  919.      );
  921. buffer[len++]='n';
  923. pos=begin+len;
  924. if(pos<offset) {
  925. len=0;
  926. begin=pos;
  927. }
  928. if(pos>offset+length) {
  929. read_unlock(&nl_table_lock);
  930. goto done;
  931. }
  932. }
  933. read_unlock(&nl_table_lock);
  934. }
  935. *eof = 1;
  937. done:
  938. *start=buffer+(offset-begin);
  939. len-=(offset-begin);
  940. if(len>length)
  941. len=length;
  942. if(len<0)
  943. len=0;
  944. return len;
  945. }
  946. #endif
  948. struct proto_ops netlink_ops = {
  949. family: PF_NETLINK,
  951. release: netlink_release,
  952. bind: netlink_bind,
  953. connect: netlink_connect,
  954. socketpair: sock_no_socketpair,
  955. accept: sock_no_accept,
  956. getname: netlink_getname,
  957. poll: datagram_poll,
  958. ioctl: sock_no_ioctl,
  959. listen: sock_no_listen,
  960. shutdown: sock_no_shutdown,
  961. setsockopt: sock_no_setsockopt,
  962. getsockopt: sock_no_getsockopt,
  963. sendmsg: netlink_sendmsg,
  964. recvmsg: netlink_recvmsg,
  965. mmap: sock_no_mmap,
  966. sendpage: sock_no_sendpage,
  967. };
  969. struct net_proto_family netlink_family_ops = {
  970. PF_NETLINK,
  971. netlink_create
  972. };
  974. static int __init netlink_proto_init(void)
  975. {
  976. struct sk_buff *dummy_skb;
  978. if (sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb)) {
  979. printk(KERN_CRIT "netlink_init: panicn");
  980. return -1;
  981. }
  982. sock_register(&netlink_family_ops);
  983. #ifdef CONFIG_PROC_FS
  984. create_proc_read_entry("net/netlink", 0, 0, netlink_read_proc, NULL);
  985. #endif
  986. return 0;
  987. }
  989. static void __exit netlink_proto_exit(void)
  990. {
  991.        sock_unregister(PF_NETLINK);
  992.        remove_proc_entry("net/netlink", NULL);
  993. }
  995. module_init(netlink_proto_init);
  996. module_exit(netlink_proto_exit);