1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <linux/module.h> 3 4 #include <net/sock.h> 5 #include <linux/netlink.h> 6 #include <linux/sock_diag.h> 7 #include <linux/netlink_diag.h> 8 #include <linux/rhashtable.h> 9 10 #include "af_netlink.h" 11 12 static int sk_diag_dump_groups(struct sock *sk, struct sk_buff *nlskb) 13 { 14 struct netlink_sock *nlk = nlk_sk(sk); 15 16 if (nlk->groups == NULL) 17 return 0; 18 19 return nla_put(nlskb, NETLINK_DIAG_GROUPS, NLGRPSZ(nlk->ngroups), 20 nlk->groups); 21 } 22 23 static int sk_diag_put_flags(struct sock *sk, struct sk_buff *skb) 24 { 25 struct netlink_sock *nlk = nlk_sk(sk); 26 u32 flags = 0; 27 28 if (nlk->cb_running) 29 flags |= NDIAG_FLAG_CB_RUNNING; 30 if (nlk->flags & NETLINK_F_RECV_PKTINFO) 31 flags |= NDIAG_FLAG_PKTINFO; 32 if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR) 33 flags |= NDIAG_FLAG_BROADCAST_ERROR; 34 if (nlk->flags & NETLINK_F_RECV_NO_ENOBUFS) 35 flags |= NDIAG_FLAG_NO_ENOBUFS; 36 if (nlk->flags & NETLINK_F_LISTEN_ALL_NSID) 37 flags |= NDIAG_FLAG_LISTEN_ALL_NSID; 38 if (nlk->flags & NETLINK_F_CAP_ACK) 39 flags |= NDIAG_FLAG_CAP_ACK; 40 41 return nla_put_u32(skb, NETLINK_DIAG_FLAGS, flags); 42 } 43 44 static int sk_diag_fill(struct sock *sk, struct sk_buff *skb, 45 struct netlink_diag_req *req, 46 u32 portid, u32 seq, u32 flags, int sk_ino) 47 { 48 struct nlmsghdr *nlh; 49 struct netlink_diag_msg *rep; 50 struct netlink_sock *nlk = nlk_sk(sk); 51 52 nlh = nlmsg_put(skb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*rep), 53 flags); 54 if (!nlh) 55 return -EMSGSIZE; 56 57 rep = nlmsg_data(nlh); 58 rep->ndiag_family = AF_NETLINK; 59 rep->ndiag_type = sk->sk_type; 60 rep->ndiag_protocol = sk->sk_protocol; 61 rep->ndiag_state = sk->sk_state; 62 63 rep->ndiag_ino = sk_ino; 64 rep->ndiag_portid = nlk->portid; 65 rep->ndiag_dst_portid = nlk->dst_portid; 66 rep->ndiag_dst_group = nlk->dst_group; 67 sock_diag_save_cookie(sk, rep->ndiag_cookie); 68 69 if ((req->ndiag_show & NDIAG_SHOW_GROUPS) && 70 sk_diag_dump_groups(sk, skb)) 71 goto out_nlmsg_trim; 72 73 if ((req->ndiag_show & NDIAG_SHOW_MEMINFO) && 74 sock_diag_put_meminfo(sk, skb, NETLINK_DIAG_MEMINFO)) 75 goto out_nlmsg_trim; 76 77 if ((req->ndiag_show & NDIAG_SHOW_FLAGS) && 78 sk_diag_put_flags(sk, skb)) 79 goto out_nlmsg_trim; 80 81 nlmsg_end(skb, nlh); 82 return 0; 83 84 out_nlmsg_trim: 85 nlmsg_cancel(skb, nlh); 86 return -EMSGSIZE; 87 } 88 89 static int __netlink_diag_dump(struct sk_buff *skb, struct netlink_callback *cb, 90 int protocol, int s_num) 91 { 92 struct rhashtable_iter *hti = (void *)cb->args[2]; 93 struct netlink_table *tbl = &nl_table[protocol]; 94 struct net *net = sock_net(skb->sk); 95 struct netlink_diag_req *req; 96 struct netlink_sock *nlsk; 97 struct sock *sk; 98 int num = 2; 99 int ret = 0; 100 101 req = nlmsg_data(cb->nlh); 102 103 if (s_num > 1) 104 goto mc_list; 105 106 num--; 107 108 if (!hti) { 109 hti = kmalloc(sizeof(*hti), GFP_KERNEL); 110 if (!hti) 111 return -ENOMEM; 112 113 cb->args[2] = (long)hti; 114 } 115 116 if (!s_num) 117 rhashtable_walk_enter(&tbl->hash, hti); 118 119 rhashtable_walk_start(hti); 120 121 while ((nlsk = rhashtable_walk_next(hti))) { 122 if (IS_ERR(nlsk)) { 123 ret = PTR_ERR(nlsk); 124 if (ret == -EAGAIN) { 125 ret = 0; 126 continue; 127 } 128 break; 129 } 130 131 sk = (struct sock *)nlsk; 132 133 if (!net_eq(sock_net(sk), net)) 134 continue; 135 136 if (sk_diag_fill(sk, skb, req, 137 NETLINK_CB(cb->skb).portid, 138 cb->nlh->nlmsg_seq, 139 NLM_F_MULTI, 140 sock_i_ino(sk)) < 0) { 141 ret = 1; 142 break; 143 } 144 } 145 146 rhashtable_walk_stop(hti); 147 148 if (ret) 149 goto done; 150 151 rhashtable_walk_exit(hti); 152 num++; 153 154 mc_list: 155 read_lock(&nl_table_lock); 156 sk_for_each_bound(sk, &tbl->mc_list) { 157 if (sk_hashed(sk)) 158 continue; 159 if (!net_eq(sock_net(sk), net)) 160 continue; 161 if (num < s_num) { 162 num++; 163 continue; 164 } 165 166 if (sk_diag_fill(sk, skb, req, 167 NETLINK_CB(cb->skb).portid, 168 cb->nlh->nlmsg_seq, 169 NLM_F_MULTI, 170 sock_i_ino(sk)) < 0) { 171 ret = 1; 172 break; 173 } 174 num++; 175 } 176 read_unlock(&nl_table_lock); 177 178 done: 179 cb->args[0] = num; 180 181 return ret; 182 } 183 184 static int netlink_diag_dump(struct sk_buff *skb, struct netlink_callback *cb) 185 { 186 struct netlink_diag_req *req; 187 int s_num = cb->args[0]; 188 int err = 0; 189 190 req = nlmsg_data(cb->nlh); 191 192 if (req->sdiag_protocol == NDIAG_PROTO_ALL) { 193 int i; 194 195 for (i = cb->args[1]; i < MAX_LINKS; i++) { 196 err = __netlink_diag_dump(skb, cb, i, s_num); 197 if (err) 198 break; 199 s_num = 0; 200 } 201 cb->args[1] = i; 202 } else { 203 if (req->sdiag_protocol >= MAX_LINKS) 204 return -ENOENT; 205 206 err = __netlink_diag_dump(skb, cb, req->sdiag_protocol, s_num); 207 } 208 209 return err < 0 ? err : skb->len; 210 } 211 212 static int netlink_diag_dump_done(struct netlink_callback *cb) 213 { 214 struct rhashtable_iter *hti = (void *)cb->args[2]; 215 216 if (cb->args[0] == 1) 217 rhashtable_walk_exit(hti); 218 219 kfree(hti); 220 221 return 0; 222 } 223 224 static int netlink_diag_handler_dump(struct sk_buff *skb, struct nlmsghdr *h) 225 { 226 int hdrlen = sizeof(struct netlink_diag_req); 227 struct net *net = sock_net(skb->sk); 228 229 if (nlmsg_len(h) < hdrlen) 230 return -EINVAL; 231 232 if (h->nlmsg_flags & NLM_F_DUMP) { 233 struct netlink_dump_control c = { 234 .dump = netlink_diag_dump, 235 .done = netlink_diag_dump_done, 236 }; 237 return netlink_dump_start(net->diag_nlsk, skb, h, &c); 238 } else 239 return -EOPNOTSUPP; 240 } 241 242 static const struct sock_diag_handler netlink_diag_handler = { 243 .family = AF_NETLINK, 244 .dump = netlink_diag_handler_dump, 245 }; 246 247 static int __init netlink_diag_init(void) 248 { 249 return sock_diag_register(&netlink_diag_handler); 250 } 251 252 static void __exit netlink_diag_exit(void) 253 { 254 sock_diag_unregister(&netlink_diag_handler); 255 } 256 257 module_init(netlink_diag_init); 258 module_exit(netlink_diag_exit); 259 MODULE_LICENSE("GPL"); 260 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 16 /* AF_NETLINK */); 261