udp_diag.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * udp_diag.c Module for monitoring UDP transport protocols sockets.
  4. *
  5. * Authors: Pavel Emelyanov, <xemul@parallels.com>
  6. */
  7. #include <linux/module.h>
  8. #include <linux/inet_diag.h>
  9. #include <linux/udp.h>
  10. #include <net/udp.h>
  11. #include <net/udplite.h>
  12. #include <linux/sock_diag.h>
  13. static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
  14. struct netlink_callback *cb,
  15. const struct inet_diag_req_v2 *req,
  16. struct nlattr *bc, bool net_admin)
  17. {
  18. if (!inet_diag_bc_sk(bc, sk))
  19. return 0;
  20. return inet_sk_diag_fill(sk, NULL, skb, cb, req, NLM_F_MULTI,
  21. net_admin);
  22. }
  23. static int udp_dump_one(struct udp_table *tbl,
  24. struct netlink_callback *cb,
  25. const struct inet_diag_req_v2 *req)
  26. {
  27. struct sk_buff *in_skb = cb->skb;
  28. int err = -EINVAL;
  29. struct sock *sk = NULL;
  30. struct sk_buff *rep;
  31. struct net *net = sock_net(in_skb->sk);
  32. rcu_read_lock();
  33. if (req->sdiag_family == AF_INET)
  34. /* src and dst are swapped for historical reasons */
  35. sk = __udp4_lib_lookup(net,
  36. req->id.idiag_src[0], req->id.idiag_sport,
  37. req->id.idiag_dst[0], req->id.idiag_dport,
  38. req->id.idiag_if, 0, tbl, NULL);
  39. #if IS_ENABLED(CONFIG_IPV6)
  40. else if (req->sdiag_family == AF_INET6)
  41. sk = __udp6_lib_lookup(net,
  42. (struct in6_addr *)req->id.idiag_src,
  43. req->id.idiag_sport,
  44. (struct in6_addr *)req->id.idiag_dst,
  45. req->id.idiag_dport,
  46. req->id.idiag_if, 0, tbl, NULL);
  47. #endif
  48. if (sk && !refcount_inc_not_zero(&sk->sk_refcnt))
  49. sk = NULL;
  50. rcu_read_unlock();
  51. err = -ENOENT;
  52. if (!sk)
  53. goto out_nosk;
  54. err = sock_diag_check_cookie(sk, req->id.idiag_cookie);
  55. if (err)
  56. goto out;
  57. err = -ENOMEM;
  58. rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
  59. inet_diag_msg_attrs_size() +
  60. nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
  61. GFP_KERNEL);
  62. if (!rep)
  63. goto out;
  64. err = inet_sk_diag_fill(sk, NULL, rep, cb, req, 0,
  65. netlink_net_capable(in_skb, CAP_NET_ADMIN));
  66. if (err < 0) {
  67. WARN_ON(err == -EMSGSIZE);
  68. kfree_skb(rep);
  69. goto out;
  70. }
  71. err = netlink_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid,
  72. MSG_DONTWAIT);
  73. if (err > 0)
  74. err = 0;
  75. out:
  76. if (sk)
  77. sock_put(sk);
  78. out_nosk:
  79. return err;
  80. }
  81. static void udp_dump(struct udp_table *table, struct sk_buff *skb,
  82. struct netlink_callback *cb,
  83. const struct inet_diag_req_v2 *r)
  84. {
  85. bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
  86. struct net *net = sock_net(skb->sk);
  87. struct inet_diag_dump_data *cb_data;
  88. int num, s_num, slot, s_slot;
  89. struct nlattr *bc;
  90. cb_data = cb->data;
  91. bc = cb_data->inet_diag_nla_bc;
  92. s_slot = cb->args[0];
  93. num = s_num = cb->args[1];
  94. for (slot = s_slot; slot <= table->mask; s_num = 0, slot++) {
  95. struct udp_hslot *hslot = &table->hash[slot];
  96. struct sock *sk;
  97. num = 0;
  98. if (hlist_empty(&hslot->head))
  99. continue;
  100. spin_lock_bh(&hslot->lock);
  101. sk_for_each(sk, &hslot->head) {
  102. struct inet_sock *inet = inet_sk(sk);
  103. if (!net_eq(sock_net(sk), net))
  104. continue;
  105. if (num < s_num)
  106. goto next;
  107. if (!(r->idiag_states & (1 << sk->sk_state)))
  108. goto next;
  109. if (r->sdiag_family != AF_UNSPEC &&
  110. sk->sk_family != r->sdiag_family)
  111. goto next;
  112. if (r->id.idiag_sport != inet->inet_sport &&
  113. r->id.idiag_sport)
  114. goto next;
  115. if (r->id.idiag_dport != inet->inet_dport &&
  116. r->id.idiag_dport)
  117. goto next;
  118. if (sk_diag_dump(sk, skb, cb, r, bc, net_admin) < 0) {
  119. spin_unlock_bh(&hslot->lock);
  120. goto done;
  121. }
  122. next:
  123. num++;
  124. }
  125. spin_unlock_bh(&hslot->lock);
  126. }
  127. done:
  128. cb->args[0] = slot;
  129. cb->args[1] = num;
  130. }
  131. static void udp_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
  132. const struct inet_diag_req_v2 *r)
  133. {
  134. udp_dump(&udp_table, skb, cb, r);
  135. }
  136. static int udp_diag_dump_one(struct netlink_callback *cb,
  137. const struct inet_diag_req_v2 *req)
  138. {
  139. return udp_dump_one(&udp_table, cb, req);
  140. }
  141. static void udp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
  142. void *info)
  143. {
  144. r->idiag_rqueue = udp_rqueue_get(sk);
  145. r->idiag_wqueue = sk_wmem_alloc_get(sk);
  146. }
  147. #ifdef CONFIG_INET_DIAG_DESTROY
  148. static int __udp_diag_destroy(struct sk_buff *in_skb,
  149. const struct inet_diag_req_v2 *req,
  150. struct udp_table *tbl)
  151. {
  152. struct net *net = sock_net(in_skb->sk);
  153. struct sock *sk;
  154. int err;
  155. rcu_read_lock();
  156. if (req->sdiag_family == AF_INET)
  157. sk = __udp4_lib_lookup(net,
  158. req->id.idiag_dst[0], req->id.idiag_dport,
  159. req->id.idiag_src[0], req->id.idiag_sport,
  160. req->id.idiag_if, 0, tbl, NULL);
  161. #if IS_ENABLED(CONFIG_IPV6)
  162. else if (req->sdiag_family == AF_INET6) {
  163. if (ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_dst) &&
  164. ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_src))
  165. sk = __udp4_lib_lookup(net,
  166. req->id.idiag_dst[3], req->id.idiag_dport,
  167. req->id.idiag_src[3], req->id.idiag_sport,
  168. req->id.idiag_if, 0, tbl, NULL);
  169. else
  170. sk = __udp6_lib_lookup(net,
  171. (struct in6_addr *)req->id.idiag_dst,
  172. req->id.idiag_dport,
  173. (struct in6_addr *)req->id.idiag_src,
  174. req->id.idiag_sport,
  175. req->id.idiag_if, 0, tbl, NULL);
  176. }
  177. #endif
  178. else {
  179. rcu_read_unlock();
  180. return -EINVAL;
  181. }
  182. if (sk && !refcount_inc_not_zero(&sk->sk_refcnt))
  183. sk = NULL;
  184. rcu_read_unlock();
  185. if (!sk)
  186. return -ENOENT;
  187. if (sock_diag_check_cookie(sk, req->id.idiag_cookie)) {
  188. sock_put(sk);
  189. return -ENOENT;
  190. }
  191. err = sock_diag_destroy(sk, ECONNABORTED);
  192. sock_put(sk);
  193. return err;
  194. }
  195. static int udp_diag_destroy(struct sk_buff *in_skb,
  196. const struct inet_diag_req_v2 *req)
  197. {
  198. return __udp_diag_destroy(in_skb, req, &udp_table);
  199. }
  200. static int udplite_diag_destroy(struct sk_buff *in_skb,
  201. const struct inet_diag_req_v2 *req)
  202. {
  203. return __udp_diag_destroy(in_skb, req, &udplite_table);
  204. }
  205. #endif
  206. static const struct inet_diag_handler udp_diag_handler = {
  207. .dump = udp_diag_dump,
  208. .dump_one = udp_diag_dump_one,
  209. .idiag_get_info = udp_diag_get_info,
  210. .idiag_type = IPPROTO_UDP,
  211. .idiag_info_size = 0,
  212. #ifdef CONFIG_INET_DIAG_DESTROY
  213. .destroy = udp_diag_destroy,
  214. #endif
  215. };
  216. static void udplite_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
  217. const struct inet_diag_req_v2 *r)
  218. {
  219. udp_dump(&udplite_table, skb, cb, r);
  220. }
  221. static int udplite_diag_dump_one(struct netlink_callback *cb,
  222. const struct inet_diag_req_v2 *req)
  223. {
  224. return udp_dump_one(&udplite_table, cb, req);
  225. }
  226. static const struct inet_diag_handler udplite_diag_handler = {
  227. .dump = udplite_diag_dump,
  228. .dump_one = udplite_diag_dump_one,
  229. .idiag_get_info = udp_diag_get_info,
  230. .idiag_type = IPPROTO_UDPLITE,
  231. .idiag_info_size = 0,
  232. #ifdef CONFIG_INET_DIAG_DESTROY
  233. .destroy = udplite_diag_destroy,
  234. #endif
  235. };
  236. static int __init udp_diag_init(void)
  237. {
  238. int err;
  239. err = inet_diag_register(&udp_diag_handler);
  240. if (err)
  241. goto out;
  242. err = inet_diag_register(&udplite_diag_handler);
  243. if (err)
  244. goto out_lite;
  245. out:
  246. return err;
  247. out_lite:
  248. inet_diag_unregister(&udp_diag_handler);
  249. goto out;
  250. }
  251. static void __exit udp_diag_exit(void)
  252. {
  253. inet_diag_unregister(&udplite_diag_handler);
  254. inet_diag_unregister(&udp_diag_handler);
  255. }
  256. module_init(udp_diag_init);
  257. module_exit(udp_diag_exit);
  258. MODULE_LICENSE("GPL");
  259. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-17 /* AF_INET - IPPROTO_UDP */);
  260. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-136 /* AF_INET - IPPROTO_UDPLITE */);