1 | /* |
2 | * Copyright (c) 2014 Intel Corporation. All rights reserved. |
3 | * Copyright (c) 2014 Chelsio, Inc. All rights reserved. |
4 | * |
5 | * This software is available to you under a choice of one of two |
6 | * licenses. You may choose to be licensed under the terms of the GNU |
7 | * General Public License (GPL) Version 2, available from the file |
8 | * COPYING in the main directory of this source tree, or the |
9 | * OpenIB.org BSD license below: |
10 | * |
11 | * Redistribution and use in source and binary forms, with or |
12 | * without modification, are permitted provided that the following |
13 | * conditions are met: |
14 | * |
15 | * - Redistributions of source code must retain the above |
16 | * copyright notice, this list of conditions and the following |
17 | * disclaimer. |
18 | * |
19 | * - Redistributions in binary form must reproduce the above |
20 | * copyright notice, this list of conditions and the following |
21 | * disclaimer in the documentation and/or other materials |
22 | * provided with the distribution. |
23 | * |
24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
25 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
26 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
27 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
28 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
29 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
31 | * SOFTWARE. |
32 | */ |
33 | |
34 | #include "iwpm_util.h" |
35 | |
36 | static const char iwpm_ulib_name[IWPM_ULIBNAME_SIZE] = "iWarpPortMapperUser" ; |
37 | u16 iwpm_ulib_version = IWPM_UABI_VERSION_MIN; |
38 | static int iwpm_user_pid = IWPM_PID_UNDEFINED; |
39 | static atomic_t echo_nlmsg_seq; |
40 | |
41 | /** |
42 | * iwpm_valid_pid - Check if the userspace iwarp port mapper pid is valid |
43 | * |
44 | * Returns true if the pid is greater than zero, otherwise returns false |
45 | */ |
46 | int iwpm_valid_pid(void) |
47 | { |
48 | return iwpm_user_pid > 0; |
49 | } |
50 | |
51 | /** |
52 | * iwpm_register_pid - Send a netlink query to userspace |
53 | * to get the iwarp port mapper pid |
54 | * @pm_msg: Contains driver info to send to the userspace port mapper |
55 | * @nl_client: The index of the netlink client |
56 | * |
57 | * nlmsg attributes: |
58 | * [IWPM_NLA_REG_PID_SEQ] |
59 | * [IWPM_NLA_REG_IF_NAME] |
60 | * [IWPM_NLA_REG_IBDEV_NAME] |
61 | * [IWPM_NLA_REG_ULIB_NAME] |
62 | */ |
63 | int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client) |
64 | { |
65 | struct sk_buff *skb = NULL; |
66 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
67 | struct nlmsghdr *nlh; |
68 | u32 msg_seq; |
69 | const char *err_str = "" ; |
70 | int ret = -EINVAL; |
71 | |
72 | if (iwpm_check_registration(nl_client, IWPM_REG_VALID) || |
73 | iwpm_user_pid == IWPM_PID_UNAVAILABLE) |
74 | return 0; |
75 | skb = iwpm_create_nlmsg(nl_op: RDMA_NL_IWPM_REG_PID, nlh: &nlh, nl_client); |
76 | if (!skb) { |
77 | err_str = "Unable to create a nlmsg" ; |
78 | goto pid_query_error; |
79 | } |
80 | nlh->nlmsg_seq = iwpm_get_nlmsg_seq(); |
81 | nlmsg_request = iwpm_get_nlmsg_request(nlmsg_seq: nlh->nlmsg_seq, nl_client, GFP_KERNEL); |
82 | if (!nlmsg_request) { |
83 | err_str = "Unable to allocate netlink request" ; |
84 | goto pid_query_error; |
85 | } |
86 | msg_seq = atomic_read(v: &echo_nlmsg_seq); |
87 | |
88 | /* fill in the pid request message */ |
89 | err_str = "Unable to put attribute of the nlmsg" ; |
90 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &msg_seq, type: IWPM_NLA_REG_PID_SEQ); |
91 | if (ret) |
92 | goto pid_query_error; |
93 | ret = ibnl_put_attr(skb, nlh, IFNAMSIZ, |
94 | data: pm_msg->if_name, type: IWPM_NLA_REG_IF_NAME); |
95 | if (ret) |
96 | goto pid_query_error; |
97 | ret = ibnl_put_attr(skb, nlh, IWPM_DEVNAME_SIZE, |
98 | data: pm_msg->dev_name, type: IWPM_NLA_REG_IBDEV_NAME); |
99 | if (ret) |
100 | goto pid_query_error; |
101 | ret = ibnl_put_attr(skb, nlh, IWPM_ULIBNAME_SIZE, |
102 | data: (char *)iwpm_ulib_name, type: IWPM_NLA_REG_ULIB_NAME); |
103 | if (ret) |
104 | goto pid_query_error; |
105 | |
106 | nlmsg_end(skb, nlh); |
107 | |
108 | pr_debug("%s: Multicasting a nlmsg (dev = %s ifname = %s iwpm = %s)\n" , |
109 | __func__, pm_msg->dev_name, pm_msg->if_name, iwpm_ulib_name); |
110 | |
111 | ret = rdma_nl_multicast(net: &init_net, skb, group: RDMA_NL_GROUP_IWPM, GFP_KERNEL); |
112 | if (ret) { |
113 | skb = NULL; /* skb is freed in the netlink send-op handling */ |
114 | iwpm_user_pid = IWPM_PID_UNAVAILABLE; |
115 | err_str = "Unable to send a nlmsg" ; |
116 | goto pid_query_error; |
117 | } |
118 | nlmsg_request->req_buffer = pm_msg; |
119 | ret = iwpm_wait_complete_req(nlmsg_request); |
120 | return ret; |
121 | pid_query_error: |
122 | pr_info("%s: %s (client = %u)\n" , __func__, err_str, nl_client); |
123 | dev_kfree_skb(skb); |
124 | if (nlmsg_request) |
125 | iwpm_free_nlmsg_request(kref: &nlmsg_request->kref); |
126 | return ret; |
127 | } |
128 | |
129 | /** |
130 | * iwpm_add_mapping - Send a netlink add mapping request to |
131 | * the userspace port mapper |
132 | * @pm_msg: Contains the local ip/tcp address info to send |
133 | * @nl_client: The index of the netlink client |
134 | * |
135 | * nlmsg attributes: |
136 | * [IWPM_NLA_MANAGE_MAPPING_SEQ] |
137 | * [IWPM_NLA_MANAGE_ADDR] |
138 | * [IWPM_NLA_MANAGE_FLAGS] |
139 | * |
140 | * If the request is successful, the pm_msg stores |
141 | * the port mapper response (mapped address info) |
142 | */ |
143 | int iwpm_add_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client) |
144 | { |
145 | struct sk_buff *skb = NULL; |
146 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
147 | struct nlmsghdr *nlh; |
148 | u32 msg_seq; |
149 | const char *err_str = "" ; |
150 | int ret = -EINVAL; |
151 | |
152 | if (!iwpm_valid_pid()) |
153 | return 0; |
154 | if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) { |
155 | err_str = "Unregistered port mapper client" ; |
156 | goto add_mapping_error; |
157 | } |
158 | skb = iwpm_create_nlmsg(nl_op: RDMA_NL_IWPM_ADD_MAPPING, nlh: &nlh, nl_client); |
159 | if (!skb) { |
160 | err_str = "Unable to create a nlmsg" ; |
161 | goto add_mapping_error; |
162 | } |
163 | nlh->nlmsg_seq = iwpm_get_nlmsg_seq(); |
164 | nlmsg_request = iwpm_get_nlmsg_request(nlmsg_seq: nlh->nlmsg_seq, nl_client, GFP_KERNEL); |
165 | if (!nlmsg_request) { |
166 | err_str = "Unable to allocate netlink request" ; |
167 | goto add_mapping_error; |
168 | } |
169 | msg_seq = atomic_read(v: &echo_nlmsg_seq); |
170 | /* fill in the add mapping message */ |
171 | err_str = "Unable to put attribute of the nlmsg" ; |
172 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &msg_seq, |
173 | type: IWPM_NLA_MANAGE_MAPPING_SEQ); |
174 | if (ret) |
175 | goto add_mapping_error; |
176 | ret = ibnl_put_attr(skb, nlh, len: sizeof(struct sockaddr_storage), |
177 | data: &pm_msg->loc_addr, type: IWPM_NLA_MANAGE_ADDR); |
178 | if (ret) |
179 | goto add_mapping_error; |
180 | |
181 | /* If flags are required and we're not V4, then return a quiet error */ |
182 | if (pm_msg->flags && iwpm_ulib_version == IWPM_UABI_VERSION_MIN) { |
183 | ret = -EINVAL; |
184 | goto add_mapping_error_nowarn; |
185 | } |
186 | if (iwpm_ulib_version > IWPM_UABI_VERSION_MIN) { |
187 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &pm_msg->flags, |
188 | type: IWPM_NLA_MANAGE_FLAGS); |
189 | if (ret) |
190 | goto add_mapping_error; |
191 | } |
192 | |
193 | nlmsg_end(skb, nlh); |
194 | nlmsg_request->req_buffer = pm_msg; |
195 | |
196 | ret = rdma_nl_unicast_wait(net: &init_net, skb, pid: iwpm_user_pid); |
197 | if (ret) { |
198 | skb = NULL; /* skb is freed in the netlink send-op handling */ |
199 | iwpm_user_pid = IWPM_PID_UNDEFINED; |
200 | err_str = "Unable to send a nlmsg" ; |
201 | goto add_mapping_error; |
202 | } |
203 | ret = iwpm_wait_complete_req(nlmsg_request); |
204 | return ret; |
205 | add_mapping_error: |
206 | pr_info("%s: %s (client = %u)\n" , __func__, err_str, nl_client); |
207 | add_mapping_error_nowarn: |
208 | dev_kfree_skb(skb); |
209 | if (nlmsg_request) |
210 | iwpm_free_nlmsg_request(kref: &nlmsg_request->kref); |
211 | return ret; |
212 | } |
213 | |
214 | /** |
215 | * iwpm_add_and_query_mapping - Process the port mapper response to |
216 | * iwpm_add_and_query_mapping request |
217 | * @pm_msg: Contains the local ip/tcp address info to send |
218 | * @nl_client: The index of the netlink client |
219 | * |
220 | * nlmsg attributes: |
221 | * [IWPM_NLA_QUERY_MAPPING_SEQ] |
222 | * [IWPM_NLA_QUERY_LOCAL_ADDR] |
223 | * [IWPM_NLA_QUERY_REMOTE_ADDR] |
224 | * [IWPM_NLA_QUERY_FLAGS] |
225 | */ |
226 | int iwpm_add_and_query_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client) |
227 | { |
228 | struct sk_buff *skb = NULL; |
229 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
230 | struct nlmsghdr *nlh; |
231 | u32 msg_seq; |
232 | const char *err_str = "" ; |
233 | int ret = -EINVAL; |
234 | |
235 | if (!iwpm_valid_pid()) |
236 | return 0; |
237 | if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) { |
238 | err_str = "Unregistered port mapper client" ; |
239 | goto query_mapping_error; |
240 | } |
241 | ret = -ENOMEM; |
242 | skb = iwpm_create_nlmsg(nl_op: RDMA_NL_IWPM_QUERY_MAPPING, nlh: &nlh, nl_client); |
243 | if (!skb) { |
244 | err_str = "Unable to create a nlmsg" ; |
245 | goto query_mapping_error; |
246 | } |
247 | nlh->nlmsg_seq = iwpm_get_nlmsg_seq(); |
248 | nlmsg_request = iwpm_get_nlmsg_request(nlmsg_seq: nlh->nlmsg_seq, |
249 | nl_client, GFP_KERNEL); |
250 | if (!nlmsg_request) { |
251 | err_str = "Unable to allocate netlink request" ; |
252 | goto query_mapping_error; |
253 | } |
254 | msg_seq = atomic_read(v: &echo_nlmsg_seq); |
255 | |
256 | /* fill in the query message */ |
257 | err_str = "Unable to put attribute of the nlmsg" ; |
258 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &msg_seq, |
259 | type: IWPM_NLA_QUERY_MAPPING_SEQ); |
260 | if (ret) |
261 | goto query_mapping_error; |
262 | ret = ibnl_put_attr(skb, nlh, len: sizeof(struct sockaddr_storage), |
263 | data: &pm_msg->loc_addr, type: IWPM_NLA_QUERY_LOCAL_ADDR); |
264 | if (ret) |
265 | goto query_mapping_error; |
266 | ret = ibnl_put_attr(skb, nlh, len: sizeof(struct sockaddr_storage), |
267 | data: &pm_msg->rem_addr, type: IWPM_NLA_QUERY_REMOTE_ADDR); |
268 | if (ret) |
269 | goto query_mapping_error; |
270 | |
271 | /* If flags are required and we're not V4, then return a quite error */ |
272 | if (pm_msg->flags && iwpm_ulib_version == IWPM_UABI_VERSION_MIN) { |
273 | ret = -EINVAL; |
274 | goto query_mapping_error_nowarn; |
275 | } |
276 | if (iwpm_ulib_version > IWPM_UABI_VERSION_MIN) { |
277 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &pm_msg->flags, |
278 | type: IWPM_NLA_QUERY_FLAGS); |
279 | if (ret) |
280 | goto query_mapping_error; |
281 | } |
282 | |
283 | nlmsg_end(skb, nlh); |
284 | nlmsg_request->req_buffer = pm_msg; |
285 | |
286 | ret = rdma_nl_unicast_wait(net: &init_net, skb, pid: iwpm_user_pid); |
287 | if (ret) { |
288 | skb = NULL; /* skb is freed in the netlink send-op handling */ |
289 | err_str = "Unable to send a nlmsg" ; |
290 | goto query_mapping_error; |
291 | } |
292 | ret = iwpm_wait_complete_req(nlmsg_request); |
293 | return ret; |
294 | query_mapping_error: |
295 | pr_info("%s: %s (client = %u)\n" , __func__, err_str, nl_client); |
296 | query_mapping_error_nowarn: |
297 | dev_kfree_skb(skb); |
298 | if (nlmsg_request) |
299 | iwpm_free_nlmsg_request(kref: &nlmsg_request->kref); |
300 | return ret; |
301 | } |
302 | |
303 | /** |
304 | * iwpm_remove_mapping - Send a netlink remove mapping request |
305 | * to the userspace port mapper |
306 | * |
307 | * @local_addr: Local ip/tcp address to remove |
308 | * @nl_client: The index of the netlink client |
309 | * |
310 | * nlmsg attributes: |
311 | * [IWPM_NLA_MANAGE_MAPPING_SEQ] |
312 | * [IWPM_NLA_MANAGE_ADDR] |
313 | */ |
314 | int iwpm_remove_mapping(struct sockaddr_storage *local_addr, u8 nl_client) |
315 | { |
316 | struct sk_buff *skb = NULL; |
317 | struct nlmsghdr *nlh; |
318 | u32 msg_seq; |
319 | const char *err_str = "" ; |
320 | int ret = -EINVAL; |
321 | |
322 | if (!iwpm_valid_pid()) |
323 | return 0; |
324 | if (iwpm_check_registration(nl_client, IWPM_REG_UNDEF)) { |
325 | err_str = "Unregistered port mapper client" ; |
326 | goto remove_mapping_error; |
327 | } |
328 | skb = iwpm_create_nlmsg(nl_op: RDMA_NL_IWPM_REMOVE_MAPPING, nlh: &nlh, nl_client); |
329 | if (!skb) { |
330 | ret = -ENOMEM; |
331 | err_str = "Unable to create a nlmsg" ; |
332 | goto remove_mapping_error; |
333 | } |
334 | msg_seq = atomic_read(v: &echo_nlmsg_seq); |
335 | nlh->nlmsg_seq = iwpm_get_nlmsg_seq(); |
336 | err_str = "Unable to put attribute of the nlmsg" ; |
337 | ret = ibnl_put_attr(skb, nlh, len: sizeof(u32), data: &msg_seq, |
338 | type: IWPM_NLA_MANAGE_MAPPING_SEQ); |
339 | if (ret) |
340 | goto remove_mapping_error; |
341 | ret = ibnl_put_attr(skb, nlh, len: sizeof(struct sockaddr_storage), |
342 | data: local_addr, type: IWPM_NLA_MANAGE_ADDR); |
343 | if (ret) |
344 | goto remove_mapping_error; |
345 | |
346 | nlmsg_end(skb, nlh); |
347 | |
348 | ret = rdma_nl_unicast_wait(net: &init_net, skb, pid: iwpm_user_pid); |
349 | if (ret) { |
350 | skb = NULL; /* skb is freed in the netlink send-op handling */ |
351 | iwpm_user_pid = IWPM_PID_UNDEFINED; |
352 | err_str = "Unable to send a nlmsg" ; |
353 | goto remove_mapping_error; |
354 | } |
355 | iwpm_print_sockaddr(sockaddr: local_addr, |
356 | msg: "remove_mapping: Local sockaddr:" ); |
357 | return 0; |
358 | remove_mapping_error: |
359 | pr_info("%s: %s (client = %u)\n" , __func__, err_str, nl_client); |
360 | if (skb) |
361 | dev_kfree_skb_any(skb); |
362 | return ret; |
363 | } |
364 | |
365 | /* netlink attribute policy for the received response to register pid request */ |
366 | static const struct nla_policy resp_reg_policy[IWPM_NLA_RREG_PID_MAX] = { |
367 | [IWPM_NLA_RREG_PID_SEQ] = { .type = NLA_U32 }, |
368 | [IWPM_NLA_RREG_IBDEV_NAME] = { .type = NLA_STRING, |
369 | .len = IWPM_DEVNAME_SIZE - 1 }, |
370 | [IWPM_NLA_RREG_ULIB_NAME] = { .type = NLA_STRING, |
371 | .len = IWPM_ULIBNAME_SIZE - 1 }, |
372 | [IWPM_NLA_RREG_ULIB_VER] = { .type = NLA_U16 }, |
373 | [IWPM_NLA_RREG_PID_ERR] = { .type = NLA_U16 } |
374 | }; |
375 | |
376 | /** |
377 | * iwpm_register_pid_cb - Process the port mapper response to |
378 | * iwpm_register_pid query |
379 | * @skb: The socket buffer |
380 | * @cb: Contains the received message (payload and netlink header) |
381 | * |
382 | * If successful, the function receives the userspace port mapper pid |
383 | * which is used in future communication with the port mapper |
384 | */ |
385 | int iwpm_register_pid_cb(struct sk_buff *skb, struct netlink_callback *cb) |
386 | { |
387 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
388 | struct nlattr *nltb[IWPM_NLA_RREG_PID_MAX]; |
389 | struct iwpm_dev_data *pm_msg; |
390 | char *dev_name, *iwpm_name; |
391 | u32 msg_seq; |
392 | u8 nl_client; |
393 | u16 iwpm_version; |
394 | const char *msg_type = "Register Pid response" ; |
395 | |
396 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_RREG_PID_MAX, |
397 | nlmsg_policy: resp_reg_policy, nltb, msg_type)) |
398 | return -EINVAL; |
399 | |
400 | msg_seq = nla_get_u32(nla: nltb[IWPM_NLA_RREG_PID_SEQ]); |
401 | nlmsg_request = iwpm_find_nlmsg_request(echo_seq: msg_seq); |
402 | if (!nlmsg_request) { |
403 | pr_info("%s: Could not find a matching request (seq = %u)\n" , |
404 | __func__, msg_seq); |
405 | return -EINVAL; |
406 | } |
407 | pm_msg = nlmsg_request->req_buffer; |
408 | nl_client = nlmsg_request->nl_client; |
409 | dev_name = (char *)nla_data(nla: nltb[IWPM_NLA_RREG_IBDEV_NAME]); |
410 | iwpm_name = (char *)nla_data(nla: nltb[IWPM_NLA_RREG_ULIB_NAME]); |
411 | iwpm_version = nla_get_u16(nla: nltb[IWPM_NLA_RREG_ULIB_VER]); |
412 | |
413 | /* check device name, ulib name and version */ |
414 | if (strcmp(pm_msg->dev_name, dev_name) || |
415 | strcmp(iwpm_ulib_name, iwpm_name) || |
416 | iwpm_version < IWPM_UABI_VERSION_MIN) { |
417 | |
418 | pr_info("%s: Incorrect info (dev = %s name = %s version = %u)\n" , |
419 | __func__, dev_name, iwpm_name, iwpm_version); |
420 | nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR; |
421 | goto register_pid_response_exit; |
422 | } |
423 | iwpm_user_pid = cb->nlh->nlmsg_pid; |
424 | iwpm_ulib_version = iwpm_version; |
425 | if (iwpm_ulib_version < IWPM_UABI_VERSION) |
426 | pr_warn_once("%s: Down level iwpmd/pid %d. Continuing..." , |
427 | __func__, iwpm_user_pid); |
428 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
429 | pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n" , |
430 | __func__, iwpm_user_pid); |
431 | iwpm_set_registration(nl_client, IWPM_REG_VALID); |
432 | register_pid_response_exit: |
433 | nlmsg_request->request_done = 1; |
434 | /* always for found nlmsg_request */ |
435 | kref_put(kref: &nlmsg_request->kref, release: iwpm_free_nlmsg_request); |
436 | barrier(); |
437 | up(sem: &nlmsg_request->sem); |
438 | return 0; |
439 | } |
440 | |
441 | /* netlink attribute policy for the received response to add mapping request */ |
442 | static const struct nla_policy resp_add_policy[IWPM_NLA_RMANAGE_MAPPING_MAX] = { |
443 | [IWPM_NLA_RMANAGE_MAPPING_SEQ] = { .type = NLA_U32 }, |
444 | [IWPM_NLA_RMANAGE_ADDR] = { |
445 | .len = sizeof(struct sockaddr_storage) }, |
446 | [IWPM_NLA_RMANAGE_MAPPED_LOC_ADDR] = { |
447 | .len = sizeof(struct sockaddr_storage) }, |
448 | [IWPM_NLA_RMANAGE_MAPPING_ERR] = { .type = NLA_U16 } |
449 | }; |
450 | |
451 | /** |
452 | * iwpm_add_mapping_cb - Process the port mapper response to |
453 | * iwpm_add_mapping request |
454 | * @skb: The socket buffer |
455 | * @cb: Contains the received message (payload and netlink header) |
456 | */ |
457 | int iwpm_add_mapping_cb(struct sk_buff *skb, struct netlink_callback *cb) |
458 | { |
459 | struct iwpm_sa_data *pm_msg; |
460 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
461 | struct nlattr *nltb[IWPM_NLA_RMANAGE_MAPPING_MAX]; |
462 | struct sockaddr_storage *local_sockaddr; |
463 | struct sockaddr_storage *mapped_sockaddr; |
464 | const char *msg_type; |
465 | u32 msg_seq; |
466 | |
467 | msg_type = "Add Mapping response" ; |
468 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_RMANAGE_MAPPING_MAX, |
469 | nlmsg_policy: resp_add_policy, nltb, msg_type)) |
470 | return -EINVAL; |
471 | |
472 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
473 | |
474 | msg_seq = nla_get_u32(nla: nltb[IWPM_NLA_RMANAGE_MAPPING_SEQ]); |
475 | nlmsg_request = iwpm_find_nlmsg_request(echo_seq: msg_seq); |
476 | if (!nlmsg_request) { |
477 | pr_info("%s: Could not find a matching request (seq = %u)\n" , |
478 | __func__, msg_seq); |
479 | return -EINVAL; |
480 | } |
481 | pm_msg = nlmsg_request->req_buffer; |
482 | local_sockaddr = (struct sockaddr_storage *) |
483 | nla_data(nla: nltb[IWPM_NLA_RMANAGE_ADDR]); |
484 | mapped_sockaddr = (struct sockaddr_storage *) |
485 | nla_data(nla: nltb[IWPM_NLA_RMANAGE_MAPPED_LOC_ADDR]); |
486 | |
487 | if (iwpm_compare_sockaddr(a_sockaddr: local_sockaddr, b_sockaddr: &pm_msg->loc_addr)) { |
488 | nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR; |
489 | goto add_mapping_response_exit; |
490 | } |
491 | if (mapped_sockaddr->ss_family != local_sockaddr->ss_family) { |
492 | pr_info("%s: Sockaddr family doesn't match the requested one\n" , |
493 | __func__); |
494 | nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR; |
495 | goto add_mapping_response_exit; |
496 | } |
497 | memcpy(&pm_msg->mapped_loc_addr, mapped_sockaddr, |
498 | sizeof(*mapped_sockaddr)); |
499 | iwpm_print_sockaddr(sockaddr: &pm_msg->loc_addr, |
500 | msg: "add_mapping: Local sockaddr:" ); |
501 | iwpm_print_sockaddr(sockaddr: &pm_msg->mapped_loc_addr, |
502 | msg: "add_mapping: Mapped local sockaddr:" ); |
503 | |
504 | add_mapping_response_exit: |
505 | nlmsg_request->request_done = 1; |
506 | /* always for found request */ |
507 | kref_put(kref: &nlmsg_request->kref, release: iwpm_free_nlmsg_request); |
508 | barrier(); |
509 | up(sem: &nlmsg_request->sem); |
510 | return 0; |
511 | } |
512 | |
513 | /* netlink attribute policy for the response to add and query mapping request |
514 | * and response with remote address info |
515 | */ |
516 | static const struct nla_policy resp_query_policy[IWPM_NLA_RQUERY_MAPPING_MAX] = { |
517 | [IWPM_NLA_RQUERY_MAPPING_SEQ] = { .type = NLA_U32 }, |
518 | [IWPM_NLA_RQUERY_LOCAL_ADDR] = { |
519 | .len = sizeof(struct sockaddr_storage) }, |
520 | [IWPM_NLA_RQUERY_REMOTE_ADDR] = { |
521 | .len = sizeof(struct sockaddr_storage) }, |
522 | [IWPM_NLA_RQUERY_MAPPED_LOC_ADDR] = { |
523 | .len = sizeof(struct sockaddr_storage) }, |
524 | [IWPM_NLA_RQUERY_MAPPED_REM_ADDR] = { |
525 | .len = sizeof(struct sockaddr_storage) }, |
526 | [IWPM_NLA_RQUERY_MAPPING_ERR] = { .type = NLA_U16 } |
527 | }; |
528 | |
529 | /** |
530 | * iwpm_add_and_query_mapping_cb - Process the port mapper response to |
531 | * iwpm_add_and_query_mapping request |
532 | * @skb: The socket buffer |
533 | * @cb: Contains the received message (payload and netlink header) |
534 | */ |
535 | int iwpm_add_and_query_mapping_cb(struct sk_buff *skb, |
536 | struct netlink_callback *cb) |
537 | { |
538 | struct iwpm_sa_data *pm_msg; |
539 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
540 | struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX]; |
541 | struct sockaddr_storage *local_sockaddr, *remote_sockaddr; |
542 | struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr; |
543 | const char *msg_type; |
544 | u32 msg_seq; |
545 | u16 err_code; |
546 | |
547 | msg_type = "Query Mapping response" ; |
548 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_RQUERY_MAPPING_MAX, |
549 | nlmsg_policy: resp_query_policy, nltb, msg_type)) |
550 | return -EINVAL; |
551 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
552 | |
553 | msg_seq = nla_get_u32(nla: nltb[IWPM_NLA_RQUERY_MAPPING_SEQ]); |
554 | nlmsg_request = iwpm_find_nlmsg_request(echo_seq: msg_seq); |
555 | if (!nlmsg_request) { |
556 | pr_info("%s: Could not find a matching request (seq = %u)\n" , |
557 | __func__, msg_seq); |
558 | return -EINVAL; |
559 | } |
560 | pm_msg = nlmsg_request->req_buffer; |
561 | local_sockaddr = (struct sockaddr_storage *) |
562 | nla_data(nla: nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]); |
563 | remote_sockaddr = (struct sockaddr_storage *) |
564 | nla_data(nla: nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]); |
565 | mapped_loc_sockaddr = (struct sockaddr_storage *) |
566 | nla_data(nla: nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]); |
567 | mapped_rem_sockaddr = (struct sockaddr_storage *) |
568 | nla_data(nla: nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]); |
569 | |
570 | err_code = nla_get_u16(nla: nltb[IWPM_NLA_RQUERY_MAPPING_ERR]); |
571 | if (err_code == IWPM_REMOTE_QUERY_REJECT) { |
572 | pr_info("%s: Received a Reject (pid = %u, echo seq = %u)\n" , |
573 | __func__, cb->nlh->nlmsg_pid, msg_seq); |
574 | nlmsg_request->err_code = IWPM_REMOTE_QUERY_REJECT; |
575 | } |
576 | if (iwpm_compare_sockaddr(a_sockaddr: local_sockaddr, b_sockaddr: &pm_msg->loc_addr) || |
577 | iwpm_compare_sockaddr(a_sockaddr: remote_sockaddr, b_sockaddr: &pm_msg->rem_addr)) { |
578 | pr_info("%s: Incorrect local sockaddr\n" , __func__); |
579 | nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR; |
580 | goto query_mapping_response_exit; |
581 | } |
582 | if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family || |
583 | mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) { |
584 | pr_info("%s: Sockaddr family doesn't match the requested one\n" , |
585 | __func__); |
586 | nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR; |
587 | goto query_mapping_response_exit; |
588 | } |
589 | memcpy(&pm_msg->mapped_loc_addr, mapped_loc_sockaddr, |
590 | sizeof(*mapped_loc_sockaddr)); |
591 | memcpy(&pm_msg->mapped_rem_addr, mapped_rem_sockaddr, |
592 | sizeof(*mapped_rem_sockaddr)); |
593 | |
594 | iwpm_print_sockaddr(sockaddr: &pm_msg->loc_addr, |
595 | msg: "query_mapping: Local sockaddr:" ); |
596 | iwpm_print_sockaddr(sockaddr: &pm_msg->mapped_loc_addr, |
597 | msg: "query_mapping: Mapped local sockaddr:" ); |
598 | iwpm_print_sockaddr(sockaddr: &pm_msg->rem_addr, |
599 | msg: "query_mapping: Remote sockaddr:" ); |
600 | iwpm_print_sockaddr(sockaddr: &pm_msg->mapped_rem_addr, |
601 | msg: "query_mapping: Mapped remote sockaddr:" ); |
602 | query_mapping_response_exit: |
603 | nlmsg_request->request_done = 1; |
604 | /* always for found request */ |
605 | kref_put(kref: &nlmsg_request->kref, release: iwpm_free_nlmsg_request); |
606 | barrier(); |
607 | up(sem: &nlmsg_request->sem); |
608 | return 0; |
609 | } |
610 | |
611 | /** |
612 | * iwpm_remote_info_cb - Process remote connecting peer address info, which |
613 | * the port mapper has received from the connecting peer |
614 | * @skb: The socket buffer |
615 | * @cb: Contains the received message (payload and netlink header) |
616 | * |
617 | * Stores the IPv4/IPv6 address info in a hash table |
618 | */ |
619 | int iwpm_remote_info_cb(struct sk_buff *skb, struct netlink_callback *cb) |
620 | { |
621 | struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX]; |
622 | struct sockaddr_storage *local_sockaddr, *remote_sockaddr; |
623 | struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr; |
624 | struct iwpm_remote_info *rem_info; |
625 | const char *msg_type; |
626 | u8 nl_client; |
627 | int ret = -EINVAL; |
628 | |
629 | msg_type = "Remote Mapping info" ; |
630 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_RQUERY_MAPPING_MAX, |
631 | nlmsg_policy: resp_query_policy, nltb, msg_type)) |
632 | return ret; |
633 | |
634 | nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type); |
635 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
636 | |
637 | local_sockaddr = (struct sockaddr_storage *) |
638 | nla_data(nla: nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]); |
639 | remote_sockaddr = (struct sockaddr_storage *) |
640 | nla_data(nla: nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]); |
641 | mapped_loc_sockaddr = (struct sockaddr_storage *) |
642 | nla_data(nla: nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]); |
643 | mapped_rem_sockaddr = (struct sockaddr_storage *) |
644 | nla_data(nla: nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]); |
645 | |
646 | if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family || |
647 | mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) { |
648 | pr_info("%s: Sockaddr family doesn't match the requested one\n" , |
649 | __func__); |
650 | return ret; |
651 | } |
652 | rem_info = kzalloc(size: sizeof(struct iwpm_remote_info), GFP_ATOMIC); |
653 | if (!rem_info) { |
654 | ret = -ENOMEM; |
655 | return ret; |
656 | } |
657 | memcpy(&rem_info->mapped_loc_sockaddr, mapped_loc_sockaddr, |
658 | sizeof(struct sockaddr_storage)); |
659 | memcpy(&rem_info->remote_sockaddr, remote_sockaddr, |
660 | sizeof(struct sockaddr_storage)); |
661 | memcpy(&rem_info->mapped_rem_sockaddr, mapped_rem_sockaddr, |
662 | sizeof(struct sockaddr_storage)); |
663 | rem_info->nl_client = nl_client; |
664 | |
665 | iwpm_add_remote_info(reminfo: rem_info); |
666 | |
667 | iwpm_print_sockaddr(sockaddr: local_sockaddr, |
668 | msg: "remote_info: Local sockaddr:" ); |
669 | iwpm_print_sockaddr(sockaddr: mapped_loc_sockaddr, |
670 | msg: "remote_info: Mapped local sockaddr:" ); |
671 | iwpm_print_sockaddr(sockaddr: remote_sockaddr, |
672 | msg: "remote_info: Remote sockaddr:" ); |
673 | iwpm_print_sockaddr(sockaddr: mapped_rem_sockaddr, |
674 | msg: "remote_info: Mapped remote sockaddr:" ); |
675 | return ret; |
676 | } |
677 | |
678 | /* netlink attribute policy for the received request for mapping info */ |
679 | static const struct nla_policy resp_mapinfo_policy[IWPM_NLA_MAPINFO_REQ_MAX] = { |
680 | [IWPM_NLA_MAPINFO_ULIB_NAME] = { .type = NLA_STRING, |
681 | .len = IWPM_ULIBNAME_SIZE - 1 }, |
682 | [IWPM_NLA_MAPINFO_ULIB_VER] = { .type = NLA_U16 } |
683 | }; |
684 | |
685 | /** |
686 | * iwpm_mapping_info_cb - Process a notification that the userspace |
687 | * port mapper daemon is started |
688 | * @skb: The socket buffer |
689 | * @cb: Contains the received message (payload and netlink header) |
690 | * |
691 | * Using the received port mapper pid, send all the local mapping |
692 | * info records to the userspace port mapper |
693 | */ |
694 | int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb) |
695 | { |
696 | struct nlattr *nltb[IWPM_NLA_MAPINFO_REQ_MAX]; |
697 | const char *msg_type = "Mapping Info response" ; |
698 | u8 nl_client; |
699 | char *iwpm_name; |
700 | u16 iwpm_version; |
701 | int ret = -EINVAL; |
702 | |
703 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_MAPINFO_REQ_MAX, |
704 | nlmsg_policy: resp_mapinfo_policy, nltb, msg_type)) { |
705 | pr_info("%s: Unable to parse nlmsg\n" , __func__); |
706 | return ret; |
707 | } |
708 | iwpm_name = (char *)nla_data(nla: nltb[IWPM_NLA_MAPINFO_ULIB_NAME]); |
709 | iwpm_version = nla_get_u16(nla: nltb[IWPM_NLA_MAPINFO_ULIB_VER]); |
710 | if (strcmp(iwpm_ulib_name, iwpm_name) || |
711 | iwpm_version < IWPM_UABI_VERSION_MIN) { |
712 | pr_info("%s: Invalid port mapper name = %s version = %u\n" , |
713 | __func__, iwpm_name, iwpm_version); |
714 | return ret; |
715 | } |
716 | nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type); |
717 | iwpm_set_registration(nl_client, IWPM_REG_INCOMPL); |
718 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
719 | iwpm_user_pid = cb->nlh->nlmsg_pid; |
720 | |
721 | if (iwpm_ulib_version < IWPM_UABI_VERSION) |
722 | pr_warn_once("%s: Down level iwpmd/pid %d. Continuing..." , |
723 | __func__, iwpm_user_pid); |
724 | |
725 | if (!iwpm_mapinfo_available()) |
726 | return 0; |
727 | pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n" , |
728 | __func__, iwpm_user_pid); |
729 | ret = iwpm_send_mapinfo(nl_client, iwpm_pid: iwpm_user_pid); |
730 | return ret; |
731 | } |
732 | |
733 | /* netlink attribute policy for the received mapping info ack */ |
734 | static const struct nla_policy ack_mapinfo_policy[IWPM_NLA_MAPINFO_NUM_MAX] = { |
735 | [IWPM_NLA_MAPINFO_SEQ] = { .type = NLA_U32 }, |
736 | [IWPM_NLA_MAPINFO_SEND_NUM] = { .type = NLA_U32 }, |
737 | [IWPM_NLA_MAPINFO_ACK_NUM] = { .type = NLA_U32 } |
738 | }; |
739 | |
740 | /** |
741 | * iwpm_ack_mapping_info_cb - Process the port mapper ack for |
742 | * the provided local mapping info records |
743 | * @skb: The socket buffer |
744 | * @cb: Contains the received message (payload and netlink header) |
745 | */ |
746 | int iwpm_ack_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb) |
747 | { |
748 | struct nlattr *nltb[IWPM_NLA_MAPINFO_NUM_MAX]; |
749 | u32 mapinfo_send, mapinfo_ack; |
750 | const char *msg_type = "Mapping Info Ack" ; |
751 | |
752 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_MAPINFO_NUM_MAX, |
753 | nlmsg_policy: ack_mapinfo_policy, nltb, msg_type)) |
754 | return -EINVAL; |
755 | mapinfo_send = nla_get_u32(nla: nltb[IWPM_NLA_MAPINFO_SEND_NUM]); |
756 | mapinfo_ack = nla_get_u32(nla: nltb[IWPM_NLA_MAPINFO_ACK_NUM]); |
757 | if (mapinfo_ack != mapinfo_send) |
758 | pr_info("%s: Invalid mapinfo number (sent = %u ack-ed = %u)\n" , |
759 | __func__, mapinfo_send, mapinfo_ack); |
760 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
761 | return 0; |
762 | } |
763 | |
764 | /* netlink attribute policy for the received port mapper error message */ |
765 | static const struct nla_policy map_error_policy[IWPM_NLA_ERR_MAX] = { |
766 | [IWPM_NLA_ERR_SEQ] = { .type = NLA_U32 }, |
767 | [IWPM_NLA_ERR_CODE] = { .type = NLA_U16 }, |
768 | }; |
769 | |
770 | /** |
771 | * iwpm_mapping_error_cb - Process port mapper notification for error |
772 | * |
773 | * @skb: The socket buffer |
774 | * @cb: Contains the received message (payload and netlink header) |
775 | */ |
776 | int iwpm_mapping_error_cb(struct sk_buff *skb, struct netlink_callback *cb) |
777 | { |
778 | struct iwpm_nlmsg_request *nlmsg_request = NULL; |
779 | int nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type); |
780 | struct nlattr *nltb[IWPM_NLA_ERR_MAX]; |
781 | u32 msg_seq; |
782 | u16 err_code; |
783 | const char *msg_type = "Mapping Error Msg" ; |
784 | |
785 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_ERR_MAX, |
786 | nlmsg_policy: map_error_policy, nltb, msg_type)) |
787 | return -EINVAL; |
788 | |
789 | msg_seq = nla_get_u32(nla: nltb[IWPM_NLA_ERR_SEQ]); |
790 | err_code = nla_get_u16(nla: nltb[IWPM_NLA_ERR_CODE]); |
791 | pr_info("%s: Received msg seq = %u err code = %u client = %d\n" , |
792 | __func__, msg_seq, err_code, nl_client); |
793 | /* look for nlmsg_request */ |
794 | nlmsg_request = iwpm_find_nlmsg_request(echo_seq: msg_seq); |
795 | if (!nlmsg_request) { |
796 | /* not all errors have associated requests */ |
797 | pr_debug("Could not find matching req (seq = %u)\n" , msg_seq); |
798 | return 0; |
799 | } |
800 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
801 | nlmsg_request->err_code = err_code; |
802 | nlmsg_request->request_done = 1; |
803 | /* always for found request */ |
804 | kref_put(kref: &nlmsg_request->kref, release: iwpm_free_nlmsg_request); |
805 | barrier(); |
806 | up(sem: &nlmsg_request->sem); |
807 | return 0; |
808 | } |
809 | |
810 | /* netlink attribute policy for the received hello request */ |
811 | static const struct nla_policy hello_policy[IWPM_NLA_HELLO_MAX] = { |
812 | [IWPM_NLA_HELLO_ABI_VERSION] = { .type = NLA_U16 } |
813 | }; |
814 | |
815 | /** |
816 | * iwpm_hello_cb - Process a hello message from iwpmd |
817 | * |
818 | * @skb: The socket buffer |
819 | * @cb: Contains the received message (payload and netlink header) |
820 | * |
821 | * Using the received port mapper pid, send the kernel's abi_version |
822 | * after adjusting it to support the iwpmd version. |
823 | */ |
824 | int iwpm_hello_cb(struct sk_buff *skb, struct netlink_callback *cb) |
825 | { |
826 | struct nlattr *nltb[IWPM_NLA_HELLO_MAX]; |
827 | const char *msg_type = "Hello request" ; |
828 | u8 nl_client; |
829 | u16 abi_version; |
830 | int ret = -EINVAL; |
831 | |
832 | if (iwpm_parse_nlmsg(cb, policy_max: IWPM_NLA_HELLO_MAX, nlmsg_policy: hello_policy, nltb, |
833 | msg_type)) { |
834 | pr_info("%s: Unable to parse nlmsg\n" , __func__); |
835 | return ret; |
836 | } |
837 | abi_version = nla_get_u16(nla: nltb[IWPM_NLA_HELLO_ABI_VERSION]); |
838 | nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type); |
839 | iwpm_set_registration(nl_client, IWPM_REG_INCOMPL); |
840 | atomic_set(v: &echo_nlmsg_seq, i: cb->nlh->nlmsg_seq); |
841 | iwpm_ulib_version = min_t(u16, IWPM_UABI_VERSION, abi_version); |
842 | pr_debug("Using ABI version %u\n" , iwpm_ulib_version); |
843 | iwpm_user_pid = cb->nlh->nlmsg_pid; |
844 | ret = iwpm_send_hello(nl_client, iwpm_pid: iwpm_user_pid, abi_version: iwpm_ulib_version); |
845 | return ret; |
846 | } |
847 | |