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