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

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

嵌入式Linux

开发平台：

Unix_Linux

ip_queue.c：源码内容
  1. /*
  2.  * This is a module which is used for queueing IPv4 packets and
  3.  * communicating with userspace via netlink.
  4.  *
  5.  * (C) 2000 James Morris, this code is GPL.
  6.  *
  7.  * 2000-03-27: Simplified code (thanks to Andi Kleen for clues).
  8.  * 2000-05-20: Fixed notifier problems (following Miguel Freitas' report).
  9.  * 2000-06-19: Fixed so nfmark is copied to metadata (reported by Sebastian 
  10.  *             Zander).
  11.  * 2000-08-01: Added Nick Williams' MAC support.
  12.  *
  13.  */
  14. #include <linux/module.h>
  15. #include <linux/skbuff.h>
  16. #include <linux/init.h>
  17. #include <linux/ip.h>
  18. #include <linux/notifier.h>
  19. #include <linux/netdevice.h>
  20. #include <linux/netfilter.h>
  21. #include <linux/netlink.h>
  22. #include <linux/spinlock.h>
  23. #include <linux/rtnetlink.h>
  24. #include <linux/sysctl.h>
  25. #include <linux/proc_fs.h>
  26. #include <net/sock.h>
  27. #include <net/route.h>
  29. #include <linux/netfilter_ipv4/ip_queue.h>
  30. #include <linux/netfilter_ipv4/ip_tables.h>
  32. #define IPQ_QMAX_DEFAULT 1024
  33. #define IPQ_PROC_FS_NAME "ip_queue"
  34. #define NET_IPQ_QMAX 2088
  35. #define NET_IPQ_QMAX_NAME "ip_queue_maxlen"
  37. typedef struct ipq_rt_info {
  38. __u8 tos;
  39. __u32 daddr;
  40. __u32 saddr;
  41. } ipq_rt_info_t;
  43. typedef struct ipq_queue_element {
  44. struct list_head list; /* Links element into queue */
  45. int verdict; /* Current verdict */
  46. struct nf_info *info; /* Extra info from netfilter */
  47. struct sk_buff *skb; /* Packet inside */
  48. ipq_rt_info_t rt_info; /* May need post-mangle routing */
  49. } ipq_queue_element_t;
  51. typedef int (*ipq_send_cb_t)(ipq_queue_element_t *e);
  53. typedef struct ipq_peer {
  54. pid_t pid; /* PID of userland peer */
  55. unsigned char died; /* We think the peer died */
  56. unsigned char copy_mode; /* Copy packet as well as metadata? */
  57. size_t copy_range; /* Range past metadata to copy */
  58. ipq_send_cb_t send; /* Callback for sending data to peer */
  59. } ipq_peer_t;
  61. typedef struct ipq_queue {
  62.   int len; /* Current queue len */
  63.   int *maxlen; /* Maximum queue len, via sysctl */
  64.   unsigned char flushing; /* If queue is being flushed */
  65.   unsigned char terminate; /* If the queue is being terminated */
  66.   struct list_head list; /* Head of packet queue */
  67.   spinlock_t lock; /* Queue spinlock */
  68.   ipq_peer_t peer; /* Userland peer */
  69. } ipq_queue_t;
  71. /****************************************************************************
  72.  *
  73.  * Packet queue
  74.  *
  75.  ****************************************************************************/
  76. /* Dequeue a packet if matched by cmp, or the next available if cmp is NULL */
  77. static ipq_queue_element_t *
  78. ipq_dequeue(ipq_queue_t *q,
  79.             int (*cmp)(ipq_queue_element_t *, unsigned long),
  80.             unsigned long data)
  81. {
  82. struct list_head *i;
  84. spin_lock_bh(&q->lock);
  85. for (i = q->list.prev; i != &q->list; i = i->prev) {
  86. ipq_queue_element_t *e = (ipq_queue_element_t *)i;
  88. if (!cmp || cmp(e, data)) {
  89. list_del(&e->list);
  90. q->len--;
  91. spin_unlock_bh(&q->lock);
  92. return e;
  93. }
  94. }
  95. spin_unlock_bh(&q->lock);
  96. return NULL;
  97. }
  99. /* Flush all packets */
  100. static void ipq_flush(ipq_queue_t *q)
  101. {
  102. ipq_queue_element_t *e;
  104. spin_lock_bh(&q->lock);
  105. q->flushing = 1;
  106. spin_unlock_bh(&q->lock);
  107. while ((e = ipq_dequeue(q, NULL, 0))) {
  108. e->verdict = NF_DROP;
  109. nf_reinject(e->skb, e->info, e->verdict);
  110. kfree(e);
  111. }
  112. spin_lock_bh(&q->lock);
  113. q->flushing = 0;
  114. spin_unlock_bh(&q->lock);
  115. }
  117. static ipq_queue_t *ipq_create_queue(nf_queue_outfn_t outfn,
  118.                                      ipq_send_cb_t send_cb,
  119.                                      int *errp, int *sysctl_qmax)
  120. {
  121. int status;
  122. ipq_queue_t *q;
  124. *errp = 0;
  125. q = kmalloc(sizeof(ipq_queue_t), GFP_KERNEL);
  126. if (q == NULL) {
  127. *errp = -ENOMEM;
  128. return NULL;
  129. }
  130. q->peer.pid = 0;
  131. q->peer.died = 0;
  132. q->peer.copy_mode = IPQ_COPY_NONE;
  133. q->peer.copy_range = 0;
  134. q->peer.send = send_cb;
  135. q->len = 0;
  136. q->maxlen = sysctl_qmax;
  137. q->flushing = 0;
  138. q->terminate = 0;
  139. INIT_LIST_HEAD(&q->list);
  140. spin_lock_init(&q->lock);
  141. status = nf_register_queue_handler(PF_INET, outfn, q);
  142. if (status < 0) {
  143. *errp = -EBUSY;
  144. kfree(q);
  145. return NULL;
  146. }
  147. return q;
  148. }
  150. static int ipq_enqueue(ipq_queue_t *q,
  151.                        struct sk_buff *skb, struct nf_info *info)
  152. {
  153. ipq_queue_element_t *e;
  154. int status;
  156. e = kmalloc(sizeof(*e), GFP_ATOMIC);
  157. if (e == NULL) {
  158. printk(KERN_ERR "ip_queue: OOM in enqueuen");
  159. return -ENOMEM;
  160. }
  162. e->verdict = NF_DROP;
  163. e->info = info;
  164. e->skb = skb;
  166. if (e->info->hook == NF_IP_LOCAL_OUT) {
  167. struct iphdr *iph = skb->nh.iph;
  169. e->rt_info.tos = iph->tos;
  170. e->rt_info.daddr = iph->daddr;
  171. e->rt_info.saddr = iph->saddr;
  172. }
  174. spin_lock_bh(&q->lock);
  175. if (q->len >= *q->maxlen) {
  176. spin_unlock_bh(&q->lock);
  177. if (net_ratelimit()) 
  178. printk(KERN_WARNING "ip_queue: full at %d entries, "
  179.        "dropping packet(s).n", q->len);
  180. goto free_drop;
  181. }
  182. if (q->flushing || q->peer.copy_mode == IPQ_COPY_NONE
  183.     || q->peer.pid == 0 || q->peer.died || q->terminate) {
  184. spin_unlock_bh(&q->lock);
  185. goto free_drop;
  186. }
  187. status = q->peer.send(e);
  188. if (status > 0) {
  189. list_add(&e->list, &q->list);
  190. q->len++;
  191. spin_unlock_bh(&q->lock);
  192. return status;
  193. }
  194. spin_unlock_bh(&q->lock);
  195. if (status == -ECONNREFUSED) {
  196. printk(KERN_INFO "ip_queue: peer %d died, "
  197.        "resetting state and flushing queuen", q->peer.pid);
  198. q->peer.died = 1;
  199. q->peer.pid = 0;
  200. q->peer.copy_mode = IPQ_COPY_NONE;
  201. q->peer.copy_range = 0;
  202. ipq_flush(q);
  203. }
  204. free_drop:
  205. kfree(e);
  206. return -EBUSY;
  207. }
  209. static void ipq_destroy_queue(ipq_queue_t *q)
  210. {
  211. nf_unregister_queue_handler(PF_INET);
  212. spin_lock_bh(&q->lock);
  213. q->terminate = 1;
  214. spin_unlock_bh(&q->lock);
  215. ipq_flush(q);
  216. kfree(q);
  217. }
  219. static int ipq_mangle_ipv4(ipq_verdict_msg_t *v, ipq_queue_element_t *e)
  220. {
  221. int diff;
  222. struct iphdr *user_iph = (struct iphdr *)v->payload;
  224. if (v->data_len < sizeof(*user_iph))
  225. return 0;
  226. diff = v->data_len - e->skb->len;
  227. if (diff < 0)
  228. skb_trim(e->skb, v->data_len);
  229. else if (diff > 0) {
  230. if (v->data_len > 0xFFFF)
  231. return -EINVAL;
  232. if (diff > skb_tailroom(e->skb)) {
  233. struct sk_buff *newskb;
  235. newskb = skb_copy_expand(e->skb,
  236.                          skb_headroom(e->skb),
  237.                          diff,
  238.                          GFP_ATOMIC);
  239. if (newskb == NULL) {
  240. printk(KERN_WARNING "ip_queue: OOM "
  241.       "in mangle, dropping packetn");
  242. return -ENOMEM;
  243. }
  244. if (e->skb->sk)
  245. skb_set_owner_w(newskb, e->skb->sk);
  246. kfree_skb(e->skb);
  247. e->skb = newskb;
  248. }
  249. skb_put(e->skb, diff);
  250. }
  251. memcpy(e->skb->data, v->payload, v->data_len);
  252. e->skb->nfcache |= NFC_ALTERED;
  254. /*
  255.  * Extra routing may needed on local out, as the QUEUE target never
  256.  * returns control to the table.
  257.  */
  258. if (e->info->hook == NF_IP_LOCAL_OUT) {
  259. struct iphdr *iph = e->skb->nh.iph;
  261. if (!(iph->tos == e->rt_info.tos
  262.       && iph->daddr == e->rt_info.daddr
  263.       && iph->saddr == e->rt_info.saddr))
  264. return ip_route_me_harder(&e->skb);
  265. }
  266. return 0;
  267. }
  269. static inline int id_cmp(ipq_queue_element_t *e, unsigned long id)
  270. {
  271. return (id == (unsigned long )e);
  272. }
  274. static int ipq_set_verdict(ipq_queue_t *q,
  275.                            ipq_verdict_msg_t *v, unsigned int len)
  276. {
  277. ipq_queue_element_t *e;
  279. if (v->value > NF_MAX_VERDICT)
  280. return -EINVAL;
  281. e = ipq_dequeue(q, id_cmp, v->id);
  282. if (e == NULL)
  283. return -ENOENT;
  284. else {
  285. e->verdict = v->value;
  286. if (v->data_len && v->data_len == len)
  287. if (ipq_mangle_ipv4(v, e) < 0)
  288. e->verdict = NF_DROP;
  289. nf_reinject(e->skb, e->info, e->verdict);
  290. kfree(e);
  291. return 0;
  292. }
  293. }
  295. static int ipq_receive_peer(ipq_queue_t *q, ipq_peer_msg_t *m,
  296.                             unsigned char type, unsigned int len)
  297. {
  299. int status = 0;
  300. int busy;
  302. spin_lock_bh(&q->lock);
  303. busy = (q->terminate || q->flushing);
  304. spin_unlock_bh(&q->lock);
  305. if (busy)
  306. return -EBUSY;
  307. if (len < sizeof(ipq_peer_msg_t))
  308. return -EINVAL;
  309. switch (type) {
  310. case IPQM_MODE:
  311. switch (m->msg.mode.value) {
  312. case IPQ_COPY_META:
  313. q->peer.copy_mode = IPQ_COPY_META;
  314. q->peer.copy_range = 0;
  315. break;
  316. case IPQ_COPY_PACKET:
  317. q->peer.copy_mode = IPQ_COPY_PACKET;
  318. q->peer.copy_range = m->msg.mode.range;
  319. if (q->peer.copy_range > 0xFFFF)
  320. q->peer.copy_range = 0xFFFF;
  321. break;
  322. default:
  323. status = -EINVAL;
  324. }
  325. break;
  326. case IPQM_VERDICT:
  327. if (m->msg.verdict.value > NF_MAX_VERDICT)
  328. status = -EINVAL;
  329. else
  330. status = ipq_set_verdict(q,
  331.                          &m->msg.verdict,
  332.                          len - sizeof(*m));
  333. break;
  334. default:
  335.  status = -EINVAL;
  336. }
  337. return status;
  338. }
  340. static inline int dev_cmp(ipq_queue_element_t *e, unsigned long ifindex)
  341. {
  342. if (e->info->indev)
  343. if (e->info->indev->ifindex == ifindex)
  344. return 1;
  345. if (e->info->outdev)
  346. if (e->info->outdev->ifindex == ifindex)
  347. return 1;
  348. return 0;
  349. }
  351. /* Drop any queued packets associated with device ifindex */
  352. static void ipq_dev_drop(ipq_queue_t *q, int ifindex)
  353. {
  354. ipq_queue_element_t *e;
  356. while ((e = ipq_dequeue(q, dev_cmp, ifindex))) {
  357. e->verdict = NF_DROP;
  358. nf_reinject(e->skb, e->info, e->verdict);
  359. kfree(e);
  360. }
  361. }
  363. /****************************************************************************
  364.  *
  365.  * Netfilter interface
  366.  *
  367.  ****************************************************************************/
  369. /*
  370.  * Packets arrive here from netfilter for queuing to userspace.
  371.  * All of them must be fed back via nf_reinject() or Alexey will kill Rusty.
  372.  */
  373. static int netfilter_receive(struct sk_buff *skb,
  374.                              struct nf_info *info, void *data)
  375. {
  376. return ipq_enqueue((ipq_queue_t *)data, skb, info);
  377. }
  379. /****************************************************************************
  380.  *
  381.  * Netlink interface.
  382.  *
  383.  ****************************************************************************/
  385. static struct sock *nfnl = NULL;
  386. ipq_queue_t *nlq = NULL;
  388. static struct sk_buff *netlink_build_message(ipq_queue_element_t *e, int *errp)
  389. {
  390. unsigned char *old_tail;
  391. size_t size = 0;
  392. size_t data_len = 0;
  393. struct sk_buff *skb;
  394. ipq_packet_msg_t *pm;
  395. struct nlmsghdr *nlh;
  397. switch (nlq->peer.copy_mode) {
  398. size_t copy_range;
  400. case IPQ_COPY_META:
  401. size = NLMSG_SPACE(sizeof(*pm));
  402. data_len = 0;
  403. break;
  404. case IPQ_COPY_PACKET:
  405. copy_range = nlq->peer.copy_range;
  406. if (copy_range == 0 || copy_range > e->skb->len)
  407. data_len = e->skb->len;
  408. else
  409. data_len = copy_range;
  410. size = NLMSG_SPACE(sizeof(*pm) + data_len);
  412. break;
  413. case IPQ_COPY_NONE:
  414. default:
  415. *errp = -EINVAL;
  416. return NULL;
  417. }
  418. skb = alloc_skb(size, GFP_ATOMIC);
  419. if (!skb)
  420. goto nlmsg_failure;
  421. old_tail = skb->tail;
  422. nlh = NLMSG_PUT(skb, 0, 0, IPQM_PACKET, size - sizeof(*nlh));
  423. pm = NLMSG_DATA(nlh);
  424. memset(pm, 0, sizeof(*pm));
  425. pm->packet_id = (unsigned long )e;
  426. pm->data_len = data_len;
  427. pm->timestamp_sec = e->skb->stamp.tv_sec;
  428. pm->timestamp_usec = e->skb->stamp.tv_usec;
  429. pm->mark = e->skb->nfmark;
  430. pm->hook = e->info->hook;
  431. if (e->info->indev) strcpy(pm->indev_name, e->info->indev->name);
  432. else pm->indev_name[0] = '';
  433. if (e->info->outdev) strcpy(pm->outdev_name, e->info->outdev->name);
  434. else pm->outdev_name[0] = '';
  435. pm->hw_protocol = e->skb->protocol;
  436. if (e->info->indev && e->skb->dev) {
  437. pm->hw_type = e->skb->dev->type;
  438. if (e->skb->dev->hard_header_parse)
  439. pm->hw_addrlen =
  440. e->skb->dev->hard_header_parse(e->skb,
  441.                                pm->hw_addr);
  442. }
  443. if (data_len)
  444. memcpy(pm->payload, e->skb->data, data_len);
  445. nlh->nlmsg_len = skb->tail - old_tail;
  446. NETLINK_CB(skb).dst_groups = 0;
  447. return skb;
  448. nlmsg_failure:
  449. if (skb)
  450. kfree_skb(skb);
  451. *errp = 0;
  452. printk(KERN_ERR "ip_queue: error creating netlink messagen");
  453. return NULL;
  454. }
  456. static int netlink_send_peer(ipq_queue_element_t *e)
  457. {
  458. int status = 0;
  459. struct sk_buff *skb;
  461. skb = netlink_build_message(e, &status);
  462. if (skb == NULL)
  463. return status;
  464. return netlink_unicast(nfnl, skb, nlq->peer.pid, MSG_DONTWAIT);
  465. }
  467. #define RCV_SKB_FAIL(err) do { netlink_ack(skb, nlh, (err)); return; } while (0);
  469. static __inline__ void netlink_receive_user_skb(struct sk_buff *skb)
  470. {
  471. int status, type;
  472. struct nlmsghdr *nlh;
  474. if (skb->len < sizeof(struct nlmsghdr))
  475. return;
  477. nlh = (struct nlmsghdr *)skb->data;
  478. if (nlh->nlmsg_len < sizeof(struct nlmsghdr)
  479.     || skb->len < nlh->nlmsg_len)
  480.      return;
  482. if(nlh->nlmsg_pid <= 0
  483.     || !(nlh->nlmsg_flags & NLM_F_REQUEST)
  484.     || nlh->nlmsg_flags & NLM_F_MULTI)
  485. RCV_SKB_FAIL(-EINVAL);
  486. if (nlh->nlmsg_flags & MSG_TRUNC)
  487. RCV_SKB_FAIL(-ECOMM);
  488. type = nlh->nlmsg_type;
  489. if (type < NLMSG_NOOP || type >= IPQM_MAX)
  490. RCV_SKB_FAIL(-EINVAL);
  491. if (type <= IPQM_BASE)
  492. return;
  493. if(!cap_raised(NETLINK_CB(skb).eff_cap, CAP_NET_ADMIN))
  494. RCV_SKB_FAIL(-EPERM);
  495. if (nlq->peer.pid && !nlq->peer.died
  496.     && (nlq->peer.pid != nlh->nlmsg_pid)) {
  497.      printk(KERN_WARNING "ip_queue: peer pid changed from %d to "
  498.            "%d, flushing queuen", nlq->peer.pid, nlh->nlmsg_pid);
  499. ipq_flush(nlq);
  500. }
  501. nlq->peer.pid = nlh->nlmsg_pid;
  502. nlq->peer.died = 0;
  503. status = ipq_receive_peer(nlq, NLMSG_DATA(nlh),
  504.                           type, skb->len - NLMSG_LENGTH(0));
  505. if (status < 0)
  506. RCV_SKB_FAIL(status);
  507. if (nlh->nlmsg_flags & NLM_F_ACK)
  508. netlink_ack(skb, nlh, 0);
  509.         return;
  510. }
  512. /* Note: we are only dealing with single part messages at the moment. */
  513. static void netlink_receive_user_sk(struct sock *sk, int len)
  514. {
  515. do {
  516. struct sk_buff *skb;
  518. if (rtnl_shlock_nowait())
  519. return;
  520. while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
  521. netlink_receive_user_skb(skb);
  522. kfree_skb(skb);
  523. }
  524. up(&rtnl_sem);
  525. } while (nfnl && nfnl->receive_queue.qlen);
  526. }
  528. /****************************************************************************
  529.  *
  530.  * System events
  531.  *
  532.  ****************************************************************************/
  534. static int receive_event(struct notifier_block *this,
  535.                          unsigned long event, void *ptr)
  536. {
  537. struct net_device *dev = ptr;
  539. /* Drop any packets associated with the downed device */
  540. if (event == NETDEV_DOWN)
  541. ipq_dev_drop(nlq, dev->ifindex);
  542. return NOTIFY_DONE;
  543. }
  545. struct notifier_block ipq_dev_notifier = {
  546. receive_event,
  547. NULL,
  548. 0
  549. };
  551. /****************************************************************************
  552.  *
  553.  * Sysctl - queue tuning.
  554.  *
  555.  ****************************************************************************/
  557. static int sysctl_maxlen = IPQ_QMAX_DEFAULT;
  559. static struct ctl_table_header *ipq_sysctl_header;
  561. static ctl_table ipq_table[] = {
  562. { NET_IPQ_QMAX, NET_IPQ_QMAX_NAME, &sysctl_maxlen,
  563.   sizeof(sysctl_maxlen), 0644,  NULL, proc_dointvec },
  564.   { 0 }
  565. };
  567. static ctl_table ipq_dir_table[] = {
  568. {NET_IPV4, "ipv4", NULL, 0, 0555, ipq_table, 0, 0, 0, 0, 0},
  569. { 0 }
  570. };
  572. static ctl_table ipq_root_table[] = {
  573. {CTL_NET, "net", NULL, 0, 0555, ipq_dir_table, 0, 0, 0, 0, 0},
  574. { 0 }
  575. };
  577. /****************************************************************************
  578.  *
  579.  * Procfs - debugging info.
  580.  *
  581.  ****************************************************************************/
  583. static int ipq_get_info(char *buffer, char **start, off_t offset, int length)
  584. {
  585. int len;
  587. spin_lock_bh(&nlq->lock);
  588. len = sprintf(buffer,
  589.               "Peer pid            : %dn"
  590.               "Peer died           : %dn"
  591.               "Peer copy mode      : %dn"
  592.               "Peer copy range     : %Zun"
  593.               "Queue length        : %dn"
  594.               "Queue max. length   : %dn"
  595.               "Queue flushing      : %dn"
  596.               "Queue terminate     : %dn",
  597.               nlq->peer.pid,
  598.               nlq->peer.died,
  599.               nlq->peer.copy_mode,
  600.               nlq->peer.copy_range,
  601.               nlq->len,
  602.               *nlq->maxlen,
  603.               nlq->flushing,
  604.               nlq->terminate);
  605. spin_unlock_bh(&nlq->lock);
  606. *start = buffer + offset;
  607. len -= offset;
  608. if (len > length)
  609. len = length;
  610. else if (len < 0)
  611. len = 0;
  612. return len;
  613. }
  615. /****************************************************************************
  616.  *
  617.  * Module stuff.
  618.  *
  619.  ****************************************************************************/
  621. static int __init init(void)
  622. {
  623. int status = 0;
  624. struct proc_dir_entry *proc;
  626. nfnl = netlink_kernel_create(NETLINK_FIREWALL, netlink_receive_user_sk);
  627. if (nfnl == NULL) {
  628. printk(KERN_ERR "ip_queue: initialisation failed: unable to "
  629.        "create kernel netlink socketn");
  630. return -ENOMEM;
  631. }
  632. nlq = ipq_create_queue(netfilter_receive,
  633.                        netlink_send_peer, &status, &sysctl_maxlen);
  634. if (nlq == NULL) {
  635. printk(KERN_ERR "ip_queue: initialisation failed: unable to "
  636.        "create queuen");
  637. sock_release(nfnl->socket);
  638. return status;
  639. }
  640. proc = proc_net_create(IPQ_PROC_FS_NAME, 0, ipq_get_info);
  641. if (proc) proc->owner = THIS_MODULE;
  642. else {
  643. ipq_destroy_queue(nlq);
  644. sock_release(nfnl->socket);
  645. return -ENOMEM;
  646. }
  647. register_netdevice_notifier(&ipq_dev_notifier);
  648. ipq_sysctl_header = register_sysctl_table(ipq_root_table, 0);
  649. return status;
  650. }
  652. static void __exit fini(void)
  653. {
  654. unregister_sysctl_table(ipq_sysctl_header);
  655. proc_net_remove(IPQ_PROC_FS_NAME);
  656. unregister_netdevice_notifier(&ipq_dev_notifier);
  657. ipq_destroy_queue(nlq);
  658. sock_release(nfnl->socket);
  659. }
  661. MODULE_DESCRIPTION("IPv4 packet queue handler");
  662. MODULE_LICENSE("GPL");
  664. module_init(init);
  665. module_exit(fini);