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 const struct inet_sock
*inet
= inet_sk(sk
);
52 struct tcp_sock
*tp
= tcp_sk(sk
);
53 const struct inet_connection_sock
*icsk
= inet_csk(sk
);
56 struct tcp_info
*info
= NULL
;
57 struct tcpdiag_meminfo
*minfo
= NULL
;
58 unsigned char *b
= skb
->tail
;
60 nlh
= NLMSG_PUT(skb
, pid
, seq
, TCPDIAG_GETSOCK
, sizeof(*r
));
61 nlh
->nlmsg_flags
= nlmsg_flags
;
63 if (sk
->sk_state
!= TCP_TIME_WAIT
) {
64 if (ext
& (1<<(TCPDIAG_MEMINFO
-1)))
65 minfo
= TCPDIAG_PUT(skb
, TCPDIAG_MEMINFO
, sizeof(*minfo
));
66 if (ext
& (1<<(TCPDIAG_INFO
-1)))
67 info
= TCPDIAG_PUT(skb
, TCPDIAG_INFO
, sizeof(*info
));
69 if (ext
& (1<<(TCPDIAG_CONG
-1))) {
70 size_t len
= strlen(tp
->ca_ops
->name
);
71 strcpy(TCPDIAG_PUT(skb
, TCPDIAG_CONG
, len
+1),
75 r
->tcpdiag_family
= sk
->sk_family
;
76 r
->tcpdiag_state
= sk
->sk_state
;
78 r
->tcpdiag_retrans
= 0;
80 r
->id
.tcpdiag_if
= sk
->sk_bound_dev_if
;
81 r
->id
.tcpdiag_cookie
[0] = (u32
)(unsigned long)sk
;
82 r
->id
.tcpdiag_cookie
[1] = (u32
)(((unsigned long)sk
>> 31) >> 1);
84 if (r
->tcpdiag_state
== TCP_TIME_WAIT
) {
85 const struct inet_timewait_sock
*tw
= inet_twsk(sk
);
86 long tmo
= tw
->tw_ttd
- jiffies
;
90 r
->id
.tcpdiag_sport
= tw
->tw_sport
;
91 r
->id
.tcpdiag_dport
= tw
->tw_dport
;
92 r
->id
.tcpdiag_src
[0] = tw
->tw_rcv_saddr
;
93 r
->id
.tcpdiag_dst
[0] = tw
->tw_daddr
;
94 r
->tcpdiag_state
= tw
->tw_substate
;
96 r
->tcpdiag_expires
= (tmo
*1000+HZ
-1)/HZ
;
97 r
->tcpdiag_rqueue
= 0;
98 r
->tcpdiag_wqueue
= 0;
100 r
->tcpdiag_inode
= 0;
101 #ifdef CONFIG_IP_TCPDIAG_IPV6
102 if (r
->tcpdiag_family
== AF_INET6
) {
103 const struct tcp6_timewait_sock
*tcp6tw
= tcp6_twsk(sk
);
105 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
106 &tcp6tw
->tw_v6_rcv_saddr
);
107 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
108 &tcp6tw
->tw_v6_daddr
);
111 nlh
->nlmsg_len
= skb
->tail
- b
;
115 r
->id
.tcpdiag_sport
= inet
->sport
;
116 r
->id
.tcpdiag_dport
= inet
->dport
;
117 r
->id
.tcpdiag_src
[0] = inet
->rcv_saddr
;
118 r
->id
.tcpdiag_dst
[0] = inet
->daddr
;
120 #ifdef CONFIG_IP_TCPDIAG_IPV6
121 if (r
->tcpdiag_family
== AF_INET6
) {
122 struct ipv6_pinfo
*np
= inet6_sk(sk
);
124 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
126 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
131 #define EXPIRES_IN_MS(tmo) ((tmo-jiffies)*1000+HZ-1)/HZ
133 if (icsk
->icsk_pending
== ICSK_TIME_RETRANS
) {
134 r
->tcpdiag_timer
= 1;
135 r
->tcpdiag_retrans
= icsk
->icsk_retransmits
;
136 r
->tcpdiag_expires
= EXPIRES_IN_MS(icsk
->icsk_timeout
);
137 } else if (icsk
->icsk_pending
== ICSK_TIME_PROBE0
) {
138 r
->tcpdiag_timer
= 4;
139 r
->tcpdiag_retrans
= tp
->probes_out
;
140 r
->tcpdiag_expires
= EXPIRES_IN_MS(icsk
->icsk_timeout
);
141 } else if (timer_pending(&sk
->sk_timer
)) {
142 r
->tcpdiag_timer
= 2;
143 r
->tcpdiag_retrans
= tp
->probes_out
;
144 r
->tcpdiag_expires
= EXPIRES_IN_MS(sk
->sk_timer
.expires
);
146 r
->tcpdiag_timer
= 0;
147 r
->tcpdiag_expires
= 0;
151 r
->tcpdiag_rqueue
= tp
->rcv_nxt
- tp
->copied_seq
;
152 r
->tcpdiag_wqueue
= tp
->write_seq
- tp
->snd_una
;
153 r
->tcpdiag_uid
= sock_i_uid(sk
);
154 r
->tcpdiag_inode
= sock_i_ino(sk
);
157 minfo
->tcpdiag_rmem
= atomic_read(&sk
->sk_rmem_alloc
);
158 minfo
->tcpdiag_wmem
= sk
->sk_wmem_queued
;
159 minfo
->tcpdiag_fmem
= sk
->sk_forward_alloc
;
160 minfo
->tcpdiag_tmem
= atomic_read(&sk
->sk_wmem_alloc
);
164 tcp_get_info(sk
, info
);
166 if (sk
->sk_state
< TCP_TIME_WAIT
&& tp
->ca_ops
->get_info
)
167 tp
->ca_ops
->get_info(tp
, ext
, skb
);
169 nlh
->nlmsg_len
= skb
->tail
- b
;
174 skb_trim(skb
, b
- skb
->data
);
178 #ifdef CONFIG_IP_TCPDIAG_IPV6
179 extern struct sock
*tcp_v6_lookup(struct in6_addr
*saddr
, u16 sport
,
180 struct in6_addr
*daddr
, u16 dport
,
183 static inline struct sock
*tcp_v6_lookup(struct in6_addr
*saddr
, u16 sport
,
184 struct in6_addr
*daddr
, u16 dport
,
191 static int tcpdiag_get_exact(struct sk_buff
*in_skb
, const struct nlmsghdr
*nlh
)
195 struct tcpdiagreq
*req
= NLMSG_DATA(nlh
);
198 if (req
->tcpdiag_family
== AF_INET
) {
199 sk
= inet_lookup(&tcp_hashinfo
, req
->id
.tcpdiag_dst
[0],
200 req
->id
.tcpdiag_dport
, req
->id
.tcpdiag_src
[0],
201 req
->id
.tcpdiag_sport
, req
->id
.tcpdiag_if
);
203 #ifdef CONFIG_IP_TCPDIAG_IPV6
204 else if (req
->tcpdiag_family
== AF_INET6
) {
205 sk
= tcp_v6_lookup((struct in6_addr
*)req
->id
.tcpdiag_dst
, req
->id
.tcpdiag_dport
,
206 (struct in6_addr
*)req
->id
.tcpdiag_src
, req
->id
.tcpdiag_sport
,
218 if ((req
->id
.tcpdiag_cookie
[0] != TCPDIAG_NOCOOKIE
||
219 req
->id
.tcpdiag_cookie
[1] != TCPDIAG_NOCOOKIE
) &&
220 ((u32
)(unsigned long)sk
!= req
->id
.tcpdiag_cookie
[0] ||
221 (u32
)((((unsigned long)sk
) >> 31) >> 1) != req
->id
.tcpdiag_cookie
[1]))
225 rep
= alloc_skb(NLMSG_SPACE(sizeof(struct tcpdiagmsg
)+
226 sizeof(struct tcpdiag_meminfo
)+
227 sizeof(struct tcp_info
)+64), GFP_KERNEL
);
231 if (tcpdiag_fill(rep
, sk
, req
->tcpdiag_ext
,
232 NETLINK_CB(in_skb
).pid
,
233 nlh
->nlmsg_seq
, 0) <= 0)
236 err
= netlink_unicast(tcpnl
, rep
, NETLINK_CB(in_skb
).pid
, MSG_DONTWAIT
);
242 if (sk
->sk_state
== TCP_TIME_WAIT
)
243 inet_twsk_put((struct inet_timewait_sock
*)sk
);
250 static int bitstring_match(const u32
*a1
, const u32
*a2
, int bits
)
252 int words
= bits
>> 5;
257 if (memcmp(a1
, a2
, words
<< 2))
267 mask
= htonl((0xffffffff) << (32 - bits
));
269 if ((w1
^ w2
) & mask
)
277 static int tcpdiag_bc_run(const void *bc
, int len
,
278 const struct tcpdiag_entry
*entry
)
282 const struct tcpdiag_bc_op
*op
= bc
;
290 case TCPDIAG_BC_S_GE
:
291 yes
= entry
->sport
>= op
[1].no
;
293 case TCPDIAG_BC_S_LE
:
294 yes
= entry
->dport
<= op
[1].no
;
296 case TCPDIAG_BC_D_GE
:
297 yes
= entry
->dport
>= op
[1].no
;
299 case TCPDIAG_BC_D_LE
:
300 yes
= entry
->dport
<= op
[1].no
;
302 case TCPDIAG_BC_AUTO
:
303 yes
= !(entry
->userlocks
& SOCK_BINDPORT_LOCK
);
305 case TCPDIAG_BC_S_COND
:
306 case TCPDIAG_BC_D_COND
:
308 struct tcpdiag_hostcond
*cond
= (struct tcpdiag_hostcond
*)(op
+1);
311 if (cond
->port
!= -1 &&
312 cond
->port
!= (op
->code
== TCPDIAG_BC_S_COND
?
313 entry
->sport
: entry
->dport
)) {
318 if (cond
->prefix_len
== 0)
321 if (op
->code
== TCPDIAG_BC_S_COND
)
326 if (bitstring_match(addr
, cond
->addr
, cond
->prefix_len
))
328 if (entry
->family
== AF_INET6
&&
329 cond
->family
== AF_INET
) {
330 if (addr
[0] == 0 && addr
[1] == 0 &&
331 addr
[2] == htonl(0xffff) &&
332 bitstring_match(addr
+3, cond
->addr
, cond
->prefix_len
))
351 static int valid_cc(const void *bc
, int len
, int cc
)
354 const struct tcpdiag_bc_op
*op
= bc
;
368 static int tcpdiag_bc_audit(const void *bytecode
, int bytecode_len
)
370 const unsigned char *bc
= bytecode
;
371 int len
= bytecode_len
;
374 struct tcpdiag_bc_op
*op
= (struct tcpdiag_bc_op
*)bc
;
376 //printk("BC: %d %d %d {%d} / %d\n", op->code, op->yes, op->no, op[1].no, len);
378 case TCPDIAG_BC_AUTO
:
379 case TCPDIAG_BC_S_COND
:
380 case TCPDIAG_BC_D_COND
:
381 case TCPDIAG_BC_S_GE
:
382 case TCPDIAG_BC_S_LE
:
383 case TCPDIAG_BC_D_GE
:
384 case TCPDIAG_BC_D_LE
:
385 if (op
->yes
< 4 || op
->yes
> len
+4)
388 if (op
->no
< 4 || op
->no
> len
+4)
391 !valid_cc(bytecode
, bytecode_len
, len
-op
->no
))
395 if (op
->yes
< 4 || op
->yes
> len
+4)
404 return len
== 0 ? 0 : -EINVAL
;
407 static int tcpdiag_dump_sock(struct sk_buff
*skb
, struct sock
*sk
,
408 struct netlink_callback
*cb
)
410 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
412 if (cb
->nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(*r
))) {
413 struct tcpdiag_entry entry
;
414 struct rtattr
*bc
= (struct rtattr
*)(r
+ 1);
415 struct inet_sock
*inet
= inet_sk(sk
);
417 entry
.family
= sk
->sk_family
;
418 #ifdef CONFIG_IP_TCPDIAG_IPV6
419 if (entry
.family
== AF_INET6
) {
420 struct ipv6_pinfo
*np
= inet6_sk(sk
);
422 entry
.saddr
= np
->rcv_saddr
.s6_addr32
;
423 entry
.daddr
= np
->daddr
.s6_addr32
;
427 entry
.saddr
= &inet
->rcv_saddr
;
428 entry
.daddr
= &inet
->daddr
;
430 entry
.sport
= inet
->num
;
431 entry
.dport
= ntohs(inet
->dport
);
432 entry
.userlocks
= sk
->sk_userlocks
;
434 if (!tcpdiag_bc_run(RTA_DATA(bc
), RTA_PAYLOAD(bc
), &entry
))
438 return tcpdiag_fill(skb
, sk
, r
->tcpdiag_ext
, NETLINK_CB(cb
->skb
).pid
,
439 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
);
442 static int tcpdiag_fill_req(struct sk_buff
*skb
, struct sock
*sk
,
443 struct request_sock
*req
,
446 const struct inet_request_sock
*ireq
= inet_rsk(req
);
447 struct inet_sock
*inet
= inet_sk(sk
);
448 unsigned char *b
= skb
->tail
;
449 struct tcpdiagmsg
*r
;
450 struct nlmsghdr
*nlh
;
453 nlh
= NLMSG_PUT(skb
, pid
, seq
, TCPDIAG_GETSOCK
, sizeof(*r
));
454 nlh
->nlmsg_flags
= NLM_F_MULTI
;
457 r
->tcpdiag_family
= sk
->sk_family
;
458 r
->tcpdiag_state
= TCP_SYN_RECV
;
459 r
->tcpdiag_timer
= 1;
460 r
->tcpdiag_retrans
= req
->retrans
;
462 r
->id
.tcpdiag_if
= sk
->sk_bound_dev_if
;
463 r
->id
.tcpdiag_cookie
[0] = (u32
)(unsigned long)req
;
464 r
->id
.tcpdiag_cookie
[1] = (u32
)(((unsigned long)req
>> 31) >> 1);
466 tmo
= req
->expires
- jiffies
;
470 r
->id
.tcpdiag_sport
= inet
->sport
;
471 r
->id
.tcpdiag_dport
= ireq
->rmt_port
;
472 r
->id
.tcpdiag_src
[0] = ireq
->loc_addr
;
473 r
->id
.tcpdiag_dst
[0] = ireq
->rmt_addr
;
474 r
->tcpdiag_expires
= jiffies_to_msecs(tmo
),
475 r
->tcpdiag_rqueue
= 0;
476 r
->tcpdiag_wqueue
= 0;
477 r
->tcpdiag_uid
= sock_i_uid(sk
);
478 r
->tcpdiag_inode
= 0;
479 #ifdef CONFIG_IP_TCPDIAG_IPV6
480 if (r
->tcpdiag_family
== AF_INET6
) {
481 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_src
,
482 &tcp6_rsk(req
)->loc_addr
);
483 ipv6_addr_copy((struct in6_addr
*)r
->id
.tcpdiag_dst
,
484 &tcp6_rsk(req
)->rmt_addr
);
487 nlh
->nlmsg_len
= skb
->tail
- b
;
492 skb_trim(skb
, b
- skb
->data
);
496 static int tcpdiag_dump_reqs(struct sk_buff
*skb
, struct sock
*sk
,
497 struct netlink_callback
*cb
)
499 struct tcpdiag_entry entry
;
500 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
501 struct inet_connection_sock
*icsk
= inet_csk(sk
);
502 struct listen_sock
*lopt
;
503 struct rtattr
*bc
= NULL
;
504 struct inet_sock
*inet
= inet_sk(sk
);
506 int reqnum
, s_reqnum
;
510 s_reqnum
= cb
->args
[4];
515 entry
.family
= sk
->sk_family
;
517 read_lock_bh(&icsk
->icsk_accept_queue
.syn_wait_lock
);
519 lopt
= icsk
->icsk_accept_queue
.listen_opt
;
520 if (!lopt
|| !lopt
->qlen
)
523 if (cb
->nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(*r
))) {
524 bc
= (struct rtattr
*)(r
+ 1);
525 entry
.sport
= inet
->num
;
526 entry
.userlocks
= sk
->sk_userlocks
;
529 for (j
= s_j
; j
< TCP_SYNQ_HSIZE
; j
++) {
530 struct request_sock
*req
, *head
= lopt
->syn_table
[j
];
533 for (req
= head
; req
; reqnum
++, req
= req
->dl_next
) {
534 struct inet_request_sock
*ireq
= inet_rsk(req
);
536 if (reqnum
< s_reqnum
)
538 if (r
->id
.tcpdiag_dport
!= ireq
->rmt_port
&&
544 #ifdef CONFIG_IP_TCPDIAG_IPV6
545 (entry
.family
== AF_INET6
) ?
546 tcp6_rsk(req
)->loc_addr
.s6_addr32
:
550 #ifdef CONFIG_IP_TCPDIAG_IPV6
551 (entry
.family
== AF_INET6
) ?
552 tcp6_rsk(req
)->rmt_addr
.s6_addr32
:
555 entry
.dport
= ntohs(ireq
->rmt_port
);
557 if (!tcpdiag_bc_run(RTA_DATA(bc
),
558 RTA_PAYLOAD(bc
), &entry
))
562 err
= tcpdiag_fill_req(skb
, sk
, req
,
563 NETLINK_CB(cb
->skb
).pid
,
567 cb
->args
[4] = reqnum
;
576 read_unlock_bh(&icsk
->icsk_accept_queue
.syn_wait_lock
);
581 static int tcpdiag_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
585 struct tcpdiagreq
*r
= NLMSG_DATA(cb
->nlh
);
588 s_num
= num
= cb
->args
[2];
590 if (cb
->args
[0] == 0) {
591 if (!(r
->tcpdiag_states
&(TCPF_LISTEN
|TCPF_SYN_RECV
)))
593 inet_listen_lock(&tcp_hashinfo
);
594 for (i
= s_i
; i
< INET_LHTABLE_SIZE
; i
++) {
596 struct hlist_node
*node
;
599 sk_for_each(sk
, node
, &tcp_hashinfo
.listening_hash
[i
]) {
600 struct inet_sock
*inet
= inet_sk(sk
);
607 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
611 if (!(r
->tcpdiag_states
&TCPF_LISTEN
) ||
612 r
->id
.tcpdiag_dport
||
616 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
617 inet_listen_unlock(&tcp_hashinfo
);
622 if (!(r
->tcpdiag_states
&TCPF_SYN_RECV
))
625 if (tcpdiag_dump_reqs(skb
, sk
, cb
) < 0) {
626 inet_listen_unlock(&tcp_hashinfo
);
640 inet_listen_unlock(&tcp_hashinfo
);
643 s_i
= num
= s_num
= 0;
646 if (!(r
->tcpdiag_states
&~(TCPF_LISTEN
|TCPF_SYN_RECV
)))
649 for (i
= s_i
; i
< tcp_hashinfo
.ehash_size
; i
++) {
650 struct inet_ehash_bucket
*head
= &tcp_hashinfo
.ehash
[i
];
652 struct hlist_node
*node
;
657 read_lock_bh(&head
->lock
);
660 sk_for_each(sk
, node
, &head
->chain
) {
661 struct inet_sock
*inet
= inet_sk(sk
);
665 if (!(r
->tcpdiag_states
& (1 << sk
->sk_state
)))
667 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
670 if (r
->id
.tcpdiag_dport
!= inet
->dport
&& r
->id
.tcpdiag_dport
)
672 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
673 read_unlock_bh(&head
->lock
);
680 if (r
->tcpdiag_states
&TCPF_TIME_WAIT
) {
681 sk_for_each(sk
, node
,
682 &tcp_hashinfo
.ehash
[i
+ tcp_hashinfo
.ehash_size
].chain
) {
683 struct inet_sock
*inet
= inet_sk(sk
);
687 if (r
->id
.tcpdiag_sport
!= inet
->sport
&&
690 if (r
->id
.tcpdiag_dport
!= inet
->dport
&&
693 if (tcpdiag_dump_sock(skb
, sk
, cb
) < 0) {
694 read_unlock_bh(&head
->lock
);
701 read_unlock_bh(&head
->lock
);
710 static int tcpdiag_dump_done(struct netlink_callback
*cb
)
716 static __inline__
int
717 tcpdiag_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
719 if (!(nlh
->nlmsg_flags
&NLM_F_REQUEST
))
722 if (nlh
->nlmsg_type
!= TCPDIAG_GETSOCK
)
725 if (NLMSG_LENGTH(sizeof(struct tcpdiagreq
)) > skb
->len
)
728 if (nlh
->nlmsg_flags
&NLM_F_DUMP
) {
729 if (nlh
->nlmsg_len
> 4 + NLMSG_SPACE(sizeof(struct tcpdiagreq
))) {
730 struct rtattr
*rta
= (struct rtattr
*)(NLMSG_DATA(nlh
) + sizeof(struct tcpdiagreq
));
731 if (rta
->rta_type
!= TCPDIAG_REQ_BYTECODE
||
733 rta
->rta_len
> nlh
->nlmsg_len
- NLMSG_SPACE(sizeof(struct tcpdiagreq
)))
735 if (tcpdiag_bc_audit(RTA_DATA(rta
), RTA_PAYLOAD(rta
)))
738 return netlink_dump_start(tcpnl
, skb
, nlh
,
742 return tcpdiag_get_exact(skb
, nlh
);
750 static inline void tcpdiag_rcv_skb(struct sk_buff
*skb
)
753 struct nlmsghdr
* nlh
;
755 if (skb
->len
>= NLMSG_SPACE(0)) {
756 nlh
= (struct nlmsghdr
*)skb
->data
;
757 if (nlh
->nlmsg_len
< sizeof(*nlh
) || skb
->len
< nlh
->nlmsg_len
)
759 err
= tcpdiag_rcv_msg(skb
, nlh
);
760 if (err
|| nlh
->nlmsg_flags
& NLM_F_ACK
)
761 netlink_ack(skb
, nlh
, err
);
765 static void tcpdiag_rcv(struct sock
*sk
, int len
)
768 unsigned int qlen
= skb_queue_len(&sk
->sk_receive_queue
);
770 while (qlen
-- && (skb
= skb_dequeue(&sk
->sk_receive_queue
))) {
771 tcpdiag_rcv_skb(skb
);
776 static int __init
tcpdiag_init(void)
778 tcpnl
= netlink_kernel_create(NETLINK_TCPDIAG
, tcpdiag_rcv
,
785 static void __exit
tcpdiag_exit(void)
787 sock_release(tcpnl
->sk_socket
);
790 module_init(tcpdiag_init
);
791 module_exit(tcpdiag_exit
);
792 MODULE_LICENSE("GPL");
This page took 0.06253 seconds and 5 git commands to generate.