LCOV - code coverage report
Current view: top level - lib - fko_user.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 58 61 95.1 %
Date: 2016-06-07 Functions: 3 3 100.0 %
Branches: 77 88 87.5 %

           Branch data     Line data    Source code
       1                 :            : /**
       2                 :            :  * \file lib/fko_user.c
       3                 :            :  *
       4                 :            :  * \brief Set/Get the current username.
       5                 :            :  */
       6                 :            : 
       7                 :            : /*  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
       8                 :            :  *  Copyright (C) 2009-2015 fwknop developers and contributors. For a full
       9                 :            :  *  list of contributors, see the file 'CREDITS'.
      10                 :            :  *
      11                 :            :  *  License (GNU General Public License):
      12                 :            :  *
      13                 :            :  *  This program is free software; you can redistribute it and/or
      14                 :            :  *  modify it under the terms of the GNU General Public License
      15                 :            :  *  as published by the Free Software Foundation; either version 2
      16                 :            :  *  of the License, or (at your option) any later version.
      17                 :            :  *
      18                 :            :  *  This program is distributed in the hope that it will be useful,
      19                 :            :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      20                 :            :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      21                 :            :  *  GNU General Public License for more details.
      22                 :            :  *
      23                 :            :  *  You should have received a copy of the GNU General Public License
      24                 :            :  *  along with this program; if not, write to the Free Software
      25                 :            :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
      26                 :            :  *  USA
      27                 :            :  *
      28                 :            :  *****************************************************************************
      29                 :            : */
      30                 :            : #include "fko_common.h"
      31                 :            : #include "fko.h"
      32                 :            : 
      33                 :            : #ifdef __MINGW32__
      34                 :            :   #include "../win32/getlogin.h"
      35                 :            : #elif WIN32
      36                 :            :   #include <getlogin.h>
      37                 :            : #endif
      38                 :            : 
      39                 :            : /* Get or Set the username for the fko context spa data.
      40                 :            : */
      41                 :            : int
      42                 :     866279 : fko_set_username(fko_ctx_t ctx, const char * const spoof_user)
      43                 :            : {
      44                 :     866279 :     char   *username = NULL;
      45                 :     866279 :     int     res = FKO_SUCCESS, is_user_heap_allocated=0;
      46                 :            : 
      47                 :            : #if HAVE_LIBFIU
      48         [ +  + ]:     866279 :     fiu_return_on("fko_set_username_init", FKO_ERROR_CTX_NOT_INITIALIZED);
      49                 :            : #endif
      50                 :            : 
      51                 :            :     /* Must be initialized
      52                 :            :     */
      53 [ +  + ][ +  - ]:     866276 :     if(!CTX_INITIALIZED(ctx))
      54                 :            :         return FKO_ERROR_CTX_NOT_INITIALIZED;
      55                 :            : 
      56                 :            :     /* If spoof_user was not passed in, check for a SPOOF_USER environment
      57                 :            :      * variable.  If it is set, use its value.
      58                 :            :     */
      59 [ +  + ][ +  - ]:     866254 :     if(spoof_user != NULL && spoof_user[0] != '\0')
      60                 :            :     {
      61                 :            : #if HAVE_LIBFIU
      62         [ +  + ]:        225 :         fiu_return_on("fko_set_username_strdup", FKO_ERROR_MEMORY_ALLOCATION);
      63                 :            : #endif
      64                 :        222 :         username = strdup(spoof_user);
      65         [ +  - ]:        222 :         if(username == NULL)
      66                 :            :             return(FKO_ERROR_MEMORY_ALLOCATION);
      67                 :            :         is_user_heap_allocated = 1;
      68                 :            :     }
      69                 :            :     else
      70                 :     866029 :         username = getenv("SPOOF_USER");
      71                 :            : 
      72                 :            :     /* Try to get the username from the system.
      73                 :            :     */
      74         [ +  + ]:     866251 :     if(username == NULL)
      75                 :            :     {
      76                 :            :         /* Since we've already tried looking at an env variable, try
      77                 :            :          * LOGNAME next (and the cuserid() man page recommends this)
      78                 :            :         */
      79         [ +  + ]:     866023 :         if((username = getenv("LOGNAME")) == NULL)
      80                 :            :         {
      81                 :            : #ifdef _XOPEN_SOURCE
      82                 :            :             /* cuserid will return the effective user (i.e. su or setuid).
      83                 :            :             */
      84                 :          1 :             username = cuserid(NULL);
      85                 :            : #else
      86                 :            :             username = getlogin();
      87                 :            : #endif
      88                 :            :             /* if we still didn't get a username, continue falling back
      89                 :            :             */
      90         [ -  + ]:          1 :             if(username == NULL)
      91                 :            :             {
      92         [ #  # ]:          0 :                 if((username = getenv("USER")) == NULL)
      93                 :            :                 {
      94                 :          0 :                     username = strdup("NO_USER");
      95         [ #  # ]:          0 :                     if(username == NULL)
      96                 :            :                         return(FKO_ERROR_MEMORY_ALLOCATION);
      97                 :            :                     is_user_heap_allocated = 1;
      98                 :            :                 }
      99                 :            :             }
     100                 :            :         }
     101                 :            :     }
     102                 :            : 
     103                 :            :     /* Truncate the username if it is too long.
     104                 :            :     */
     105         [ +  + ]:     866251 :     if(strnlen(username, MAX_SPA_USERNAME_SIZE) == MAX_SPA_USERNAME_SIZE)
     106                 :         14 :         *(username + MAX_SPA_USERNAME_SIZE - 1) = '\0';
     107                 :            : 
     108         [ +  + ]:     866251 :     if((res = validate_username(username)) != FKO_SUCCESS)
     109                 :            :     {
     110         [ +  - ]:         13 :         if(is_user_heap_allocated == 1)
     111                 :         13 :             free(username);
     112                 :            : #if HAVE_LIBFIU
     113         [ +  + ]:         13 :         fiu_return_on("fko_set_username_valuser", FKO_ERROR_INVALID_DATA);
     114                 :            : #endif
     115                 :         11 :         return res;
     116                 :            :     }
     117                 :            : 
     118                 :            :     /* Just in case this is a subsequent call to this function.  We
     119                 :            :      * do not want to be leaking memory.
     120                 :            :     */
     121         [ +  + ]:     866238 :     if(ctx->username != NULL)
     122                 :        233 :         free(ctx->username);
     123                 :            : 
     124                 :     866238 :     ctx->username = strdup(username);
     125                 :            : 
     126                 :     866238 :     ctx->state |= FKO_DATA_MODIFIED;
     127                 :            : 
     128         [ +  + ]:     866238 :     if(is_user_heap_allocated == 1)
     129                 :        209 :         free(username);
     130                 :            : 
     131         [ +  + ]:     866238 :     if(ctx->username == NULL)
     132                 :            :         return(FKO_ERROR_MEMORY_ALLOCATION);
     133                 :            : 
     134                 :     866182 :     return(FKO_SUCCESS);
     135                 :            : }
     136                 :            : 
     137                 :            : /* Return the current username for this fko context.
     138                 :            : */
     139                 :            : int
     140                 :       5480 : fko_get_username(fko_ctx_t ctx, char **username)
     141                 :            : {
     142                 :            : 
     143                 :            : #if HAVE_LIBFIU
     144         [ +  + ]:       5480 :     fiu_return_on("fko_get_username_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     145                 :            : #endif
     146                 :            : 
     147                 :            :     /* Must be initialized
     148                 :            :     */
     149 [ +  + ][ +  - ]:       5478 :     if(!CTX_INITIALIZED(ctx))
     150                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     151                 :            : 
     152         [ +  + ]:       5326 :     if(username == NULL)
     153                 :            :         return(FKO_ERROR_INVALID_DATA);
     154                 :            : 
     155                 :            : #if HAVE_LIBFIU
     156         [ +  + ]:       5258 :     fiu_return_on("fko_get_username_val", FKO_ERROR_INVALID_DATA);
     157                 :            : #endif
     158                 :            : 
     159                 :       5256 :     *username = ctx->username;
     160                 :            : 
     161                 :       5256 :     return(FKO_SUCCESS);
     162                 :            : }
     163                 :            : 
     164                 :            : int
     165                 :    1720485 : validate_username(const char *username)
     166                 :            : {
     167                 :            :     int i;
     168                 :            : 
     169 [ +  - ][ +  + ]:    1720485 :     if(username == NULL || strnlen(username, MAX_SPA_USERNAME_SIZE) == 0)
     170                 :            :         return(FKO_ERROR_INVALID_DATA_USER_MISSING);
     171                 :            : 
     172                 :            :     /* Exclude a few chars - this list is consistent with MS guidance since
     173                 :            :      * libfko runs on Windows:
     174                 :            :      *      http://technet.microsoft.com/en-us/library/bb726984.aspx
     175                 :            :     */
     176         [ +  + ]:    9151213 :     for (i=0; i < (int)strnlen(username, MAX_SPA_USERNAME_SIZE); i++)
     177                 :            :     {
     178         [ +  + ]:    7484284 :         if((isalnum(username[i]) == 0)
     179         [ +  + ]:     310401 :                 && ((username[i] < 0x20 || username[i] > 0x7e)
     180                 :            :                 /* Not allowed chars: " / \ [ ] : ; | = , + * ? < >
     181                 :            :                 */
     182         [ +  + ]:     285822 :                 || (username[i] == 0x22
     183                 :     285822 :                     || username[i] == 0x2f
     184         [ +  + ]:     284004 :                     || username[i] == 0x5c
     185         [ +  + ]:     283976 :                     || username[i] == 0x5b
     186         [ +  + ]:     264061 :                     || username[i] == 0x5d
     187         [ +  + ]:     263941 :                     || username[i] == 0x3a
     188         [ +  + ]:     263936 :                     || username[i] == 0x3b
     189         [ +  + ]:     263920 :                     || username[i] == 0x7c
     190         [ +  + ]:     263883 :                     || username[i] == 0x3d
     191         [ +  + ]:     263871 :                     || username[i] == 0x2c
     192         [ +  + ]:     262050 :                     || username[i] == 0x2b
     193         [ +  + ]:     260228 :                     || username[i] == 0x2a
     194         [ +  + ]:     258412 :                     || username[i] == 0x3f
     195         [ +  + ]:     258407 :                     || username[i] == 0x3c
     196         [ +  + ]:     258382 :                     || username[i] == 0x3e)))
     197                 :            :         {
     198         [ +  + ]:      52020 :             if(i == 0)
     199                 :            :             {
     200                 :            :                 return(FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL);
     201                 :            :             }
     202                 :            :             else
     203                 :            :             {
     204                 :      19863 :                 return(FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL);
     205                 :            :             }
     206                 :            :         }
     207                 :            :     }
     208                 :            : 
     209                 :            :     return FKO_SUCCESS;
     210                 :            : }
     211                 :            : 
     212                 :            : /***EOF***/

Generated by: LCOV version 1.10