LCOV - code coverage report
Current view: top level - lib - name.c (source / functions) Hit Total Coverage
Test: GNU Generic Security Service Lines: 96 174 55.2 %
Date: 2010-05-20 Functions: 9 12 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 40 122 32.8 %

           Branch data     Line data    Source code
       1                 :            : /* name.c --- Implementation of GSS-API Name Manipulation functions.
       2                 :            :  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010  Simon Josefsson
       3                 :            :  *
       4                 :            :  * This file is part of the Generic Security Service (GSS).
       5                 :            :  *
       6                 :            :  * GSS is free software; you can redistribute it and/or modify it
       7                 :            :  * under the terms of the GNU General Public License as published by
       8                 :            :  * the Free Software Foundation; either version 3 of the License, or
       9                 :            :  * (at your option) any later version.
      10                 :            :  *
      11                 :            :  * GSS is distributed in the hope that it will be useful, but WITHOUT
      12                 :            :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      13                 :            :  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      14                 :            :  * License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU General Public License
      17                 :            :  * along with GSS; if not, see http://www.gnu.org/licenses or write to
      18                 :            :  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth
      19                 :            :  * Floor, Boston, MA 02110-1301, USA.
      20                 :            :  *
      21                 :            :  */
      22                 :            : 
      23                 :            : #include "internal.h"
      24                 :            : 
      25                 :            : /* _gss_find_mech */
      26                 :            : #include "meta.h"
      27                 :            : 
      28                 :            : /**
      29                 :            :  * gss_import_name:
      30                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
      31                 :            :  * @input_name_buffer: (buffer, octet-string, read) Buffer containing
      32                 :            :  *   contiguous string name to convert.
      33                 :            :  * @input_name_type: (Object ID, read, optional) Object ID specifying
      34                 :            :  *   type of printable name.  Applications may specify either
      35                 :            :  *   GSS_C_NO_OID to use a mechanism-specific default printable
      36                 :            :  *   syntax, or an OID recognized by the GSS-API implementation to
      37                 :            :  *   name a specific namespace.
      38                 :            :  * @output_name: (gss_name_t, modify) Returned name in internal form.
      39                 :            :  *   Storage associated with this name must be freed by the
      40                 :            :  *   application after use with a call to gss_release_name().
      41                 :            :  *
      42                 :            :  * Convert a contiguous string name to internal form.  In general, the
      43                 :            :  * internal name returned (via the @output_name parameter) will not
      44                 :            :  * be an MN; the exception to this is if the @input_name_type
      45                 :            :  * indicates that the contiguous string provided via the
      46                 :            :  * @input_name_buffer parameter is of type GSS_C_NT_EXPORT_NAME, in
      47                 :            :  * which case the returned internal name will be an MN for the
      48                 :            :  * mechanism that exported the name.
      49                 :            :  *
      50                 :            :  * Return value:
      51                 :            :  *
      52                 :            :  * `GSS_S_COMPLETE`: Successful completion.
      53                 :            :  *
      54                 :            :  * `GSS_S_BAD_NAMETYPE`: The input_name_type was unrecognized.
      55                 :            :  *
      56                 :            :  * `GSS_S_BAD_NAME`: The input_name parameter could not be interpreted
      57                 :            :  * as a name of the specified type.
      58                 :            :  *
      59                 :            :  * `GSS_S_BAD_MECH`: The input name-type was GSS_C_NT_EXPORT_NAME, but
      60                 :            :  * the mechanism contained within the input-name is not supported.
      61                 :            :  **/
      62                 :            : OM_uint32
      63                 :          2 : gss_import_name (OM_uint32 * minor_status,
      64                 :            :                  const gss_buffer_t input_name_buffer,
      65                 :            :                  const gss_OID input_name_type, gss_name_t * output_name)
      66                 :            : {
      67         [ -  + ]:          2 :   if (!output_name)
      68                 :            :     {
      69         [ #  # ]:          0 :       if (minor_status)
      70                 :          0 :         *minor_status = 0;
      71                 :          0 :       return GSS_S_BAD_NAME | GSS_S_CALL_INACCESSIBLE_WRITE;
      72                 :            :     }
      73                 :            : 
      74                 :          2 :   *output_name = malloc (sizeof (**output_name));
      75         [ -  + ]:          2 :   if (!*output_name)
      76                 :            :     {
      77         [ #  # ]:          0 :       if (minor_status)
      78                 :          0 :         *minor_status = ENOMEM;
      79                 :          0 :       return GSS_S_FAILURE;
      80                 :            :     }
      81                 :          2 :   (*output_name)->length = input_name_buffer->length;
      82                 :          2 :   (*output_name)->value = malloc (input_name_buffer->length);
      83         [ -  + ]:          2 :   if (!(*output_name)->value)
      84                 :            :     {
      85                 :          0 :       free (*output_name);
      86         [ #  # ]:          0 :       if (minor_status)
      87                 :          0 :         *minor_status = ENOMEM;
      88                 :          0 :       return GSS_S_FAILURE;
      89                 :            :     }
      90                 :          4 :   memcpy ((*output_name)->value,
      91                 :          2 :           input_name_buffer->value, input_name_buffer->length);
      92                 :            : 
      93                 :          2 :   (*output_name)->type = input_name_type;
      94                 :            : 
      95         [ +  - ]:          2 :   if (minor_status)
      96                 :          2 :     *minor_status = 0;
      97                 :          2 :   return GSS_S_COMPLETE;
      98                 :            : }
      99                 :            : 
     100                 :            : /**
     101                 :            :  * gss_display_name:
     102                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     103                 :            :  * @input_name: (gss_name_t, read) Name to be displayed.
     104                 :            :  * @output_name_buffer: (buffer, character-string, modify) Buffer to
     105                 :            :  *   receive textual name string.  The application must free storage
     106                 :            :  *   associated with this name after use with a call to
     107                 :            :  *   gss_release_buffer().
     108                 :            :  * @output_name_type: (Object ID, modify, optional) The type of the
     109                 :            :  *   returned name.  The returned gss_OID will be a pointer into
     110                 :            :  *   static storage, and should be treated as read-only by the caller
     111                 :            :  *   (in particular, the application should not attempt to free
     112                 :            :  *   it). Specify NULL if not required.
     113                 :            :  *
     114                 :            :  * Allows an application to obtain a textual representation of an
     115                 :            :  * opaque internal-form name for display purposes.  The syntax of a
     116                 :            :  * printable name is defined by the GSS-API implementation.
     117                 :            :  *
     118                 :            :  * If input_name denotes an anonymous principal, the implementation
     119                 :            :  * should return the gss_OID value GSS_C_NT_ANONYMOUS as the
     120                 :            :  * output_name_type, and a textual name that is syntactically distinct
     121                 :            :  * from all valid supported printable names in output_name_buffer.
     122                 :            :  *
     123                 :            :  * If input_name was created by a call to gss_import_name, specifying
     124                 :            :  * GSS_C_NO_OID as the name-type, implementations that employ lazy
     125                 :            :  * conversion between name types may return GSS_C_NO_OID via the
     126                 :            :  * output_name_type parameter.
     127                 :            :  *
     128                 :            :  * Return value:
     129                 :            :  *
     130                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     131                 :            :  *
     132                 :            :  * `GSS_S_BAD_NAME`: @input_name was ill-formed.
     133                 :            :  **/
     134                 :            : OM_uint32
     135                 :          1 : gss_display_name (OM_uint32 * minor_status,
     136                 :            :                   const gss_name_t input_name,
     137                 :            :                   gss_buffer_t output_name_buffer, gss_OID * output_name_type)
     138                 :            : {
     139         [ -  + ]:          1 :   if (!input_name)
     140                 :            :     {
     141         [ #  # ]:          0 :       if (minor_status)
     142                 :          0 :         *minor_status = 0;
     143                 :          0 :       return GSS_S_BAD_NAME;
     144                 :            :     }
     145                 :            : 
     146                 :          1 :   output_name_buffer->length = input_name->length;
     147                 :          1 :   output_name_buffer->value = malloc (input_name->length + 1);
     148         [ -  + ]:          1 :   if (!output_name_buffer->value)
     149                 :            :     {
     150         [ #  # ]:          0 :       if (minor_status)
     151                 :          0 :         *minor_status = ENOMEM;
     152                 :          0 :       return GSS_S_FAILURE;
     153                 :            :     }
     154         [ +  - ]:          1 :   if (input_name->value)
     155                 :          1 :     memcpy (output_name_buffer->value, input_name->value, input_name->length);
     156                 :            : 
     157         [ -  + ]:          1 :   if (output_name_type)
     158                 :          0 :     *output_name_type = input_name->type;
     159                 :            : 
     160         [ +  - ]:          1 :   if (minor_status)
     161                 :          1 :     *minor_status = 0;
     162                 :          1 :   return GSS_S_COMPLETE;
     163                 :            : }
     164                 :            : 
     165                 :            : /**
     166                 :            :  * gss_compare_name:
     167                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     168                 :            :  * @name1: (gss_name_t, read) Internal-form name.
     169                 :            :  * @name2: (gss_name_t, read) Internal-form name.
     170                 :            :  * @name_equal: (boolean, modify) Non-zero - names refer to same
     171                 :            :  *   entity. Zero - names refer to different entities (strictly, the
     172                 :            :  *   names are not known to refer to the same identity).
     173                 :            :  *
     174                 :            :  * Allows an application to compare two internal-form names to
     175                 :            :  * determine whether they refer to the same entity.
     176                 :            :  *
     177                 :            :  * If either name presented to gss_compare_name denotes an anonymous
     178                 :            :  * principal, the routines should indicate that the two names do not
     179                 :            :  * refer to the same identity.
     180                 :            :  *
     181                 :            :  * Return value:
     182                 :            :  *
     183                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     184                 :            :  *
     185                 :            :  * `GSS_S_BAD_NAMETYPE`: The two names were of incomparable types.
     186                 :            :  *
     187                 :            :  * `GSS_S_BAD_NAME`: One or both of name1 or name2 was ill-formed.
     188                 :            :  **/
     189                 :            : OM_uint32
     190                 :          0 : gss_compare_name (OM_uint32 * minor_status,
     191                 :            :                   const gss_name_t name1,
     192                 :            :                   const gss_name_t name2, int *name_equal)
     193                 :            : {
     194         [ #  # ]:          0 :   if (minor_status)
     195                 :          0 :     *minor_status = 0;
     196                 :            : 
     197 [ #  # ][ #  # ]:          0 :   if (!name1 || !name2)
     198                 :          0 :     return GSS_S_BAD_NAME | GSS_S_CALL_INACCESSIBLE_READ;
     199                 :            : 
     200         [ #  # ]:          0 :   if (!gss_oid_equal (name1->type, name2->type))
     201                 :          0 :     return GSS_S_BAD_NAMETYPE;
     202                 :            : 
     203         [ #  # ]:          0 :   if (name_equal)
     204 [ #  # ][ #  # ]:          0 :     *name_equal = (name1->length == name2->length) &&
     205                 :          0 :       memcmp (name1->value, name2->value, name1->length) == 0;
     206                 :            : 
     207                 :          0 :   return GSS_S_COMPLETE;
     208                 :            : }
     209                 :            : 
     210                 :            : /**
     211                 :            :  * gss_release_name:
     212                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     213                 :            :  * @name: (gss_name_t, modify) The name to be deleted.
     214                 :            :  *
     215                 :            :  * Free GSSAPI-allocated storage associated with an internal-form
     216                 :            :  * name.  The name is set to GSS_C_NO_NAME on successful completion of
     217                 :            :  * this call.
     218                 :            :  *
     219                 :            :  * Return value:
     220                 :            :  *
     221                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     222                 :            :  *
     223                 :            :  * `GSS_S_BAD_NAME`: The name parameter did not contain a valid name.
     224                 :            :  **/
     225                 :            : OM_uint32
     226                 :          6 : gss_release_name (OM_uint32 * minor_status, gss_name_t * name)
     227                 :            : {
     228         [ +  + ]:          6 :   if (minor_status)
     229                 :          2 :     *minor_status = 0;
     230                 :            : 
     231         [ -  + ]:          6 :   if (!name)
     232                 :          0 :     return GSS_S_BAD_NAME | GSS_S_CALL_INACCESSIBLE_READ;
     233                 :            : 
     234         [ +  - ]:          6 :   if (*name != GSS_C_NO_NAME)
     235                 :            :     {
     236         [ +  - ]:          6 :       if ((*name)->value)
     237                 :          6 :         free ((*name)->value);
     238                 :            : 
     239                 :          6 :       free (*name);
     240                 :          6 :       *name = GSS_C_NO_NAME;
     241                 :            :     }
     242                 :            : 
     243                 :          6 :   return GSS_S_COMPLETE;
     244                 :            : }
     245                 :            : 
     246                 :            : /**
     247                 :            :  * gss_inquire_names_for_mech:
     248                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     249                 :            :  * @mechanism: (gss_OID, read) The mechanism to be interrogated.
     250                 :            :  * @name_types: (gss_OID_set, modify) Set of name-types supported by
     251                 :            :  *   the specified mechanism.  The returned OID set must be freed by
     252                 :            :  *   the application after use with a call to gss_release_oid_set().
     253                 :            :  *
     254                 :            :  * Returns the set of nametypes supported by the specified mechanism.
     255                 :            :  *
     256                 :            :  * Return value:
     257                 :            :  *
     258                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     259                 :            :  **/
     260                 :            : OM_uint32
     261                 :          2 : gss_inquire_names_for_mech (OM_uint32 * minor_status,
     262                 :            :                             const gss_OID mechanism, gss_OID_set * name_types)
     263                 :            : {
     264                 :            :   OM_uint32 maj_stat;
     265                 :            :   _gss_mech_api_t mech;
     266                 :            :   int i;
     267                 :            : 
     268                 :          2 :   mech = _gss_find_mech (mechanism);
     269                 :            : 
     270                 :          2 :   maj_stat = gss_create_empty_oid_set (minor_status, name_types);
     271         [ -  + ]:          2 :   if (maj_stat != GSS_S_COMPLETE)
     272                 :          0 :     return maj_stat;
     273                 :            : 
     274         [ +  + ]:          8 :   for (i = 0; mech->name_types[i]; i++)
     275                 :            :     {
     276                 :          6 :       maj_stat = gss_add_oid_set_member (minor_status, mech->name_types[i],
     277                 :            :                                          name_types);
     278         [ -  + ]:          6 :       if (maj_stat != GSS_S_COMPLETE)
     279                 :            :         {
     280                 :          0 :           gss_release_oid_set (minor_status, name_types);
     281                 :          0 :           return maj_stat;
     282                 :            :         }
     283                 :            :     }
     284                 :            : 
     285         [ +  - ]:          2 :   if (minor_status)
     286                 :          2 :     *minor_status = 0;
     287                 :          2 :   return GSS_S_COMPLETE;
     288                 :            : }
     289                 :            : 
     290                 :            : /* Add mechanism MECH to OID set MECH_TYPES if mechanism MECH support
     291                 :            :    the NAME_TYPE name type. */
     292                 :            : static OM_uint32
     293                 :          1 : _gss_inquire_mechs_for_name3 (OM_uint32 * minor_status,
     294                 :            :                               gss_OID mech,
     295                 :            :                               gss_OID name_type, gss_OID_set * mech_types)
     296                 :            : {
     297                 :            :   gss_OID_set oids;
     298                 :            :   int supported;
     299                 :            :   OM_uint32 maj_stat;
     300                 :            : 
     301                 :          1 :   maj_stat = gss_inquire_names_for_mech (minor_status, mech, &oids);
     302         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     303                 :          0 :     return maj_stat;
     304                 :            : 
     305                 :          1 :   maj_stat = gss_test_oid_set_member (minor_status, name_type,
     306                 :            :                                       oids, &supported);
     307                 :          1 :   gss_release_oid_set (minor_status, &oids);
     308         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     309                 :          0 :     return maj_stat;
     310                 :            : 
     311         [ +  - ]:          1 :   if (supported)
     312                 :            :     {
     313                 :          1 :       maj_stat = gss_add_oid_set_member (minor_status, mech, mech_types);
     314         [ -  + ]:          1 :       if (GSS_ERROR (maj_stat))
     315                 :          0 :         return maj_stat;
     316                 :            :     }
     317                 :            : 
     318         [ +  - ]:          1 :   if (minor_status)
     319                 :          1 :     *minor_status = 0;
     320                 :          1 :   return GSS_S_COMPLETE;
     321                 :            : }
     322                 :            : 
     323                 :            : /* Iterate over SUPPORTED_MECH_TYPES and invoke
     324                 :            :    gss_inquire_mechs_for_name3 on each type, thus adding all mechanism
     325                 :            :    OIDs, that support the NAME_TYPE name type, to OUT_MECH_TYPES. */
     326                 :            : static OM_uint32
     327                 :          1 : _gss_inquire_mechs_for_name2 (OM_uint32 * minor_status,
     328                 :            :                               gss_OID name_type,
     329                 :            :                               gss_OID_set * out_mech_types,
     330                 :            :                               gss_OID_set supported_mech_types)
     331                 :            : {
     332                 :            :   OM_uint32 maj_stat;
     333                 :            :   size_t i;
     334                 :            : 
     335         [ +  + ]:          2 :   for (i = 0; i < supported_mech_types->count; i++)
     336                 :            :     {
     337                 :          1 :       maj_stat = _gss_inquire_mechs_for_name3
     338                 :          1 :         (minor_status, &(supported_mech_types->elements)[i],
     339                 :            :          name_type, out_mech_types);
     340         [ -  + ]:          1 :       if (GSS_ERROR (maj_stat))
     341                 :          0 :         return maj_stat;
     342                 :            :     }
     343                 :            : 
     344         [ +  - ]:          1 :   if (minor_status)
     345                 :          1 :     *minor_status = 0;
     346                 :          1 :   return GSS_S_COMPLETE;
     347                 :            : }
     348                 :            : 
     349                 :            : /* List all supported mechanisms, and invoke
     350                 :            :    gss_inquire_mechs_for_name2, thus adding all mechanism OIDs, that
     351                 :            :    support the NAME_TYPE name type, to OUT_MECH_TYPES. */
     352                 :            : static OM_uint32
     353                 :          1 : _gss_inquire_mechs_for_name1 (OM_uint32 * minor_status,
     354                 :            :                               gss_OID name_type, gss_OID_set * out_mech_types)
     355                 :            : {
     356                 :            :   OM_uint32 maj_stat;
     357                 :            :   gss_OID_set supported_mech_types;
     358                 :            : 
     359                 :          1 :   maj_stat = gss_indicate_mechs (minor_status, &supported_mech_types);
     360         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     361                 :          0 :     return maj_stat;
     362                 :            : 
     363                 :          1 :   maj_stat = _gss_inquire_mechs_for_name2 (minor_status, name_type,
     364                 :            :                                            out_mech_types,
     365                 :            :                                            supported_mech_types);
     366                 :          1 :   gss_release_oid_set (minor_status, &supported_mech_types);
     367         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     368                 :          0 :     return maj_stat;
     369                 :            : 
     370         [ +  - ]:          1 :   if (minor_status)
     371                 :          1 :     *minor_status = 0;
     372                 :          1 :   return GSS_S_COMPLETE;
     373                 :            : }
     374                 :            : 
     375                 :            : /**
     376                 :            :  * gss_inquire_mechs_for_name:
     377                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     378                 :            :  * @input_name: (gss_name_t, read) The name to which the inquiry
     379                 :            :  *   relates.
     380                 :            :  * @mech_types: (gss_OID_set, modify) Set of mechanisms that may
     381                 :            :  *   support the specified name.  The returned OID set must be freed
     382                 :            :  *   by the caller after use with a call to gss_release_oid_set().
     383                 :            :  *
     384                 :            :  * Returns the set of mechanisms supported by the GSS-API
     385                 :            :  * implementation that may be able to process the specified name.
     386                 :            :  *
     387                 :            :  * Each mechanism returned will recognize at least one element within
     388                 :            :  * the name.  It is permissible for this routine to be implemented
     389                 :            :  * within a mechanism-independent GSS-API layer, using the type
     390                 :            :  * information contained within the presented name, and based on
     391                 :            :  * registration information provided by individual mechanism
     392                 :            :  * implementations.  This means that the returned mech_types set may
     393                 :            :  * indicate that a particular mechanism will understand the name when
     394                 :            :  * in fact it would refuse to accept the name as input to
     395                 :            :  * gss_canonicalize_name, gss_init_sec_context, gss_acquire_cred or
     396                 :            :  * gss_add_cred (due to some property of the specific name, as opposed
     397                 :            :  * to the name type).  Thus this routine should be used only as a
     398                 :            :  * prefilter for a call to a subsequent mechanism-specific routine.
     399                 :            :  *
     400                 :            :  * Return value:
     401                 :            :  *
     402                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     403                 :            :  *
     404                 :            :  * `GSS_S_BAD_NAME`: The input_name parameter was ill-formed.
     405                 :            :  *
     406                 :            :  * `GSS_S_BAD_NAMETYPE`: The input_name parameter contained an invalid
     407                 :            :  * or unsupported type of name.
     408                 :            :  **/
     409                 :            : OM_uint32
     410                 :          1 : gss_inquire_mechs_for_name (OM_uint32 * minor_status,
     411                 :            :                             const gss_name_t input_name,
     412                 :            :                             gss_OID_set * mech_types)
     413                 :            : {
     414                 :            :   OM_uint32 maj_stat;
     415                 :            : 
     416         [ -  + ]:          1 :   if (input_name == GSS_C_NO_NAME)
     417                 :            :     {
     418         [ #  # ]:          0 :       if (minor_status)
     419                 :          0 :         *minor_status = 0;
     420                 :          0 :       return GSS_S_BAD_NAME | GSS_S_CALL_INACCESSIBLE_READ;
     421                 :            :     }
     422                 :            : 
     423                 :          1 :   maj_stat = gss_create_empty_oid_set (minor_status, mech_types);
     424         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     425                 :          0 :     return maj_stat;
     426                 :            : 
     427                 :          1 :   maj_stat = _gss_inquire_mechs_for_name1 (minor_status,
     428                 :            :                                            input_name->type, mech_types);
     429         [ -  + ]:          1 :   if (GSS_ERROR (maj_stat))
     430                 :            :     {
     431                 :          0 :       gss_release_oid_set (minor_status, mech_types);
     432                 :          0 :       return maj_stat;
     433                 :            :     }
     434                 :            : 
     435         [ +  - ]:          1 :   if (minor_status)
     436                 :          1 :     *minor_status = 0;
     437                 :          1 :   return GSS_S_COMPLETE;
     438                 :            : }
     439                 :            : 
     440                 :            : /**
     441                 :            :  * gss_export_name:
     442                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     443                 :            :  * @input_name: (gss_name_t, read) The MN to be exported.
     444                 :            :  * @exported_name: (gss_buffer_t, octet-string, modify) The canonical
     445                 :            :  *   contiguous string form of @input_name.  Storage associated with
     446                 :            :  *   this string must freed by the application after use with
     447                 :            :  *   gss_release_buffer().
     448                 :            :  *
     449                 :            :  * To produce a canonical contiguous string representation of a
     450                 :            :  * mechanism name (MN), suitable for direct comparison (e.g. with
     451                 :            :  * memcmp) for use in authorization functions (e.g. matching entries
     452                 :            :  * in an access-control list).  The @input_name parameter must specify
     453                 :            :  * a valid MN (i.e. an internal name generated by
     454                 :            :  * gss_accept_sec_context() or by gss_canonicalize_name()).
     455                 :            :  *
     456                 :            :  * Return value:
     457                 :            :  *
     458                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     459                 :            :  *
     460                 :            :  * `GSS_S_NAME_NOT_MN`: The provided internal name was not a mechanism
     461                 :            :  * name.
     462                 :            :  *
     463                 :            :  * `GSS_S_BAD_NAME`: The provided internal name was ill-formed.
     464                 :            :  *
     465                 :            :  * `GSS_S_BAD_NAMETYPE`: The internal name was of a type not supported
     466                 :            :  * by the GSS-API implementation.
     467                 :            :  **/
     468                 :            : OM_uint32
     469                 :          0 : gss_export_name (OM_uint32 * minor_status,
     470                 :            :                  const gss_name_t input_name, gss_buffer_t exported_name)
     471                 :            : {
     472                 :            :   OM_uint32 maj_stat;
     473                 :            :   gss_OID_set mechs;
     474                 :            :   _gss_mech_api_t mech;
     475                 :            : 
     476                 :          0 :   maj_stat = gss_inquire_mechs_for_name (minor_status, input_name, &mechs);
     477         [ #  # ]:          0 :   if (GSS_ERROR (maj_stat))
     478                 :          0 :     return maj_stat;
     479                 :            : 
     480         [ #  # ]:          0 :   if (mechs->count == 0)
     481                 :            :     {
     482         [ #  # ]:          0 :       if (minor_status)
     483                 :          0 :         *minor_status = 0;
     484                 :          0 :       return GSS_S_BAD_NAMETYPE;
     485                 :            :     }
     486                 :            : 
     487                 :            :   /* We just select a random mechanism that support this name-type.
     488                 :            :      I'm not sure how we can be more predicatable, given the
     489                 :            :      definition of this function. */
     490                 :            : 
     491                 :          0 :   mech = _gss_find_mech (mechs->elements);
     492         [ #  # ]:          0 :   if (mech == NULL)
     493                 :            :     {
     494         [ #  # ]:          0 :       if (minor_status)
     495                 :          0 :         *minor_status = 0;
     496                 :          0 :       return GSS_S_BAD_MECH;
     497                 :            :     }
     498                 :            : 
     499                 :          0 :   return mech->export_name (minor_status, input_name, exported_name);
     500                 :            : }
     501                 :            : 
     502                 :            : /**
     503                 :            :  * gss_canonicalize_name:
     504                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     505                 :            :  * @input_name: (gss_name_t, read) The name for which a canonical form
     506                 :            :  *   is desired.
     507                 :            :  * @mech_type: (Object ID, read) The authentication mechanism for
     508                 :            :  *   which the canonical form of the name is desired.  The desired
     509                 :            :  *   mechanism must be specified explicitly; no default is provided.
     510                 :            :  * @output_name: (gss_name_t, modify) The resultant canonical name.
     511                 :            :  *   Storage associated with this name must be freed by the
     512                 :            :  *   application after use with a call to gss_release_name().
     513                 :            :  *
     514                 :            :  * Generate a canonical mechanism name (MN) from an arbitrary internal
     515                 :            :  * name.  The mechanism name is the name that would be returned to a
     516                 :            :  * context acceptor on successful authentication of a context where
     517                 :            :  * the initiator used the input_name in a successful call to
     518                 :            :  * gss_acquire_cred, specifying an OID set containing @mech_type as
     519                 :            :  * its only member, followed by a call to gss_init_sec_context(),
     520                 :            :  * specifying @mech_type as the authentication mechanism.
     521                 :            :  *
     522                 :            :  * Return value:
     523                 :            :  *
     524                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     525                 :            :  **/
     526                 :            : OM_uint32
     527                 :          0 : gss_canonicalize_name (OM_uint32 * minor_status,
     528                 :            :                        const gss_name_t input_name,
     529                 :            :                        const gss_OID mech_type, gss_name_t * output_name)
     530                 :            : {
     531                 :            :   _gss_mech_api_t mech;
     532                 :            : 
     533                 :          0 :   mech = _gss_find_mech (mech_type);
     534         [ #  # ]:          0 :   if (mech == NULL)
     535                 :            :     {
     536         [ #  # ]:          0 :       if (minor_status)
     537                 :          0 :         *minor_status = 0;
     538                 :          0 :       return GSS_S_BAD_MECH;
     539                 :            :     }
     540                 :            : 
     541                 :          0 :   return mech->canonicalize_name (minor_status, input_name,
     542                 :            :                                   mech_type, output_name);
     543                 :            : }
     544                 :            : 
     545                 :            : /**
     546                 :            :  * gss_duplicate_name:
     547                 :            :  * @minor_status: (Integer, modify) Mechanism specific status code.
     548                 :            :  * @src_name: (gss_name_t, read) Internal name to be duplicated.
     549                 :            :  * @dest_name: (gss_name_t, modify) The resultant copy of @src_name.
     550                 :            :  *   Storage associated with this name must be freed by the application
     551                 :            :  *   after use with a call to gss_release_name().
     552                 :            :  *
     553                 :            :  * Create an exact duplicate of the existing internal name @src_name.
     554                 :            :  * The new @dest_name will be independent of src_name (i.e. @src_name
     555                 :            :  * and @dest_name must both be released, and the release of one shall
     556                 :            :  * not affect the validity of the other).
     557                 :            :  *
     558                 :            :  * Return value:
     559                 :            :  *
     560                 :            :  * `GSS_S_COMPLETE`: Successful completion.
     561                 :            :  *
     562                 :            :  * `GSS_S_BAD_NAME`: The src_name parameter was ill-formed.
     563                 :            :  **/
     564                 :            : OM_uint32
     565                 :          4 : gss_duplicate_name (OM_uint32 * minor_status,
     566                 :            :                     const gss_name_t src_name, gss_name_t * dest_name)
     567                 :            : {
     568         [ -  + ]:          4 :   if (src_name == GSS_C_NO_NAME)
     569                 :            :     {
     570         [ #  # ]:          0 :       if (minor_status)
     571                 :          0 :         *minor_status = 0;
     572                 :          0 :       return GSS_S_BAD_NAME;
     573                 :            :     }
     574                 :            : 
     575         [ -  + ]:          4 :   if (!dest_name)
     576                 :            :     {
     577         [ #  # ]:          0 :       if (minor_status)
     578                 :          0 :         *minor_status = 0;
     579                 :          0 :       return GSS_S_FAILURE | GSS_S_CALL_INACCESSIBLE_WRITE;
     580                 :            :     }
     581                 :            : 
     582                 :          4 :   *dest_name = malloc (sizeof (**dest_name));
     583         [ -  + ]:          4 :   if (!*dest_name)
     584                 :            :     {
     585         [ #  # ]:          0 :       if (minor_status)
     586                 :          0 :         *minor_status = ENOMEM;
     587                 :          0 :       return GSS_S_FAILURE;
     588                 :            :     }
     589                 :          4 :   (*dest_name)->type = src_name->type;
     590                 :          4 :   (*dest_name)->length = src_name->length;
     591                 :          4 :   (*dest_name)->value = malloc (src_name->length + 1);
     592         [ -  + ]:          4 :   if (!(*dest_name)->value)
     593                 :            :     {
     594                 :          0 :       free (*dest_name);
     595         [ #  # ]:          0 :       if (minor_status)
     596                 :          0 :         *minor_status = ENOMEM;
     597                 :          0 :       return GSS_S_FAILURE;
     598                 :            :     }
     599                 :          4 :   memcpy ((*dest_name)->value, src_name->value, src_name->length);
     600                 :          4 :   (*dest_name)->value[src_name->length] = '\0';
     601                 :            : 
     602         [ +  - ]:          4 :   if (minor_status)
     603                 :          4 :     *minor_status = 0;
     604                 :          4 :   return GSS_S_COMPLETE;
     605                 :            : }

Generated by: LCOV version 1.8