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.moore@hp.com>
   9  *
  10  */
  11
  12 /*
  13  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
  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, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  28  *
  29  */
  30
  31 #include <linux/types.h>
  32 #include <linux/socket.h>
  33 #include <linux/string.h>
  34 #include <linux/skbuff.h>
  35 #include <net/sock.h>
  36 #include <net/netlink.h>
  37 #include <net/genetlink.h>
  38 #include <net/netlabel.h>
  39 #include <net/cipso_ipv4.h>
  40
  41 #include "netlabel_domainhash.h"
  42 #include "netlabel_user.h"
  43 #include "netlabel_mgmt.h"
  44
  45 /* NetLabel Generic NETLINK CIPSOv4 family */
  46 static struct genl_family netlbl_mgmt_gnl_family = {
  47         .id = GENL_ID_GENERATE,
  48         .hdrsize = 0,
  49         .name = NETLBL_NLTYPE_MGMT_NAME,
  50         .version = NETLBL_PROTO_VERSION,
  51         .maxattr = 0,
  52 };
  53
  54
  55 /*
  56  * NetLabel Command Handlers
  57  */
  58
  59 /**
  60  * netlbl_mgmt_add - Handle an ADD message
  61  * @skb: the NETLINK buffer
  62  * @info: the Generic NETLINK info block
  63  *
  64  * Description:
  65  * Process a user generated ADD message and add the domains from the message
  66  * to the hash table.  See netlabel.h for a description of the message format.
  67  * Returns zero on success, negative values on failure.
  68  *
  69  */
  70 static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
  71 {
  72         int ret_val = -EINVAL;
  73         struct nlattr *msg_ptr = netlbl_netlink_payload_data(skb);
  74         int msg_len = netlbl_netlink_payload_len(skb);
  75         u32 count;
  76         struct netlbl_dom_map *entry = NULL;
  77         u32 iter;
  78         u32 tmp_val;
  79         int tmp_size;
  80
  81         ret_val = netlbl_netlink_cap_check(skb, CAP_NET_ADMIN);
  82         if (ret_val != 0)
  83                 goto add_failure;
  84
  85         if (msg_len < NETLBL_LEN_U32)
  86                 goto add_failure;
  87         count = netlbl_getinc_u32(&msg_ptr, &msg_len);
  88
  89         for (iter = 0; iter < count && msg_len > 0; iter++, entry = NULL) {
  90                 if (msg_len <= 0) {
  91                         ret_val = -EINVAL;
  92                         goto add_failure;
  93                 }
  94                 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
  95                 if (entry == NULL) {
  96                         ret_val = -ENOMEM;
  97                         goto add_failure;
  98                 }
  99                 tmp_size = nla_len(msg_ptr);
 100                 if (tmp_size <= 0 || tmp_size > msg_len) {
 101                         ret_val = -EINVAL;
 102                         goto add_failure;
 103                 }
 104                 entry->domain = kmalloc(tmp_size, GFP_KERNEL);
 105                 if (entry->domain == NULL) {
 106                         ret_val = -ENOMEM;
 107                         goto add_failure;
 108                 }
 109                 nla_strlcpy(entry->domain, msg_ptr, tmp_size);
 110                 entry->domain[tmp_size - 1] = '\0';
 111                 msg_ptr = nla_next(msg_ptr, &msg_len);
 112
 113                 if (msg_len < NETLBL_LEN_U32) {
 114                         ret_val = -EINVAL;
 115                         goto add_failure;
 116                 }
 117                 tmp_val = netlbl_getinc_u32(&msg_ptr, &msg_len);
 118                 entry->type = tmp_val;
 119                 switch (tmp_val) {
 120                 case NETLBL_NLTYPE_UNLABELED:
 121                         ret_val = netlbl_domhsh_add(entry);
 122                         break;
 123                 case NETLBL_NLTYPE_CIPSOV4:
 124                         if (msg_len < NETLBL_LEN_U32) {
 125                                 ret_val = -EINVAL;
 126                                 goto add_failure;
 127                         }
 128                         tmp_val = netlbl_getinc_u32(&msg_ptr, &msg_len);
 129                         /* We should be holding a rcu_read_lock() here
 130                          * while we hold the result but since the entry
 131                          * will always be deleted when the CIPSO DOI
 132                          * is deleted we aren't going to keep the lock. */
 133                         rcu_read_lock();
 134                         entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
 135                         if (entry->type_def.cipsov4 == NULL) {
 136                                 rcu_read_unlock();
 137                                 ret_val = -EINVAL;
 138                                 goto add_failure;
 139                         }
 140                         ret_val = netlbl_domhsh_add(entry);
 141                         rcu_read_unlock();
 142                         break;
 143                 default:
 144                         ret_val = -EINVAL;
 145                 }
 146                 if (ret_val != 0)
 147                         goto add_failure;
 148         }
 149
 150         netlbl_netlink_send_ack(info,
 151                                 netlbl_mgmt_gnl_family.id,
 152                                 NLBL_MGMT_C_ACK,
 153                                 NETLBL_E_OK);
 154         return 0;
 155
 156 add_failure:
 157         if (entry)
 158                 kfree(entry->domain);
 159         kfree(entry);
 160         netlbl_netlink_send_ack(info,
 161                                 netlbl_mgmt_gnl_family.id,
 162                                 NLBL_MGMT_C_ACK,
 163                                 -ret_val);
 164         return ret_val;
 165 }
 166
 167 /**
 168  * netlbl_mgmt_remove - Handle a REMOVE message
 169  * @skb: the NETLINK buffer
 170  * @info: the Generic NETLINK info block
 171  *
 172  * Description:
 173  * Process a user generated REMOVE message and remove the specified domain
 174  * mappings.  Returns zero on success, negative values on failure.
 175  *
 176  */
 177 static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
 178 {
 179         int ret_val = -EINVAL;
 180         struct nlattr *msg_ptr = netlbl_netlink_payload_data(skb);
 181         int msg_len = netlbl_netlink_payload_len(skb);
 182         u32 count;
 183         u32 iter;
 184         int tmp_size;
 185         unsigned char *domain;
 186
 187         ret_val = netlbl_netlink_cap_check(skb, CAP_NET_ADMIN);
 188         if (ret_val != 0)
 189                 goto remove_return;
 190
 191         if (msg_len < NETLBL_LEN_U32)
 192                 goto remove_return;
 193         count = netlbl_getinc_u32(&msg_ptr, &msg_len);
 194
 195         for (iter = 0; iter < count && msg_len > 0; iter++) {
 196                 if (msg_len <= 0) {
 197                         ret_val = -EINVAL;
 198                         goto remove_return;
 199                 }
 200                 tmp_size = nla_len(msg_ptr);
 201                 domain = nla_data(msg_ptr);
 202                 if (tmp_size <= 0 || tmp_size > msg_len ||
 203                     domain[tmp_size - 1] != '\0') {
 204                         ret_val = -EINVAL;
 205                         goto remove_return;
 206                 }
 207                 ret_val = netlbl_domhsh_remove(domain);
 208                 if (ret_val != 0)
 209                         goto remove_return;
 210                 msg_ptr = nla_next(msg_ptr, &msg_len);
 211         }
 212
 213         ret_val = 0;
 214
 215 remove_return:
 216         netlbl_netlink_send_ack(info,
 217                                 netlbl_mgmt_gnl_family.id,
 218                                 NLBL_MGMT_C_ACK,
 219                                 -ret_val);
 220         return ret_val;
 221 }
 222
 223 /**
 224  * netlbl_mgmt_list - Handle a LIST message
 225  * @skb: the NETLINK buffer
 226  * @info: the Generic NETLINK info block
 227  *
 228  * Description:
 229  * Process a user generated LIST message and dumps the domain hash table in a
 230  * form suitable for use in a kernel generated LIST message.  Returns zero on
 231  * success, negative values on failure.
 232  *
 233  */
 234 static int netlbl_mgmt_list(struct sk_buff *skb, struct genl_info *info)
 235 {
 236         int ret_val = -ENOMEM;
 237         struct sk_buff *ans_skb;
 238
 239         ans_skb = netlbl_domhsh_dump(NLMSG_SPACE(GENL_HDRLEN));
 240         if (ans_skb == NULL)
 241                 goto list_failure;
 242         netlbl_netlink_hdr_push(ans_skb,
 243                                 info->snd_pid,
 244                                 0,
 245                                 netlbl_mgmt_gnl_family.id,
 246                                 NLBL_MGMT_C_LIST);
 247
 248         ret_val = netlbl_netlink_snd(ans_skb, info->snd_pid);
 249         if (ret_val != 0)
 250                 goto list_failure;
 251
 252         return 0;
 253
 254 list_failure:
 255         netlbl_netlink_send_ack(info,
 256                                 netlbl_mgmt_gnl_family.id,
 257                                 NLBL_MGMT_C_ACK,
 258                                 -ret_val);
 259         return ret_val;
 260 }
 261
 262 /**
 263  * netlbl_mgmt_adddef - Handle an ADDDEF message
 264  * @skb: the NETLINK buffer
 265  * @info: the Generic NETLINK info block
 266  *
 267  * Description:
 268  * Process a user generated ADDDEF message and respond accordingly.  Returns
 269  * zero on success, negative values on failure.
 270  *
 271  */
 272 static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
 273 {
 274         int ret_val = -EINVAL;
 275         struct nlattr *msg_ptr = netlbl_netlink_payload_data(skb);
 276         int msg_len = netlbl_netlink_payload_len(skb);
 277         struct netlbl_dom_map *entry = NULL;
 278         u32 tmp_val;
 279
 280         ret_val = netlbl_netlink_cap_check(skb, CAP_NET_ADMIN);
 281         if (ret_val != 0)
 282                 goto adddef_failure;
 283
 284         if (msg_len < NETLBL_LEN_U32)
 285                 goto adddef_failure;
 286         tmp_val = netlbl_getinc_u32(&msg_ptr, &msg_len);
 287
 288         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 289         if (entry == NULL) {
 290                 ret_val = -ENOMEM;
 291                 goto adddef_failure;
 292         }
 293
 294         entry->type = tmp_val;
 295         switch (entry->type) {
 296         case NETLBL_NLTYPE_UNLABELED:
 297                 ret_val = netlbl_domhsh_add_default(entry);
 298                 break;
 299         case NETLBL_NLTYPE_CIPSOV4:
 300                 if (msg_len < NETLBL_LEN_U32) {
 301                         ret_val = -EINVAL;
 302                         goto adddef_failure;
 303                 }
 304                 tmp_val = netlbl_getinc_u32(&msg_ptr, &msg_len);
 305                 /* We should be holding a rcu_read_lock here while we
 306                  * hold the result but since the entry will always be
 307                  * deleted when the CIPSO DOI is deleted we are going
 308                  * to skip the lock. */
 309                 rcu_read_lock();
 310                 entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
 311                 if (entry->type_def.cipsov4 == NULL) {
 312                         rcu_read_unlock();
 313                         ret_val = -EINVAL;
 314                         goto adddef_failure;
 315                 }
 316                 ret_val = netlbl_domhsh_add_default(entry);
 317                 rcu_read_unlock();
 318                 break;
 319         default:
 320                 ret_val = -EINVAL;
 321         }
 322         if (ret_val != 0)
 323                 goto adddef_failure;
 324
 325         netlbl_netlink_send_ack(info,
 326                                 netlbl_mgmt_gnl_family.id,
 327                                 NLBL_MGMT_C_ACK,
 328                                 NETLBL_E_OK);
 329         return 0;
 330
 331 adddef_failure:
 332         kfree(entry);
 333         netlbl_netlink_send_ack(info,
 334                                 netlbl_mgmt_gnl_family.id,
 335                                 NLBL_MGMT_C_ACK,
 336                                 -ret_val);
 337         return ret_val;
 338 }
 339
 340 /**
 341  * netlbl_mgmt_removedef - Handle a REMOVEDEF message
 342  * @skb: the NETLINK buffer
 343  * @info: the Generic NETLINK info block
 344  *
 345  * Description:
 346  * Process a user generated REMOVEDEF message and remove the default domain
 347  * mapping.  Returns zero on success, negative values on failure.
 348  *
 349  */
 350 static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
 351 {
 352         int ret_val;
 353
 354         ret_val = netlbl_netlink_cap_check(skb, CAP_NET_ADMIN);
 355         if (ret_val != 0)
 356                 goto removedef_return;
 357
 358         ret_val = netlbl_domhsh_remove_default();
 359
 360 removedef_return:
 361         netlbl_netlink_send_ack(info,
 362                                 netlbl_mgmt_gnl_family.id,
 363                                 NLBL_MGMT_C_ACK,
 364                                 -ret_val);
 365         return ret_val;
 366 }
 367
 368 /**
 369  * netlbl_mgmt_listdef - Handle a LISTDEF message
 370  * @skb: the NETLINK buffer
 371  * @info: the Generic NETLINK info block
 372  *
 373  * Description:
 374  * Process a user generated LISTDEF message and dumps the default domain
 375  * mapping in a form suitable for use in a kernel generated LISTDEF message.
 376  * Returns zero on success, negative values on failure.
 377  *
 378  */
 379 static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info)
 380 {
 381         int ret_val = -ENOMEM;
 382         struct sk_buff *ans_skb;
 383
 384         ans_skb = netlbl_domhsh_dump_default(NLMSG_SPACE(GENL_HDRLEN));
 385         if (ans_skb == NULL)
 386                 goto listdef_failure;
 387         netlbl_netlink_hdr_push(ans_skb,
 388                                 info->snd_pid,
 389                                 0,
 390                                 netlbl_mgmt_gnl_family.id,
 391                                 NLBL_MGMT_C_LISTDEF);
 392
 393         ret_val = netlbl_netlink_snd(ans_skb, info->snd_pid);
 394         if (ret_val != 0)
 395                 goto listdef_failure;
 396
 397         return 0;
 398
 399 listdef_failure:
 400         netlbl_netlink_send_ack(info,
 401                                 netlbl_mgmt_gnl_family.id,
 402                                 NLBL_MGMT_C_ACK,
 403                                 -ret_val);
 404         return ret_val;
 405 }
 406
 407 /**
 408  * netlbl_mgmt_modules - Handle a MODULES message
 409  * @skb: the NETLINK buffer
 410  * @info: the Generic NETLINK info block
 411  *
 412  * Description:
 413  * Process a user generated MODULES message and respond accordingly.
 414  *
 415  */
 416 static int netlbl_mgmt_modules(struct sk_buff *skb, struct genl_info *info)
 417 {
 418         int ret_val = -ENOMEM;
 419         size_t data_size;
 420         u32 mod_count;
 421         struct sk_buff *ans_skb = NULL;
 422
 423         /* unlabeled + cipsov4 */
 424         mod_count = 2;
 425
 426         data_size = GENL_HDRLEN + NETLBL_LEN_U32 + mod_count * NETLBL_LEN_U32;
 427         ans_skb = netlbl_netlink_alloc_skb(0, data_size, GFP_KERNEL);
 428         if (ans_skb == NULL)
 429                 goto modules_failure;
 430
 431         if (netlbl_netlink_hdr_put(ans_skb,
 432                                    info->snd_pid,
 433                                    0,
 434                                    netlbl_mgmt_gnl_family.id,
 435                                    NLBL_MGMT_C_MODULES) == NULL)
 436                 goto modules_failure;
 437
 438         ret_val = nla_put_u32(ans_skb, NLA_U32, mod_count);
 439         if (ret_val != 0)
 440                 goto modules_failure;
 441         ret_val = nla_put_u32(ans_skb, NLA_U32, NETLBL_NLTYPE_UNLABELED);
 442         if (ret_val != 0)
 443                 goto modules_failure;
 444         ret_val = nla_put_u32(ans_skb, NLA_U32, NETLBL_NLTYPE_CIPSOV4);
 445         if (ret_val != 0)
 446                 goto modules_failure;
 447
 448         ret_val = netlbl_netlink_snd(ans_skb, info->snd_pid);
 449         if (ret_val != 0)
 450                 goto modules_failure;
 451
 452         return 0;
 453
 454 modules_failure:
 455         kfree_skb(ans_skb);
 456         netlbl_netlink_send_ack(info,
 457                                 netlbl_mgmt_gnl_family.id,
 458                                 NLBL_MGMT_C_ACK,
 459                                 -ret_val);
 460         return ret_val;
 461 }
 462
 463 /**
 464  * netlbl_mgmt_version - Handle a VERSION message
 465  * @skb: the NETLINK buffer
 466  * @info: the Generic NETLINK info block
 467  *
 468  * Description:
 469  * Process a user generated VERSION message and respond accordingly.  Returns
 470  * zero on success, negative values on failure.
 471  *
 472  */
 473 static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info)
 474 {
 475         int ret_val = -ENOMEM;
 476         struct sk_buff *ans_skb = NULL;
 477
 478         ans_skb = netlbl_netlink_alloc_skb(0,
 479                                            GENL_HDRLEN + NETLBL_LEN_U32,
 480                                            GFP_KERNEL);
 481         if (ans_skb == NULL)
 482                 goto version_failure;
 483         if (netlbl_netlink_hdr_put(ans_skb,
 484                                    info->snd_pid,
 485                                    0,
 486                                    netlbl_mgmt_gnl_family.id,
 487                                    NLBL_MGMT_C_VERSION) == NULL)
 488                 goto version_failure;
 489
 490         ret_val = nla_put_u32(ans_skb, NLA_U32, NETLBL_PROTO_VERSION);
 491         if (ret_val != 0)
 492                 goto version_failure;
 493
 494         ret_val = netlbl_netlink_snd(ans_skb, info->snd_pid);
 495         if (ret_val != 0)
 496                 goto version_failure;
 497
 498         return 0;
 499
 500 version_failure:
 501         kfree_skb(ans_skb);
 502         netlbl_netlink_send_ack(info,
 503                                 netlbl_mgmt_gnl_family.id,
 504                                 NLBL_MGMT_C_ACK,
 505                                 -ret_val);
 506         return ret_val;
 507 }
 508
 509
 510 /*
 511  * NetLabel Generic NETLINK Command Definitions
 512  */
 513
 514 static struct genl_ops netlbl_mgmt_genl_c_add = {
 515         .cmd = NLBL_MGMT_C_ADD,
 516         .flags = 0,
 517         .doit = netlbl_mgmt_add,
 518         .dumpit = NULL,
 519 };
 520
 521 static struct genl_ops netlbl_mgmt_genl_c_remove = {
 522         .cmd = NLBL_MGMT_C_REMOVE,
 523         .flags = 0,
 524         .doit = netlbl_mgmt_remove,
 525         .dumpit = NULL,
 526 };
 527
 528 static struct genl_ops netlbl_mgmt_genl_c_list = {
 529         .cmd = NLBL_MGMT_C_LIST,
 530         .flags = 0,
 531         .doit = netlbl_mgmt_list,
 532         .dumpit = NULL,
 533 };
 534
 535 static struct genl_ops netlbl_mgmt_genl_c_adddef = {
 536         .cmd = NLBL_MGMT_C_ADDDEF,
 537         .flags = 0,
 538         .doit = netlbl_mgmt_adddef,
 539         .dumpit = NULL,
 540 };
 541
 542 static struct genl_ops netlbl_mgmt_genl_c_removedef = {
 543         .cmd = NLBL_MGMT_C_REMOVEDEF,
 544         .flags = 0,
 545         .doit = netlbl_mgmt_removedef,
 546         .dumpit = NULL,
 547 };
 548
 549 static struct genl_ops netlbl_mgmt_genl_c_listdef = {
 550         .cmd = NLBL_MGMT_C_LISTDEF,
 551         .flags = 0,
 552         .doit = netlbl_mgmt_listdef,
 553         .dumpit = NULL,
 554 };
 555
 556 static struct genl_ops netlbl_mgmt_genl_c_modules = {
 557         .cmd = NLBL_MGMT_C_MODULES,
 558         .flags = 0,
 559         .doit = netlbl_mgmt_modules,
 560         .dumpit = NULL,
 561 };
 562
 563 static struct genl_ops netlbl_mgmt_genl_c_version = {
 564         .cmd = NLBL_MGMT_C_VERSION,
 565         .flags = 0,
 566         .doit = netlbl_mgmt_version,
 567         .dumpit = NULL,
 568 };
 569
 570 /*
 571  * NetLabel Generic NETLINK Protocol Functions
 572  */
 573
 574 /**
 575  * netlbl_mgmt_genl_init - Register the NetLabel management component
 576  *
 577  * Description:
 578  * Register the NetLabel management component with the Generic NETLINK
 579  * mechanism.  Returns zero on success, negative values on failure.
 580  *
 581  */
 582 int netlbl_mgmt_genl_init(void)
 583 {
 584         int ret_val;
 585
 586         ret_val = genl_register_family(&netlbl_mgmt_gnl_family);
 587         if (ret_val != 0)
 588                 return ret_val;
 589
 590         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 591                                     &netlbl_mgmt_genl_c_add);
 592         if (ret_val != 0)
 593                 return ret_val;
 594         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 595                                     &netlbl_mgmt_genl_c_remove);
 596         if (ret_val != 0)
 597                 return ret_val;
 598         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 599                                     &netlbl_mgmt_genl_c_list);
 600         if (ret_val != 0)
 601                 return ret_val;
 602         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 603                                     &netlbl_mgmt_genl_c_adddef);
 604         if (ret_val != 0)
 605                 return ret_val;
 606         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 607                                     &netlbl_mgmt_genl_c_removedef);
 608         if (ret_val != 0)
 609                 return ret_val;
 610         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 611                                     &netlbl_mgmt_genl_c_listdef);
 612         if (ret_val != 0)
 613                 return ret_val;
 614         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 615                                     &netlbl_mgmt_genl_c_modules);
 616         if (ret_val != 0)
 617                 return ret_val;
 618         ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
 619                                     &netlbl_mgmt_genl_c_version);
 620         if (ret_val != 0)
 621                 return ret_val;
 622
 623         return 0;
 624 }