core/iwpm_msg.c

   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(RDMA_NL_IWPM_REG_PID, &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(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(&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, sizeof(u32), &msg_seq, IWPM_NLA_REG_PID_SEQ);
  91         if (ret)
  92                 goto pid_query_error;
  93         ret = ibnl_put_attr(skb, nlh, IFNAMSIZ,
  94                             pm_msg->if_name, IWPM_NLA_REG_IF_NAME);
  95         if (ret)
  96                 goto pid_query_error;
  97         ret = ibnl_put_attr(skb, nlh, IWPM_DEVNAME_SIZE,
  98                                 pm_msg->dev_name, IWPM_NLA_REG_IBDEV_NAME);
  99         if (ret)
 100                 goto pid_query_error;
 101         ret = ibnl_put_attr(skb, nlh, IWPM_ULIBNAME_SIZE,
 102                                 (char *)iwpm_ulib_name, 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(&init_net, skb, 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(&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(RDMA_NL_IWPM_ADD_MAPPING, &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(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(&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, sizeof(u32), &msg_seq,
 173                                 IWPM_NLA_MANAGE_MAPPING_SEQ);
 174         if (ret)
 175                 goto add_mapping_error;
 176         ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
 177                                 &pm_msg->loc_addr, 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, sizeof(u32), &pm_msg->flags,
 188                                 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(&init_net, skb, 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(&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(RDMA_NL_IWPM_QUERY_MAPPING, &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(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(&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, sizeof(u32), &msg_seq,
 259                                 IWPM_NLA_QUERY_MAPPING_SEQ);
 260         if (ret)
 261                 goto query_mapping_error;
 262         ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
 263                                 &pm_msg->loc_addr, IWPM_NLA_QUERY_LOCAL_ADDR);
 264         if (ret)
 265                 goto query_mapping_error;
 266         ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
 267                                 &pm_msg->rem_addr, 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, sizeof(u32), &pm_msg->flags,
 278                                 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(&init_net, skb, 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(&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(RDMA_NL_IWPM_REMOVE_MAPPING, &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(&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, sizeof(u32), &msg_seq,
 338                                 IWPM_NLA_MANAGE_MAPPING_SEQ);
 339         if (ret)
 340                 goto remove_mapping_error;
 341         ret = ibnl_put_attr(skb, nlh, sizeof(struct sockaddr_storage),
 342                                 local_addr, 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(&init_net, skb, 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(local_addr,
 356                         "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, IWPM_NLA_RREG_PID_MAX,
 397                                 resp_reg_policy, nltb, msg_type))
 398                 return -EINVAL;
 399
 400         msg_seq = nla_get_u32(nltb[IWPM_NLA_RREG_PID_SEQ]);
 401         nlmsg_request = iwpm_find_nlmsg_request(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(nltb[IWPM_NLA_RREG_IBDEV_NAME]);
 410         iwpm_name = (char *)nla_data(nltb[IWPM_NLA_RREG_ULIB_NAME]);
 411         iwpm_version = nla_get_u16(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(&echo_nlmsg_seq, 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(&nlmsg_request->kref, iwpm_free_nlmsg_request);
 436         barrier();
 437         up(&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, IWPM_NLA_RMANAGE_MAPPING_MAX,
 469                                 resp_add_policy, nltb, msg_type))
 470                 return -EINVAL;
 471
 472         atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
 473
 474         msg_seq = nla_get_u32(nltb[IWPM_NLA_RMANAGE_MAPPING_SEQ]);
 475         nlmsg_request = iwpm_find_nlmsg_request(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(nltb[IWPM_NLA_RMANAGE_ADDR]);
 484         mapped_sockaddr = (struct sockaddr_storage *)
 485                         nla_data(nltb[IWPM_NLA_RMANAGE_MAPPED_LOC_ADDR]);
 486
 487         if (iwpm_compare_sockaddr(local_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(&pm_msg->loc_addr,
 500                         "add_mapping: Local sockaddr:");
 501         iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
 502                         "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(&nlmsg_request->kref, iwpm_free_nlmsg_request);
 508         barrier();
 509         up(&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, IWPM_NLA_RQUERY_MAPPING_MAX,
 549                                 resp_query_policy, nltb, msg_type))
 550                 return -EINVAL;
 551         atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
 552
 553         msg_seq = nla_get_u32(nltb[IWPM_NLA_RQUERY_MAPPING_SEQ]);
 554         nlmsg_request = iwpm_find_nlmsg_request(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(nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]);
 563         remote_sockaddr = (struct sockaddr_storage *)
 564                         nla_data(nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]);
 565         mapped_loc_sockaddr = (struct sockaddr_storage *)
 566                         nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
 567         mapped_rem_sockaddr = (struct sockaddr_storage *)
 568                         nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]);
 569
 570         err_code = nla_get_u16(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(local_sockaddr, &pm_msg->loc_addr) ||
 577                 iwpm_compare_sockaddr(remote_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(&pm_msg->loc_addr,
 595                         "query_mapping: Local sockaddr:");
 596         iwpm_print_sockaddr(&pm_msg->mapped_loc_addr,
 597                         "query_mapping: Mapped local sockaddr:");
 598         iwpm_print_sockaddr(&pm_msg->rem_addr,
 599                         "query_mapping: Remote sockaddr:");
 600         iwpm_print_sockaddr(&pm_msg->mapped_rem_addr,
 601                         "query_mapping: Mapped remote sockaddr:");
 602 query_mapping_response_exit:
 603         nlmsg_request->request_done = 1;
 604         /* always for found request */
 605         kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
 606         barrier();
 607         up(&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, IWPM_NLA_RQUERY_MAPPING_MAX,
 631                                 resp_query_policy, nltb, msg_type))
 632                 return ret;
 633
 634         nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
 635         atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
 636
 637         local_sockaddr = (struct sockaddr_storage *)
 638                         nla_data(nltb[IWPM_NLA_RQUERY_LOCAL_ADDR]);
 639         remote_sockaddr = (struct sockaddr_storage *)
 640                         nla_data(nltb[IWPM_NLA_RQUERY_REMOTE_ADDR]);
 641         mapped_loc_sockaddr = (struct sockaddr_storage *)
 642                         nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]);
 643         mapped_rem_sockaddr = (struct sockaddr_storage *)
 644                         nla_data(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(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(rem_info);
 666
 667         iwpm_print_sockaddr(local_sockaddr,
 668                         "remote_info: Local sockaddr:");
 669         iwpm_print_sockaddr(mapped_loc_sockaddr,
 670                         "remote_info: Mapped local sockaddr:");
 671         iwpm_print_sockaddr(remote_sockaddr,
 672                         "remote_info: Remote sockaddr:");
 673         iwpm_print_sockaddr(mapped_rem_sockaddr,
 674                         "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, IWPM_NLA_MAPINFO_REQ_MAX,
 704                                 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(nltb[IWPM_NLA_MAPINFO_ULIB_NAME]);
 709         iwpm_version = nla_get_u16(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(&echo_nlmsg_seq, 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_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, IWPM_NLA_MAPINFO_NUM_MAX,
 753                                 ack_mapinfo_policy, nltb, msg_type))
 754                 return -EINVAL;
 755         mapinfo_send = nla_get_u32(nltb[IWPM_NLA_MAPINFO_SEND_NUM]);
 756         mapinfo_ack = nla_get_u32(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(&echo_nlmsg_seq, 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, IWPM_NLA_ERR_MAX,
 786                                 map_error_policy, nltb, msg_type))
 787                 return -EINVAL;
 788
 789         msg_seq = nla_get_u32(nltb[IWPM_NLA_ERR_SEQ]);
 790         err_code = nla_get_u16(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(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(&echo_nlmsg_seq, 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(&nlmsg_request->kref, iwpm_free_nlmsg_request);
 805         barrier();
 806         up(&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, IWPM_NLA_HELLO_MAX, 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(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(&echo_nlmsg_seq, 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_user_pid, iwpm_ulib_version);
 845         return ret;
 846 }