Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc-merge
[linux-2.6] / net / ipv4 / inet_diag.c
1 /*
2  * inet_diag.c  Module for monitoring INET transport protocols sockets.
3  *
4  * Version:     $Id: inet_diag.c,v 1.3 2002/02/01 22:01:04 davem Exp $
5  *
6  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
7  *
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.
12  */
13
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>
22
23 #include <net/icmp.h>
24 #include <net/tcp.h>
25 #include <net/ipv6.h>
26 #include <net/inet_common.h>
27 #include <net/inet_connection_sock.h>
28 #include <net/inet_hashtables.h>
29 #include <net/inet_timewait_sock.h>
30 #include <net/inet6_hashtables.h>
31
32 #include <linux/inet.h>
33 #include <linux/stddef.h>
34
35 #include <linux/inet_diag.h>
36
37 static const struct inet_diag_handler **inet_diag_table;
38
39 struct inet_diag_entry {
40         u32 *saddr;
41         u32 *daddr;
42         u16 sport;
43         u16 dport;
44         u16 family;
45         u16 userlocks;
46 };
47
48 static struct sock *idiagnl;
49
50 #define INET_DIAG_PUT(skb, attrtype, attrlen) \
51         RTA_DATA(__RTA_PUT(skb, attrtype, attrlen))
52
53 static int inet_diag_fill(struct sk_buff *skb, struct sock *sk,
54                         int ext, u32 pid, u32 seq, u16 nlmsg_flags,
55                         const struct nlmsghdr *unlh)
56 {
57         const struct inet_sock *inet = inet_sk(sk);
58         const struct inet_connection_sock *icsk = inet_csk(sk);
59         struct inet_diag_msg *r;
60         struct nlmsghdr  *nlh;
61         void *info = NULL;
62         struct inet_diag_meminfo  *minfo = NULL;
63         unsigned char    *b = skb->tail;
64         const struct inet_diag_handler *handler;
65
66         handler = inet_diag_table[unlh->nlmsg_type];
67         BUG_ON(handler == NULL);
68
69         nlh = NLMSG_PUT(skb, pid, seq, unlh->nlmsg_type, sizeof(*r));
70         nlh->nlmsg_flags = nlmsg_flags;
71
72         r = NLMSG_DATA(nlh);
73         if (sk->sk_state != TCP_TIME_WAIT) {
74                 if (ext & (1 << (INET_DIAG_MEMINFO - 1)))
75                         minfo = INET_DIAG_PUT(skb, INET_DIAG_MEMINFO,
76                                               sizeof(*minfo));
77                 if (ext & (1 << (INET_DIAG_INFO - 1)))
78                         info = INET_DIAG_PUT(skb, INET_DIAG_INFO,
79                                            handler->idiag_info_size);
80                 
81                 if ((ext & (1 << (INET_DIAG_CONG - 1))) && icsk->icsk_ca_ops) {
82                         size_t len = strlen(icsk->icsk_ca_ops->name);
83                         strcpy(INET_DIAG_PUT(skb, INET_DIAG_CONG, len + 1),
84                                icsk->icsk_ca_ops->name);
85                 }
86         }
87         r->idiag_family = sk->sk_family;
88         r->idiag_state = sk->sk_state;
89         r->idiag_timer = 0;
90         r->idiag_retrans = 0;
91
92         r->id.idiag_if = sk->sk_bound_dev_if;
93         r->id.idiag_cookie[0] = (u32)(unsigned long)sk;
94         r->id.idiag_cookie[1] = (u32)(((unsigned long)sk >> 31) >> 1);
95
96         if (r->idiag_state == TCP_TIME_WAIT) {
97                 const struct inet_timewait_sock *tw = inet_twsk(sk);
98                 long tmo = tw->tw_ttd - jiffies;
99                 if (tmo < 0)
100                         tmo = 0;
101
102                 r->id.idiag_sport = tw->tw_sport;
103                 r->id.idiag_dport = tw->tw_dport;
104                 r->id.idiag_src[0] = tw->tw_rcv_saddr;
105                 r->id.idiag_dst[0] = tw->tw_daddr;
106                 r->idiag_state = tw->tw_substate;
107                 r->idiag_timer = 3;
108                 r->idiag_expires = (tmo * 1000 + HZ - 1) / HZ;
109                 r->idiag_rqueue = 0;
110                 r->idiag_wqueue = 0;
111                 r->idiag_uid = 0;
112                 r->idiag_inode = 0;
113 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
114                 if (r->idiag_family == AF_INET6) {
115                         const struct tcp6_timewait_sock *tcp6tw = tcp6_twsk(sk);
116
117                         ipv6_addr_copy((struct in6_addr *)r->id.idiag_src,
118                                        &tcp6tw->tw_v6_rcv_saddr);
119                         ipv6_addr_copy((struct in6_addr *)r->id.idiag_dst,
120                                        &tcp6tw->tw_v6_daddr);
121                 }
122 #endif
123                 nlh->nlmsg_len = skb->tail - b;
124                 return skb->len;
125         }
126
127         r->id.idiag_sport = inet->sport;
128         r->id.idiag_dport = inet->dport;
129         r->id.idiag_src[0] = inet->rcv_saddr;
130         r->id.idiag_dst[0] = inet->daddr;
131
132 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
133         if (r->idiag_family == AF_INET6) {
134                 struct ipv6_pinfo *np = inet6_sk(sk);
135
136                 ipv6_addr_copy((struct in6_addr *)r->id.idiag_src,
137                                &np->rcv_saddr);
138                 ipv6_addr_copy((struct in6_addr *)r->id.idiag_dst,
139                                &np->daddr);
140         }
141 #endif
142
143 #define EXPIRES_IN_MS(tmo)  ((tmo - jiffies) * 1000 + HZ - 1) / HZ
144
145         if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
146                 r->idiag_timer = 1;
147                 r->idiag_retrans = icsk->icsk_retransmits;
148                 r->idiag_expires = EXPIRES_IN_MS(icsk->icsk_timeout);
149         } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
150                 r->idiag_timer = 4;
151                 r->idiag_retrans = icsk->icsk_probes_out;
152                 r->idiag_expires = EXPIRES_IN_MS(icsk->icsk_timeout);
153         } else if (timer_pending(&sk->sk_timer)) {
154                 r->idiag_timer = 2;
155                 r->idiag_retrans = icsk->icsk_probes_out;
156                 r->idiag_expires = EXPIRES_IN_MS(sk->sk_timer.expires);
157         } else {
158                 r->idiag_timer = 0;
159                 r->idiag_expires = 0;
160         }
161 #undef EXPIRES_IN_MS
162
163         r->idiag_uid = sock_i_uid(sk);
164         r->idiag_inode = sock_i_ino(sk);
165
166         if (minfo) {
167                 minfo->idiag_rmem = atomic_read(&sk->sk_rmem_alloc);
168                 minfo->idiag_wmem = sk->sk_wmem_queued;
169                 minfo->idiag_fmem = sk->sk_forward_alloc;
170                 minfo->idiag_tmem = atomic_read(&sk->sk_wmem_alloc);
171         }
172
173         handler->idiag_get_info(sk, r, info);
174
175         if (sk->sk_state < TCP_TIME_WAIT &&
176             icsk->icsk_ca_ops && icsk->icsk_ca_ops->get_info)
177                 icsk->icsk_ca_ops->get_info(sk, ext, skb);
178
179         nlh->nlmsg_len = skb->tail - b;
180         return skb->len;
181
182 rtattr_failure:
183 nlmsg_failure:
184         skb_trim(skb, b - skb->data);
185         return -1;
186 }
187
188 static int inet_diag_get_exact(struct sk_buff *in_skb, const struct nlmsghdr *nlh)
189 {
190         int err;
191         struct sock *sk;
192         struct inet_diag_req *req = NLMSG_DATA(nlh);
193         struct sk_buff *rep;
194         struct inet_hashinfo *hashinfo;
195         const struct inet_diag_handler *handler;
196
197         handler = inet_diag_table[nlh->nlmsg_type];
198         BUG_ON(handler == NULL);
199         hashinfo = handler->idiag_hashinfo;
200
201         if (req->idiag_family == AF_INET) {
202                 sk = inet_lookup(hashinfo, req->id.idiag_dst[0],
203                                  req->id.idiag_dport, req->id.idiag_src[0],
204                                  req->id.idiag_sport, req->id.idiag_if);
205         }
206 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
207         else if (req->idiag_family == AF_INET6) {
208                 sk = inet6_lookup(hashinfo,
209                                   (struct in6_addr *)req->id.idiag_dst,
210                                   req->id.idiag_dport,
211                                   (struct in6_addr *)req->id.idiag_src,
212                                   req->id.idiag_sport,
213                                   req->id.idiag_if);
214         }
215 #endif
216         else {
217                 return -EINVAL;
218         }
219
220         if (sk == NULL)
221                 return -ENOENT;
222
223         err = -ESTALE;
224         if ((req->id.idiag_cookie[0] != INET_DIAG_NOCOOKIE ||
225              req->id.idiag_cookie[1] != INET_DIAG_NOCOOKIE) &&
226             ((u32)(unsigned long)sk != req->id.idiag_cookie[0] ||
227              (u32)((((unsigned long)sk) >> 31) >> 1) != req->id.idiag_cookie[1]))
228                 goto out;
229
230         err = -ENOMEM;
231         rep = alloc_skb(NLMSG_SPACE((sizeof(struct inet_diag_msg) +
232                                      sizeof(struct inet_diag_meminfo) +
233                                      handler->idiag_info_size + 64)),
234                         GFP_KERNEL);
235         if (!rep)
236                 goto out;
237
238         if (inet_diag_fill(rep, sk, req->idiag_ext,
239                          NETLINK_CB(in_skb).pid,
240                          nlh->nlmsg_seq, 0, nlh) <= 0)
241                 BUG();
242
243         err = netlink_unicast(idiagnl, rep, NETLINK_CB(in_skb).pid,
244                               MSG_DONTWAIT);
245         if (err > 0)
246                 err = 0;
247
248 out:
249         if (sk) {
250                 if (sk->sk_state == TCP_TIME_WAIT)
251                         inet_twsk_put((struct inet_timewait_sock *)sk);
252                 else
253                         sock_put(sk);
254         }
255         return err;
256 }
257
258 static int bitstring_match(const u32 *a1, const u32 *a2, int bits)
259 {
260         int words = bits >> 5;
261
262         bits &= 0x1f;
263
264         if (words) {
265                 if (memcmp(a1, a2, words << 2))
266                         return 0;
267         }
268         if (bits) {
269                 __u32 w1, w2;
270                 __u32 mask;
271
272                 w1 = a1[words];
273                 w2 = a2[words];
274
275                 mask = htonl((0xffffffff) << (32 - bits));
276
277                 if ((w1 ^ w2) & mask)
278                         return 0;
279         }
280
281         return 1;
282 }
283
284
285 static int inet_diag_bc_run(const void *bc, int len,
286                           const struct inet_diag_entry *entry)
287 {
288         while (len > 0) {
289                 int yes = 1;
290                 const struct inet_diag_bc_op *op = bc;
291
292                 switch (op->code) {
293                 case INET_DIAG_BC_NOP:
294                         break;
295                 case INET_DIAG_BC_JMP:
296                         yes = 0;
297                         break;
298                 case INET_DIAG_BC_S_GE:
299                         yes = entry->sport >= op[1].no;
300                         break;
301                 case INET_DIAG_BC_S_LE:
302                         yes = entry->dport <= op[1].no;
303                         break;
304                 case INET_DIAG_BC_D_GE:
305                         yes = entry->dport >= op[1].no;
306                         break;
307                 case INET_DIAG_BC_D_LE:
308                         yes = entry->dport <= op[1].no;
309                         break;
310                 case INET_DIAG_BC_AUTO:
311                         yes = !(entry->userlocks & SOCK_BINDPORT_LOCK);
312                         break;
313                 case INET_DIAG_BC_S_COND:
314                 case INET_DIAG_BC_D_COND: {
315                         struct inet_diag_hostcond *cond;
316                         u32 *addr;
317
318                         cond = (struct inet_diag_hostcond *)(op + 1);
319                         if (cond->port != -1 &&
320                             cond->port != (op->code == INET_DIAG_BC_S_COND ?
321                                              entry->sport : entry->dport)) {
322                                 yes = 0;
323                                 break;
324                         }
325                         
326                         if (cond->prefix_len == 0)
327                                 break;
328
329                         if (op->code == INET_DIAG_BC_S_COND)
330                                 addr = entry->saddr;
331                         else
332                                 addr = entry->daddr;
333
334                         if (bitstring_match(addr, cond->addr, cond->prefix_len))
335                                 break;
336                         if (entry->family == AF_INET6 &&
337                             cond->family == AF_INET) {
338                                 if (addr[0] == 0 && addr[1] == 0 &&
339                                     addr[2] == htonl(0xffff) &&
340                                     bitstring_match(addr + 3, cond->addr,
341                                                     cond->prefix_len))
342                                         break;
343                         }
344                         yes = 0;
345                         break;
346                 }
347                 }
348
349                 if (yes) { 
350                         len -= op->yes;
351                         bc += op->yes;
352                 } else {
353                         len -= op->no;
354                         bc += op->no;
355                 }
356         }
357         return (len == 0);
358 }
359
360 static int valid_cc(const void *bc, int len, int cc)
361 {
362         while (len >= 0) {
363                 const struct inet_diag_bc_op *op = bc;
364
365                 if (cc > len)
366                         return 0;
367                 if (cc == len)
368                         return 1;
369                 if (op->yes < 4)
370                         return 0;
371                 len -= op->yes;
372                 bc  += op->yes;
373         }
374         return 0;
375 }
376
377 static int inet_diag_bc_audit(const void *bytecode, int bytecode_len)
378 {
379         const unsigned char *bc = bytecode;
380         int  len = bytecode_len;
381
382         while (len > 0) {
383                 struct inet_diag_bc_op *op = (struct inet_diag_bc_op *)bc;
384
385 //printk("BC: %d %d %d {%d} / %d\n", op->code, op->yes, op->no, op[1].no, len);
386                 switch (op->code) {
387                 case INET_DIAG_BC_AUTO:
388                 case INET_DIAG_BC_S_COND:
389                 case INET_DIAG_BC_D_COND:
390                 case INET_DIAG_BC_S_GE:
391                 case INET_DIAG_BC_S_LE:
392                 case INET_DIAG_BC_D_GE:
393                 case INET_DIAG_BC_D_LE:
394                         if (op->yes < 4 || op->yes > len + 4)
395                                 return -EINVAL;
396                 case INET_DIAG_BC_JMP:
397                         if (op->no < 4 || op->no > len + 4)
398                                 return -EINVAL;
399                         if (op->no < len &&
400                             !valid_cc(bytecode, bytecode_len, len - op->no))
401                                 return -EINVAL;
402                         break;
403                 case INET_DIAG_BC_NOP:
404                         if (op->yes < 4 || op->yes > len + 4)
405                                 return -EINVAL;
406                         break;
407                 default:
408                         return -EINVAL;
409                 }
410                 bc += op->yes;
411                 len -= op->yes;
412         }
413         return len == 0 ? 0 : -EINVAL;
414 }
415
416 static int inet_diag_dump_sock(struct sk_buff *skb, struct sock *sk,
417                              struct netlink_callback *cb)
418 {
419         struct inet_diag_req *r = NLMSG_DATA(cb->nlh);
420
421         if (cb->nlh->nlmsg_len > 4 + NLMSG_SPACE(sizeof(*r))) {
422                 struct inet_diag_entry entry;
423                 struct rtattr *bc = (struct rtattr *)(r + 1);
424                 struct inet_sock *inet = inet_sk(sk);
425
426                 entry.family = sk->sk_family;
427 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
428                 if (entry.family == AF_INET6) {
429                         struct ipv6_pinfo *np = inet6_sk(sk);
430
431                         entry.saddr = np->rcv_saddr.s6_addr32;
432                         entry.daddr = np->daddr.s6_addr32;
433                 } else
434 #endif
435                 {
436                         entry.saddr = &inet->rcv_saddr;
437                         entry.daddr = &inet->daddr;
438                 }
439                 entry.sport = inet->num;
440                 entry.dport = ntohs(inet->dport);
441                 entry.userlocks = sk->sk_userlocks;
442
443                 if (!inet_diag_bc_run(RTA_DATA(bc), RTA_PAYLOAD(bc), &entry))
444                         return 0;
445         }
446
447         return inet_diag_fill(skb, sk, r->idiag_ext, NETLINK_CB(cb->skb).pid,
448                             cb->nlh->nlmsg_seq, NLM_F_MULTI, cb->nlh);
449 }
450
451 static int inet_diag_fill_req(struct sk_buff *skb, struct sock *sk,
452                             struct request_sock *req,
453                             u32 pid, u32 seq,
454                             const struct nlmsghdr *unlh)
455 {
456         const struct inet_request_sock *ireq = inet_rsk(req);
457         struct inet_sock *inet = inet_sk(sk);
458         unsigned char *b = skb->tail;
459         struct inet_diag_msg *r;
460         struct nlmsghdr *nlh;
461         long tmo;
462
463         nlh = NLMSG_PUT(skb, pid, seq, unlh->nlmsg_type, sizeof(*r));
464         nlh->nlmsg_flags = NLM_F_MULTI;
465         r = NLMSG_DATA(nlh);
466
467         r->idiag_family = sk->sk_family;
468         r->idiag_state = TCP_SYN_RECV;
469         r->idiag_timer = 1;
470         r->idiag_retrans = req->retrans;
471
472         r->id.idiag_if = sk->sk_bound_dev_if;
473         r->id.idiag_cookie[0] = (u32)(unsigned long)req;
474         r->id.idiag_cookie[1] = (u32)(((unsigned long)req >> 31) >> 1);
475
476         tmo = req->expires - jiffies;
477         if (tmo < 0)
478                 tmo = 0;
479
480         r->id.idiag_sport = inet->sport;
481         r->id.idiag_dport = ireq->rmt_port;
482         r->id.idiag_src[0] = ireq->loc_addr;
483         r->id.idiag_dst[0] = ireq->rmt_addr;
484         r->idiag_expires = jiffies_to_msecs(tmo);
485         r->idiag_rqueue = 0;
486         r->idiag_wqueue = 0;
487         r->idiag_uid = sock_i_uid(sk);
488         r->idiag_inode = 0;
489 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
490         if (r->idiag_family == AF_INET6) {
491                 ipv6_addr_copy((struct in6_addr *)r->id.idiag_src,
492                                &tcp6_rsk(req)->loc_addr);
493                 ipv6_addr_copy((struct in6_addr *)r->id.idiag_dst,
494                                &tcp6_rsk(req)->rmt_addr);
495         }
496 #endif
497         nlh->nlmsg_len = skb->tail - b;
498
499         return skb->len;
500
501 nlmsg_failure:
502         skb_trim(skb, b - skb->data);
503         return -1;
504 }
505
506 static int inet_diag_dump_reqs(struct sk_buff *skb, struct sock *sk,
507                              struct netlink_callback *cb)
508 {
509         struct inet_diag_entry entry;
510         struct inet_diag_req *r = NLMSG_DATA(cb->nlh);
511         struct inet_connection_sock *icsk = inet_csk(sk);
512         struct listen_sock *lopt;
513         struct rtattr *bc = NULL;
514         struct inet_sock *inet = inet_sk(sk);
515         int j, s_j;
516         int reqnum, s_reqnum;
517         int err = 0;
518
519         s_j = cb->args[3];
520         s_reqnum = cb->args[4];
521
522         if (s_j > 0)
523                 s_j--;
524
525         entry.family = sk->sk_family;
526
527         read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
528
529         lopt = icsk->icsk_accept_queue.listen_opt;
530         if (!lopt || !lopt->qlen)
531                 goto out;
532
533         if (cb->nlh->nlmsg_len > 4 + NLMSG_SPACE(sizeof(*r))) {
534                 bc = (struct rtattr *)(r + 1);
535                 entry.sport = inet->num;
536                 entry.userlocks = sk->sk_userlocks;
537         }
538
539         for (j = s_j; j < lopt->nr_table_entries; j++) {
540                 struct request_sock *req, *head = lopt->syn_table[j];
541
542                 reqnum = 0;
543                 for (req = head; req; reqnum++, req = req->dl_next) {
544                         struct inet_request_sock *ireq = inet_rsk(req);
545
546                         if (reqnum < s_reqnum)
547                                 continue;
548                         if (r->id.idiag_dport != ireq->rmt_port &&
549                             r->id.idiag_dport)
550                                 continue;
551
552                         if (bc) {
553                                 entry.saddr =
554 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
555                                         (entry.family == AF_INET6) ?
556                                         tcp6_rsk(req)->loc_addr.s6_addr32 :
557 #endif
558                                         &ireq->loc_addr;
559                                 entry.daddr = 
560 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
561                                         (entry.family == AF_INET6) ?
562                                         tcp6_rsk(req)->rmt_addr.s6_addr32 :
563 #endif
564                                         &ireq->rmt_addr;
565                                 entry.dport = ntohs(ireq->rmt_port);
566
567                                 if (!inet_diag_bc_run(RTA_DATA(bc),
568                                                     RTA_PAYLOAD(bc), &entry))
569                                         continue;
570                         }
571
572                         err = inet_diag_fill_req(skb, sk, req,
573                                                NETLINK_CB(cb->skb).pid,
574                                                cb->nlh->nlmsg_seq, cb->nlh);
575                         if (err < 0) {
576                                 cb->args[3] = j + 1;
577                                 cb->args[4] = reqnum;
578                                 goto out;
579                         }
580                 }
581
582                 s_reqnum = 0;
583         }
584
585 out:
586         read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
587
588         return err;
589 }
590
591 static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
592 {
593         int i, num;
594         int s_i, s_num;
595         struct inet_diag_req *r = NLMSG_DATA(cb->nlh);
596         const struct inet_diag_handler *handler;
597         struct inet_hashinfo *hashinfo;
598
599         handler = inet_diag_table[cb->nlh->nlmsg_type];
600         BUG_ON(handler == NULL);
601         hashinfo = handler->idiag_hashinfo;
602                 
603         s_i = cb->args[1];
604         s_num = num = cb->args[2];
605
606         if (cb->args[0] == 0) {
607                 if (!(r->idiag_states & (TCPF_LISTEN | TCPF_SYN_RECV)))
608                         goto skip_listen_ht;
609
610                 inet_listen_lock(hashinfo);
611                 for (i = s_i; i < INET_LHTABLE_SIZE; i++) {
612                         struct sock *sk;
613                         struct hlist_node *node;
614
615                         num = 0;
616                         sk_for_each(sk, node, &hashinfo->listening_hash[i]) {
617                                 struct inet_sock *inet = inet_sk(sk);
618
619                                 if (num < s_num) {
620                                         num++;
621                                         continue;
622                                 }
623
624                                 if (r->id.idiag_sport != inet->sport &&
625                                     r->id.idiag_sport)
626                                         goto next_listen;
627
628                                 if (!(r->idiag_states & TCPF_LISTEN) ||
629                                     r->id.idiag_dport ||
630                                     cb->args[3] > 0)
631                                         goto syn_recv;
632
633                                 if (inet_diag_dump_sock(skb, sk, cb) < 0) {
634                                         inet_listen_unlock(hashinfo);
635                                         goto done;
636                                 }
637
638 syn_recv:
639                                 if (!(r->idiag_states & TCPF_SYN_RECV))
640                                         goto next_listen;
641
642                                 if (inet_diag_dump_reqs(skb, sk, cb) < 0) {
643                                         inet_listen_unlock(hashinfo);
644                                         goto done;
645                                 }
646
647 next_listen:
648                                 cb->args[3] = 0;
649                                 cb->args[4] = 0;
650                                 ++num;
651                         }
652
653                         s_num = 0;
654                         cb->args[3] = 0;
655                         cb->args[4] = 0;
656                 }
657                 inet_listen_unlock(hashinfo);
658 skip_listen_ht:
659                 cb->args[0] = 1;
660                 s_i = num = s_num = 0;
661         }
662
663         if (!(r->idiag_states & ~(TCPF_LISTEN | TCPF_SYN_RECV)))
664                 return skb->len;
665
666         for (i = s_i; i < hashinfo->ehash_size; i++) {
667                 struct inet_ehash_bucket *head = &hashinfo->ehash[i];
668                 struct sock *sk;
669                 struct hlist_node *node;
670
671                 if (i > s_i)
672                         s_num = 0;
673
674                 read_lock_bh(&head->lock);
675
676                 num = 0;
677                 sk_for_each(sk, node, &head->chain) {
678                         struct inet_sock *inet = inet_sk(sk);
679
680                         if (num < s_num)
681                                 goto next_normal;
682                         if (!(r->idiag_states & (1 << sk->sk_state)))
683                                 goto next_normal;
684                         if (r->id.idiag_sport != inet->sport &&
685                             r->id.idiag_sport)
686                                 goto next_normal;
687                         if (r->id.idiag_dport != inet->dport && r->id.idiag_dport)
688                                 goto next_normal;
689                         if (inet_diag_dump_sock(skb, sk, cb) < 0) {
690                                 read_unlock_bh(&head->lock);
691                                 goto done;
692                         }
693 next_normal:
694                         ++num;
695                 }
696
697                 if (r->idiag_states & TCPF_TIME_WAIT) {
698                         sk_for_each(sk, node,
699                                     &hashinfo->ehash[i + hashinfo->ehash_size].chain) {
700                                 struct inet_sock *inet = inet_sk(sk);
701
702                                 if (num < s_num)
703                                         goto next_dying;
704                                 if (r->id.idiag_sport != inet->sport &&
705                                     r->id.idiag_sport)
706                                         goto next_dying;
707                                 if (r->id.idiag_dport != inet->dport &&
708                                     r->id.idiag_dport)
709                                         goto next_dying;
710                                 if (inet_diag_dump_sock(skb, sk, cb) < 0) {
711                                         read_unlock_bh(&head->lock);
712                                         goto done;
713                                 }
714 next_dying:
715                                 ++num;
716                         }
717                 }
718                 read_unlock_bh(&head->lock);
719         }
720
721 done:
722         cb->args[1] = i;
723         cb->args[2] = num;
724         return skb->len;
725 }
726
727 static __inline__ int
728 inet_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
729 {
730         if (!(nlh->nlmsg_flags&NLM_F_REQUEST))
731                 return 0;
732
733         if (nlh->nlmsg_type >= INET_DIAG_GETSOCK_MAX)
734                 goto err_inval;
735
736         if (inet_diag_table[nlh->nlmsg_type] == NULL)
737                 return -ENOENT;
738
739         if (NLMSG_LENGTH(sizeof(struct inet_diag_req)) > skb->len)
740                 goto err_inval;
741
742         if (nlh->nlmsg_flags&NLM_F_DUMP) {
743                 if (nlh->nlmsg_len >
744                     (4 + NLMSG_SPACE(sizeof(struct inet_diag_req)))) {
745                         struct rtattr *rta = (void *)(NLMSG_DATA(nlh) +
746                                                  sizeof(struct inet_diag_req));
747                         if (rta->rta_type != INET_DIAG_REQ_BYTECODE ||
748                             rta->rta_len < 8 ||
749                             rta->rta_len >
750                             (nlh->nlmsg_len -
751                              NLMSG_SPACE(sizeof(struct inet_diag_req))))
752                                 goto err_inval;
753                         if (inet_diag_bc_audit(RTA_DATA(rta), RTA_PAYLOAD(rta)))
754                                 goto err_inval;
755                 }
756                 return netlink_dump_start(idiagnl, skb, nlh,
757                                           inet_diag_dump, NULL);
758         } else {
759                 return inet_diag_get_exact(skb, nlh);
760         }
761
762 err_inval:
763         return -EINVAL;
764 }
765
766
767 static inline void inet_diag_rcv_skb(struct sk_buff *skb)
768 {
769         int err;
770         struct nlmsghdr * nlh;
771
772         if (skb->len >= NLMSG_SPACE(0)) {
773                 nlh = (struct nlmsghdr *)skb->data;
774                 if (nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len)
775                         return;
776                 err = inet_diag_rcv_msg(skb, nlh);
777                 if (err || nlh->nlmsg_flags & NLM_F_ACK) 
778                         netlink_ack(skb, nlh, err);
779         }
780 }
781
782 static void inet_diag_rcv(struct sock *sk, int len)
783 {
784         struct sk_buff *skb;
785         unsigned int qlen = skb_queue_len(&sk->sk_receive_queue);
786
787         while (qlen-- && (skb = skb_dequeue(&sk->sk_receive_queue))) {
788                 inet_diag_rcv_skb(skb);
789                 kfree_skb(skb);
790         }
791 }
792
793 static DEFINE_SPINLOCK(inet_diag_register_lock);
794
795 int inet_diag_register(const struct inet_diag_handler *h)
796 {
797         const __u16 type = h->idiag_type;
798         int err = -EINVAL;
799
800         if (type >= INET_DIAG_GETSOCK_MAX)
801                 goto out;
802
803         spin_lock(&inet_diag_register_lock);
804         err = -EEXIST;
805         if (inet_diag_table[type] == NULL) {
806                 inet_diag_table[type] = h;
807                 err = 0;
808         }
809         spin_unlock(&inet_diag_register_lock);
810 out:
811         return err;
812 }
813 EXPORT_SYMBOL_GPL(inet_diag_register);
814
815 void inet_diag_unregister(const struct inet_diag_handler *h)
816 {
817         const __u16 type = h->idiag_type;
818
819         if (type >= INET_DIAG_GETSOCK_MAX)
820                 return;
821
822         spin_lock(&inet_diag_register_lock);
823         inet_diag_table[type] = NULL;
824         spin_unlock(&inet_diag_register_lock);
825
826         synchronize_rcu();
827 }
828 EXPORT_SYMBOL_GPL(inet_diag_unregister);
829
830 static int __init inet_diag_init(void)
831 {
832         const int inet_diag_table_size = (INET_DIAG_GETSOCK_MAX *
833                                           sizeof(struct inet_diag_handler *));
834         int err = -ENOMEM;
835
836         inet_diag_table = kmalloc(inet_diag_table_size, GFP_KERNEL);
837         if (!inet_diag_table)
838                 goto out;
839
840         memset(inet_diag_table, 0, inet_diag_table_size);
841         idiagnl = netlink_kernel_create(NETLINK_INET_DIAG, 0, inet_diag_rcv,
842                                         THIS_MODULE);
843         if (idiagnl == NULL)
844                 goto out_free_table;
845         err = 0;
846 out:
847         return err;
848 out_free_table:
849         kfree(inet_diag_table);
850         goto out;
851 }
852
853 static void __exit inet_diag_exit(void)
854 {
855         sock_release(idiagnl->sk_socket);
856         kfree(inet_diag_table);
857 }
858
859 module_init(inet_diag_init);
860 module_exit(inet_diag_exit);
861 MODULE_LICENSE("GPL");