]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/ipv4/tcp_diag.c
2 * tcp_diag.c Module for monitoring TCP sockets.
4 * Version: $Id: tcp_diag.c,v 1.3 2002/02/01 22:01:04 davem Exp $
6 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/config.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/fcntl.h>
18 #include <linux/random.h>
19 #include <linux/cache.h>
20 #include <linux/init.h>
21 #include <linux/time.h>
26 #include <net/inet_common.h>
28 #include <linux/inet.h>
29 #include <linux/stddef.h>
31 #include <linux/tcp_diag.h>
43 static struct sock
*tcpnl
;
45 #define TCPDIAG_PUT(skb, attrtype, attrlen) \
46 RTA_DATA(__RTA_PUT(skb, attrtype, attrlen))
48 static int tcpdiag_fill(struct sk_buff
*skb
, struct sock
*sk
,
49 int ext
, u32 pid
, u32 seq
, u16 nlmsg_flags
)
51 struct inet_sock
*inet
= inet_sk(sk
);
52 struct tcp_sock
*tp
= tcp_sk(sk
);
55 struct tcp_info
*info
= NULL
;
56 struct tcpdiag_meminfo
*minfo
= NULL
;
57 unsigned char *b
= skb
->tail
;
59 nlh
= NLMSG_PUT(skb
, pid
, seq
, TCPDIAG_GETSOCK
, sizeof(*r
));
60 nlh
->nlmsg_flags
= nlmsg_flags
;
62 if (sk
->sk_state
!= TCP_TIME_WAIT
) {
63 if (ext
& (1<<(TCPDIAG_MEMINFO
-1)))
64 minfo
= TCPDIAG_PUT(skb
, TCPDIAG_MEMINFO
, sizeof(*minfo
));
65 if (ext
& (1<<(TCPDIAG_INFO
-1)))
66 info
= TCPDIAG_PUT(skb
, TCPDIAG_INFO
, sizeof(*info
));
68 if (ext
& (1<<(TCPDIAG_CONG
-1))) {
69 size_t len
= strlen(tp
->ca_ops
->name
);
70 strcpy(TCPDIAG_PUT(skb
, TCPDIAG_CONG
, len
+1),
74 r
->tcpdiag_family
= sk
->sk_family
;
75 r
->tcpdiag_state
= sk
->sk_state
;
77 r
->tcpdiag_retrans
= 0;
79 r
->id
.tcpdiag_if
= sk
->sk_bound_dev_if
;
80 r
->id
.tcpdiag_cookie
[0] = (u32
)(unsigned long)sk
;
81 r
->id
.tcpdiag_cookie
[1] = (u32
)(((unsigned long)sk
>> 31) >> 1);
83 if (r
->tcpdiag_state
== TCP_TIME_WAIT
) {
84 const struct inet_timewait_sock
*tw
= inet_twsk(sk
);
85 long tmo
= tw
->tw_ttd
- jiffies
;
89 r
->id
.tcpdiag_sport
= tw
->tw_sport
;
90 r
->id
.tcpdiag_dport
= tw
->tw_dport
;
91 r
->id
.tcpdiag_src
[0] = tw
->tw_rcv_saddr
;
92 r
->id
.tcpdiag_dst
[0] = tw
->tw_daddr
;
93 r
->tcpdiag_state
= tw
->tw_substate
;
95 r
->tcpdiag_expires
= (tmo
*1000+HZ
-1)/HZ
;
96 r
->tcpdiag_rqueue
= 0;
97 r
->tcpdiag_wqueue
= 0;
100 #ifdef CONFIG_IP_TCPDIAG_IPV6
101 if (r
->tcpdiag_family
== AF_INET6
) {
102 const struct tcp6_timewait_sock
*tcp6tw
= tcp6_twsk(sk
);
104 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
105 &tcp6tw
->tw_v6_rcv_saddr
);
106 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
107 &tcp6tw
->tw_v6_daddr
);
110 nlh
->nlmsg_len
= skb
->tail
- b
;
114 r
->id
.tcpdiag_sport
= inet
->sport
;
115 r
->id
.tcpdiag_dport
= inet
->dport
;
116 r
->id
.tcpdiag_src
[0] = inet
->rcv_saddr
;
117 r
->id
.tcpdiag_dst
[0] = inet
->daddr
;
119 #ifdef CONFIG_IP_TCPDIAG_IPV6
120 if (r
->tcpdiag_family
== AF_INET6
) {
121 struct ipv6_pinfo
*np
= inet6_sk(sk
);
123 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
125 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
130 #define EXPIRES_IN_MS(tmo) ((tmo-jiffies)*1000+HZ-1)/HZ
132 if (tp
->pending
== TCP_TIME_RETRANS
) {
133 r
->tcpdiag_timer
= 1;
134 r
->tcpdiag_retrans
= tp
->retransmits
;
135 r
->tcpdiag_expires
= EXPIRES_IN_MS(tp
->timeout
);
136 } else if (tp
->pending
== TCP_TIME_PROBE0
) {
137 r
->tcpdiag_timer
= 4;
138 r
->tcpdiag_retrans
= tp
->probes_out
;
139 r
->tcpdiag_expires
= EXPIRES_IN_MS(tp
->timeout
);
140 } else if (timer_pending(&sk
->sk_timer
)) {
141 r
->tcpdiag_timer
= 2;
142 r
->tcpdiag_retrans
= tp
->probes_out
;
143 r
->tcpdiag_expires
= EXPIRES_IN_MS(sk
->sk_timer
.expires
);
145 r
->tcpdiag_timer
= 0;
146 r
->tcpdiag_expires
= 0;
150 r
->tcpdiag_rqueue
= tp
->rcv_nxt
- tp
->copied_seq
;
151 r
->tcpdiag_wqueue
= tp
->write_seq
- tp
->snd_una
;
152 r
->tcpdiag_uid
= sock_i_uid(sk
);
153 r
->tcpdiag_inode
= sock_i_ino(sk
);
156 minfo
->tcpdiag_rmem
= atomic_read(&sk
->sk_rmem_alloc
);
157 minfo
->tcpdiag_wmem
= sk
->sk_wmem_queued
;
158 minfo
->tcpdiag_fmem
= sk
->sk_forward_alloc
;
159 minfo
->tcpdiag_tmem
= atomic_read(&sk
->sk_wmem_alloc
);
163 tcp_get_info(sk
, info
);
165 if (sk
->sk_state
< TCP_TIME_WAIT
&& tp
->ca_ops
->get_info
)
166 tp
->ca_ops
->get_info(tp
, ext
, skb
);
168 nlh
->nlmsg_len
= skb
->tail
- b
;
173 skb_trim(skb
, b
- skb
->data
);
177 extern struct sock
*tcp_v4_lookup(u32 saddr
, u16 sport
, u32 daddr
, u16 dport
,
179 #ifdef CONFIG_IP_TCPDIAG_IPV6
180 extern struct sock
*tcp_v6_lookup(struct in6_addr
*saddr
, u16 sport
,
181 struct in6_addr
*daddr
, u16 dport
,
184 static inline struct sock
*tcp_v6_lookup(struct in6_addr
*saddr
, u16 sport
,
185 struct in6_addr
*daddr
, u16 dport
,
192 static int tcpdiag_get_exact(struct sk_buff
*in_skb
, const struct nlmsghdr
*nlh
)
196 struct tcpdiagreq
*req
= NLMSG_DATA(nlh
);
199 if (req
->tcpdiag_family
== AF_INET
) {
200 sk
= tcp_v4_lookup(req
->id
.tcpdiag_dst
[0], req
->id
.tcpdiag_dport
,
201 req
->id
.tcpdiag_src
[0], req
->id
.tcpdiag_sport
,
204 #ifdef CONFIG_IP_TCPDIAG_IPV6
205 else if (req
->tcpdiag_family
== AF_INET6
) {
206 sk
= tcp_v6_lookup((struct in6_addr
*)req
->id
.tcpdiag_dst
, req
->id
.tcpdiag_dport
,
207 (struct in6_addr
*)req
->id
.tcpdiag_src
, req
->id
.tcpdiag_sport
,
219 if ((req
->id
.tcpdiag_cookie
[0] != TCPDIAG_NOCOOKIE
||
220 req
->id
.tcpdiag_cookie
[1] != TCPDIAG_NOCOOKIE
) &&
221 ((u32
)(unsigned long)sk
!= req
->id
.tcpdiag_cookie
[0] ||
222 (u32
)((((unsigned long)sk
) >> 31) >> 1) != req
->id
.tcpdiag_cookie
[1]))
226 rep
= alloc_skb(NLMSG_SPACE(sizeof(struct tcpdiagmsg
)+
227 sizeof(struct tcpdiag_meminfo
)+
228 sizeof(struct tcp_info
)+64), GFP_KERNEL
);
232 if (tcpdiag_fill(rep
, sk
, req
->tcpdiag_ext
,
233 NETLINK_CB(in_skb
).pid
,
234 nlh
->nlmsg_seq
, 0) <= 0)
237 err
= netlink_unicast(tcpnl
, rep
, NETLINK_CB(in_skb
).pid
, MSG_DONTWAIT
);
243 if (sk
->sk_state
== TCP_TIME_WAIT
)
244 inet_twsk_put((struct inet_timewait_sock
*)sk
);
251 static int bitstring_match(const u32
*a1
, const u32
*a2
, int bits
)
253 int words
= bits
>> 5;
258 if (memcmp(a1
, a2
, words
<< 2))
268 mask
= htonl((0xffffffff) << (32 - bits
));
270 if ((w1
^ w2
) & mask
)
278 static int tcpdiag_bc_run(const void *bc
, int len
,
279 const struct tcpdiag_entry
*entry
)
283 const struct tcpdiag_bc_op
*op
= bc
;
291 case TCPDIAG_BC_S_GE
:
292 yes
= entry
->sport
>= op
[1].no
;
294 case TCPDIAG_BC_S_LE
:
295 yes
= entry
->dport
<= op
[1].no
;
297 case TCPDIAG_BC_D_GE
:
298 yes
= entry
->dport
>= op
[1].no
;
300 case TCPDIAG_BC_D_LE
:
301 yes
= entry
->dport
<= op
[1].no
;
303 case TCPDIAG_BC_AUTO
:
304 yes
= !(entry
->userlocks
& SOCK_BINDPORT_LOCK
);
306 case TCPDIAG_BC_S_COND
:
307 case TCPDIAG_BC_D_COND
:
309 struct tcpdiag_hostcond
*cond
= (struct tcpdiag_hostcond
*)(op
+1);
312 if (cond
->port
!= -1 &&
313 cond
->port
!= (op
->code
== TCPDIAG_BC_S_COND
?
314 entry
->sport
: entry
->dport
)) {
319 if (cond
->prefix_len
== 0)
322 if (op
->code
== TCPDIAG_BC_S_COND
)
327 if (bitstring_match(addr
, cond
->addr
, cond
->prefix_len
))
329 if (entry
->family
== AF_INET6
&&
330 cond
->family
== AF_INET
) {
331 if (addr
[0] == 0 && addr
[1] == 0 &&
332 addr
[2] == htonl(0xffff) &&
333 bitstring_match(addr
+3, cond
->addr
, cond
->prefix_len
))
352 static int valid_cc(const void *bc
, int len
, int cc
)
355 const struct tcpdiag_bc_op
*op
= bc
;
369 static int tcpdiag_bc_audit(const void *bytecode
, int bytecode_len
)
371 const unsigned char *bc
= bytecode
;
372 int len
= bytecode_len
;
375 struct tcpdiag_bc_op
*op
= (struct tcpdiag_bc_op
*)bc
;
377 //printk("BC: %d %d %d {%d} / %d\n", op->code, op->yes, op->no, op[1].no, len);
379 case TCPDIAG_BC_AUTO
:
380 case TCPDIAG_BC_S_COND
:
381 case TCPDIAG_BC_D_COND
:
382 case TCPDIAG_BC_S_GE
:
383 case TCPDIAG_BC_S_LE
:
384 case TCPDIAG_BC_D_GE
:
385 case TCPDIAG_BC_D_LE
:
386 if (op
->yes
< 4 || op
->yes
> len
+4)
389 if (op
->no
< 4 || op
->no
> len
+4)
392 !valid_cc(bytecode
, bytecode_len
, len
-op
->no
))
396 if (op
->yes
< 4 || op
->yes
> len
+4)
405 return len
== 0 ? 0 : -EINVAL
;
408 static int tcpdiag_dump_sock(struct sk_buff
*skb
, struct sock
*sk
,
409 struct netlink_callback
*cb
)
411 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
413 if (cb
->nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(*r
))) {
414 struct tcpdiag_entry entry
;
415 struct rtattr
*bc
= (struct rtattr
*)(r
+ 1);
416 struct inet_sock
*inet
= inet_sk(sk
);
418 entry
.family
= sk
->sk_family
;
419 #ifdef CONFIG_IP_TCPDIAG_IPV6
420 if (entry
.family
== AF_INET6
) {
421 struct ipv6_pinfo
*np
= inet6_sk(sk
);
423 entry
.saddr
= np
->rcv_saddr
.s6_addr32
;
424 entry
.daddr
= np
->daddr
.s6_addr32
;
428 entry
.saddr
= &inet
->rcv_saddr
;
429 entry
.daddr
= &inet
->daddr
;
431 entry
.sport
= inet
->num
;
432 entry
.dport
= ntohs(inet
->dport
);
433 entry
.userlocks
= sk
->sk_userlocks
;
435 if (!tcpdiag_bc_run(RTA_DATA(bc
), RTA_PAYLOAD(bc
), &entry
))
439 return tcpdiag_fill(skb
, sk
, r
->tcpdiag_ext
, NETLINK_CB(cb
->skb
).pid
,
440 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
);
443 static int tcpdiag_fill_req(struct sk_buff
*skb
, struct sock
*sk
,
444 struct request_sock
*req
,
447 const struct inet_request_sock
*ireq
= inet_rsk(req
);
448 struct inet_sock
*inet
= inet_sk(sk
);
449 unsigned char *b
= skb
->tail
;
450 struct tcpdiagmsg
*r
;
451 struct nlmsghdr
*nlh
;
454 nlh
= NLMSG_PUT(skb
, pid
, seq
, TCPDIAG_GETSOCK
, sizeof(*r
));
455 nlh
->nlmsg_flags
= NLM_F_MULTI
;
458 r
->tcpdiag_family
= sk
->sk_family
;
459 r
->tcpdiag_state
= TCP_SYN_RECV
;
460 r
->tcpdiag_timer
= 1;
461 r
->tcpdiag_retrans
= req
->retrans
;
463 r
->id
.tcpdiag_if
= sk
->sk_bound_dev_if
;
464 r
->id
.tcpdiag_cookie
[0] = (u32
)(unsigned long)req
;
465 r
->id
.tcpdiag_cookie
[1] = (u32
)(((unsigned long)req
>> 31) >> 1);
467 tmo
= req
->expires
- jiffies
;
471 r
->id
.tcpdiag_sport
= inet
->sport
;
472 r
->id
.tcpdiag_dport
= ireq
->rmt_port
;
473 r
->id
.tcpdiag_src
[0] = ireq
->loc_addr
;
474 r
->id
.tcpdiag_dst
[0] = ireq
->rmt_addr
;
475 r
->tcpdiag_expires
= jiffies_to_msecs(tmo
),
476 r
->tcpdiag_rqueue
= 0;
477 r
->tcpdiag_wqueue
= 0;
478 r
->tcpdiag_uid
= sock_i_uid(sk
);
479 r
->tcpdiag_inode
= 0;
480 #ifdef CONFIG_IP_TCPDIAG_IPV6
481 if (r
->tcpdiag_family
== AF_INET6
) {
482 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
483 &tcp6_rsk(req
)->loc_addr
);
484 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
485 &tcp6_rsk(req
)->rmt_addr
);
488 nlh
->nlmsg_len
= skb
->tail
- b
;
493 skb_trim(skb
, b
- skb
->data
);
497 static int tcpdiag_dump_reqs(struct sk_buff
*skb
, struct sock
*sk
,
498 struct netlink_callback
*cb
)
500 struct tcpdiag_entry entry
;
501 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
502 struct tcp_sock
*tp
= tcp_sk(sk
);
503 struct listen_sock
*lopt
;
504 struct rtattr
*bc
= NULL
;
505 struct inet_sock
*inet
= inet_sk(sk
);
507 int reqnum
, s_reqnum
;
511 s_reqnum
= cb
->args
[4];
516 entry
.family
= sk
->sk_family
;
518 read_lock_bh(&tp
->accept_queue
.syn_wait_lock
);
520 lopt
= tp
->accept_queue
.listen_opt
;
521 if (!lopt
|| !lopt
->qlen
)
524 if (cb
->nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(*r
))) {
525 bc
= (struct rtattr
*)(r
+ 1);
526 entry
.sport
= inet
->num
;
527 entry
.userlocks
= sk
->sk_userlocks
;
530 for (j
= s_j
; j
< TCP_SYNQ_HSIZE
; j
++) {
531 struct request_sock
*req
, *head
= lopt
->syn_table
[j
];
534 for (req
= head
; req
; reqnum
++, req
= req
->dl_next
) {
535 struct inet_request_sock
*ireq
= inet_rsk(req
);
537 if (reqnum
< s_reqnum
)
539 if (r
->id
.tcpdiag_dport
!= ireq
->rmt_port
&&
545 #ifdef CONFIG_IP_TCPDIAG_IPV6
546 (entry
.family
== AF_INET6
) ?
547 tcp6_rsk(req
)->loc_addr
.s6_addr32
:
551 #ifdef CONFIG_IP_TCPDIAG_IPV6
552 (entry
.family
== AF_INET6
) ?
553 tcp6_rsk(req
)->rmt_addr
.s6_addr32
:
556 entry
.dport
= ntohs(ireq
->rmt_port
);
558 if (!tcpdiag_bc_run(RTA_DATA(bc
),
559 RTA_PAYLOAD(bc
), &entry
))
563 err
= tcpdiag_fill_req(skb
, sk
, req
,
564 NETLINK_CB(cb
->skb
).pid
,
568 cb
->args
[4] = reqnum
;
577 read_unlock_bh(&tp
->accept_queue
.syn_wait_lock
);
582 static int tcpdiag_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
586 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
589 s_num
= num
= cb
->args
[2];
591 if (cb
->args
[0] == 0) {
592 if (!(r
->tcpdiag_states
&(TCPF_LISTEN
|TCPF_SYN_RECV
)))
594 inet_listen_lock(&tcp_hashinfo
);
595 for (i
= s_i
; i
< INET_LHTABLE_SIZE
; i
++) {
597 struct hlist_node
*node
;
600 sk_for_each(sk
, node
, &tcp_hashinfo
.listening_hash
[i
]) {
601 struct inet_sock
*inet
= inet_sk(sk
);
608 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
612 if (!(r
->tcpdiag_states
&TCPF_LISTEN
) ||
613 r
->id
.tcpdiag_dport
||
617 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
618 inet_listen_unlock(&tcp_hashinfo
);
623 if (!(r
->tcpdiag_states
&TCPF_SYN_RECV
))
626 if (tcpdiag_dump_reqs(skb
, sk
, cb
) < 0) {
627 inet_listen_unlock(&tcp_hashinfo
);
641 inet_listen_unlock(&tcp_hashinfo
);
644 s_i
= num
= s_num
= 0;
647 if (!(r
->tcpdiag_states
&~(TCPF_LISTEN
|TCPF_SYN_RECV
)))
650 for (i
= s_i
; i
< tcp_hashinfo
.ehash_size
; i
++) {
651 struct inet_ehash_bucket
*head
= &tcp_hashinfo
.ehash
[i
];
653 struct hlist_node
*node
;
658 read_lock_bh(&head
->lock
);
661 sk_for_each(sk
, node
, &head
->chain
) {
662 struct inet_sock
*inet
= inet_sk(sk
);
666 if (!(r
->tcpdiag_states
& (1 << sk
->sk_state
)))
668 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
671 if (r
->id
.tcpdiag_dport
!= inet
->dport
&& r
->id
.tcpdiag_dport
)
673 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
674 read_unlock_bh(&head
->lock
);
681 if (r
->tcpdiag_states
&TCPF_TIME_WAIT
) {
682 sk_for_each(sk
, node
,
683 &tcp_hashinfo
.ehash
[i
+ tcp_hashinfo
.ehash_size
].chain
) {
684 struct inet_sock
*inet
= inet_sk(sk
);
688 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
691 if (r
->id
.tcpdiag_dport
!= inet
->dport
&&
694 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
695 read_unlock_bh(&head
->lock
);
702 read_unlock_bh(&head
->lock
);
711 static int tcpdiag_dump_done(struct netlink_callback
*cb
)
717 static __inline__
int
718 tcpdiag_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
720 if (!(nlh
->nlmsg_flags
&NLM_F_REQUEST
))
723 if (nlh
->nlmsg_type
!= TCPDIAG_GETSOCK
)
726 if (NLMSG_LENGTH(sizeof(struct tcpdiagreq
)) > skb
->len
)
729 if (nlh
->nlmsg_flags
&NLM_F_DUMP
) {
730 if (nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(struct tcpdiagreq
))) {
731 struct rtattr
*rta
= (struct rtattr
*)(NLMSG_DATA(nlh
) + sizeof(struct tcpdiagreq
));
732 if (rta
->rta_type
!= TCPDIAG_REQ_BYTECODE
||
734 rta
->rta_len
> nlh
->nlmsg_len
- NLMSG_SPACE(sizeof(struct tcpdiagreq
)))
736 if (tcpdiag_bc_audit(RTA_DATA(rta
), RTA_PAYLOAD(rta
)))
739 return netlink_dump_start(tcpnl
, skb
, nlh
,
743 return tcpdiag_get_exact(skb
, nlh
);
751 static inline void tcpdiag_rcv_skb(struct sk_buff
*skb
)
754 struct nlmsghdr
* nlh
;
756 if (skb
->len
>= NLMSG_SPACE(0)) {
757 nlh
= (struct nlmsghdr
*)skb
->data
;
758 if (nlh
->nlmsg_len
< sizeof(*nlh
) || skb
->len
< nlh
->nlmsg_len
)
760 err
= tcpdiag_rcv_msg(skb
, nlh
);
761 if (err
|| nlh
->nlmsg_flags
& NLM_F_ACK
)
762 netlink_ack(skb
, nlh
, err
);
766 static void tcpdiag_rcv(struct sock
*sk
, int len
)
769 unsigned int qlen
= skb_queue_len(&sk
->sk_receive_queue
);
771 while (qlen
-- && (skb
= skb_dequeue(&sk
->sk_receive_queue
))) {
772 tcpdiag_rcv_skb(skb
);
777 static int __init
tcpdiag_init(void)
779 tcpnl
= netlink_kernel_create(NETLINK_TCPDIAG
, tcpdiag_rcv
,
786 static void __exit
tcpdiag_exit(void)
788 sock_release(tcpnl
->sk_socket
);
791 module_init(tcpdiag_init
);
792 module_exit(tcpdiag_exit
);
793 MODULE_LICENSE("GPL");