net: kill duplicate included header
[linux-2.6.git] / net / ipv4 / udp_diag.c
1 /*
2  * udp_diag.c   Module for monitoring UDP transport protocols sockets.
3  *
4  * Authors:     Pavel Emelyanov, <xemul@parallels.com>
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License
8  *      as published by the Free Software Foundation; either version
9  *      2 of the License, or (at your option) any later version.
10  */
11
12
13 #include <linux/module.h>
14 #include <linux/inet_diag.h>
15 #include <linux/udp.h>
16 #include <net/udp.h>
17 #include <net/udplite.h>
18 #include <linux/sock_diag.h>
19
20 static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
21                 struct netlink_callback *cb, struct inet_diag_req_v2 *req,
22                 struct nlattr *bc)
23 {
24         if (!inet_diag_bc_sk(bc, sk))
25                 return 0;
26
27         return inet_sk_diag_fill(sk, NULL, skb, req, NETLINK_CB(cb->skb).pid,
28                         cb->nlh->nlmsg_seq, NLM_F_MULTI, cb->nlh);
29 }
30
31 static int udp_dump_one(struct udp_table *tbl, struct sk_buff *in_skb,
32                 const struct nlmsghdr *nlh, struct inet_diag_req_v2 *req)
33 {
34         int err = -EINVAL;
35         struct sock *sk;
36         struct sk_buff *rep;
37
38         if (req->sdiag_family == AF_INET)
39                 sk = __udp4_lib_lookup(&init_net,
40                                 req->id.idiag_src[0], req->id.idiag_sport,
41                                 req->id.idiag_dst[0], req->id.idiag_dport,
42                                 req->id.idiag_if, tbl);
43 #if IS_ENABLED(CONFIG_IPV6)
44         else if (req->sdiag_family == AF_INET6)
45                 sk = __udp6_lib_lookup(&init_net,
46                                 (struct in6_addr *)req->id.idiag_src,
47                                 req->id.idiag_sport,
48                                 (struct in6_addr *)req->id.idiag_dst,
49                                 req->id.idiag_dport,
50                                 req->id.idiag_if, tbl);
51 #endif
52         else
53                 goto out_nosk;
54
55         err = -ENOENT;
56         if (sk == NULL)
57                 goto out_nosk;
58
59         err = sock_diag_check_cookie(sk, req->id.idiag_cookie);
60         if (err)
61                 goto out;
62
63         err = -ENOMEM;
64         rep = alloc_skb(NLMSG_SPACE((sizeof(struct inet_diag_msg) +
65                                      sizeof(struct inet_diag_meminfo) +
66                                      64)), GFP_KERNEL);
67         if (!rep)
68                 goto out;
69
70         err = inet_sk_diag_fill(sk, NULL, rep, req,
71                            NETLINK_CB(in_skb).pid,
72                            nlh->nlmsg_seq, 0, nlh);
73         if (err < 0) {
74                 WARN_ON(err == -EMSGSIZE);
75                 kfree_skb(rep);
76                 goto out;
77         }
78         err = netlink_unicast(sock_diag_nlsk, rep, NETLINK_CB(in_skb).pid,
79                               MSG_DONTWAIT);
80         if (err > 0)
81                 err = 0;
82 out:
83         if (sk)
84                 sock_put(sk);
85 out_nosk:
86         return err;
87 }
88
89 static void udp_dump(struct udp_table *table, struct sk_buff *skb, struct netlink_callback *cb,
90                 struct inet_diag_req_v2 *r, struct nlattr *bc)
91 {
92         int num, s_num, slot, s_slot;
93
94         s_slot = cb->args[0];
95         num = s_num = cb->args[1];
96
97         for (slot = s_slot; slot <= table->mask; num = s_num = 0, slot++) {
98                 struct sock *sk;
99                 struct hlist_nulls_node *node;
100                 struct udp_hslot *hslot = &table->hash[slot];
101
102                 if (hlist_nulls_empty(&hslot->head))
103                         continue;
104
105                 spin_lock_bh(&hslot->lock);
106                 sk_nulls_for_each(sk, node, &hslot->head) {
107                         struct inet_sock *inet = inet_sk(sk);
108
109                         if (num < s_num)
110                                 goto next;
111                         if (!(r->idiag_states & (1 << sk->sk_state)))
112                                 goto next;
113                         if (r->sdiag_family != AF_UNSPEC &&
114                                         sk->sk_family != r->sdiag_family)
115                                 goto next;
116                         if (r->id.idiag_sport != inet->inet_sport &&
117                             r->id.idiag_sport)
118                                 goto next;
119                         if (r->id.idiag_dport != inet->inet_dport &&
120                             r->id.idiag_dport)
121                                 goto next;
122
123                         if (sk_diag_dump(sk, skb, cb, r, bc) < 0) {
124                                 spin_unlock_bh(&hslot->lock);
125                                 goto done;
126                         }
127 next:
128                         num++;
129                 }
130                 spin_unlock_bh(&hslot->lock);
131         }
132 done:
133         cb->args[0] = slot;
134         cb->args[1] = num;
135 }
136
137 static void udp_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
138                 struct inet_diag_req_v2 *r, struct nlattr *bc)
139 {
140         udp_dump(&udp_table, skb, cb, r, bc);
141 }
142
143 static int udp_diag_dump_one(struct sk_buff *in_skb, const struct nlmsghdr *nlh,
144                 struct inet_diag_req_v2 *req)
145 {
146         return udp_dump_one(&udp_table, in_skb, nlh, req);
147 }
148
149 static const struct inet_diag_handler udp_diag_handler = {
150         .dump            = udp_diag_dump,
151         .dump_one        = udp_diag_dump_one,
152         .idiag_type      = IPPROTO_UDP,
153 };
154
155 static void udplite_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
156                 struct inet_diag_req_v2 *r, struct nlattr *bc)
157 {
158         udp_dump(&udplite_table, skb, cb, r, bc);
159 }
160
161 static int udplite_diag_dump_one(struct sk_buff *in_skb, const struct nlmsghdr *nlh,
162                 struct inet_diag_req_v2 *req)
163 {
164         return udp_dump_one(&udplite_table, in_skb, nlh, req);
165 }
166
167 static const struct inet_diag_handler udplite_diag_handler = {
168         .dump            = udplite_diag_dump,
169         .dump_one        = udplite_diag_dump_one,
170         .idiag_type      = IPPROTO_UDPLITE,
171 };
172
173 static int __init udp_diag_init(void)
174 {
175         int err;
176
177         err = inet_diag_register(&udp_diag_handler);
178         if (err)
179                 goto out;
180         err = inet_diag_register(&udplite_diag_handler);
181         if (err)
182                 goto out_lite;
183 out:
184         return err;
185 out_lite:
186         inet_diag_unregister(&udp_diag_handler);
187         goto out;
188 }
189
190 static void __exit udp_diag_exit(void)
191 {
192         inet_diag_unregister(&udplite_diag_handler);
193         inet_diag_unregister(&udp_diag_handler);
194 }
195
196 module_init(udp_diag_init);
197 module_exit(udp_diag_exit);
198 MODULE_LICENSE("GPL");
199 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-17 /* AF_INET - IPPROTO_UDP */);
200 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-136 /* AF_INET - IPPROTO_UDPLITE */);