LCOV - code coverage report
Current view: top level - server - utils.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 63 69 91.3 %
Date: 2014-11-16 Functions: 6 6 100.0 %
Branches: 42 54 77.8 %

           Branch data     Line data    Source code
       1                 :            : /**
       2                 :            :  * @file    utils.c
       3                 :            :  *
       4                 :            :  * @brief   General/Generic functions for the fwknop server.
       5                 :            :  *
       6                 :            :  *  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
       7                 :            :  *  Copyright (C) 2009-2014 fwknop developers and contributors. For a full
       8                 :            :  *  list of contributors, see the file 'CREDITS'.
       9                 :            :  *
      10                 :            :  *  License (GNU General Public License):
      11                 :            :  *
      12                 :            :  *  This program is free software; you can redistribute it and/or
      13                 :            :  *  modify it under the terms of the GNU General Public License
      14                 :            :  *  as published by the Free Software Foundation; either version 2
      15                 :            :  *  of the License, or (at your option) any later version.
      16                 :            :  *
      17                 :            :  *  This program is distributed in the hope that it will be useful,
      18                 :            :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      19                 :            :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      20                 :            :  *  GNU General Public License for more details.
      21                 :            :  *
      22                 :            :  *  You should have received a copy of the GNU General Public License
      23                 :            :  *  along with this program; if not, write to the Free Software
      24                 :            :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
      25                 :            :  *  USA
      26                 :            :  */
      27                 :            : 
      28                 :            : #include "fwknopd_common.h"
      29                 :            : #include "utils.h"
      30                 :            : #include "log_msg.h"
      31                 :            : #include <stdarg.h>
      32                 :            : 
      33                 :            : #define ASCII_LEN 16
      34                 :            : 
      35                 :            : /* Generic hex dump function.
      36                 :            : */
      37                 :            : void
      38                 :        109 : hex_dump(const unsigned char *data, const int size)
      39                 :            : {
      40                 :        109 :     int ln=0, i=0, j=0;
      41                 :        109 :     char ascii_str[ASCII_LEN+1] = {0};
      42                 :            : 
      43         [ +  + ]:      18163 :     for(i=0; i<size; i++)
      44                 :            :     {
      45         [ +  + ]:      18054 :         if((i % ASCII_LEN) == 0)
      46                 :            :         {
      47                 :            :             printf(" %s\n  0x%.4x:  ", ascii_str, i);
      48                 :            :             memset(ascii_str, 0x0, ASCII_LEN-1);
      49                 :       1221 :             j = 0;
      50                 :            :         }
      51                 :            : 
      52                 :      18054 :         printf("%.2x ", data[i]);
      53                 :            : 
      54         [ +  + ]:      18054 :         ascii_str[j++] = (data[i] < 0x20 || data[i] > 0x7e) ? '.' : data[i];
      55                 :            : 
      56         [ +  + ]:      18054 :         if(j == 8)
      57                 :            :             printf(" ");
      58                 :            :     }
      59                 :            : 
      60                 :            :     /* Remainder...
      61                 :            :     */
      62                 :        109 :     ln = strlen(ascii_str);
      63         [ +  - ]:        109 :     if(ln > 0)
      64                 :            :     {
      65         [ +  + ]:       1591 :         for(i=0; i < ASCII_LEN-ln; i++)
      66                 :            :             printf("   ");
      67         [ +  + ]:        109 :         if(ln < 8)
      68                 :            :             printf(" ");
      69                 :            : 
      70                 :            :         printf(" %s\n\n", ascii_str);
      71                 :            :     }
      72                 :        109 :     return;
      73                 :            : }
      74                 :            : 
      75                 :            : /* Basic directory checks (stat() and whether the path is actually
      76                 :            :  * a directory).
      77                 :            : */
      78                 :            : int
      79                 :         76 : is_valid_dir(const char *path)
      80                 :            : {
      81                 :            : #if HAVE_STAT
      82                 :            :     struct stat st;
      83                 :            : 
      84                 :            :     /* If we are unable to stat the given dir, then return with error.
      85                 :            :     */
      86         [ +  + ]:         76 :     if(stat(path, &st) != 0)
      87                 :            :     {
      88                 :          3 :         log_msg(LOG_ERR, "[-] unable to stat() directory: %s: %s",
      89                 :          3 :             path, strerror(errno));
      90                 :          3 :         return(0);
      91                 :            :     }
      92                 :            : 
      93         [ +  - ]:         73 :     if(!S_ISDIR(st.st_mode))
      94                 :            :         return(0);
      95                 :            : #endif /* HAVE_STAT */
      96                 :            : 
      97                 :         73 :     return(1);
      98                 :            : }
      99                 :            : 
     100                 :            : int
     101                 :      15908 : verify_file_perms_ownership(const char *file)
     102                 :            : {
     103                 :            : #if HAVE_STAT
     104                 :            :     struct stat st;
     105                 :            : 
     106                 :            :     /* Every file that fwknopd deals with should be owned
     107                 :            :      * by the user and permissions set to 600 (user read/write)
     108                 :            :     */
     109         [ +  - ]:      15908 :     if((stat(file, &st)) == 0)
     110                 :            :     {
     111                 :            :         /* Make sure it is a regular file
     112                 :            :         */
     113         [ +  + ]:      15908 :         if(S_ISREG(st.st_mode) != 1 && S_ISLNK(st.st_mode) != 1)
     114                 :            :         {
     115                 :          1 :             log_msg(LOG_WARNING,
     116                 :            :                 "[-] file: %s is not a regular file or symbolic link.",
     117                 :            :                 file
     118                 :            :             );
     119                 :          1 :             return 0;
     120                 :            :         }
     121                 :            : 
     122         [ +  + ]:      15907 :         if((st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO)) != (S_IRUSR|S_IWUSR))
     123                 :            :         {
     124                 :        217 :             log_msg(LOG_WARNING,
     125                 :            :                 "[-] file: %s permissions should only be user read/write (0600, -rw-------)",
     126                 :            :                 file
     127                 :            :             );
     128                 :            :             /* when we start in enforcing this instead of just warning
     129                 :            :              * the user
     130                 :            :             res = 0;
     131                 :            :             */
     132                 :            :         }
     133                 :            : 
     134         [ +  + ]:      15907 :         if(st.st_uid != getuid())
     135                 :            :         {
     136                 :      11840 :             log_msg(LOG_WARNING, "[-] file: %s not owned by current effective user id",
     137                 :            :                 file);
     138                 :            :             /* when we start in enforcing this instead of just warning
     139                 :            :              * the user
     140                 :            :             res = 0;
     141                 :            :             */
     142                 :            :         }
     143                 :            :     }
     144                 :            :     else
     145                 :            :     {
     146                 :            :         /* if the path doesn't exist, just return, but otherwise something
     147                 :            :          * went wrong
     148                 :            :         */
     149         [ #  # ]:          0 :         if(errno != ENOENT)
     150                 :            :         {
     151                 :          0 :             log_msg(LOG_ERR, "[-] stat() against file: %s returned: %s",
     152                 :            :                 file, strerror(errno));
     153                 :          0 :             return 0;
     154                 :            :         }
     155                 :            :     }
     156                 :            : 
     157                 :            : #endif
     158                 :            : 
     159                 :            :     return 1;
     160                 :            : }
     161                 :            : 
     162                 :            : static int
     163                 :      81815 : add_argv(char **argv_new, int *argc_new,
     164                 :            :         const char *new_arg, const fko_srv_options_t * const opts)
     165                 :            : {
     166                 :      81815 :     int buf_size = 0;
     167                 :            : 
     168         [ +  + ]:      81815 :     if(opts->verbose > 3)
     169                 :       1105 :         log_msg(LOG_INFO, "[+] add_argv() + arg: %s", new_arg);
     170                 :            : 
     171                 :      81815 :     buf_size = strlen(new_arg) + 1;
     172                 :      81815 :     argv_new[*argc_new] = calloc(1, buf_size);
     173                 :            : 
     174         [ -  + ]:      81815 :     if(argv_new[*argc_new] == NULL)
     175                 :            :     {
     176                 :          0 :         log_msg(LOG_INFO, "[*] Memory allocation error.");
     177                 :            :         return 0;
     178                 :            :     }
     179                 :      81815 :     strlcpy(argv_new[*argc_new], new_arg, buf_size);
     180                 :            : 
     181                 :      81815 :     *argc_new += 1;
     182                 :            : 
     183         [ +  + ]:      81815 :     if(*argc_new >= MAX_CMDLINE_ARGS-1)
     184                 :            :     {
     185                 :          2 :         log_msg(LOG_ERR, "[*] max command line args exceeded.");
     186                 :            :         return 0;
     187                 :            :     }
     188                 :            : 
     189                 :      81813 :     argv_new[*argc_new] = NULL;
     190                 :            : 
     191                 :            :     return 1;
     192                 :            : }
     193                 :            : 
     194                 :            : int
     195                 :      10870 : strtoargv(const char * const args_str, char **argv_new, int *argc_new,
     196                 :      81815 :         const fko_srv_options_t * const opts)
     197                 :            : {
     198                 :      10870 :     int       current_arg_ctr = 0, i;
     199                 :      10870 :     char      arg_tmp[MAX_LINE_LEN] = {0};
     200                 :            : 
     201         [ +  + ]:     594463 :     for (i=0; i < (int)strlen(args_str); i++)
     202                 :            :     {
     203         [ +  + ]:     583595 :         if (!isspace(args_str[i]))
     204                 :            :         {
     205                 :     512648 :             arg_tmp[current_arg_ctr] = args_str[i];
     206                 :     512648 :             current_arg_ctr++;
     207                 :            :         }
     208                 :            :         else
     209                 :            :         {
     210         [ +  - ]:      70947 :             if(current_arg_ctr > 0)
     211                 :            :             {
     212                 :      70947 :                 arg_tmp[current_arg_ctr] = '\0';
     213         [ +  + ]:      70947 :                 if (add_argv(argv_new, argc_new, arg_tmp, opts) != 1)
     214                 :            :                 {
     215                 :          2 :                     free_argv(argv_new, argc_new);
     216                 :          2 :                     return 0;
     217                 :            :                 }
     218                 :            :                 current_arg_ctr = 0;
     219                 :            :             }
     220                 :            :         }
     221                 :            :     }
     222                 :            : 
     223                 :            :     /* pick up the last argument in the string
     224                 :            :     */
     225         [ +  - ]:      10868 :     if(current_arg_ctr > 0)
     226                 :            :     {
     227                 :      10868 :         arg_tmp[current_arg_ctr] = '\0';
     228         [ -  + ]:      10868 :         if (add_argv(argv_new, argc_new, arg_tmp, opts) != 1)
     229                 :            :         {
     230                 :          0 :             free_argv(argv_new, argc_new);
     231                 :          0 :             return 0;
     232                 :            :         }
     233                 :            :     }
     234                 :            :     return 1;
     235                 :            : }
     236                 :            : 
     237                 :            : void
     238                 :      10870 : free_argv(char **argv_new, int *argc_new)
     239                 :            : {
     240                 :            :     int i;
     241                 :            : 
     242 [ +  - ][ +  - ]:      10870 :     if(argv_new == NULL || *argv_new == NULL)
     243                 :            :         return;
     244                 :            : 
     245         [ +  + ]:      92685 :     for (i=0; i < *argc_new; i++)
     246                 :            :     {
     247         [ +  - ]:      81815 :         if(argv_new[i] == NULL)
     248                 :            :             break;
     249                 :            :         else
     250                 :      81815 :             free(argv_new[i]);
     251                 :            :     }
     252                 :            :     return;
     253                 :            : }
     254                 :            : 
     255                 :            : /***EOF***/

Generated by: LCOV version 1.10