lib/roken/getuserinfo.c

   1 /*
   2  * Copyright (c) 2017 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include <config.h>
  35 #include "roken.h"
  36
  37 #ifdef WIN32
  38 #include <Shlobj.h>  // need to include definitions of constants
  39 #define SECURITY_WIN32
  40 #include <security.h>
  41 #else
  42 #include <sys/types.h>
  43 #include <pwd.h>
  44 #include <unistd.h>
  45 #endif
  46
  47 /**
  48  * Returns the user's SHELL.
  49  */
  50 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
  51 roken_get_shell(char *shell, size_t shellsz)
  52 {
  53     char *p;
  54
  55 #ifndef WIN32
  56     char user[128];
  57     const char *username = roken_get_username(user, sizeof(user));
  58     size_t buflen = 2048;
  59
  60     if (sysconf(_SC_GETPW_R_SIZE_MAX) > 0)
  61         buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
  62
  63     if (issuid())
  64         return "/bin/sh";
  65
  66     p = secure_getenv("SHELL");
  67     if (p != NULL && p[0] != '\0') {
  68         if (strlcpy(shell, p, shellsz) < shellsz)
  69             return shell;
  70         errno = ERANGE;
  71         return NULL;
  72     }
  73
  74 #ifdef HAVE_GETPWNAM_R
  75     {
  76         struct passwd pwd;
  77         struct passwd *pwdp;
  78         char buf[buflen];
  79
  80         if (getpwnam_r(username, &pwd, buf, buflen, &pwdp) == 0 &&
  81             pwdp != NULL && pwdp->pw_shell != NULL) {
  82             if (strlcpy(shell, pwdp->pw_shell, shellsz) < shellsz)
  83                 return shell;
  84             errno = ERANGE;
  85             return NULL;
  86         }
  87     }
  88 #endif
  89     errno = 0;
  90     return "/bin/sh";
  91 #else
  92     /* Windows */
  93     p = getenv("SHELL");
  94     if (p != NULL && p[0] != '\0') {
  95         if (strlcpy(shell, p, shellsz) < shellsz)
  96             return shell;
  97         errno = ERANGE;
  98         return NULL;
  99     }
 100     errno = 0;
 101     return NULL;
 102 #endif
 103 }
 104
 105 /**
 106  * Returns the home directory.
 107  */
 108 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
 109 roken_get_homedir(char *home, size_t homesz)
 110 {
 111     char *p;
 112
 113 #ifdef WIN32
 114     if (homesz < MAX_PATH) {
 115         errno = ERANGE;
 116         return NULL;
 117     }
 118
 119     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PROFILE, NULL,
 120                                   SHGFP_TYPE_CURRENT, home)))
 121         return home;
 122
 123     if ((p = getenv("HOMEDRIVE")) != NULL && p[0] != '\0') {
 124         if (strlcpy(home, p, homesz) >= homesz) {
 125             errno = ERANGE;
 126             return NULL;
 127         }
 128         if ((p = getenv("HOMEPATH")) != NULL) {
 129             if (strlcat(home, p, homesz) < homesz)
 130                 return home;
 131             errno = ERANGE;
 132             return NULL;
 133         }
 134         return home;
 135     }
 136     /* Fallthru to return NULL */
 137 #else
 138     char user[128];
 139     const char *username = roken_get_username(user, sizeof(user));
 140     size_t buflen = 2048;
 141
 142     if (sysconf(_SC_GETPW_R_SIZE_MAX) > 0)
 143         buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 144
 145     if (issuid()) {
 146         errno = 0;
 147         return NULL;
 148     }
 149
 150     p = secure_getenv("HOME");
 151     if (p != NULL && p[0] != '\0') {
 152         if (strlcpy(home, p, homesz) < homesz)
 153             return home;
 154         errno = ERANGE;
 155         return NULL;
 156     }
 157
 158 #ifdef HAVE_GETPWNAM_R
 159     if (username) {
 160         struct passwd pwd;
 161         struct passwd *pwdp;
 162         char buf[buflen];
 163
 164         if (getpwnam_r(username, &pwd, buf, buflen, &pwdp) == 0 &&
 165             pwdp != NULL && pwdp->pw_dir != NULL) {
 166             if (strlcpy(home, pwdp->pw_dir, homesz) < homesz)
 167                 return home;
 168             errno = ERANGE;
 169             return NULL;
 170         }
 171     }
 172 #endif
 173 #endif
 174     errno = 0;
 175     return NULL;
 176 }
 177
 178 /**
 179  * Returns the home directory on Unix, or the AppData directory on
 180  * Windows.
 181  */
 182 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
 183 roken_get_appdatadir(char *appdata, size_t appdatasz)
 184 {
 185 #ifdef WIN32
 186     char *p;
 187 #endif
 188
 189 #ifndef WIN32
 190     return roken_get_homedir(appdata, appdatasz);
 191 #else
 192     if (appdatasz < MAX_PATH) {
 193         errno = ERANGE;
 194         return NULL;
 195     }
 196
 197     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL,
 198                                   SHGFP_TYPE_CURRENT, appdata)))
 199         return appdata;
 200
 201     if ((p = getenv("APPDATA")) != NULL && p[0] != '\0') {
 202         if (strlcpy(appdata, p, appdatasz) < appdatasz)
 203             return appdata;
 204         errno = ERANGE;
 205         return NULL;
 206     }
 207
 208     errno = 0;
 209     return NULL;
 210 #endif
 211 }
 212
 213 /**
 214  * Return a bare username.  This is used for, e.g., constructing default
 215  * principal names.
 216  *
 217  * On POSIX systems, if the caller is not set-uid-like, then this will return
 218  * the value of the USER or LOGNAME environment variables (in that order of
 219  * preference), else the username found by looking up the effective UID.
 220  */
 221 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
 222 roken_get_username(char *user, size_t usersz)
 223 {
 224     char *p;
 225
 226 #ifdef WIN32
 227     ULONG sz = usersz;
 228
 229     if (GetUserNameEx(NameSamCompatible, user, &sz)) {
 230         /*
 231          * There's no EXTENDED_NAME_FORMAT for "bare username".  We we
 232          * have to parse one.
 233          */
 234         p = strchr(user, '\\');
 235         if (p != NULL) {
 236             p++;
 237             memmove(user, p, strlen(p) + 1);
 238         }
 239         return user;
 240     } else {
 241         DWORD err = GetLastError();
 242         if (err == ERROR_MORE_DATA) {
 243             errno = ERANGE;
 244             return NULL;
 245         }
 246         /* %USERNAME% is generally bare */
 247         p = getenv("USERNAME");
 248         if (p != NULL && p[0] != '\0') {
 249             if (strchr(p, '\\') != NULL)
 250                 p = strchr(p, '\\') + 1;
 251             if (strlcpy(user, p, usersz) < usersz)
 252                 return user;
 253             errno = ERANGE;
 254             return NULL;
 255         }
 256     }
 257 #else
 258     size_t buflen = 2048;
 259
 260     p = secure_getenv("USER");
 261     if (p == NULL || p[0] == '\0')
 262         p = secure_getenv("LOGNAME");
 263     if (p != NULL && p[0] != '\0') {
 264         if (strlcpy(user, p, usersz) < usersz)
 265             return user;
 266         errno = ERANGE;
 267         return NULL;
 268     }
 269
 270 #ifdef HAVE_GETPWUID_R
 271     if (sysconf(_SC_GETPW_R_SIZE_MAX) > 0)
 272         buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 273
 274     {
 275         struct passwd pwd;
 276         struct passwd *pwdp;
 277         char buf[buflen];
 278
 279         if (getpwuid_r(getuid(), &pwd, buf, buflen, &pwdp) == 0 &&
 280             pwdp != NULL && pwdp->pw_name != NULL) {
 281             if (strlcpy(user, pwdp->pw_name, usersz) < usersz)
 282                 return user;
 283             errno = ERANGE;
 284             return NULL;
 285         }
 286     }
 287 #endif
 288 #endif
 289     errno = 0;
 290     return NULL;
 291 }
 292
 293 /**
 294  * Return a bare username.  This is used for, e.g., constructing default
 295  * principal names.
 296  *
 297  * On POSIX systems this returns the name recorded in the system as currently
 298  * logged in on the current terminal.
 299  */
 300 ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
 301 roken_get_loginname(char *user, size_t usersz)
 302 {
 303 #ifdef WIN32
 304     return roken_get_username(user, usersz);
 305 #else
 306 #ifdef HAVE_GETLOGIN_R
 307     if ((errno = getlogin_r(user, usersz)) == 0)
 308         return user;
 309     if (errno != ENOENT)
 310         return NULL;
 311 #else
 312 #ifdef HAVE_GETLOGIN
 313     if ((p = getlogin()) != NULL && p[0] != '\0') {
 314         if (strlcpy(user, p, usersz) < usersz)
 315             return user;
 316         errno = ERANGE;
 317         return NULL;
 318     }
 319     if (errno != ENOENT)
 320         return NULL;
 321 #endif
 322 #endif
 323     errno = 0;
 324     return NULL;
 325 #endif
 326 }