LCOV - code coverage report
Current view: top level - net/netlabel - netlabel_calipso.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 4 194 2.1 %
Date: 2022-03-28 16:04:14 Functions: 2 25 8.0 %
Branches: 0 126 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * NetLabel CALIPSO/IPv6 Support
       4                 :            :  *
       5                 :            :  * This file defines the CALIPSO/IPv6 functions for the NetLabel system.  The
       6                 :            :  * NetLabel system manages static and dynamic label mappings for network
       7                 :            :  * protocols such as CIPSO and CALIPSO.
       8                 :            :  *
       9                 :            :  * Authors: Paul Moore <paul@paul-moore.com>
      10                 :            :  *          Huw Davies <huw@codeweavers.com>
      11                 :            :  */
      12                 :            : 
      13                 :            : /* (c) Copyright Hewlett-Packard Development Company, L.P., 2006
      14                 :            :  * (c) Copyright Huw Davies <huw@codeweavers.com>, 2015
      15                 :            :  */
      16                 :            : 
      17                 :            : #include <linux/types.h>
      18                 :            : #include <linux/socket.h>
      19                 :            : #include <linux/string.h>
      20                 :            : #include <linux/skbuff.h>
      21                 :            : #include <linux/audit.h>
      22                 :            : #include <linux/slab.h>
      23                 :            : #include <net/sock.h>
      24                 :            : #include <net/netlink.h>
      25                 :            : #include <net/genetlink.h>
      26                 :            : #include <net/netlabel.h>
      27                 :            : #include <net/calipso.h>
      28                 :            : #include <linux/atomic.h>
      29                 :            : 
      30                 :            : #include "netlabel_user.h"
      31                 :            : #include "netlabel_calipso.h"
      32                 :            : #include "netlabel_mgmt.h"
      33                 :            : #include "netlabel_domainhash.h"
      34                 :            : 
      35                 :            : /* Argument struct for calipso_doi_walk() */
      36                 :            : struct netlbl_calipso_doiwalk_arg {
      37                 :            :         struct netlink_callback *nl_cb;
      38                 :            :         struct sk_buff *skb;
      39                 :            :         u32 seq;
      40                 :            : };
      41                 :            : 
      42                 :            : /* Argument struct for netlbl_domhsh_walk() */
      43                 :            : struct netlbl_domhsh_walk_arg {
      44                 :            :         struct netlbl_audit *audit_info;
      45                 :            :         u32 doi;
      46                 :            : };
      47                 :            : 
      48                 :            : /* NetLabel Generic NETLINK CALIPSO family */
      49                 :            : static struct genl_family netlbl_calipso_gnl_family;
      50                 :            : 
      51                 :            : /* NetLabel Netlink attribute policy */
      52                 :            : static const struct nla_policy calipso_genl_policy[NLBL_CALIPSO_A_MAX + 1] = {
      53                 :            :         [NLBL_CALIPSO_A_DOI] = { .type = NLA_U32 },
      54                 :            :         [NLBL_CALIPSO_A_MTYPE] = { .type = NLA_U32 },
      55                 :            : };
      56                 :            : 
      57                 :            : /* NetLabel Command Handlers
      58                 :            :  */
      59                 :            : /**
      60                 :            :  * netlbl_calipso_add_pass - Adds a CALIPSO pass DOI definition
      61                 :            :  * @info: the Generic NETLINK info block
      62                 :            :  * @audit_info: NetLabel audit information
      63                 :            :  *
      64                 :            :  * Description:
      65                 :            :  * Create a new CALIPSO_MAP_PASS DOI definition based on the given ADD message
      66                 :            :  * and add it to the CALIPSO engine.  Return zero on success and non-zero on
      67                 :            :  * error.
      68                 :            :  *
      69                 :            :  */
      70                 :            : static int netlbl_calipso_add_pass(struct genl_info *info,
      71                 :            :                                    struct netlbl_audit *audit_info)
      72                 :            : {
      73                 :            :         int ret_val;
      74                 :            :         struct calipso_doi *doi_def = NULL;
      75                 :            : 
      76                 :            :         doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL);
      77                 :            :         if (!doi_def)
      78                 :            :                 return -ENOMEM;
      79                 :            :         doi_def->type = CALIPSO_MAP_PASS;
      80                 :            :         doi_def->doi = nla_get_u32(info->attrs[NLBL_CALIPSO_A_DOI]);
      81                 :            :         ret_val = calipso_doi_add(doi_def, audit_info);
      82                 :            :         if (ret_val != 0)
      83                 :            :                 calipso_doi_free(doi_def);
      84                 :            : 
      85                 :            :         return ret_val;
      86                 :            : }
      87                 :            : 
      88                 :            : /**
      89                 :            :  * netlbl_calipso_add - Handle an ADD message
      90                 :            :  * @skb: the NETLINK buffer
      91                 :            :  * @info: the Generic NETLINK info block
      92                 :            :  *
      93                 :            :  * Description:
      94                 :            :  * Create a new DOI definition based on the given ADD message and add it to the
      95                 :            :  * CALIPSO engine.  Returns zero on success, negative values on failure.
      96                 :            :  *
      97                 :            :  */
      98                 :          0 : static int netlbl_calipso_add(struct sk_buff *skb, struct genl_info *info)
      99                 :            : 
     100                 :            : {
     101                 :          0 :         int ret_val = -EINVAL;
     102                 :          0 :         struct netlbl_audit audit_info;
     103                 :            : 
     104         [ #  # ]:          0 :         if (!info->attrs[NLBL_CALIPSO_A_DOI] ||
     105         [ #  # ]:          0 :             !info->attrs[NLBL_CALIPSO_A_MTYPE])
     106                 :            :                 return -EINVAL;
     107                 :            : 
     108                 :          0 :         netlbl_netlink_auditinfo(skb, &audit_info);
     109         [ #  # ]:          0 :         switch (nla_get_u32(info->attrs[NLBL_CALIPSO_A_MTYPE])) {
     110                 :          0 :         case CALIPSO_MAP_PASS:
     111                 :          0 :                 ret_val = netlbl_calipso_add_pass(info, &audit_info);
     112                 :          0 :                 break;
     113                 :            :         }
     114         [ #  # ]:          0 :         if (ret_val == 0)
     115                 :          0 :                 atomic_inc(&netlabel_mgmt_protocount);
     116                 :            : 
     117                 :            :         return ret_val;
     118                 :            : }
     119                 :            : 
     120                 :            : /**
     121                 :            :  * netlbl_calipso_list - Handle a LIST message
     122                 :            :  * @skb: the NETLINK buffer
     123                 :            :  * @info: the Generic NETLINK info block
     124                 :            :  *
     125                 :            :  * Description:
     126                 :            :  * Process a user generated LIST message and respond accordingly.
     127                 :            :  * Returns zero on success and negative values on error.
     128                 :            :  *
     129                 :            :  */
     130                 :          0 : static int netlbl_calipso_list(struct sk_buff *skb, struct genl_info *info)
     131                 :            : {
     132                 :          0 :         int ret_val;
     133                 :          0 :         struct sk_buff *ans_skb = NULL;
     134                 :          0 :         void *data;
     135                 :          0 :         u32 doi;
     136                 :          0 :         struct calipso_doi *doi_def;
     137                 :            : 
     138         [ #  # ]:          0 :         if (!info->attrs[NLBL_CALIPSO_A_DOI]) {
     139                 :          0 :                 ret_val = -EINVAL;
     140                 :          0 :                 goto list_failure;
     141                 :            :         }
     142                 :            : 
     143         [ #  # ]:          0 :         doi = nla_get_u32(info->attrs[NLBL_CALIPSO_A_DOI]);
     144                 :            : 
     145                 :          0 :         doi_def = calipso_doi_getdef(doi);
     146                 :          0 :         if (!doi_def) {
     147                 :          0 :                 ret_val = -EINVAL;
     148                 :          0 :                 goto list_failure;
     149                 :            :         }
     150                 :            : 
     151                 :          0 :         ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
     152         [ #  # ]:          0 :         if (!ans_skb) {
     153                 :          0 :                 ret_val = -ENOMEM;
     154                 :          0 :                 goto list_failure_put;
     155                 :            :         }
     156                 :          0 :         data = genlmsg_put_reply(ans_skb, info, &netlbl_calipso_gnl_family,
     157                 :            :                                  0, NLBL_CALIPSO_C_LIST);
     158         [ #  # ]:          0 :         if (!data) {
     159                 :          0 :                 ret_val = -ENOMEM;
     160                 :          0 :                 goto list_failure_put;
     161                 :            :         }
     162                 :            : 
     163                 :          0 :         ret_val = nla_put_u32(ans_skb, NLBL_CALIPSO_A_MTYPE, doi_def->type);
     164         [ #  # ]:          0 :         if (ret_val != 0)
     165                 :          0 :                 goto list_failure_put;
     166                 :            : 
     167                 :          0 :         calipso_doi_putdef(doi_def);
     168                 :            : 
     169                 :          0 :         genlmsg_end(ans_skb, data);
     170                 :          0 :         return genlmsg_reply(ans_skb, info);
     171                 :            : 
     172                 :          0 : list_failure_put:
     173                 :          0 :         calipso_doi_putdef(doi_def);
     174                 :          0 : list_failure:
     175                 :          0 :         kfree_skb(ans_skb);
     176                 :          0 :         return ret_val;
     177                 :            : }
     178                 :            : 
     179                 :            : /**
     180                 :            :  * netlbl_calipso_listall_cb - calipso_doi_walk() callback for LISTALL
     181                 :            :  * @doi_def: the CALIPSO DOI definition
     182                 :            :  * @arg: the netlbl_calipso_doiwalk_arg structure
     183                 :            :  *
     184                 :            :  * Description:
     185                 :            :  * This function is designed to be used as a callback to the
     186                 :            :  * calipso_doi_walk() function for use in generating a response for a LISTALL
     187                 :            :  * message.  Returns the size of the message on success, negative values on
     188                 :            :  * failure.
     189                 :            :  *
     190                 :            :  */
     191                 :          0 : static int netlbl_calipso_listall_cb(struct calipso_doi *doi_def, void *arg)
     192                 :            : {
     193                 :          0 :         int ret_val = -ENOMEM;
     194                 :          0 :         struct netlbl_calipso_doiwalk_arg *cb_arg = arg;
     195                 :          0 :         void *data;
     196                 :            : 
     197                 :          0 :         data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).portid,
     198                 :            :                            cb_arg->seq, &netlbl_calipso_gnl_family,
     199                 :            :                            NLM_F_MULTI, NLBL_CALIPSO_C_LISTALL);
     200         [ #  # ]:          0 :         if (!data)
     201                 :          0 :                 goto listall_cb_failure;
     202                 :            : 
     203                 :          0 :         ret_val = nla_put_u32(cb_arg->skb, NLBL_CALIPSO_A_DOI, doi_def->doi);
     204         [ #  # ]:          0 :         if (ret_val != 0)
     205                 :          0 :                 goto listall_cb_failure;
     206                 :          0 :         ret_val = nla_put_u32(cb_arg->skb,
     207                 :            :                               NLBL_CALIPSO_A_MTYPE,
     208                 :            :                               doi_def->type);
     209         [ #  # ]:          0 :         if (ret_val != 0)
     210                 :          0 :                 goto listall_cb_failure;
     211                 :            : 
     212                 :          0 :         genlmsg_end(cb_arg->skb, data);
     213                 :          0 :         return 0;
     214                 :            : 
     215                 :          0 : listall_cb_failure:
     216         [ #  # ]:          0 :         genlmsg_cancel(cb_arg->skb, data);
     217                 :            :         return ret_val;
     218                 :            : }
     219                 :            : 
     220                 :            : /**
     221                 :            :  * netlbl_calipso_listall - Handle a LISTALL message
     222                 :            :  * @skb: the NETLINK buffer
     223                 :            :  * @cb: the NETLINK callback
     224                 :            :  *
     225                 :            :  * Description:
     226                 :            :  * Process a user generated LISTALL message and respond accordingly.  Returns
     227                 :            :  * zero on success and negative values on error.
     228                 :            :  *
     229                 :            :  */
     230                 :          0 : static int netlbl_calipso_listall(struct sk_buff *skb,
     231                 :            :                                   struct netlink_callback *cb)
     232                 :            : {
     233                 :          0 :         struct netlbl_calipso_doiwalk_arg cb_arg;
     234                 :          0 :         u32 doi_skip = cb->args[0];
     235                 :            : 
     236                 :          0 :         cb_arg.nl_cb = cb;
     237                 :          0 :         cb_arg.skb = skb;
     238                 :          0 :         cb_arg.seq = cb->nlh->nlmsg_seq;
     239                 :            : 
     240                 :          0 :         calipso_doi_walk(&doi_skip, netlbl_calipso_listall_cb, &cb_arg);
     241                 :            : 
     242                 :          0 :         cb->args[0] = doi_skip;
     243                 :          0 :         return skb->len;
     244                 :            : }
     245                 :            : 
     246                 :            : /**
     247                 :            :  * netlbl_calipso_remove_cb - netlbl_calipso_remove() callback for REMOVE
     248                 :            :  * @entry: LSM domain mapping entry
     249                 :            :  * @arg: the netlbl_domhsh_walk_arg structure
     250                 :            :  *
     251                 :            :  * Description:
     252                 :            :  * This function is intended for use by netlbl_calipso_remove() as the callback
     253                 :            :  * for the netlbl_domhsh_walk() function; it removes LSM domain map entries
     254                 :            :  * which are associated with the CALIPSO DOI specified in @arg.  Returns zero on
     255                 :            :  * success, negative values on failure.
     256                 :            :  *
     257                 :            :  */
     258                 :          0 : static int netlbl_calipso_remove_cb(struct netlbl_dom_map *entry, void *arg)
     259                 :            : {
     260                 :          0 :         struct netlbl_domhsh_walk_arg *cb_arg = arg;
     261                 :            : 
     262         [ #  # ]:          0 :         if (entry->def.type == NETLBL_NLTYPE_CALIPSO &&
     263         [ #  # ]:          0 :             entry->def.calipso->doi == cb_arg->doi)
     264                 :          0 :                 return netlbl_domhsh_remove_entry(entry, cb_arg->audit_info);
     265                 :            : 
     266                 :            :         return 0;
     267                 :            : }
     268                 :            : 
     269                 :            : /**
     270                 :            :  * netlbl_calipso_remove - Handle a REMOVE message
     271                 :            :  * @skb: the NETLINK buffer
     272                 :            :  * @info: the Generic NETLINK info block
     273                 :            :  *
     274                 :            :  * Description:
     275                 :            :  * Process a user generated REMOVE message and respond accordingly.  Returns
     276                 :            :  * zero on success, negative values on failure.
     277                 :            :  *
     278                 :            :  */
     279                 :          0 : static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info)
     280                 :            : {
     281                 :          0 :         int ret_val = -EINVAL;
     282                 :          0 :         struct netlbl_domhsh_walk_arg cb_arg;
     283                 :          0 :         struct netlbl_audit audit_info;
     284                 :          0 :         u32 skip_bkt = 0;
     285                 :          0 :         u32 skip_chain = 0;
     286                 :            : 
     287         [ #  # ]:          0 :         if (!info->attrs[NLBL_CALIPSO_A_DOI])
     288                 :            :                 return -EINVAL;
     289                 :            : 
     290                 :          0 :         netlbl_netlink_auditinfo(skb, &audit_info);
     291                 :          0 :         cb_arg.doi = nla_get_u32(info->attrs[NLBL_CALIPSO_A_DOI]);
     292                 :          0 :         cb_arg.audit_info = &audit_info;
     293                 :          0 :         ret_val = netlbl_domhsh_walk(&skip_bkt, &skip_chain,
     294                 :            :                                      netlbl_calipso_remove_cb, &cb_arg);
     295         [ #  # ]:          0 :         if (ret_val == 0 || ret_val == -ENOENT) {
     296                 :          0 :                 ret_val = calipso_doi_remove(cb_arg.doi, &audit_info);
     297                 :          0 :                 if (ret_val == 0)
     298                 :          0 :                         atomic_dec(&netlabel_mgmt_protocount);
     299                 :            :         }
     300                 :            : 
     301                 :            :         return ret_val;
     302                 :            : }
     303                 :            : 
     304                 :            : /* NetLabel Generic NETLINK Command Definitions
     305                 :            :  */
     306                 :            : 
     307                 :            : static const struct genl_ops netlbl_calipso_ops[] = {
     308                 :            :         {
     309                 :            :         .cmd = NLBL_CALIPSO_C_ADD,
     310                 :            :         .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
     311                 :            :         .flags = GENL_ADMIN_PERM,
     312                 :            :         .doit = netlbl_calipso_add,
     313                 :            :         .dumpit = NULL,
     314                 :            :         },
     315                 :            :         {
     316                 :            :         .cmd = NLBL_CALIPSO_C_REMOVE,
     317                 :            :         .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
     318                 :            :         .flags = GENL_ADMIN_PERM,
     319                 :            :         .doit = netlbl_calipso_remove,
     320                 :            :         .dumpit = NULL,
     321                 :            :         },
     322                 :            :         {
     323                 :            :         .cmd = NLBL_CALIPSO_C_LIST,
     324                 :            :         .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
     325                 :            :         .flags = 0,
     326                 :            :         .doit = netlbl_calipso_list,
     327                 :            :         .dumpit = NULL,
     328                 :            :         },
     329                 :            :         {
     330                 :            :         .cmd = NLBL_CALIPSO_C_LISTALL,
     331                 :            :         .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
     332                 :            :         .flags = 0,
     333                 :            :         .doit = NULL,
     334                 :            :         .dumpit = netlbl_calipso_listall,
     335                 :            :         },
     336                 :            : };
     337                 :            : 
     338                 :            : static struct genl_family netlbl_calipso_gnl_family __ro_after_init = {
     339                 :            :         .hdrsize = 0,
     340                 :            :         .name = NETLBL_NLTYPE_CALIPSO_NAME,
     341                 :            :         .version = NETLBL_PROTO_VERSION,
     342                 :            :         .maxattr = NLBL_CALIPSO_A_MAX,
     343                 :            :         .policy = calipso_genl_policy,
     344                 :            :         .module = THIS_MODULE,
     345                 :            :         .ops = netlbl_calipso_ops,
     346                 :            :         .n_ops = ARRAY_SIZE(netlbl_calipso_ops),
     347                 :            : };
     348                 :            : 
     349                 :            : /* NetLabel Generic NETLINK Protocol Functions
     350                 :            :  */
     351                 :            : 
     352                 :            : /**
     353                 :            :  * netlbl_calipso_genl_init - Register the CALIPSO NetLabel component
     354                 :            :  *
     355                 :            :  * Description:
     356                 :            :  * Register the CALIPSO packet NetLabel component with the Generic NETLINK
     357                 :            :  * mechanism.  Returns zero on success, negative values on failure.
     358                 :            :  *
     359                 :            :  */
     360                 :         13 : int __init netlbl_calipso_genl_init(void)
     361                 :            : {
     362                 :         13 :         return genl_register_family(&netlbl_calipso_gnl_family);
     363                 :            : }
     364                 :            : 
     365                 :            : static const struct netlbl_calipso_ops *calipso_ops;
     366                 :            : 
     367                 :            : /**
     368                 :            :  * netlbl_calipso_ops_register - Register the CALIPSO operations
     369                 :            :  *
     370                 :            :  * Description:
     371                 :            :  * Register the CALIPSO packet engine operations.
     372                 :            :  *
     373                 :            :  */
     374                 :            : const struct netlbl_calipso_ops *
     375                 :         13 : netlbl_calipso_ops_register(const struct netlbl_calipso_ops *ops)
     376                 :            : {
     377                 :         13 :         return xchg(&calipso_ops, ops);
     378                 :            : }
     379                 :            : EXPORT_SYMBOL(netlbl_calipso_ops_register);
     380                 :            : 
     381                 :          0 : static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void)
     382                 :            : {
     383                 :          0 :         return READ_ONCE(calipso_ops);
     384                 :            : }
     385                 :            : 
     386                 :            : /**
     387                 :            :  * calipso_doi_add - Add a new DOI to the CALIPSO protocol engine
     388                 :            :  * @doi_def: the DOI structure
     389                 :            :  * @audit_info: NetLabel audit information
     390                 :            :  *
     391                 :            :  * Description:
     392                 :            :  * The caller defines a new DOI for use by the CALIPSO engine and calls this
     393                 :            :  * function to add it to the list of acceptable domains.  The caller must
     394                 :            :  * ensure that the mapping table specified in @doi_def->map meets all of the
     395                 :            :  * requirements of the mapping type (see calipso.h for details).  Returns
     396                 :            :  * zero on success and non-zero on failure.
     397                 :            :  *
     398                 :            :  */
     399                 :          0 : int calipso_doi_add(struct calipso_doi *doi_def,
     400                 :            :                     struct netlbl_audit *audit_info)
     401                 :            : {
     402                 :          0 :         int ret_val = -ENOMSG;
     403         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     404                 :            : 
     405         [ #  # ]:          0 :         if (ops)
     406                 :          0 :                 ret_val = ops->doi_add(doi_def, audit_info);
     407                 :          0 :         return ret_val;
     408                 :            : }
     409                 :            : 
     410                 :            : /**
     411                 :            :  * calipso_doi_free - Frees a DOI definition
     412                 :            :  * @doi_def: the DOI definition
     413                 :            :  *
     414                 :            :  * Description:
     415                 :            :  * This function frees all of the memory associated with a DOI definition.
     416                 :            :  *
     417                 :            :  */
     418                 :          0 : void calipso_doi_free(struct calipso_doi *doi_def)
     419                 :            : {
     420         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     421                 :            : 
     422         [ #  # ]:          0 :         if (ops)
     423                 :          0 :                 ops->doi_free(doi_def);
     424                 :          0 : }
     425                 :            : 
     426                 :            : /**
     427                 :            :  * calipso_doi_remove - Remove an existing DOI from the CALIPSO protocol engine
     428                 :            :  * @doi: the DOI value
     429                 :            :  * @audit_secid: the LSM secid to use in the audit message
     430                 :            :  *
     431                 :            :  * Description:
     432                 :            :  * Removes a DOI definition from the CALIPSO engine.  The NetLabel routines will
     433                 :            :  * be called to release their own LSM domain mappings as well as our own
     434                 :            :  * domain list.  Returns zero on success and negative values on failure.
     435                 :            :  *
     436                 :            :  */
     437                 :          0 : int calipso_doi_remove(u32 doi, struct netlbl_audit *audit_info)
     438                 :            : {
     439                 :          0 :         int ret_val = -ENOMSG;
     440   [ #  #  #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     441                 :            : 
     442   [ #  #  #  # ]:          0 :         if (ops)
     443                 :          0 :                 ret_val = ops->doi_remove(doi, audit_info);
     444         [ #  # ]:          0 :         return ret_val;
     445                 :            : }
     446                 :            : 
     447                 :            : /**
     448                 :            :  * calipso_doi_getdef - Returns a reference to a valid DOI definition
     449                 :            :  * @doi: the DOI value
     450                 :            :  *
     451                 :            :  * Description:
     452                 :            :  * Searches for a valid DOI definition and if one is found it is returned to
     453                 :            :  * the caller.  Otherwise NULL is returned.  The caller must ensure that
     454                 :            :  * calipso_doi_putdef() is called when the caller is done.
     455                 :            :  *
     456                 :            :  */
     457                 :          0 : struct calipso_doi *calipso_doi_getdef(u32 doi)
     458                 :            : {
     459                 :          0 :         struct calipso_doi *ret_val = NULL;
     460   [ #  #  #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     461                 :            : 
     462   [ #  #  #  # ]:          0 :         if (ops)
     463                 :          0 :                 ret_val = ops->doi_getdef(doi);
     464         [ #  # ]:          0 :         return ret_val;
     465                 :            : }
     466                 :            : 
     467                 :            : /**
     468                 :            :  * calipso_doi_putdef - Releases a reference for the given DOI definition
     469                 :            :  * @doi_def: the DOI definition
     470                 :            :  *
     471                 :            :  * Description:
     472                 :            :  * Releases a DOI definition reference obtained from calipso_doi_getdef().
     473                 :            :  *
     474                 :            :  */
     475                 :          0 : void calipso_doi_putdef(struct calipso_doi *doi_def)
     476                 :            : {
     477   [ #  #  #  #  :          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
                   #  # ]
     478                 :            : 
     479   [ #  #  #  #  :          0 :         if (ops)
                   #  # ]
     480                 :          0 :                 ops->doi_putdef(doi_def);
     481                 :          0 : }
     482                 :            : 
     483                 :            : /**
     484                 :            :  * calipso_doi_walk - Iterate through the DOI definitions
     485                 :            :  * @skip_cnt: skip past this number of DOI definitions, updated
     486                 :            :  * @callback: callback for each DOI definition
     487                 :            :  * @cb_arg: argument for the callback function
     488                 :            :  *
     489                 :            :  * Description:
     490                 :            :  * Iterate over the DOI definition list, skipping the first @skip_cnt entries.
     491                 :            :  * For each entry call @callback, if @callback returns a negative value stop
     492                 :            :  * 'walking' through the list and return.  Updates the value in @skip_cnt upon
     493                 :            :  * return.  Returns zero on success, negative values on failure.
     494                 :            :  *
     495                 :            :  */
     496                 :          0 : int calipso_doi_walk(u32 *skip_cnt,
     497                 :            :                      int (*callback)(struct calipso_doi *doi_def, void *arg),
     498                 :            :                      void *cb_arg)
     499                 :            : {
     500                 :          0 :         int ret_val = -ENOMSG;
     501   [ #  #  #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     502                 :            : 
     503   [ #  #  #  # ]:          0 :         if (ops)
     504                 :          0 :                 ret_val = ops->doi_walk(skip_cnt, callback, cb_arg);
     505                 :          0 :         return ret_val;
     506                 :            : }
     507                 :            : 
     508                 :            : /**
     509                 :            :  * calipso_sock_getattr - Get the security attributes from a sock
     510                 :            :  * @sk: the sock
     511                 :            :  * @secattr: the security attributes
     512                 :            :  *
     513                 :            :  * Description:
     514                 :            :  * Query @sk to see if there is a CALIPSO option attached to the sock and if
     515                 :            :  * there is return the CALIPSO security attributes in @secattr.  This function
     516                 :            :  * requires that @sk be locked, or privately held, but it does not do any
     517                 :            :  * locking itself.  Returns zero on success and negative values on failure.
     518                 :            :  *
     519                 :            :  */
     520                 :          0 : int calipso_sock_getattr(struct sock *sk, struct netlbl_lsm_secattr *secattr)
     521                 :            : {
     522                 :          0 :         int ret_val = -ENOMSG;
     523         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     524                 :            : 
     525         [ #  # ]:          0 :         if (ops)
     526                 :          0 :                 ret_val = ops->sock_getattr(sk, secattr);
     527                 :          0 :         return ret_val;
     528                 :            : }
     529                 :            : 
     530                 :            : /**
     531                 :            :  * calipso_sock_setattr - Add a CALIPSO option to a socket
     532                 :            :  * @sk: the socket
     533                 :            :  * @doi_def: the CALIPSO DOI to use
     534                 :            :  * @secattr: the specific security attributes of the socket
     535                 :            :  *
     536                 :            :  * Description:
     537                 :            :  * Set the CALIPSO option on the given socket using the DOI definition and
     538                 :            :  * security attributes passed to the function.  This function requires
     539                 :            :  * exclusive access to @sk, which means it either needs to be in the
     540                 :            :  * process of being created or locked.  Returns zero on success and negative
     541                 :            :  * values on failure.
     542                 :            :  *
     543                 :            :  */
     544                 :          0 : int calipso_sock_setattr(struct sock *sk,
     545                 :            :                          const struct calipso_doi *doi_def,
     546                 :            :                          const struct netlbl_lsm_secattr *secattr)
     547                 :            : {
     548                 :          0 :         int ret_val = -ENOMSG;
     549         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     550                 :            : 
     551         [ #  # ]:          0 :         if (ops)
     552                 :          0 :                 ret_val = ops->sock_setattr(sk, doi_def, secattr);
     553                 :          0 :         return ret_val;
     554                 :            : }
     555                 :            : 
     556                 :            : /**
     557                 :            :  * calipso_sock_delattr - Delete the CALIPSO option from a socket
     558                 :            :  * @sk: the socket
     559                 :            :  *
     560                 :            :  * Description:
     561                 :            :  * Removes the CALIPSO option from a socket, if present.
     562                 :            :  *
     563                 :            :  */
     564                 :          0 : void calipso_sock_delattr(struct sock *sk)
     565                 :            : {
     566         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     567                 :            : 
     568         [ #  # ]:          0 :         if (ops)
     569                 :          0 :                 ops->sock_delattr(sk);
     570                 :          0 : }
     571                 :            : 
     572                 :            : /**
     573                 :            :  * calipso_req_setattr - Add a CALIPSO option to a connection request socket
     574                 :            :  * @req: the connection request socket
     575                 :            :  * @doi_def: the CALIPSO DOI to use
     576                 :            :  * @secattr: the specific security attributes of the socket
     577                 :            :  *
     578                 :            :  * Description:
     579                 :            :  * Set the CALIPSO option on the given socket using the DOI definition and
     580                 :            :  * security attributes passed to the function.  Returns zero on success and
     581                 :            :  * negative values on failure.
     582                 :            :  *
     583                 :            :  */
     584                 :          0 : int calipso_req_setattr(struct request_sock *req,
     585                 :            :                         const struct calipso_doi *doi_def,
     586                 :            :                         const struct netlbl_lsm_secattr *secattr)
     587                 :            : {
     588                 :          0 :         int ret_val = -ENOMSG;
     589         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     590                 :            : 
     591         [ #  # ]:          0 :         if (ops)
     592                 :          0 :                 ret_val = ops->req_setattr(req, doi_def, secattr);
     593                 :          0 :         return ret_val;
     594                 :            : }
     595                 :            : 
     596                 :            : /**
     597                 :            :  * calipso_req_delattr - Delete the CALIPSO option from a request socket
     598                 :            :  * @reg: the request socket
     599                 :            :  *
     600                 :            :  * Description:
     601                 :            :  * Removes the CALIPSO option from a request socket, if present.
     602                 :            :  *
     603                 :            :  */
     604                 :          0 : void calipso_req_delattr(struct request_sock *req)
     605                 :            : {
     606         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     607                 :            : 
     608         [ #  # ]:          0 :         if (ops)
     609                 :          0 :                 ops->req_delattr(req);
     610                 :          0 : }
     611                 :            : 
     612                 :            : /**
     613                 :            :  * calipso_optptr - Find the CALIPSO option in the packet
     614                 :            :  * @skb: the packet
     615                 :            :  *
     616                 :            :  * Description:
     617                 :            :  * Parse the packet's IP header looking for a CALIPSO option.  Returns a pointer
     618                 :            :  * to the start of the CALIPSO option on success, NULL if one if not found.
     619                 :            :  *
     620                 :            :  */
     621                 :          0 : unsigned char *calipso_optptr(const struct sk_buff *skb)
     622                 :            : {
     623                 :          0 :         unsigned char *ret_val = NULL;
     624         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     625                 :            : 
     626         [ #  # ]:          0 :         if (ops)
     627                 :          0 :                 ret_val = ops->skbuff_optptr(skb);
     628                 :          0 :         return ret_val;
     629                 :            : }
     630                 :            : 
     631                 :            : /**
     632                 :            :  * calipso_getattr - Get the security attributes from a memory block.
     633                 :            :  * @calipso: the CALIPSO option
     634                 :            :  * @secattr: the security attributes
     635                 :            :  *
     636                 :            :  * Description:
     637                 :            :  * Inspect @calipso and return the security attributes in @secattr.
     638                 :            :  * Returns zero on success and negative values on failure.
     639                 :            :  *
     640                 :            :  */
     641                 :          0 : int calipso_getattr(const unsigned char *calipso,
     642                 :            :                     struct netlbl_lsm_secattr *secattr)
     643                 :            : {
     644                 :          0 :         int ret_val = -ENOMSG;
     645         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     646                 :            : 
     647         [ #  # ]:          0 :         if (ops)
     648                 :          0 :                 ret_val = ops->opt_getattr(calipso, secattr);
     649                 :          0 :         return ret_val;
     650                 :            : }
     651                 :            : 
     652                 :            : /**
     653                 :            :  * calipso_skbuff_setattr - Set the CALIPSO option on a packet
     654                 :            :  * @skb: the packet
     655                 :            :  * @doi_def: the CALIPSO DOI to use
     656                 :            :  * @secattr: the security attributes
     657                 :            :  *
     658                 :            :  * Description:
     659                 :            :  * Set the CALIPSO option on the given packet based on the security attributes.
     660                 :            :  * Returns a pointer to the IP header on success and NULL on failure.
     661                 :            :  *
     662                 :            :  */
     663                 :          0 : int calipso_skbuff_setattr(struct sk_buff *skb,
     664                 :            :                            const struct calipso_doi *doi_def,
     665                 :            :                            const struct netlbl_lsm_secattr *secattr)
     666                 :            : {
     667                 :          0 :         int ret_val = -ENOMSG;
     668         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     669                 :            : 
     670         [ #  # ]:          0 :         if (ops)
     671                 :          0 :                 ret_val = ops->skbuff_setattr(skb, doi_def, secattr);
     672                 :          0 :         return ret_val;
     673                 :            : }
     674                 :            : 
     675                 :            : /**
     676                 :            :  * calipso_skbuff_delattr - Delete any CALIPSO options from a packet
     677                 :            :  * @skb: the packet
     678                 :            :  *
     679                 :            :  * Description:
     680                 :            :  * Removes any and all CALIPSO options from the given packet.  Returns zero on
     681                 :            :  * success, negative values on failure.
     682                 :            :  *
     683                 :            :  */
     684                 :          0 : int calipso_skbuff_delattr(struct sk_buff *skb)
     685                 :            : {
     686                 :          0 :         int ret_val = -ENOMSG;
     687         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     688                 :            : 
     689         [ #  # ]:          0 :         if (ops)
     690                 :          0 :                 ret_val = ops->skbuff_delattr(skb);
     691                 :          0 :         return ret_val;
     692                 :            : }
     693                 :            : 
     694                 :            : /**
     695                 :            :  * calipso_cache_invalidate - Invalidates the current CALIPSO cache
     696                 :            :  *
     697                 :            :  * Description:
     698                 :            :  * Invalidates and frees any entries in the CALIPSO cache.  Returns zero on
     699                 :            :  * success and negative values on failure.
     700                 :            :  *
     701                 :            :  */
     702                 :          0 : void calipso_cache_invalidate(void)
     703                 :            : {
     704         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     705                 :            : 
     706         [ #  # ]:          0 :         if (ops)
     707                 :          0 :                 ops->cache_invalidate();
     708                 :          0 : }
     709                 :            : 
     710                 :            : /**
     711                 :            :  * calipso_cache_add - Add an entry to the CALIPSO cache
     712                 :            :  * @calipso_ptr: the CALIPSO option
     713                 :            :  * @secattr: the packet's security attributes
     714                 :            :  *
     715                 :            :  * Description:
     716                 :            :  * Add a new entry into the CALIPSO label mapping cache.
     717                 :            :  * Returns zero on success, negative values on failure.
     718                 :            :  *
     719                 :            :  */
     720                 :          0 : int calipso_cache_add(const unsigned char *calipso_ptr,
     721                 :            :                       const struct netlbl_lsm_secattr *secattr)
     722                 :            : 
     723                 :            : {
     724                 :          0 :         int ret_val = -ENOMSG;
     725         [ #  # ]:          0 :         const struct netlbl_calipso_ops *ops = netlbl_calipso_ops_get();
     726                 :            : 
     727         [ #  # ]:          0 :         if (ops)
     728                 :          0 :                 ret_val = ops->cache_add(calipso_ptr, secattr);
     729                 :          0 :         return ret_val;
     730                 :            : }

Generated by: LCOV version 1.14