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 static int iwpm_ulib_version = 3;
38 static int iwpm_user_pid = IWPM_PID_UNDEFINED;
39 static atomic_t echo_nlmsg_seq;
40 
41 int iwpm_valid_pid(void)
42 {
43 	return iwpm_user_pid > 0;
44 }
45 EXPORT_SYMBOL(iwpm_valid_pid);
46 
47 /*
48  * iwpm_register_pid - Send a netlink query to user space
49  *                     for the iwarp port mapper pid
50  *
51  * nlmsg attributes:
52  *	[IWPM_NLA_REG_PID_SEQ]
53  *	[IWPM_NLA_REG_IF_NAME]
54  *	[IWPM_NLA_REG_IBDEV_NAME]
55  *	[IWPM_NLA_REG_ULIB_NAME]
56  */
57 int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client)
58 {
59 	struct sk_buff *skb = NULL;
60 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
61 	struct nlmsghdr *nlh;
62 	u32 msg_seq;
63 	const char *err_str = "";
64 	int ret = -EINVAL;
65 
66 	if (!iwpm_valid_client(nl_client)) {
67 		err_str = "Invalid port mapper client";
68 		goto pid_query_error;
69 	}
70 	if (iwpm_check_registration(nl_client, IWPM_REG_VALID) ||
71 			iwpm_user_pid == IWPM_PID_UNAVAILABLE)
72 		return 0;
73 	skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REG_PID, &nlh, nl_client);
74 	if (!skb) {
75 		err_str = "Unable to create a nlmsg";
76 		goto pid_query_error;
77 	}
78 	nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
79 	nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
80 	if (!nlmsg_request) {
81 		err_str = "Unable to allocate netlink request";
82 		goto pid_query_error;
83 	}
84 	msg_seq = atomic_read(&echo_nlmsg_seq);
85 
86 	/* fill in the pid request message */
87 	err_str = "Unable to put attribute of the nlmsg";
88 	ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq, IWPM_NLA_REG_PID_SEQ);
89 	if (ret)
90 		goto pid_query_error;
91 	ret = ibnl_put_attr(skb, nlh, IWPM_IFNAME_SIZE,
92 				pm_msg->if_name, IWPM_NLA_REG_IF_NAME);
93 	if (ret)
94 		goto pid_query_error;
95 	ret = ibnl_put_attr(skb, nlh, IWPM_DEVNAME_SIZE,
96 				pm_msg->dev_name, IWPM_NLA_REG_IBDEV_NAME);
97 	if (ret)
98 		goto pid_query_error;
99 	ret = ibnl_put_attr(skb, nlh, IWPM_ULIBNAME_SIZE,
100 				(char *)iwpm_ulib_name, IWPM_NLA_REG_ULIB_NAME);
101 	if (ret)
102 		goto pid_query_error;
103 
104 	pr_debug("%s: Multicasting a nlmsg (dev = %s ifname = %s iwpm = %s)\n",
105 		__func__, pm_msg->dev_name, pm_msg->if_name, iwpm_ulib_name);
106 
107 	ret = ibnl_multicast(skb, nlh, RDMA_NL_GROUP_IWPM, GFP_KERNEL);
108 	if (ret) {
109 		skb = NULL; /* skb is freed in the netlink send-op handling */
110 		iwpm_user_pid = IWPM_PID_UNAVAILABLE;
111 		err_str = "Unable to send a nlmsg";
112 		goto pid_query_error;
113 	}
114 	nlmsg_request->req_buffer = pm_msg;
115 	ret = iwpm_wait_complete_req(nlmsg_request);
116 	return ret;
117 pid_query_error:
118 	pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
119 	if (skb)
120 		dev_kfree_skb(skb);
121 	if (nlmsg_request)
122 		iwpm_free_nlmsg_request(&nlmsg_request->kref);
123 	return ret;
124 }
125 EXPORT_SYMBOL(iwpm_register_pid);
126 
127 /*
128  * iwpm_add_mapping - Send a netlink add mapping message
129  *                    to the port mapper
130  * nlmsg attributes:
131  *	[IWPM_NLA_MANAGE_MAPPING_SEQ]
132  *	[IWPM_NLA_MANAGE_ADDR]
133  */
134 int iwpm_add_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
135 {
136 	struct sk_buff *skb = NULL;
137 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
138 	struct nlmsghdr *nlh;
139 	u32 msg_seq;
140 	const char *err_str = "";
141 	int ret = -EINVAL;
142 
143 	if (!iwpm_valid_client(nl_client)) {
144 		err_str = "Invalid port mapper client";
145 		goto add_mapping_error;
146 	}
147 	if (!iwpm_valid_pid())
148 		return 0;
149 	if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
150 		err_str = "Unregistered port mapper client";
151 		goto add_mapping_error;
152 	}
153 	skb = iwpm_create_nlmsg(RDMA_NL_IWPM_ADD_MAPPING, &nlh, nl_client);
154 	if (!skb) {
155 		err_str = "Unable to create a nlmsg";
156 		goto add_mapping_error;
157 	}
158 	nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
159 	nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq, nl_client, GFP_KERNEL);
160 	if (!nlmsg_request) {
161 		err_str = "Unable to allocate netlink request";
162 		goto add_mapping_error;
163 	}
164 	msg_seq = atomic_read(&echo_nlmsg_seq);
165 	/* fill in the add mapping message */
166 	err_str = "Unable to put attribute of the nlmsg";
167 	ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
168 				IWPM_NLA_MANAGE_MAPPING_SEQ);
169 	if (ret)
170 		goto add_mapping_error;
171 	ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
172 				&pm_msg->loc_addr, IWPM_NLA_MANAGE_ADDR);
173 	if (ret)
174 		goto add_mapping_error;
175 	nlmsg_request->req_buffer = pm_msg;
176 
177 	ret = ibnl_unicast(skb, nlh, iwpm_user_pid);
178 	if (ret) {
179 		skb = NULL; /* skb is freed in the netlink send-op handling */
180 		iwpm_user_pid = IWPM_PID_UNDEFINED;
181 		err_str = "Unable to send a nlmsg";
182 		goto add_mapping_error;
183 	}
184 	ret = iwpm_wait_complete_req(nlmsg_request);
185 	return ret;
186 add_mapping_error:
187 	pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
188 	if (skb)
189 		dev_kfree_skb(skb);
190 	if (nlmsg_request)
191 		iwpm_free_nlmsg_request(&nlmsg_request->kref);
192 	return ret;
193 }
194 EXPORT_SYMBOL(iwpm_add_mapping);
195 
196 /*
197  * iwpm_add_and_query_mapping - Send a netlink add and query
198  *                              mapping message to the port mapper
199  * nlmsg attributes:
200  *	[IWPM_NLA_QUERY_MAPPING_SEQ]
201  *	[IWPM_NLA_QUERY_LOCAL_ADDR]
202  *	[IWPM_NLA_QUERY_REMOTE_ADDR]
203  */
204 int iwpm_add_and_query_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
205 {
206 	struct sk_buff *skb = NULL;
207 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
208 	struct nlmsghdr *nlh;
209 	u32 msg_seq;
210 	const char *err_str = "";
211 	int ret = -EINVAL;
212 
213 	if (!iwpm_valid_client(nl_client)) {
214 		err_str = "Invalid port mapper client";
215 		goto query_mapping_error;
216 	}
217 	if (!iwpm_valid_pid())
218 		return 0;
219 	if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
220 		err_str = "Unregistered port mapper client";
221 		goto query_mapping_error;
222 	}
223 	ret = -ENOMEM;
224 	skb = iwpm_create_nlmsg(RDMA_NL_IWPM_QUERY_MAPPING, &nlh, nl_client);
225 	if (!skb) {
226 		err_str = "Unable to create a nlmsg";
227 		goto query_mapping_error;
228 	}
229 	nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
230 	nlmsg_request = iwpm_get_nlmsg_request(nlh->nlmsg_seq,
231 				nl_client, GFP_KERNEL);
232 	if (!nlmsg_request) {
233 		err_str = "Unable to allocate netlink request";
234 		goto query_mapping_error;
235 	}
236 	msg_seq = atomic_read(&echo_nlmsg_seq);
237 
238 	/* fill in the query message */
239 	err_str = "Unable to put attribute of the nlmsg";
240 	ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
241 				IWPM_NLA_QUERY_MAPPING_SEQ);
242 	if (ret)
243 		goto query_mapping_error;
244 	ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
245 				&pm_msg->loc_addr, IWPM_NLA_QUERY_LOCAL_ADDR);
246 	if (ret)
247 		goto query_mapping_error;
248 	ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
249 				&pm_msg->rem_addr, IWPM_NLA_QUERY_REMOTE_ADDR);
250 	if (ret)
251 		goto query_mapping_error;
252 	nlmsg_request->req_buffer = pm_msg;
253 
254 	ret = ibnl_unicast(skb, nlh, iwpm_user_pid);
255 	if (ret) {
256 		skb = NULL; /* skb is freed in the netlink send-op handling */
257 		err_str = "Unable to send a nlmsg";
258 		goto query_mapping_error;
259 	}
260 	ret = iwpm_wait_complete_req(nlmsg_request);
261 	return ret;
262 query_mapping_error:
263 	pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
264 	if (skb)
265 		dev_kfree_skb(skb);
266 	if (nlmsg_request)
267 		iwpm_free_nlmsg_request(&nlmsg_request->kref);
268 	return ret;
269 }
270 EXPORT_SYMBOL(iwpm_add_and_query_mapping);
271 
272 /*
273  * iwpm_remove_mapping - Send a netlink remove mapping message
274  *                       to the port mapper
275  * nlmsg attributes:
276  *	[IWPM_NLA_MANAGE_MAPPING_SEQ]
277  *	[IWPM_NLA_MANAGE_ADDR]
278  */
279 int iwpm_remove_mapping(struct sockaddr_storage *local_addr, u8 nl_client)
280 {
281 	struct sk_buff *skb = NULL;
282 	struct nlmsghdr *nlh;
283 	u32 msg_seq;
284 	const char *err_str = "";
285 	int ret = -EINVAL;
286 
287 	if (!iwpm_valid_client(nl_client)) {
288 		err_str = "Invalid port mapper client";
289 		goto remove_mapping_error;
290 	}
291 	if (!iwpm_valid_pid())
292 		return 0;
293 	if (iwpm_check_registration(nl_client, IWPM_REG_UNDEF)) {
294 		err_str = "Unregistered port mapper client";
295 		goto remove_mapping_error;
296 	}
297 	skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REMOVE_MAPPING, &nlh, nl_client);
298 	if (!skb) {
299 		ret = -ENOMEM;
300 		err_str = "Unable to create a nlmsg";
301 		goto remove_mapping_error;
302 	}
303 	msg_seq = atomic_read(&echo_nlmsg_seq);
304 	nlh->nlmsg_seq = iwpm_get_nlmsg_seq();
305 	err_str = "Unable to put attribute of the nlmsg";
306 	ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq,
307 				IWPM_NLA_MANAGE_MAPPING_SEQ);
308 	if (ret)
309 		goto remove_mapping_error;
310 	ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
311 				local_addr, IWPM_NLA_MANAGE_ADDR);
312 	if (ret)
313 		goto remove_mapping_error;
314 
315 	ret = ibnl_unicast(skb, nlh, iwpm_user_pid);
316 	if (ret) {
317 		skb = NULL; /* skb is freed in the netlink send-op handling */
318 		iwpm_user_pid = IWPM_PID_UNDEFINED;
319 		err_str = "Unable to send a nlmsg";
320 		goto remove_mapping_error;
321 	}
322 	iwpm_print_sockaddr(local_addr,
323 			"remove_mapping: Local sockaddr:");
324 	return 0;
325 remove_mapping_error:
326 	pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
327 	if (skb)
328 		dev_kfree_skb_any(skb);
329 	return ret;
330 }
331 EXPORT_SYMBOL(iwpm_remove_mapping);
332 
333 /* netlink attribute policy for the received response to register pid request */
334 static const struct nla_policy resp_reg_policy[IWPM_NLA_RREG_PID_MAX] = {
335 	[IWPM_NLA_RREG_PID_SEQ]     = { .type = NLA_U32 },
336 	[IWPM_NLA_RREG_IBDEV_NAME]  = { .type = NLA_STRING,
337 					.len = IWPM_DEVNAME_SIZE - 1 },
338 	[IWPM_NLA_RREG_ULIB_NAME]   = { .type = NLA_STRING,
339 					.len = IWPM_ULIBNAME_SIZE - 1 },
340 	[IWPM_NLA_RREG_ULIB_VER]    = { .type = NLA_U16 },
341 	[IWPM_NLA_RREG_PID_ERR]     = { .type = NLA_U16 }
342 };
343 
344 /*
345  * iwpm_register_pid_cb - Process a port mapper response to
346  *                        iwpm_register_pid()
347  */
348 int iwpm_register_pid_cb(struct sk_buff *skb, struct netlink_callback *cb)
349 {
350 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
351 	struct nlattr *nltb[IWPM_NLA_RREG_PID_MAX];
352 	struct iwpm_dev_data *pm_msg;
353 	char *dev_name, *iwpm_name;
354 	u32 msg_seq;
355 	u8 nl_client;
356 	u16 iwpm_version;
357 	const char *msg_type = "Register Pid response";
358 
359 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_RREG_PID_MAX,
360 				resp_reg_policy, nltb, msg_type))
361 		return -EINVAL;
362 
363 	msg_seq = nla_get_u32(nltb[IWPM_NLA_RREG_PID_SEQ]);
364 	nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
365 	if (!nlmsg_request) {
366 		pr_info("%s: Could not find a matching request (seq = %u)\n",
367 				 __func__, msg_seq);
368 		return -EINVAL;
369 	}
370 	pm_msg = nlmsg_request->req_buffer;
371 	nl_client = nlmsg_request->nl_client;
372 	dev_name = (char *)nla_data(nltb[IWPM_NLA_RREG_IBDEV_NAME]);
373 	iwpm_name = (char *)nla_data(nltb[IWPM_NLA_RREG_ULIB_NAME]);
374 	iwpm_version = nla_get_u16(nltb[IWPM_NLA_RREG_ULIB_VER]);
375 
376 	/* check device name, ulib name and version */
377 	if (strcmp(pm_msg->dev_name, dev_name) ||
378 			strcmp(iwpm_ulib_name, iwpm_name) ||
379 			iwpm_version != iwpm_ulib_version) {
380 
381 		pr_info("%s: Incorrect info (dev = %s name = %s version = %d)\n",
382 				__func__, dev_name, iwpm_name, iwpm_version);
383 		nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
384 		goto register_pid_response_exit;
385 	}
386 	iwpm_user_pid = cb->nlh->nlmsg_pid;
387 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
388 	pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
389 			__func__, iwpm_user_pid);
390 	if (iwpm_valid_client(nl_client))
391 		iwpm_set_registration(nl_client, IWPM_REG_VALID);
392 register_pid_response_exit:
393 	nlmsg_request->request_done = 1;
394 	/* always for found nlmsg_request */
395 	kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
396 	barrier();
397 	wake_up(&nlmsg_request->waitq);
398 	return 0;
399 }
400 EXPORT_SYMBOL(iwpm_register_pid_cb);
401 
402 /* netlink attribute policy for the received response to add mapping request */
403 static const struct nla_policy resp_add_policy[IWPM_NLA_RMANAGE_MAPPING_MAX] = {
404 	[IWPM_NLA_MANAGE_MAPPING_SEQ]     = { .type = NLA_U32 },
405 	[IWPM_NLA_MANAGE_ADDR]            = { .len = sizeof(struct sockaddr_storage) },
406 	[IWPM_NLA_MANAGE_MAPPED_LOC_ADDR] = { .len = sizeof(struct sockaddr_storage) },
407 	[IWPM_NLA_RMANAGE_MAPPING_ERR]	  = { .type = NLA_U16 }
408 };
409 
410 /*
411  * iwpm_add_mapping_cb - Process a port mapper response to
412  *                       iwpm_add_mapping()
413  */
414 int iwpm_add_mapping_cb(struct sk_buff *skb, struct netlink_callback *cb)
415 {
416 	struct iwpm_sa_data *pm_msg;
417 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
418 	struct nlattr *nltb[IWPM_NLA_RMANAGE_MAPPING_MAX];
419 	struct sockaddr_storage *local_sockaddr;
420 	struct sockaddr_storage *mapped_sockaddr;
421 	const char *msg_type;
422 	u32 msg_seq;
423 
424 	msg_type = "Add Mapping response";
425 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_RMANAGE_MAPPING_MAX,
426 				resp_add_policy, nltb, msg_type))
427 		return -EINVAL;
428 
429 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
430 
431 	msg_seq = nla_get_u32(nltb[IWPM_NLA_MANAGE_MAPPING_SEQ]);
432 	nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
433 	if (!nlmsg_request) {
434 		pr_info("%s: Could not find a matching request (seq = %u)\n",
435 				 __func__, msg_seq);
436 		return -EINVAL;
437 	}
438 	pm_msg = nlmsg_request->req_buffer;
439 	local_sockaddr = (struct sockaddr_storage *)
440 			nla_data(nltb[IWPM_NLA_MANAGE_ADDR]);
441 	mapped_sockaddr = (struct sockaddr_storage *)
442 			nla_data(nltb[IWPM_NLA_MANAGE_MAPPED_LOC_ADDR]);
443 
444 	if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr)) {
445 		nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
446 		goto add_mapping_response_exit;
447 	}
448 	if (mapped_sockaddr->ss_family != local_sockaddr->ss_family) {
449 		pr_info("%s: Sockaddr family doesn't match the requested one\n",
450 				__func__);
451 		nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
452 		goto add_mapping_response_exit;
453 	}
454 	memcpy(&pm_msg->mapped_loc_addr, mapped_sockaddr,
455 			sizeof(*mapped_sockaddr));
456 	iwpm_print_sockaddr(&pm_msg->loc_addr,
457 			"add_mapping: Local sockaddr:");
458 	iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
459 			"add_mapping: Mapped local sockaddr:");
460 
461 add_mapping_response_exit:
462 	nlmsg_request->request_done = 1;
463 	/* always for found request */
464 	kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
465 	barrier();
466 	wake_up(&nlmsg_request->waitq);
467 	return 0;
468 }
469 EXPORT_SYMBOL(iwpm_add_mapping_cb);
470 
471 /* netlink attribute policy for the response to add and query mapping request
472  * and response with remote address info */
473 static const struct nla_policy resp_query_policy[IWPM_NLA_RQUERY_MAPPING_MAX] = {
474 	[IWPM_NLA_QUERY_MAPPING_SEQ]      = { .type = NLA_U32 },
475 	[IWPM_NLA_QUERY_LOCAL_ADDR]       = { .len = sizeof(struct sockaddr_storage) },
476 	[IWPM_NLA_QUERY_REMOTE_ADDR]      = { .len = sizeof(struct sockaddr_storage) },
477 	[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR] = { .len = sizeof(struct sockaddr_storage) },
478 	[IWPM_NLA_RQUERY_MAPPED_REM_ADDR] = { .len = sizeof(struct sockaddr_storage) },
479 	[IWPM_NLA_RQUERY_MAPPING_ERR]	  = { .type = NLA_U16 }
480 };
481 
482 /*
483  * iwpm_add_and_query_mapping_cb - Process a port mapper response to
484  *                                 iwpm_add_and_query_mapping()
485  */
486 int iwpm_add_and_query_mapping_cb(struct sk_buff *skb,
487 				struct netlink_callback *cb)
488 {
489 	struct iwpm_sa_data *pm_msg;
490 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
491 	struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
492 	struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
493 	struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
494 	const char *msg_type;
495 	u32 msg_seq;
496 	u16 err_code;
497 
498 	msg_type = "Query Mapping response";
499 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
500 				resp_query_policy, nltb, msg_type))
501 		return -EINVAL;
502 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
503 
504 	msg_seq = nla_get_u32(nltb[IWPM_NLA_QUERY_MAPPING_SEQ]);
505 	nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
506 	if (!nlmsg_request) {
507 		pr_info("%s: Could not find a matching request (seq = %u)\n",
508 				 __func__, msg_seq);
509 			return -EINVAL;
510 	}
511 	pm_msg = nlmsg_request->req_buffer;
512 	local_sockaddr = (struct sockaddr_storage *)
513 			nla_data(nltb[IWPM_NLA_QUERY_LOCAL_ADDR]);
514 	remote_sockaddr = (struct sockaddr_storage *)
515 			nla_data(nltb[IWPM_NLA_QUERY_REMOTE_ADDR]);
516 	mapped_loc_sockaddr = (struct sockaddr_storage *)
517 			nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
518 	mapped_rem_sockaddr = (struct sockaddr_storage *)
519 			nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
520 
521 	err_code = nla_get_u16(nltb[IWPM_NLA_RQUERY_MAPPING_ERR]);
522 	if (err_code == IWPM_REMOTE_QUERY_REJECT) {
523 		pr_info("%s: Received a Reject (pid = %u, echo seq = %u)\n",
524 			__func__, cb->nlh->nlmsg_pid, msg_seq);
525 		nlmsg_request->err_code = IWPM_REMOTE_QUERY_REJECT;
526 	}
527 	if (iwpm_compare_sockaddr(local_sockaddr, &pm_msg->loc_addr) ||
528 		iwpm_compare_sockaddr(remote_sockaddr, &pm_msg->rem_addr)) {
529 		pr_info("%s: Incorrect local sockaddr\n", __func__);
530 		nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
531 		goto query_mapping_response_exit;
532 	}
533 	if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
534 		mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
535 		pr_info("%s: Sockaddr family doesn't match the requested one\n",
536 				__func__);
537 		nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
538 		goto query_mapping_response_exit;
539 	}
540 	memcpy(&pm_msg->mapped_loc_addr, mapped_loc_sockaddr,
541 			sizeof(*mapped_loc_sockaddr));
542 	memcpy(&pm_msg->mapped_rem_addr, mapped_rem_sockaddr,
543 			sizeof(*mapped_rem_sockaddr));
544 
545 	iwpm_print_sockaddr(&pm_msg->loc_addr,
546 			"query_mapping: Local sockaddr:");
547 	iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
548 			"query_mapping: Mapped local sockaddr:");
549 	iwpm_print_sockaddr(&pm_msg->rem_addr,
550 			"query_mapping: Remote sockaddr:");
551 	iwpm_print_sockaddr(&pm_msg->mapped_rem_addr,
552 			"query_mapping: Mapped remote sockaddr:");
553 query_mapping_response_exit:
554 	nlmsg_request->request_done = 1;
555 	/* always for found request */
556 	kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
557 	barrier();
558 	wake_up(&nlmsg_request->waitq);
559 	return 0;
560 }
561 EXPORT_SYMBOL(iwpm_add_and_query_mapping_cb);
562 
563 /*
564  * iwpm_remote_info_cb - Process a port mapper message, containing
565  *			  the remote connecting peer address info
566  */
567 int iwpm_remote_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
568 {
569 	struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX];
570 	struct sockaddr_storage *local_sockaddr, *remote_sockaddr;
571 	struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr;
572 	struct iwpm_remote_info *rem_info;
573 	const char *msg_type;
574 	u8 nl_client;
575 	int ret = -EINVAL;
576 
577 	msg_type = "Remote Mapping info";
578 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX,
579 				resp_query_policy, nltb, msg_type))
580 		return ret;
581 
582 	nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
583 	if (!iwpm_valid_client(nl_client)) {
584 		pr_info("%s: Invalid port mapper client = %d\n",
585 				__func__, nl_client);
586 		return ret;
587 	}
588 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
589 
590 	local_sockaddr = (struct sockaddr_storage *)
591 			nla_data(nltb[IWPM_NLA_QUERY_LOCAL_ADDR]);
592 	remote_sockaddr = (struct sockaddr_storage *)
593 			nla_data(nltb[IWPM_NLA_QUERY_REMOTE_ADDR]);
594 	mapped_loc_sockaddr = (struct sockaddr_storage *)
595 			nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
596 	mapped_rem_sockaddr = (struct sockaddr_storage *)
597 			nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
598 
599 	if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family ||
600 		mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) {
601 		pr_info("%s: Sockaddr family doesn't match the requested one\n",
602 				__func__);
603 		return ret;
604 	}
605 	rem_info = kzalloc(sizeof(struct iwpm_remote_info), GFP_ATOMIC);
606 	if (!rem_info) {
607 		pr_err("%s: Unable to allocate a remote info\n", __func__);
608 		ret = -ENOMEM;
609 		return ret;
610 	}
611 	memcpy(&rem_info->mapped_loc_sockaddr, mapped_loc_sockaddr,
612 	       sizeof(struct sockaddr_storage));
613 	memcpy(&rem_info->remote_sockaddr, remote_sockaddr,
614 	       sizeof(struct sockaddr_storage));
615 	memcpy(&rem_info->mapped_rem_sockaddr, mapped_rem_sockaddr,
616 	       sizeof(struct sockaddr_storage));
617 	rem_info->nl_client = nl_client;
618 
619 	iwpm_add_remote_info(rem_info);
620 
621 	iwpm_print_sockaddr(local_sockaddr,
622 			"remote_info: Local sockaddr:");
623 	iwpm_print_sockaddr(mapped_loc_sockaddr,
624 			"remote_info: Mapped local sockaddr:");
625 	iwpm_print_sockaddr(remote_sockaddr,
626 			"remote_info: Remote sockaddr:");
627 	iwpm_print_sockaddr(mapped_rem_sockaddr,
628 			"remote_info: Mapped remote sockaddr:");
629 	return ret;
630 }
631 EXPORT_SYMBOL(iwpm_remote_info_cb);
632 
633 /* netlink attribute policy for the received request for mapping info */
634 static const struct nla_policy resp_mapinfo_policy[IWPM_NLA_MAPINFO_REQ_MAX] = {
635 	[IWPM_NLA_MAPINFO_ULIB_NAME] = { .type = NLA_STRING,
636 					.len = IWPM_ULIBNAME_SIZE - 1 },
637 	[IWPM_NLA_MAPINFO_ULIB_VER]  = { .type = NLA_U16 }
638 };
639 
640 /*
641  * iwpm_mapping_info_cb - Process a port mapper request for mapping info
642  */
643 int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
644 {
645 	struct nlattr *nltb[IWPM_NLA_MAPINFO_REQ_MAX];
646 	const char *msg_type = "Mapping Info response";
647 	u8 nl_client;
648 	char *iwpm_name;
649 	u16 iwpm_version;
650 	int ret = -EINVAL;
651 
652 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_REQ_MAX,
653 				resp_mapinfo_policy, nltb, msg_type)) {
654 		pr_info("%s: Unable to parse nlmsg\n", __func__);
655 		return ret;
656 	}
657 	iwpm_name = (char *)nla_data(nltb[IWPM_NLA_MAPINFO_ULIB_NAME]);
658 	iwpm_version = nla_get_u16(nltb[IWPM_NLA_MAPINFO_ULIB_VER]);
659 	if (strcmp(iwpm_ulib_name, iwpm_name) ||
660 			iwpm_version != iwpm_ulib_version) {
661 		pr_info("%s: Invalid port mapper name = %s version = %d\n",
662 				__func__, iwpm_name, iwpm_version);
663 		return ret;
664 	}
665 	nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
666 	if (!iwpm_valid_client(nl_client)) {
667 		pr_info("%s: Invalid port mapper client = %d\n",
668 				__func__, nl_client);
669 		return ret;
670 	}
671 	iwpm_set_registration(nl_client, IWPM_REG_INCOMPL);
672 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
673 	iwpm_user_pid = cb->nlh->nlmsg_pid;
674 	if (!iwpm_mapinfo_available())
675 		return 0;
676 	pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
677 		 __func__, iwpm_user_pid);
678 	ret = iwpm_send_mapinfo(nl_client, iwpm_user_pid);
679 	return ret;
680 }
681 EXPORT_SYMBOL(iwpm_mapping_info_cb);
682 
683 /* netlink attribute policy for the received mapping info ack */
684 static const struct nla_policy ack_mapinfo_policy[IWPM_NLA_MAPINFO_NUM_MAX] = {
685 	[IWPM_NLA_MAPINFO_SEQ]    =   { .type = NLA_U32 },
686 	[IWPM_NLA_MAPINFO_SEND_NUM] = { .type = NLA_U32 },
687 	[IWPM_NLA_MAPINFO_ACK_NUM] =  { .type = NLA_U32 }
688 };
689 
690 /*
691  * iwpm_ack_mapping_info_cb - Process a port mapper ack for
692  *                            the provided mapping info records
693  */
694 int iwpm_ack_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
695 {
696 	struct nlattr *nltb[IWPM_NLA_MAPINFO_NUM_MAX];
697 	u32 mapinfo_send, mapinfo_ack;
698 	const char *msg_type = "Mapping Info Ack";
699 
700 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_MAPINFO_NUM_MAX,
701 				ack_mapinfo_policy, nltb, msg_type))
702 		return -EINVAL;
703 	mapinfo_send = nla_get_u32(nltb[IWPM_NLA_MAPINFO_SEND_NUM]);
704 	mapinfo_ack = nla_get_u32(nltb[IWPM_NLA_MAPINFO_ACK_NUM]);
705 	if (mapinfo_ack != mapinfo_send)
706 		pr_info("%s: Invalid mapinfo number (sent = %u ack-ed = %u)\n",
707 			__func__, mapinfo_send, mapinfo_ack);
708 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
709 	return 0;
710 }
711 EXPORT_SYMBOL(iwpm_ack_mapping_info_cb);
712 
713 /* netlink attribute policy for the received port mapper error message */
714 static const struct nla_policy map_error_policy[IWPM_NLA_ERR_MAX] = {
715 	[IWPM_NLA_ERR_SEQ]        = { .type = NLA_U32 },
716 	[IWPM_NLA_ERR_CODE]       = { .type = NLA_U16 },
717 };
718 
719 /*
720  * iwpm_mapping_error_cb - Process a port mapper error message
721  */
722 int iwpm_mapping_error_cb(struct sk_buff *skb, struct netlink_callback *cb)
723 {
724 	struct iwpm_nlmsg_request *nlmsg_request = NULL;
725 	int nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
726 	struct nlattr *nltb[IWPM_NLA_ERR_MAX];
727 	u32 msg_seq;
728 	u16 err_code;
729 	const char *msg_type = "Mapping Error Msg";
730 
731 	if (iwpm_parse_nlmsg(cb, IWPM_NLA_ERR_MAX,
732 				map_error_policy, nltb, msg_type))
733 		return -EINVAL;
734 
735 	msg_seq = nla_get_u32(nltb[IWPM_NLA_ERR_SEQ]);
736 	err_code = nla_get_u16(nltb[IWPM_NLA_ERR_CODE]);
737 	pr_info("%s: Received msg seq = %u err code = %u client = %d\n",
738 				__func__, msg_seq, err_code, nl_client);
739 	/* look for nlmsg_request */
740 	nlmsg_request = iwpm_find_nlmsg_request(msg_seq);
741 	if (!nlmsg_request) {
742 		/* not all errors have associated requests */
743 		pr_debug("Could not find matching req (seq = %u)\n", msg_seq);
744 		return 0;
745 	}
746 	atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
747 	nlmsg_request->err_code = err_code;
748 	nlmsg_request->request_done = 1;
749 	/* always for found request */
750 	kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
751 	barrier();
752 	wake_up(&nlmsg_request->waitq);
753 	return 0;
754 }
755 EXPORT_SYMBOL(iwpm_mapping_error_cb);
756