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

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

嵌入式Linux

开发平台：

Unix_Linux

ip6_queue.c：源码内容
  1. /*
  2.  * This is a module which is used for queueing IPv6 packets and
  3.  * communicating with userspace via netlink.
  4.  *
  5.  * (C) 2001 Fernando Anton, this code is GPL.
  6.  *     IPv64 Project - Work based in IPv64 draft by Arturo Azcorra.
  7.  *     Universidad Carlos III de Madrid - Leganes (Madrid) - Spain
  8.  *     Universidad Politecnica de Alcala de Henares - Alcala de H. (Madrid) - Spain
  9.  *     email: fanton@it.uc3m.es
  10.  *
  11.  * 2001-11-06: First try. Working with ip_queue.c for IPv4 and trying
  12.  *             to adapt it to IPv6
  13.  *             HEAVILY based in ipqueue.c by James Morris. It's just
  14.  *             a little modified version of it, so he's nearly the
  15.  *             real coder of this.
  16.  *             Few changes needed, mainly the hard_routing code and
  17.  *             the netlink socket protocol (we're NETLINK_IP6_FW).
  18.  *
  19.  */
  20. #include <linux/module.h>
  21. #include <linux/skbuff.h>
  22. #include <linux/init.h>
  23. #include <linux/ipv6.h>
  24. #include <linux/notifier.h>
  25. #include <linux/netdevice.h>
  26. #include <linux/netfilter.h>
  27. #include <linux/netlink.h>
  28. #include <linux/spinlock.h>
  29. #include <linux/rtnetlink.h>
  30. #include <linux/sysctl.h>
  31. #include <linux/proc_fs.h>
  32. #include <net/sock.h>
  33. #include <net/ipv6.h>
  34. #include <net/ip6_route.h>
  36. /* We're still usign the following structs. No need to change them: */
  37. /*   ipq_packet_msg                                                 */
  38. /*   ipq_mode_msg                                                   */
  39. /*   ipq_verdict_msg                                                */
  40. /*   ipq_peer_msg                                                   */
  41. #include <linux/netfilter_ipv4/ip_queue.h>
  42. #include <linux/netfilter_ipv4/ip_tables.h>
  43. #include <linux/netfilter_ipv6/ip6_tables.h>
  45. #define IPQ_QMAX_DEFAULT 1024
  46. #define IPQ_PROC_FS_NAME "ip6_queue"
  47. #define NET_IPQ_QMAX 2088
  48. #define NET_IPQ_QMAX_NAME "ip6_queue_maxlen"
  50. typedef struct ip6q_rt_info {
  51. struct in6_addr daddr;
  52. struct in6_addr saddr;
  53. } ip6q_rt_info_t;
  55. typedef struct ip6q_queue_element {
  56. struct list_head list; /* Links element into queue */
  57. int verdict; /* Current verdict */
  58. struct nf_info *info; /* Extra info from netfilter */
  59. struct sk_buff *skb; /* Packet inside */
  60. ip6q_rt_info_t rt_info; /* May need post-mangle routing */
  61. } ip6q_queue_element_t;
  63. typedef int (*ip6q_send_cb_t)(ip6q_queue_element_t *e);
  65. typedef struct ip6q_peer {
  66. pid_t pid; /* PID of userland peer */
  67. unsigned char died; /* We think the peer died */
  68. unsigned char copy_mode; /* Copy packet as well as metadata? */
  69. size_t copy_range; /* Range past metadata to copy */
  70. ip6q_send_cb_t send; /* Callback for sending data to peer */
  71. } ip6q_peer_t;
  73. typedef struct ip6q_queue {
  74.   int len; /* Current queue len */
  75.   int *maxlen; /* Maximum queue len, via sysctl */
  76.   unsigned char flushing; /* If queue is being flushed */
  77.   unsigned char terminate; /* If the queue is being terminated */
  78.   struct list_head list; /* Head of packet queue */
  79.   spinlock_t lock; /* Queue spinlock */
  80.   ip6q_peer_t peer; /* Userland peer */
  81. } ip6q_queue_t;
  83. /****************************************************************************
  84.  *
  85.  * Packet queue
  86.  *
  87.  ****************************************************************************/
  88. /* Dequeue a packet if matched by cmp, or the next available if cmp is NULL */
  89. static ip6q_queue_element_t *
  90. ip6q_dequeue(ip6q_queue_t *q,
  91.             int (*cmp)(ip6q_queue_element_t *, unsigned long),
  92.             unsigned long data)
  93. {
  94. struct list_head *i;
  96. spin_lock_bh(&q->lock);
  97. for (i = q->list.prev; i != &q->list; i = i->prev) {
  98. ip6q_queue_element_t *e = (ip6q_queue_element_t *)i;
  100. if (!cmp || cmp(e, data)) {
  101. list_del(&e->list);
  102. q->len--;
  103. spin_unlock_bh(&q->lock);
  104. return e;
  105. }
  106. }
  107. spin_unlock_bh(&q->lock);
  108. return NULL;
  109. }
  111. /* Flush all packets */
  112. static void ip6q_flush(ip6q_queue_t *q)
  113. {
  114. ip6q_queue_element_t *e;
  116. spin_lock_bh(&q->lock);
  117. q->flushing = 1;
  118. spin_unlock_bh(&q->lock);
  119. while ((e = ip6q_dequeue(q, NULL, 0))) {
  120. e->verdict = NF_DROP;
  121. nf_reinject(e->skb, e->info, e->verdict);
  122. kfree(e);
  123. }
  124. spin_lock_bh(&q->lock);
  125. q->flushing = 0;
  126. spin_unlock_bh(&q->lock);
  127. }
  129. static ip6q_queue_t *ip6q_create_queue(nf_queue_outfn_t outfn,
  130.                                      ip6q_send_cb_t send_cb,
  131.                                      int *errp, int *sysctl_qmax)
  132. {
  133. int status;
  134. ip6q_queue_t *q;
  136. *errp = 0;
  137. q = kmalloc(sizeof(ip6q_queue_t), GFP_KERNEL);
  138. if (q == NULL) {
  139. *errp = -ENOMEM;
  140. return NULL;
  141. }
  142. q->peer.pid = 0;
  143. q->peer.died = 0;
  144. q->peer.copy_mode = IPQ_COPY_NONE;
  145. q->peer.copy_range = 0;
  146. q->peer.send = send_cb;
  147. q->len = 0;
  148. q->maxlen = sysctl_qmax;
  149. q->flushing = 0;
  150. q->terminate = 0;
  151. INIT_LIST_HEAD(&q->list);
  152. spin_lock_init(&q->lock);
  153. status = nf_register_queue_handler(PF_INET6, outfn, q);
  154. if (status < 0) {
  155. *errp = -EBUSY;
  156. kfree(q);
  157. return NULL;
  158. }
  159. return q;
  160. }
  162. static int ip6q_enqueue(ip6q_queue_t *q,
  163.                        struct sk_buff *skb, struct nf_info *info)
  164. {
  165. ip6q_queue_element_t *e;
  166. int status;
  168. e = kmalloc(sizeof(*e), GFP_ATOMIC);
  169. if (e == NULL) {
  170. printk(KERN_ERR "ip6_queue: OOM in enqueuen");
  171. return -ENOMEM;
  172. }
  174. e->verdict = NF_DROP;
  175. e->info = info;
  176. e->skb = skb;
  178. if (e->info->hook == NF_IP_LOCAL_OUT) {
  179. struct ipv6hdr *iph = skb->nh.ipv6h;
  181. e->rt_info.daddr = iph->daddr;
  182. e->rt_info.saddr = iph->saddr;
  183. }
  185. spin_lock_bh(&q->lock);
  186. if (q->len >= *q->maxlen) {
  187. spin_unlock_bh(&q->lock);
  188. if (net_ratelimit()) 
  189. printk(KERN_WARNING "ip6_queue: full at %d entries, "
  190.        "dropping packet(s).n", q->len);
  191. goto free_drop;
  192. }
  193. if (q->flushing || q->peer.copy_mode == IPQ_COPY_NONE
  194.     || q->peer.pid == 0 || q->peer.died || q->terminate) {
  195. spin_unlock_bh(&q->lock);
  196. goto free_drop;
  197. }
  198. status = q->peer.send(e);
  199. if (status > 0) {
  200. list_add(&e->list, &q->list);
  201. q->len++;
  202. spin_unlock_bh(&q->lock);
  203. return status;
  204. }
  205. spin_unlock_bh(&q->lock);
  206. if (status == -ECONNREFUSED) {
  207. printk(KERN_INFO "ip6_queue: peer %d died, "
  208.        "resetting state and flushing queuen", q->peer.pid);
  209. q->peer.died = 1;
  210. q->peer.pid = 0;
  211. q->peer.copy_mode = IPQ_COPY_NONE;
  212. q->peer.copy_range = 0;
  213. ip6q_flush(q);
  214. }
  215. free_drop:
  216. kfree(e);
  217. return -EBUSY;
  218. }
  220. static void ip6q_destroy_queue(ip6q_queue_t *q)
  221. {
  222. nf_unregister_queue_handler(PF_INET6);
  223. spin_lock_bh(&q->lock);
  224. q->terminate = 1;
  225. spin_unlock_bh(&q->lock);
  226. ip6q_flush(q);
  227. kfree(q);
  228. }
  230. /*
  231.  * Taken from net/ipv6/ip6_output.c
  232.  *
  233.  * We should use the one there, but is defined static
  234.  * so we put this just here and let the things as
  235.  * they are now.
  236.  *
  237.  * If that one is modified, this one should be modified too.
  238.  */
  239. static int route6_me_harder(struct sk_buff *skb)
  240. {
  241. struct ipv6hdr *iph = skb->nh.ipv6h;
  242. struct dst_entry *dst;
  243. struct flowi fl;
  245. fl.proto = iph->nexthdr;
  246. fl.fl6_dst = &iph->daddr;
  247. fl.fl6_src = &iph->saddr;
  248. fl.oif = skb->sk ? skb->sk->bound_dev_if : 0;
  249. fl.fl6_flowlabel = 0;
  250. fl.uli_u.ports.dport = 0;
  251. fl.uli_u.ports.sport = 0;
  253. dst = ip6_route_output(skb->sk, &fl);
  255. if (dst->error) {
  256. if (net_ratelimit())
  257. printk(KERN_DEBUG "route6_me_harder: No more route.n");
  258. return -EINVAL;
  259. }
  261. /* Drop old route. */
  262. dst_release(skb->dst);
  264. skb->dst = dst;
  265. return 0;
  266. }
  267. static int ip6q_mangle_ipv6(ipq_verdict_msg_t *v, ip6q_queue_element_t *e)
  268. {
  269. int diff;
  270. struct ipv6hdr *user_iph = (struct ipv6hdr *)v->payload;
  272. if (v->data_len < sizeof(*user_iph))
  273. return 0;
  274. diff = v->data_len - e->skb->len;
  275. if (diff < 0)
  276. skb_trim(e->skb, v->data_len);
  277. else if (diff > 0) {
  278. if (v->data_len > 0xFFFF)
  279. return -EINVAL;
  280. if (diff > skb_tailroom(e->skb)) {
  281. struct sk_buff *newskb;
  283. newskb = skb_copy_expand(e->skb,
  284.                          skb_headroom(e->skb),
  285.                          diff,
  286.                          GFP_ATOMIC);
  287. if (newskb == NULL) {
  288. printk(KERN_WARNING "ip6_queue: OOM "
  289.       "in mangle, dropping packetn");
  290. return -ENOMEM;
  291. }
  292. if (e->skb->sk)
  293. skb_set_owner_w(newskb, e->skb->sk);
  294. kfree_skb(e->skb);
  295. e->skb = newskb;
  296. }
  297. skb_put(e->skb, diff);
  298. }
  299. memcpy(e->skb->data, v->payload, v->data_len);
  300. e->skb->nfcache |= NFC_ALTERED;
  302. /*
  303.  * Extra routing may needed on local out, as the QUEUE target never
  304.  * returns control to the table.
  305.          * Not a nice way to cmp, but works
  306.  */
  307. if (e->info->hook == NF_IP_LOCAL_OUT) {
  308. struct ipv6hdr *iph = e->skb->nh.ipv6h;
  309. if (!(   iph->daddr.in6_u.u6_addr32[0] == e->rt_info.daddr.in6_u.u6_addr32[0]
  310.                       && iph->daddr.in6_u.u6_addr32[1] == e->rt_info.daddr.in6_u.u6_addr32[1]
  311.                       && iph->daddr.in6_u.u6_addr32[2] == e->rt_info.daddr.in6_u.u6_addr32[2]
  312.                       && iph->daddr.in6_u.u6_addr32[3] == e->rt_info.daddr.in6_u.u6_addr32[3]
  313.       && iph->saddr.in6_u.u6_addr32[0] == e->rt_info.saddr.in6_u.u6_addr32[0]
  314.       && iph->saddr.in6_u.u6_addr32[1] == e->rt_info.saddr.in6_u.u6_addr32[1]
  315.       && iph->saddr.in6_u.u6_addr32[2] == e->rt_info.saddr.in6_u.u6_addr32[2]
  316.       && iph->saddr.in6_u.u6_addr32[3] == e->rt_info.saddr.in6_u.u6_addr32[3]))
  317. return route6_me_harder(e->skb);
  318. }
  319. return 0;
  320. }
  322. static inline int id_cmp(ip6q_queue_element_t *e, unsigned long id)
  323. {
  324. return (id == (unsigned long )e);
  325. }
  327. static int ip6q_set_verdict(ip6q_queue_t *q,
  328.                            ipq_verdict_msg_t *v, unsigned int len)
  329. {
  330. ip6q_queue_element_t *e;
  332. if (v->value > NF_MAX_VERDICT)
  333. return -EINVAL;
  334. e = ip6q_dequeue(q, id_cmp, v->id);
  335. if (e == NULL)
  336. return -ENOENT;
  337. else {
  338. e->verdict = v->value;
  339. if (v->data_len && v->data_len == len)
  340. if (ip6q_mangle_ipv6(v, e) < 0)
  341. e->verdict = NF_DROP;
  342. nf_reinject(e->skb, e->info, e->verdict);
  343. kfree(e);
  344. return 0;
  345. }
  346. }
  348. static int ip6q_receive_peer(ip6q_queue_t* q, ipq_peer_msg_t *m,
  349.                             unsigned char type, unsigned int len)
  350. {
  352. int status = 0;
  353. int busy;
  355. spin_lock_bh(&q->lock);
  356. busy = (q->terminate || q->flushing);
  357. spin_unlock_bh(&q->lock);
  358. if (busy)
  359. return -EBUSY;
  360. if (len < sizeof(ipq_peer_msg_t))
  361. return -EINVAL;
  362. switch (type) {
  363. case IPQM_MODE:
  364. switch (m->msg.mode.value) {
  365. case IPQ_COPY_META:
  366. q->peer.copy_mode = IPQ_COPY_META;
  367. q->peer.copy_range = 0;
  368. break;
  369. case IPQ_COPY_PACKET:
  370. q->peer.copy_mode = IPQ_COPY_PACKET;
  371. q->peer.copy_range = m->msg.mode.range;
  372. if (q->peer.copy_range > 0xFFFF)
  373. q->peer.copy_range = 0xFFFF;
  374. break;
  375. default:
  376. status = -EINVAL;
  377. }
  378. break;
  379. case IPQM_VERDICT:
  380. if (m->msg.verdict.value > NF_MAX_VERDICT)
  381. status = -EINVAL;
  382. else
  383. status = ip6q_set_verdict(q,
  384.                          &m->msg.verdict,
  385.                          len - sizeof(*m));
  386. break;
  387. default:
  388.  status = -EINVAL;
  389. }
  390. return status;
  391. }
  393. static inline int dev_cmp(ip6q_queue_element_t *e, unsigned long ifindex)
  394. {
  395. if (e->info->indev)
  396. if (e->info->indev->ifindex == ifindex)
  397. return 1;
  398. if (e->info->outdev)
  399. if (e->info->outdev->ifindex == ifindex)
  400. return 1;
  401. return 0;
  402. }
  404. /* Drop any queued packets associated with device ifindex */
  405. static void ip6q_dev_drop(ip6q_queue_t *q, int ifindex)
  406. {
  407. ip6q_queue_element_t *e;
  409. while ((e = ip6q_dequeue(q, dev_cmp, ifindex))) {
  410. e->verdict = NF_DROP;
  411. nf_reinject(e->skb, e->info, e->verdict);
  412. kfree(e);
  413. }
  414. }
  416. /****************************************************************************
  417.  *
  418.  * Netfilter interface
  419.  *
  420.  ****************************************************************************/
  422. /*
  423.  * Packets arrive here from netfilter for queuing to userspace.
  424.  * All of them must be fed back via nf_reinject() or Alexey will kill Rusty.
  425.  */
  426. static int netfilter6_receive(struct sk_buff *skb,
  427.                              struct nf_info *info, void *data)
  428. {
  429. return ip6q_enqueue((ip6q_queue_t *)data, skb, info);
  430. }
  432. /****************************************************************************
  433.  *
  434.  * Netlink interface.
  435.  *
  436.  ****************************************************************************/
  438. static struct sock *nfnl = NULL;
  439. /* This is not a static one, so we should not repeat its name */
  440. ip6q_queue_t *nlq6 = NULL;
  442. static struct sk_buff *netlink_build_message(ip6q_queue_element_t *e, int *errp)
  443. {
  444. unsigned char *old_tail;
  445. size_t size = 0;
  446. size_t data_len = 0;
  447. struct sk_buff *skb;
  448. ipq_packet_msg_t *pm;
  449. struct nlmsghdr *nlh;
  451. switch (nlq6->peer.copy_mode) {
  452. size_t copy_range;
  454. case IPQ_COPY_META:
  455. size = NLMSG_SPACE(sizeof(*pm));
  456. data_len = 0;
  457. break;
  458. case IPQ_COPY_PACKET:
  459. copy_range = nlq6->peer.copy_range;
  460. if (copy_range == 0 || copy_range > e->skb->len)
  461. data_len = e->skb->len;
  462. else
  463. data_len = copy_range;
  464. size = NLMSG_SPACE(sizeof(*pm) + data_len);
  466. break;
  467. case IPQ_COPY_NONE:
  468. default:
  469. *errp = -EINVAL;
  470. return NULL;
  471. }
  472. skb = alloc_skb(size, GFP_ATOMIC);
  473. if (!skb)
  474. goto nlmsg_failure;
  475. old_tail = skb->tail;
  476. nlh = NLMSG_PUT(skb, 0, 0, IPQM_PACKET, size - sizeof(*nlh));
  477. pm = NLMSG_DATA(nlh);
  478. memset(pm, 0, sizeof(*pm));
  479. pm->packet_id = (unsigned long )e;
  480. pm->data_len = data_len;
  481. pm->timestamp_sec = e->skb->stamp.tv_sec;
  482. pm->timestamp_usec = e->skb->stamp.tv_usec;
  483. pm->mark = e->skb->nfmark;
  484. pm->hook = e->info->hook;
  485. if (e->info->indev) strcpy(pm->indev_name, e->info->indev->name);
  486. else pm->indev_name[0] = '';
  487. if (e->info->outdev) strcpy(pm->outdev_name, e->info->outdev->name);
  488. else pm->outdev_name[0] = '';
  489. pm->hw_protocol = e->skb->protocol;
  490. if (e->info->indev && e->skb->dev) {
  491. pm->hw_type = e->skb->dev->type;
  492. if (e->skb->dev->hard_header_parse)
  493. pm->hw_addrlen =
  494. e->skb->dev->hard_header_parse(e->skb,
  495.                                pm->hw_addr);
  496. }
  497. if (data_len)
  498. memcpy(pm->payload, e->skb->data, data_len);
  499. nlh->nlmsg_len = skb->tail - old_tail;
  500. NETLINK_CB(skb).dst_groups = 0;
  501. return skb;
  502. nlmsg_failure:
  503. if (skb)
  504. kfree_skb(skb);
  505. *errp = 0;
  506. printk(KERN_ERR "ip6_queue: error creating netlink messagen");
  507. return NULL;
  508. }
  510. static int netlink_send_peer(ip6q_queue_element_t *e)
  511. {
  512. int status = 0;
  513. struct sk_buff *skb;
  515. skb = netlink_build_message(e, &status);
  516. if (skb == NULL)
  517. return status;
  518. return netlink_unicast(nfnl, skb, nlq6->peer.pid, MSG_DONTWAIT);
  519. }
  521. #define RCV_SKB_FAIL(err) do { netlink_ack(skb, nlh, (err)); return; } while (0);
  523. static __inline__ void netlink_receive_user_skb(struct sk_buff *skb)
  524. {
  525. int status, type;
  526. struct nlmsghdr *nlh;
  528. if (skb->len < sizeof(struct nlmsghdr))
  529. return;
  531. nlh = (struct nlmsghdr *)skb->data;
  532. if (nlh->nlmsg_len < sizeof(struct nlmsghdr)
  533.     || skb->len < nlh->nlmsg_len)
  534.      return;
  536. if(nlh->nlmsg_pid <= 0
  537.     || !(nlh->nlmsg_flags & NLM_F_REQUEST)
  538.     || nlh->nlmsg_flags & NLM_F_MULTI)
  539. RCV_SKB_FAIL(-EINVAL);
  540. if (nlh->nlmsg_flags & MSG_TRUNC)
  541. RCV_SKB_FAIL(-ECOMM);
  542. type = nlh->nlmsg_type;
  543. if (type < NLMSG_NOOP || type >= IPQM_MAX)
  544. RCV_SKB_FAIL(-EINVAL);
  545. if (type <= IPQM_BASE)
  546. return;
  547. if(!cap_raised(NETLINK_CB(skb).eff_cap, CAP_NET_ADMIN))
  548. RCV_SKB_FAIL(-EPERM);
  549. if (nlq6->peer.pid && !nlq6->peer.died
  550.     && (nlq6->peer.pid != nlh->nlmsg_pid)) {
  551.      printk(KERN_WARNING "ip6_queue: peer pid changed from %d to "
  552.            "%d, flushing queuen", nlq6->peer.pid, nlh->nlmsg_pid);
  553. ip6q_flush(nlq6);
  554. }
  555. nlq6->peer.pid = nlh->nlmsg_pid;
  556. nlq6->peer.died = 0;
  557. status = ip6q_receive_peer(nlq6, NLMSG_DATA(nlh),
  558.                           type, skb->len - NLMSG_LENGTH(0));
  559. if (status < 0)
  560. RCV_SKB_FAIL(status);
  561. if (nlh->nlmsg_flags & NLM_F_ACK)
  562. netlink_ack(skb, nlh, 0);
  563.         return;
  564. }
  566. /* Note: we are only dealing with single part messages at the moment. */
  567. static void netlink_receive_user_sk(struct sock *sk, int len)
  568. {
  569. do {
  570. struct sk_buff *skb;
  572. if (rtnl_shlock_nowait())
  573. return;
  574. while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
  575. netlink_receive_user_skb(skb);
  576. kfree_skb(skb);
  577. }
  578. up(&rtnl_sem);
  579. } while (nfnl && nfnl->receive_queue.qlen);
  580. }
  582. /****************************************************************************
  583.  *
  584.  * System events
  585.  *
  586.  ****************************************************************************/
  588. static int receive_event(struct notifier_block *this,
  589.                          unsigned long event, void *ptr)
  590. {
  591. struct net_device *dev = ptr;
  593. /* Drop any packets associated with the downed device */
  594. if (event == NETDEV_DOWN)
  595. ip6q_dev_drop(nlq6, dev->ifindex);
  596. return NOTIFY_DONE;
  597. }
  599. struct notifier_block ip6q_dev_notifier = {
  600. receive_event,
  601. NULL,
  602. 0
  603. };
  605. /****************************************************************************
  606.  *
  607.  * Sysctl - queue tuning.
  608.  *
  609.  ****************************************************************************/
  611. static int sysctl_maxlen = IPQ_QMAX_DEFAULT;
  613. static struct ctl_table_header *ip6q_sysctl_header;
  615. static ctl_table ip6q_table[] = {
  616. { NET_IPQ_QMAX, NET_IPQ_QMAX_NAME, &sysctl_maxlen,
  617.   sizeof(sysctl_maxlen), 0644,  NULL, proc_dointvec },
  618.   { 0 }
  619. };
  621. static ctl_table ip6q_dir_table[] = {
  622. {NET_IPV6, "ipv6", NULL, 0, 0555, ip6q_table, 0, 0, 0, 0, 0},
  623. { 0 }
  624. };
  626. static ctl_table ip6q_root_table[] = {
  627. {CTL_NET, "net", NULL, 0, 0555, ip6q_dir_table, 0, 0, 0, 0, 0},
  628. { 0 }
  629. };
  631. /****************************************************************************
  632.  *
  633.  * Procfs - debugging info.
  634.  *
  635.  ****************************************************************************/
  637. static int ip6q_get_info(char *buffer, char **start, off_t offset, int length)
  638. {
  639. int len;
  641. spin_lock_bh(&nlq6->lock);
  642. len = sprintf(buffer,
  643.               "Peer pid            : %dn"
  644.               "Peer died           : %dn"
  645.               "Peer copy mode      : %dn"
  646.               "Peer copy range     : %Zun"
  647.               "Queue length        : %dn"
  648.               "Queue max. length   : %dn"
  649.               "Queue flushing      : %dn"
  650.               "Queue terminate     : %dn",
  651.               nlq6->peer.pid,
  652.               nlq6->peer.died,
  653.               nlq6->peer.copy_mode,
  654.               nlq6->peer.copy_range,
  655.               nlq6->len,
  656.               *nlq6->maxlen,
  657.               nlq6->flushing,
  658.               nlq6->terminate);
  659. spin_unlock_bh(&nlq6->lock);
  660. *start = buffer + offset;
  661. len -= offset;
  662. if (len > length)
  663. len = length;
  664. else if (len < 0)
  665. len = 0;
  666. return len;
  667. }
  669. /****************************************************************************
  670.  *
  671.  * Module stuff.
  672.  *
  673.  ****************************************************************************/
  675. static int __init init(void)
  676. {
  677. int status = 0;
  678. struct proc_dir_entry *proc;
  680.         /* We must create the NETLINK_IP6_FW protocol service */
  681. nfnl = netlink_kernel_create(NETLINK_IP6_FW, netlink_receive_user_sk);
  682. if (nfnl == NULL) {
  683. printk(KERN_ERR "ip6_queue: initialisation failed: unable to "
  684.        "create kernel netlink socketn");
  685. return -ENOMEM;
  686. }
  687. nlq6 = ip6q_create_queue(netfilter6_receive,
  688.                        netlink_send_peer, &status, &sysctl_maxlen);
  689. if (nlq6 == NULL) {
  690. printk(KERN_ERR "ip6_queue: initialisation failed: unable to "
  691.        "create queuen");
  692. sock_release(nfnl->socket);
  693. return status;
  694. }
  695.         /* The file will be /proc/net/ip6_queue */
  696. proc = proc_net_create(IPQ_PROC_FS_NAME, 0, ip6q_get_info);
  697. if (proc) proc->owner = THIS_MODULE;
  698. else {
  699. ip6q_destroy_queue(nlq6);
  700. sock_release(nfnl->socket);
  701. return -ENOMEM;
  702. }
  703. register_netdevice_notifier(&ip6q_dev_notifier);
  704. ip6q_sysctl_header = register_sysctl_table(ip6q_root_table, 0);
  705. return status;
  706. }
  708. static void __exit fini(void)
  709. {
  710. unregister_sysctl_table(ip6q_sysctl_header);
  711. proc_net_remove(IPQ_PROC_FS_NAME);
  712. unregister_netdevice_notifier(&ip6q_dev_notifier);
  713. ip6q_destroy_queue(nlq6);
  714. sock_release(nfnl->socket);
  715. }
  717. MODULE_DESCRIPTION("IPv6 packet queue handler");
  718. MODULE_LICENSE("GPL");
  720. module_init(init);
  721. module_exit(fini);