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