net/netlabel/netlabel_mgmt.c

   1 /*
   2  * NetLabel Management Support
   3  *
   4  * This file defines the management functions for the NetLabel system.  The
   5  * NetLabel system manages static and dynamic label mappings for network
   6  * protocols such as CIPSO and RIPSO.
   7  *
   8  * Author: Paul Moore <paul@paul-moore.com>
   9  *
  10  */
  11
  12 /*
  13  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
  14  *
  15  * This program is free software;  you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  23  * the GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program;  if not, see <http://www.gnu.org/licenses/>.
  27  *
  28  */
  29
  30 #include <linux/types.h>
  31 #include <linux/socket.h>
  32 #include <linux/string.h>
  33 #include <linux/skbuff.h>
  34 #include <linux/in.h>
  35 #include <linux/in6.h>
  36 #include <linux/slab.h>
  37 #include <net/sock.h>
  38 #include <net/netlink.h>
  39 #include <net/genetlink.h>
  40 #include <net/ip.h>
  41 #include <net/ipv6.h>
  42 #include <net/netlabel.h>
  43 #include <net/cipso_ipv4.h>
  44 #include <net/calipso.h>
  45 #include <linux/atomic.h>
  46
  47 #include "netlabel_calipso.h"
  48 #include "netlabel_domainhash.h"
  49 #include "netlabel_user.h"
  50 #include "netlabel_mgmt.h"
  51
  52 /* NetLabel configured protocol counter */
  53 atomic_t netlabel_mgmt_protocount = ATOMIC_INIT(0);
  54
  55 /* Argument struct for netlbl_domhsh_walk() */
  56 struct netlbl_domhsh_walk_arg {
  57         struct netlink_callback *nl_cb;
  58         struct sk_buff *skb;
  59         u32 seq;
  60 };
  61
  62 /* NetLabel Generic NETLINK CIPSOv4 family */
  63 static struct genl_family netlbl_mgmt_gnl_family = {
  64         .id = GENL_ID_GENERATE,
  65         .hdrsize = 0,
  66         .name = NETLBL_NLTYPE_MGMT_NAME,
  67         .version = NETLBL_PROTO_VERSION,
  68         .maxattr = NLBL_MGMT_A_MAX,
  69 };
  70
  71 /* NetLabel Netlink attribute policy */
  72 static const struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = {
  73         [NLBL_MGMT_A_DOMAIN] = { .type = NLA_NUL_STRING },
  74         [NLBL_MGMT_A_PROTOCOL] = { .type = NLA_U32 },
  75         [NLBL_MGMT_A_VERSION] = { .type = NLA_U32 },
  76         [NLBL_MGMT_A_CV4DOI] = { .type = NLA_U32 },
  77         [NLBL_MGMT_A_FAMILY] = { .type = NLA_U16 },
  78         [NLBL_MGMT_A_CLPDOI] = { .type = NLA_U32 },
  79 };
  80
  81 /*
  82  * Helper Functions
  83  */
  84
  85 /**
  86  * netlbl_mgmt_add - Handle an ADD message
  87  * @info: the Generic NETLINK info block
  88  * @audit_info: NetLabel audit information
  89  *
  90  * Description:
  91  * Helper function for the ADD and ADDDEF messages to add the domain mappings
  92  * from the message to the hash table.  See netlabel.h for a description of the
  93  * message format.  Returns zero on success, negative values on failure.
  94  *
  95  */
  96 static int netlbl_mgmt_add_common(struct genl_info *info,
  97                                   struct netlbl_audit *audit_info)
  98 {
  99         void *pmap = NULL;
 100         int ret_val = -EINVAL;
 101         struct netlbl_domaddr_map *addrmap = NULL;
 102         struct cipso_v4_doi *cipsov4 = NULL;
 103 #if IS_ENABLED(CONFIG_IPV6)
 104         struct calipso_doi *calipso = NULL;
 105 #endif
 106         u32 tmp_val;
 107         struct netlbl_dom_map *entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 108
 109         if (!entry)
 110                 return -ENOMEM;
 111         entry->def.type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
 112         if (info->attrs[NLBL_MGMT_A_DOMAIN]) {
 113                 size_t tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]);
 114                 entry->domain = kmalloc(tmp_size, GFP_KERNEL);
 115                 if (entry->domain == NULL) {
 116                         ret_val = -ENOMEM;
 117                         goto add_free_entry;
 118                 }
 119                 nla_strlcpy(entry->domain,
 120                             info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size);
 121         }
 122
 123         /* NOTE: internally we allow/use a entry->def.type value of
 124          *       NETLBL_NLTYPE_ADDRSELECT but we don't currently allow users
 125          *       to pass that as a protocol value because we need to know the
 126          *       "real" protocol */
 127
 128         switch (entry->def.type) {
 129         case NETLBL_NLTYPE_UNLABELED:
 130                 if (info->attrs[NLBL_MGMT_A_FAMILY])
 131                         entry->family =
 132                                 nla_get_u16(info->attrs[NLBL_MGMT_A_FAMILY]);
 133                 else
 134                         entry->family = AF_UNSPEC;
 135                 break;
 136         case NETLBL_NLTYPE_CIPSOV4:
 137                 if (!info->attrs[NLBL_MGMT_A_CV4DOI])
 138                         goto add_free_domain;
 139
 140                 tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
 141                 cipsov4 = cipso_v4_doi_getdef(tmp_val);
 142                 if (cipsov4 == NULL)
 143                         goto add_free_domain;
 144                 entry->family = AF_INET;
 145                 entry->def.cipso = cipsov4;
 146                 break;
 147 #if IS_ENABLED(CONFIG_IPV6)
 148         case NETLBL_NLTYPE_CALIPSO:
 149                 if (!info->attrs[NLBL_MGMT_A_CLPDOI])
 150                         goto add_free_domain;
 151
 152                 tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CLPDOI]);
 153                 calipso = calipso_doi_getdef(tmp_val);
 154                 if (calipso == NULL)
 155                         goto add_free_domain;
 156                 entry->family = AF_INET6;
 157                 entry->def.calipso = calipso;
 158                 break;
 159 #endif /* IPv6 */
 160         default:
 161                 goto add_free_domain;
 162         }
 163
 164         if ((entry->family == AF_INET && info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
 165             (entry->family == AF_INET6 && info->attrs[NLBL_MGMT_A_IPV4ADDR]))
 166                 goto add_doi_put_def;
 167
 168         if (info->attrs[NLBL_MGMT_A_IPV4ADDR]) {
 169                 struct in_addr *addr;
 170                 struct in_addr *mask;
 171                 struct netlbl_domaddr4_map *map;
 172
 173                 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
 174                 if (addrmap == NULL) {
 175                         ret_val = -ENOMEM;
 176                         goto add_doi_put_def;
 177                 }
 178                 INIT_LIST_HEAD(&addrmap->list4);
 179                 INIT_LIST_HEAD(&addrmap->list6);
 180
 181                 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4ADDR]) !=
 182                     sizeof(struct in_addr)) {
 183                         ret_val = -EINVAL;
 184                         goto add_free_addrmap;
 185                 }
 186                 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4MASK]) !=
 187                     sizeof(struct in_addr)) {
 188                         ret_val = -EINVAL;
 189                         goto add_free_addrmap;
 190                 }
 191                 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV4ADDR]);
 192                 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV4MASK]);
 193
 194                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 195                 if (map == NULL) {
 196                         ret_val = -ENOMEM;
 197                         goto add_free_addrmap;
 198                 }
 199                 pmap = map;
 200                 map->list.addr = addr->s_addr & mask->s_addr;
 201                 map->list.mask = mask->s_addr;
 202                 map->list.valid = 1;
 203                 map->def.type = entry->def.type;
 204                 if (cipsov4)
 205                         map->def.cipso = cipsov4;
 206
 207                 ret_val = netlbl_af4list_add(&map->list, &addrmap->list4);
 208                 if (ret_val != 0)
 209                         goto add_free_map;
 210
 211                 entry->family = AF_INET;
 212                 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
 213                 entry->def.addrsel = addrmap;
 214 #if IS_ENABLED(CONFIG_IPV6)
 215         } else if (info->attrs[NLBL_MGMT_A_IPV6ADDR]) {
 216                 struct in6_addr *addr;
 217                 struct in6_addr *mask;
 218                 struct netlbl_domaddr6_map *map;
 219
 220                 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
 221                 if (addrmap == NULL) {
 222                         ret_val = -ENOMEM;
 223                         goto add_doi_put_def;
 224                 }
 225                 INIT_LIST_HEAD(&addrmap->list4);
 226                 INIT_LIST_HEAD(&addrmap->list6);
 227
 228                 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6ADDR]) !=
 229                     sizeof(struct in6_addr)) {
 230                         ret_val = -EINVAL;
 231                         goto add_free_addrmap;
 232                 }
 233                 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6MASK]) !=
 234                     sizeof(struct in6_addr)) {
 235                         ret_val = -EINVAL;
 236                         goto add_free_addrmap;
 237                 }
 238                 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV6ADDR]);
 239                 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV6MASK]);
 240
 241                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 242                 if (map == NULL) {
 243                         ret_val = -ENOMEM;
 244                         goto add_free_addrmap;
 245                 }
 246                 pmap = map;
 247                 map->list.addr = *addr;
 248                 map->list.addr.s6_addr32[0] &= mask->s6_addr32[0];
 249                 map->list.addr.s6_addr32[1] &= mask->s6_addr32[1];
 250                 map->list.addr.s6_addr32[2] &= mask->s6_addr32[2];
 251                 map->list.addr.s6_addr32[3] &= mask->s6_addr32[3];
 252                 map->list.mask = *mask;
 253                 map->list.valid = 1;
 254                 map->def.type = entry->def.type;
 255                 if (calipso)
 256                         map->def.calipso = calipso;
 257
 258                 ret_val = netlbl_af6list_add(&map->list, &addrmap->list6);
 259                 if (ret_val != 0)
 260                         goto add_free_map;
 261
 262                 entry->family = AF_INET6;
 263                 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
 264                 entry->def.addrsel = addrmap;
 265 #endif /* IPv6 */
 266         }
 267
 268         ret_val = netlbl_domhsh_add(entry, audit_info);
 269         if (ret_val != 0)
 270                 goto add_free_map;
 271
 272         return 0;
 273
 274 add_free_map:
 275         kfree(pmap);
 276 add_free_addrmap:
 277         kfree(addrmap);
 278 add_doi_put_def:
 279         cipso_v4_doi_putdef(cipsov4);
 280 #if IS_ENABLED(CONFIG_IPV6)
 281         calipso_doi_putdef(calipso);
 282 #endif
 283 add_free_domain:
 284         kfree(entry->domain);
 285 add_free_entry:
 286         kfree(entry);
 287         return ret_val;
 288 }
 289
 290 /**
 291  * netlbl_mgmt_listentry - List a NetLabel/LSM domain map entry
 292  * @skb: the NETLINK buffer
 293  * @entry: the map entry
 294  *
 295  * Description:
 296  * This function is a helper function used by the LISTALL and LISTDEF command
 297  * handlers.  The caller is responsible for ensuring that the RCU read lock
 298  * is held.  Returns zero on success, negative values on failure.
 299  *
 300  */
 301 static int netlbl_mgmt_listentry(struct sk_buff *skb,
 302                                  struct netlbl_dom_map *entry)
 303 {
 304         int ret_val = 0;
 305         struct nlattr *nla_a;
 306         struct nlattr *nla_b;
 307         struct netlbl_af4list *iter4;
 308 #if IS_ENABLED(CONFIG_IPV6)
 309         struct netlbl_af6list *iter6;
 310 #endif
 311
 312         if (entry->domain != NULL) {
 313                 ret_val = nla_put_string(skb,
 314                                          NLBL_MGMT_A_DOMAIN, entry->domain);
 315                 if (ret_val != 0)
 316                         return ret_val;
 317         }
 318
 319         ret_val = nla_put_u16(skb, NLBL_MGMT_A_FAMILY, entry->family);
 320         if (ret_val != 0)
 321                 return ret_val;
 322
 323         switch (entry->def.type) {
 324         case NETLBL_NLTYPE_ADDRSELECT:
 325                 nla_a = nla_nest_start(skb, NLBL_MGMT_A_SELECTORLIST);
 326                 if (nla_a == NULL)
 327                         return -ENOMEM;
 328
 329                 netlbl_af4list_foreach_rcu(iter4, &entry->def.addrsel->list4) {
 330                         struct netlbl_domaddr4_map *map4;
 331                         struct in_addr addr_struct;
 332
 333                         nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
 334                         if (nla_b == NULL)
 335                                 return -ENOMEM;
 336
 337                         addr_struct.s_addr = iter4->addr;
 338                         ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4ADDR,
 339                                                   addr_struct.s_addr);
 340                         if (ret_val != 0)
 341                                 return ret_val;
 342                         addr_struct.s_addr = iter4->mask;
 343                         ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4MASK,
 344                                                   addr_struct.s_addr);
 345                         if (ret_val != 0)
 346                                 return ret_val;
 347                         map4 = netlbl_domhsh_addr4_entry(iter4);
 348                         ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
 349                                               map4->def.type);
 350                         if (ret_val != 0)
 351                                 return ret_val;
 352                         switch (map4->def.type) {
 353                         case NETLBL_NLTYPE_CIPSOV4:
 354                                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
 355                                                       map4->def.cipso->doi);
 356                                 if (ret_val != 0)
 357                                         return ret_val;
 358                                 break;
 359                         }
 360
 361                         nla_nest_end(skb, nla_b);
 362                 }
 363 #if IS_ENABLED(CONFIG_IPV6)
 364                 netlbl_af6list_foreach_rcu(iter6, &entry->def.addrsel->list6) {
 365                         struct netlbl_domaddr6_map *map6;
 366
 367                         nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
 368                         if (nla_b == NULL)
 369                                 return -ENOMEM;
 370
 371                         ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6ADDR,
 372                                                    &iter6->addr);
 373                         if (ret_val != 0)
 374                                 return ret_val;
 375                         ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6MASK,
 376                                                    &iter6->mask);
 377                         if (ret_val != 0)
 378                                 return ret_val;
 379                         map6 = netlbl_domhsh_addr6_entry(iter6);
 380                         ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
 381                                               map6->def.type);
 382                         if (ret_val != 0)
 383                                 return ret_val;
 384
 385                         switch (map6->def.type) {
 386                         case NETLBL_NLTYPE_CALIPSO:
 387                                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CLPDOI,
 388                                                       map6->def.calipso->doi);
 389                                 if (ret_val != 0)
 390                                         return ret_val;
 391                                 break;
 392                         }
 393
 394                         nla_nest_end(skb, nla_b);
 395                 }
 396 #endif /* IPv6 */
 397
 398                 nla_nest_end(skb, nla_a);
 399                 break;
 400         case NETLBL_NLTYPE_UNLABELED:
 401                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
 402                                       entry->def.type);
 403                 break;
 404         case NETLBL_NLTYPE_CIPSOV4:
 405                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
 406                                       entry->def.type);
 407                 if (ret_val != 0)
 408                         return ret_val;
 409                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
 410                                       entry->def.cipso->doi);
 411                 break;
 412         case NETLBL_NLTYPE_CALIPSO:
 413                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
 414                                       entry->def.type);
 415                 if (ret_val != 0)
 416                         return ret_val;
 417                 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CLPDOI,
 418                                       entry->def.calipso->doi);
 419                 break;
 420         }
 421
 422         return ret_val;
 423 }
 424
 425 /*
 426  * NetLabel Command Handlers
 427  */
 428
 429 /**
 430  * netlbl_mgmt_add - Handle an ADD message
 431  * @skb: the NETLINK buffer
 432  * @info: the Generic NETLINK info block
 433  *
 434  * Description:
 435  * Process a user generated ADD message and add the domains from the message
 436  * to the hash table.  See netlabel.h for a description of the message format.
 437  * Returns zero on success, negative values on failure.
 438  *
 439  */
 440 static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
 441 {
 442         struct netlbl_audit audit_info;
 443
 444         if ((!info->attrs[NLBL_MGMT_A_DOMAIN]) ||
 445             (!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
 446             (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
 447              info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
 448             (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
 449              info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
 450             ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
 451              (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
 452             ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
 453              (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
 454                 return -EINVAL;
 455
 456         netlbl_netlink_auditinfo(skb, &audit_info);
 457
 458         return netlbl_mgmt_add_common(info, &audit_info);
 459 }
 460
 461 /**
 462  * netlbl_mgmt_remove - Handle a REMOVE message
 463  * @skb: the NETLINK buffer
 464  * @info: the Generic NETLINK info block
 465  *
 466  * Description:
 467  * Process a user generated REMOVE message and remove the specified domain
 468  * mappings.  Returns zero on success, negative values on failure.
 469  *
 470  */
 471 static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
 472 {
 473         char *domain;
 474         struct netlbl_audit audit_info;
 475
 476         if (!info->attrs[NLBL_MGMT_A_DOMAIN])
 477                 return -EINVAL;
 478
 479         netlbl_netlink_auditinfo(skb, &audit_info);
 480
 481         domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
 482         return netlbl_domhsh_remove(domain, AF_UNSPEC, &audit_info);
 483 }
 484
 485 /**
 486  * netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL
 487  * @entry: the domain mapping hash table entry
 488  * @arg: the netlbl_domhsh_walk_arg structure
 489  *
 490  * Description:
 491  * This function is designed to be used as a callback to the
 492  * netlbl_domhsh_walk() function for use in generating a response for a LISTALL
 493  * message.  Returns the size of the message on success, negative values on
 494  * failure.
 495  *
 496  */
 497 static int netlbl_mgmt_listall_cb(struct netlbl_dom_map *entry, void *arg)
 498 {
 499         int ret_val = -ENOMEM;
 500         struct netlbl_domhsh_walk_arg *cb_arg = arg;
 501         void *data;
 502
 503         data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).portid,
 504                            cb_arg->seq, &netlbl_mgmt_gnl_family,
 505                            NLM_F_MULTI, NLBL_MGMT_C_LISTALL);
 506         if (data == NULL)
 507                 goto listall_cb_failure;
 508
 509         ret_val = netlbl_mgmt_listentry(cb_arg->skb, entry);
 510         if (ret_val != 0)
 511                 goto listall_cb_failure;
 512
 513         cb_arg->seq++;
 514         genlmsg_end(cb_arg->skb, data);
 515         return 0;
 516
 517 listall_cb_failure:
 518         genlmsg_cancel(cb_arg->skb, data);
 519         return ret_val;
 520 }
 521
 522 /**
 523  * netlbl_mgmt_listall - Handle a LISTALL message
 524  * @skb: the NETLINK buffer
 525  * @cb: the NETLINK callback
 526  *
 527  * Description:
 528  * Process a user generated LISTALL message and dumps the domain hash table in
 529  * a form suitable for use in a kernel generated LISTALL message.  Returns zero
 530  * on success, negative values on failure.
 531  *
 532  */
 533 static int netlbl_mgmt_listall(struct sk_buff *skb,
 534                                struct netlink_callback *cb)
 535 {
 536         struct netlbl_domhsh_walk_arg cb_arg;
 537         u32 skip_bkt = cb->args[0];
 538         u32 skip_chain = cb->args[1];
 539
 540         cb_arg.nl_cb = cb;
 541         cb_arg.skb = skb;
 542         cb_arg.seq = cb->nlh->nlmsg_seq;
 543
 544         netlbl_domhsh_walk(&skip_bkt,
 545                            &skip_chain,
 546                            netlbl_mgmt_listall_cb,
 547                            &cb_arg);
 548
 549         cb->args[0] = skip_bkt;
 550         cb->args[1] = skip_chain;
 551         return skb->len;
 552 }
 553
 554 /**
 555  * netlbl_mgmt_adddef - Handle an ADDDEF message
 556  * @skb: the NETLINK buffer
 557  * @info: the Generic NETLINK info block
 558  *
 559  * Description:
 560  * Process a user generated ADDDEF message and respond accordingly.  Returns
 561  * zero on success, negative values on failure.
 562  *
 563  */
 564 static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
 565 {
 566         struct netlbl_audit audit_info;
 567
 568         if ((!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
 569             (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
 570              info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
 571             (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
 572              info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
 573             ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
 574              (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
 575             ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
 576              (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
 577                 return -EINVAL;
 578
 579         netlbl_netlink_auditinfo(skb, &audit_info);
 580
 581         return netlbl_mgmt_add_common(info, &audit_info);
 582 }
 583
 584 /**
 585  * netlbl_mgmt_removedef - Handle a REMOVEDEF message
 586  * @skb: the NETLINK buffer
 587  * @info: the Generic NETLINK info block
 588  *
 589  * Description:
 590  * Process a user generated REMOVEDEF message and remove the default domain
 591  * mapping.  Returns zero on success, negative values on failure.
 592  *
 593  */
 594 static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
 595 {
 596         struct netlbl_audit audit_info;
 597
 598         netlbl_netlink_auditinfo(skb, &audit_info);
 599
 600         return netlbl_domhsh_remove_default(AF_UNSPEC, &audit_info);
 601 }
 602
 603 /**
 604  * netlbl_mgmt_listdef - Handle a LISTDEF message
 605  * @skb: the NETLINK buffer
 606  * @info: the Generic NETLINK info block
 607  *
 608  * Description:
 609  * Process a user generated LISTDEF message and dumps the default domain
 610  * mapping in a form suitable for use in a kernel generated LISTDEF message.
 611  * Returns zero on success, negative values on failure.
 612  *
 613  */
 614 static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info)
 615 {
 616         int ret_val = -ENOMEM;
 617         struct sk_buff *ans_skb = NULL;
 618         void *data;
 619         struct netlbl_dom_map *entry;
 620         u16 family;
 621
 622         if (info->attrs[NLBL_MGMT_A_FAMILY])
 623                 family = nla_get_u16(info->attrs[NLBL_MGMT_A_FAMILY]);
 624         else
 625                 family = AF_INET;
 626
 627         ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 628         if (ans_skb == NULL)
 629                 return -ENOMEM;
 630         data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
 631                                  0, NLBL_MGMT_C_LISTDEF);
 632         if (data == NULL)
 633                 goto listdef_failure;
 634
 635         rcu_read_lock();
 636         entry = netlbl_domhsh_getentry(NULL, family);
 637         if (entry == NULL) {
 638                 ret_val = -ENOENT;
 639                 goto listdef_failure_lock;
 640         }
 641         ret_val = netlbl_mgmt_listentry(ans_skb, entry);
 642         rcu_read_unlock();
 643         if (ret_val != 0)
 644                 goto listdef_failure;
 645
 646         genlmsg_end(ans_skb, data);
 647         return genlmsg_reply(ans_skb, info);
 648
 649 listdef_failure_lock:
 650         rcu_read_unlock();
 651 listdef_failure:
 652         kfree_skb(ans_skb);
 653         return ret_val;
 654 }
 655
 656 /**
 657  * netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response
 658  * @skb: the skb to write to
 659  * @cb: the NETLINK callback
 660  * @protocol: the NetLabel protocol to use in the message
 661  *
 662  * Description:
 663  * This function is to be used in conjunction with netlbl_mgmt_protocols() to
 664  * answer a application's PROTOCOLS message.  Returns the size of the message
 665  * on success, negative values on failure.
 666  *
 667  */
 668 static int netlbl_mgmt_protocols_cb(struct sk_buff *skb,
 669                                     struct netlink_callback *cb,
 670                                     u32 protocol)
 671 {
 672         int ret_val = -ENOMEM;
 673         void *data;
 674
 675         data = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
 676                            &netlbl_mgmt_gnl_family, NLM_F_MULTI,
 677                            NLBL_MGMT_C_PROTOCOLS);
 678         if (data == NULL)
 679                 goto protocols_cb_failure;
 680
 681         ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol);
 682         if (ret_val != 0)
 683                 goto protocols_cb_failure;
 684
 685         genlmsg_end(skb, data);
 686         return 0;
 687
 688 protocols_cb_failure:
 689         genlmsg_cancel(skb, data);
 690         return ret_val;
 691 }
 692
 693 /**
 694  * netlbl_mgmt_protocols - Handle a PROTOCOLS message
 695  * @skb: the NETLINK buffer
 696  * @cb: the NETLINK callback
 697  *
 698  * Description:
 699  * Process a user generated PROTOCOLS message and respond accordingly.
 700  *
 701  */
 702 static int netlbl_mgmt_protocols(struct sk_buff *skb,
 703                                  struct netlink_callback *cb)
 704 {
 705         u32 protos_sent = cb->args[0];
 706
 707         if (protos_sent == 0) {
 708                 if (netlbl_mgmt_protocols_cb(skb,
 709                                              cb,
 710                                              NETLBL_NLTYPE_UNLABELED) < 0)
 711                         goto protocols_return;
 712                 protos_sent++;
 713         }
 714         if (protos_sent == 1) {
 715                 if (netlbl_mgmt_protocols_cb(skb,
 716                                              cb,
 717                                              NETLBL_NLTYPE_CIPSOV4) < 0)
 718                         goto protocols_return;
 719                 protos_sent++;
 720         }
 721 #if IS_ENABLED(CONFIG_IPV6)
 722         if (protos_sent == 2) {
 723                 if (netlbl_mgmt_protocols_cb(skb,
 724                                              cb,
 725                                              NETLBL_NLTYPE_CALIPSO) < 0)
 726                         goto protocols_return;
 727                 protos_sent++;
 728         }
 729 #endif
 730
 731 protocols_return:
 732         cb->args[0] = protos_sent;
 733         return skb->len;
 734 }
 735
 736 /**
 737  * netlbl_mgmt_version - Handle a VERSION message
 738  * @skb: the NETLINK buffer
 739  * @info: the Generic NETLINK info block
 740  *
 741  * Description:
 742  * Process a user generated VERSION message and respond accordingly.  Returns
 743  * zero on success, negative values on failure.
 744  *
 745  */
 746 static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info)
 747 {
 748         int ret_val = -ENOMEM;
 749         struct sk_buff *ans_skb = NULL;
 750         void *data;
 751
 752         ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 753         if (ans_skb == NULL)
 754                 return -ENOMEM;
 755         data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
 756                                  0, NLBL_MGMT_C_VERSION);
 757         if (data == NULL)
 758                 goto version_failure;
 759
 760         ret_val = nla_put_u32(ans_skb,
 761                               NLBL_MGMT_A_VERSION,
 762                               NETLBL_PROTO_VERSION);
 763         if (ret_val != 0)
 764                 goto version_failure;
 765
 766         genlmsg_end(ans_skb, data);
 767         return genlmsg_reply(ans_skb, info);
 768
 769 version_failure:
 770         kfree_skb(ans_skb);
 771         return ret_val;
 772 }
 773
 774
 775 /*
 776  * NetLabel Generic NETLINK Command Definitions
 777  */
 778
 779 static const struct genl_ops netlbl_mgmt_genl_ops[] = {
 780         {
 781         .cmd = NLBL_MGMT_C_ADD,
 782         .flags = GENL_ADMIN_PERM,
 783         .policy = netlbl_mgmt_genl_policy,
 784         .doit = netlbl_mgmt_add,
 785         .dumpit = NULL,
 786         },
 787         {
 788         .cmd = NLBL_MGMT_C_REMOVE,
 789         .flags = GENL_ADMIN_PERM,
 790         .policy = netlbl_mgmt_genl_policy,
 791         .doit = netlbl_mgmt_remove,
 792         .dumpit = NULL,
 793         },
 794         {
 795         .cmd = NLBL_MGMT_C_LISTALL,
 796         .flags = 0,
 797         .policy = netlbl_mgmt_genl_policy,
 798         .doit = NULL,
 799         .dumpit = netlbl_mgmt_listall,
 800         },
 801         {
 802         .cmd = NLBL_MGMT_C_ADDDEF,
 803         .flags = GENL_ADMIN_PERM,
 804         .policy = netlbl_mgmt_genl_policy,
 805         .doit = netlbl_mgmt_adddef,
 806         .dumpit = NULL,
 807         },
 808         {
 809         .cmd = NLBL_MGMT_C_REMOVEDEF,
 810         .flags = GENL_ADMIN_PERM,
 811         .policy = netlbl_mgmt_genl_policy,
 812         .doit = netlbl_mgmt_removedef,
 813         .dumpit = NULL,
 814         },
 815         {
 816         .cmd = NLBL_MGMT_C_LISTDEF,
 817         .flags = 0,
 818         .policy = netlbl_mgmt_genl_policy,
 819         .doit = netlbl_mgmt_listdef,
 820         .dumpit = NULL,
 821         },
 822         {
 823         .cmd = NLBL_MGMT_C_PROTOCOLS,
 824         .flags = 0,
 825         .policy = netlbl_mgmt_genl_policy,
 826         .doit = NULL,
 827         .dumpit = netlbl_mgmt_protocols,
 828         },
 829         {
 830         .cmd = NLBL_MGMT_C_VERSION,
 831         .flags = 0,
 832         .policy = netlbl_mgmt_genl_policy,
 833         .doit = netlbl_mgmt_version,
 834         .dumpit = NULL,
 835         },
 836 };
 837
 838 /*
 839  * NetLabel Generic NETLINK Protocol Functions
 840  */
 841
 842 /**
 843  * netlbl_mgmt_genl_init - Register the NetLabel management component
 844  *
 845  * Description:
 846  * Register the NetLabel management component with the Generic NETLINK
 847  * mechanism.  Returns zero on success, negative values on failure.
 848  *
 849  */
 850 int __init netlbl_mgmt_genl_init(void)
 851 {
 852         return genl_register_family_with_ops(&netlbl_mgmt_gnl_family,
 853                                              netlbl_mgmt_genl_ops);
 854 }