source3/auth/user_util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Username handling
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 1997-2001.
   6    Copyright (C) Volker Lendecke 2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/filesys.h"
  24 #include "auth.h"
  25
  26 /*******************************************************************
  27  Map a username from a dos name to a unix name by looking in the username
  28  map. Note that this modifies the name in place.
  29  This is the main function that should be called *once* on
  30  any incoming or new username - in order to canonicalize the name.
  31  This is being done to de-couple the case conversions from the user mapping
  32  function. Previously, the map_username was being called
  33  every time Get_Pwnam_alloc was called.
  34  Returns True if username was changed, false otherwise.
  35 ********************************************************************/
  36
  37 static char *last_from = NULL;
  38 static char *last_to = NULL;
  39
  40 static const char *get_last_from(void)
  41 {
  42         if (!last_from) {
  43                 return "";
  44         }
  45         return last_from;
  46 }
  47
  48 static const char *get_last_to(void)
  49 {
  50         if (!last_to) {
  51                 return "";
  52         }
  53         return last_to;
  54 }
  55
  56 static bool set_last_from_to(const char *from, const char *to)
  57 {
  58         char *orig_from = last_from;
  59         char *orig_to = last_to;
  60
  61         last_from = SMB_STRDUP(from);
  62         last_to = SMB_STRDUP(to);
  63
  64         SAFE_FREE(orig_from);
  65         SAFE_FREE(orig_to);
  66
  67         if (!last_from || !last_to) {
  68                 SAFE_FREE(last_from);
  69                 SAFE_FREE(last_to);
  70                 return false;
  71         }
  72         return true;
  73 }
  74
  75 static char *skip_space(char *s)
  76 {
  77         while (isspace((int)(*s))) {
  78                 s += 1;
  79         }
  80         return s;
  81 }
  82
  83 static bool fetch_map_from_gencache(TALLOC_CTX *ctx,
  84                         const char *user_in,
  85                         char **p_user_out)
  86 {
  87         char *key, *value;
  88         bool found;
  89
  90         if (lp_username_map_cache_time() == 0) {
  91                 return false;
  92         }
  93
  94         key = talloc_asprintf_strupper_m(ctx, "USERNAME_MAP/%s",
  95                                          user_in);
  96         if (key == NULL) {
  97                 return false;
  98         }
  99         found = gencache_get(key, &value, NULL);
 100         TALLOC_FREE(key);
 101         if (!found) {
 102                 return false;
 103         }
 104         TALLOC_FREE(*p_user_out);
 105         *p_user_out = talloc_strdup(ctx, value);
 106         SAFE_FREE(value);
 107         if (!*p_user_out) {
 108                 return false;
 109         }
 110         return true;
 111 }
 112
 113 static void store_map_in_gencache(TALLOC_CTX *ctx, const char *from, const char *to)
 114 {
 115         char *key;
 116         int cache_time = lp_username_map_cache_time();
 117
 118         if (cache_time == 0) {
 119                 return;
 120         }
 121
 122         key = talloc_asprintf_strupper_m(ctx, "USERNAME_MAP/%s",
 123                                          from);
 124         if (key == NULL) {
 125                 return;
 126         }
 127         gencache_set(key, to, cache_time + time(NULL));
 128         TALLOC_FREE(key);
 129 }
 130
 131 /****************************************************************************
 132  Check if a user is in a netgroup user list. If at first we don't succeed,
 133  try lower case.
 134 ****************************************************************************/
 135
 136 bool user_in_netgroup(TALLOC_CTX *ctx, const char *user, const char *ngname)
 137 {
 138 #ifdef HAVE_NETGROUP
 139         static char *my_yp_domain = NULL;
 140         char *lowercase_user = NULL;
 141
 142         if (my_yp_domain == NULL) {
 143                 yp_get_default_domain(&my_yp_domain);
 144         }
 145
 146         if (my_yp_domain == NULL) {
 147                 DEBUG(5,("Unable to get default yp domain, "
 148                         "let's try without specifying it\n"));
 149         }
 150
 151         DEBUG(5,("looking for user %s of domain %s in netgroup %s\n",
 152                 user, my_yp_domain?my_yp_domain:"(ANY)", ngname));
 153
 154         if (innetgr(ngname, NULL, user, my_yp_domain)) {
 155                 DEBUG(5,("user_in_netgroup: Found\n"));
 156                 return true;
 157         }
 158
 159         /*
 160          * Ok, innetgr is case sensitive. Try once more with lowercase
 161          * just in case. Attempt to fix #703. JRA.
 162          */
 163         lowercase_user = talloc_strdup(ctx, user);
 164         if (!lowercase_user) {
 165                 return false;
 166         }
 167         if (!strlower_m(lowercase_user)) {
 168                 return false;
 169         }
 170
 171         if (strcmp(user,lowercase_user) == 0) {
 172                 /* user name was already lower case! */
 173                 return false;
 174         }
 175
 176         DEBUG(5,("looking for user %s of domain %s in netgroup %s\n",
 177                 lowercase_user, my_yp_domain?my_yp_domain:"(ANY)", ngname));
 178
 179         if (innetgr(ngname, NULL, lowercase_user, my_yp_domain)) {
 180                 DEBUG(5,("user_in_netgroup: Found\n"));
 181                 return true;
 182         }
 183 #endif /* HAVE_NETGROUP */
 184         return false;
 185 }
 186
 187 /****************************************************************************
 188  Check if a user is in a user list - can check combinations of UNIX
 189  and netgroup lists.
 190 ****************************************************************************/
 191
 192 bool user_in_list(TALLOC_CTX *ctx, const char *user,const char **list)
 193 {
 194         if (!list || !*list)
 195                 return False;
 196
 197         DEBUG(10,("user_in_list: checking user %s in list\n", user));
 198
 199         while (*list) {
 200
 201                 DEBUG(10,("user_in_list: checking user |%s| against |%s|\n",
 202                           user, *list));
 203
 204                 /*
 205                  * Check raw username.
 206                  */
 207                 if (strequal(user, *list))
 208                         return(True);
 209
 210                 /*
 211                  * Now check to see if any combination
 212                  * of UNIX and netgroups has been specified.
 213                  */
 214
 215                 if(**list == '@') {
 216                         /*
 217                          * Old behaviour. Check netgroup list
 218                          * followed by UNIX list.
 219                          */
 220                         if(user_in_netgroup(ctx, user, *list +1))
 221                                 return True;
 222                         if(user_in_group(user, *list +1))
 223                                 return True;
 224                 } else if (**list == '+') {
 225
 226                         if((*(*list +1)) == '&') {
 227                                 /*
 228                                  * Search UNIX list followed by netgroup.
 229                                  */
 230                                 if(user_in_group(user, *list +2))
 231                                         return True;
 232                                 if(user_in_netgroup(ctx, user, *list +2))
 233                                         return True;
 234
 235                         } else {
 236
 237                                 /*
 238                                  * Just search UNIX list.
 239                                  */
 240
 241                                 if(user_in_group(user, *list +1))
 242                                         return True;
 243                         }
 244
 245                 } else if (**list == '&') {
 246
 247                         if(*(*list +1) == '+') {
 248                                 /*
 249                                  * Search netgroup list followed by UNIX list.
 250                                  */
 251                                 if(user_in_netgroup(ctx, user, *list +2))
 252                                         return True;
 253                                 if(user_in_group(user, *list +2))
 254                                         return True;
 255                         } else {
 256                                 /*
 257                                  * Just search netgroup list.
 258                                  */
 259                                 if(user_in_netgroup(ctx, user, *list +1))
 260                                         return True;
 261                         }
 262                 }
 263
 264                 list++;
 265         }
 266         return(False);
 267 }
 268
 269 bool map_username(TALLOC_CTX *ctx, const char *user_in, char **p_user_out)
 270 {
 271         XFILE *f;
 272         char *mapfile = lp_username_map(talloc_tos());
 273         char *s;
 274         char buf[512];
 275         bool mapped_user = False;
 276         char *cmd = lp_username_map_script(talloc_tos());
 277
 278         *p_user_out = NULL;
 279
 280         if (!user_in)
 281                 return false;
 282
 283         /* Initially make a copy of the incoming name. */
 284         *p_user_out = talloc_strdup(ctx, user_in);
 285         if (!*p_user_out) {
 286                 return false;
 287         }
 288
 289         if (strequal(user_in,get_last_to()))
 290                 return false;
 291
 292         if (strequal(user_in,get_last_from())) {
 293                 DEBUG(3,("Mapped user %s to %s\n",user_in,get_last_to()));
 294                 TALLOC_FREE(*p_user_out);
 295                 *p_user_out = talloc_strdup(ctx, get_last_to());
 296                 return true;
 297         }
 298
 299         if (fetch_map_from_gencache(ctx, user_in, p_user_out)) {
 300                 return true;
 301         }
 302
 303         /* first try the username map script */
 304
 305         if ( *cmd ) {
 306                 char **qlines;
 307                 char *command = NULL;
 308                 int numlines, ret, fd;
 309
 310                 command = talloc_asprintf(ctx,
 311                                         "%s \"%s\"",
 312                                         cmd,
 313                                         user_in);
 314                 if (!command) {
 315                         return false;
 316                 }
 317
 318                 DEBUG(10,("Running [%s]\n", command));
 319                 ret = smbrun(command, &fd);
 320                 DEBUGADD(10,("returned [%d]\n", ret));
 321
 322                 TALLOC_FREE(command);
 323
 324                 if ( ret != 0 ) {
 325                         if (fd != -1)
 326                                 close(fd);
 327                         return False;
 328                 }
 329
 330                 numlines = 0;
 331                 qlines = fd_lines_load(fd, &numlines, 0, ctx);
 332                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
 333                 close(fd);
 334
 335                 /* should be either no lines or a single line with the mapped username */
 336
 337                 if (numlines && qlines) {
 338                         DEBUG(3,("Mapped user %s to %s\n", user_in, qlines[0] ));
 339                         set_last_from_to(user_in, qlines[0]);
 340                         store_map_in_gencache(ctx, user_in, qlines[0]);
 341                         TALLOC_FREE(*p_user_out);
 342                         *p_user_out = talloc_strdup(ctx, qlines[0]);
 343                         if (!*p_user_out) {
 344                                 return false;
 345                         }
 346                 }
 347
 348                 TALLOC_FREE(qlines);
 349
 350                 return numlines != 0;
 351         }
 352
 353         /* ok.  let's try the mapfile */
 354         if (!*mapfile)
 355                 return False;
 356
 357         f = x_fopen(mapfile,O_RDONLY, 0);
 358         if (!f) {
 359                 DEBUG(0,("can't open username map %s. Error %s\n",mapfile, strerror(errno) ));
 360                 return False;
 361         }
 362
 363         DEBUG(4,("Scanning username map %s\n",mapfile));
 364
 365         while((s=fgets_slash(buf,sizeof(buf),f))!=NULL) {
 366                 char *unixname = s;
 367                 char *dosname = strchr_m(unixname,'=');
 368                 char **dosuserlist;
 369                 bool return_if_mapped = False;
 370
 371                 if (!dosname)
 372                         continue;
 373
 374                 *dosname++ = 0;
 375
 376                 unixname = skip_space(unixname);
 377
 378                 if ('!' == *unixname) {
 379                         return_if_mapped = True;
 380                         unixname = skip_space(unixname+1);
 381                 }
 382
 383                 if (!*unixname || strchr_m("#;",*unixname))
 384                         continue;
 385
 386                 {
 387                         int l = strlen(unixname);
 388                         while (l && isspace((int)unixname[l-1])) {
 389                                 unixname[l-1] = 0;
 390                                 l--;
 391                         }
 392                 }
 393
 394                 /* skip lines like 'user = ' */
 395
 396                 dosuserlist = str_list_make_v3(ctx, dosname, NULL);
 397                 if (!dosuserlist) {
 398                         DEBUG(0,("Bad username map entry.  Unable to build user list.  Ignoring.\n"));
 399                         continue;
 400                 }
 401
 402                 if (strchr_m(dosname,'*') ||
 403                     user_in_list(ctx, user_in, (const char **)dosuserlist)) {
 404                         DEBUG(3,("Mapped user %s to %s\n",user_in,unixname));
 405                         mapped_user = True;
 406
 407                         set_last_from_to(user_in, unixname);
 408                         store_map_in_gencache(ctx, user_in, unixname);
 409                         TALLOC_FREE(*p_user_out);
 410                         *p_user_out = talloc_strdup(ctx, unixname);
 411                         if (!*p_user_out) {
 412                                 TALLOC_FREE(dosuserlist);
 413                                 x_fclose(f);
 414                                 return false;
 415                         }
 416
 417                         if ( return_if_mapped ) {
 418                                 TALLOC_FREE(dosuserlist);
 419                                 x_fclose(f);
 420                                 return True;
 421                         }
 422                 }
 423
 424                 TALLOC_FREE(dosuserlist);
 425         }
 426
 427         x_fclose(f);
 428
 429         /*
 430          * If we didn't successfully map a user in the loop above,
 431          * setup the last_from and last_to as an optimization so
 432          * that we don't scan the file again for the same user.
 433          */
 434         if (!mapped_user) {
 435                 DEBUG(8, ("The user '%s' has no mapping. "
 436                           "Skip it next time.\n", user_in));
 437                 set_last_from_to(user_in, user_in);
 438                 store_map_in_gencache(ctx, user_in, user_in);
 439         }
 440
 441         return mapped_user;
 442 }