source/lib/util_pwdb.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Password and authentication handling
   5    Copyright (C) Jeremy Allison 1996-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "nterr.h"
  25 #include "sids.h"
  26
  27 extern int DEBUGLEVEL;
  28
  29 extern fstring global_myworkgroup;
  30
  31 extern pstring global_myname;
  32
  33 typedef struct
  34 {
  35         uint32 rid;
  36         char *defaultname;
  37         char *name;
  38 } rid_name;
  39
  40 /*
  41  * A list of the rids of well known BUILTIN and Domain users
  42  * and groups.
  43  */
  44
  45 static rid_name builtin_alias_rids[] =
  46 {
  47     { BUILTIN_ALIAS_RID_ADMINS       , "Administrators"    , NULL },
  48     { BUILTIN_ALIAS_RID_USERS        , "Users"             , NULL },
  49     { BUILTIN_ALIAS_RID_GUESTS       , "Guests"            , NULL },
  50     { BUILTIN_ALIAS_RID_POWER_USERS  , "Power Users"       , NULL },
  51
  52     { BUILTIN_ALIAS_RID_ACCOUNT_OPS  , "Account Operators" , NULL },
  53     { BUILTIN_ALIAS_RID_SYSTEM_OPS   , "System Operators"  , NULL },
  54     { BUILTIN_ALIAS_RID_PRINT_OPS    , "Print Operators"   , NULL },
  55     { BUILTIN_ALIAS_RID_BACKUP_OPS   , "Backup Operators"  , NULL },
  56     { BUILTIN_ALIAS_RID_REPLICATOR   , "Replicator"        , NULL },
  57     { 0                              , NULL                , NULL}
  58 };
  59
  60 /* array lookup of well-known Domain RID users. */
  61 static rid_name domain_user_rids[] =
  62 {
  63     { DOMAIN_USER_RID_ADMIN         , "Administrator" , NULL },
  64     { DOMAIN_USER_RID_GUEST         , "Guest"         , NULL },
  65     { 0                             , NULL            , NULL}
  66 };
  67
  68 /* array lookup of well-known Domain RID groups. */
  69 static rid_name domain_group_rids[] =
  70 {
  71     { DOMAIN_GROUP_RID_ADMINS       , "Domain Admins" , NULL },
  72     { DOMAIN_GROUP_RID_USERS        , "Domain Users"  , NULL },
  73     { DOMAIN_GROUP_RID_GUESTS       , "Domain Guests" , NULL },
  74     { 0                             , NULL            , NULL}
  75 };
  76
  77 /*******************************************************************
  78   make an entry in wk name map
  79   the name is strdup()ed!
  80  *******************************************************************/
  81 static BOOL make_alias_entry(rid_name *map, char *defaultname, char *name)
  82 {
  83         if(isdigit(*defaultname))
  84         {
  85                 long rid = -1;
  86                 char *s;
  87
  88                 if(*defaultname == '0')
  89                 {
  90                         if(defaultname[1] == 'x')
  91                         {
  92                                 s = "%lx";
  93                                 defaultname += 2;
  94                         }
  95                         else
  96                         {
  97                                 s = "%lo";
  98                         }
  99                 }
 100                 else
 101                 {
 102                         s = "%ld";
 103                 }
 104
 105                 sscanf(defaultname, s, &rid);
 106
 107                 for( ; map->rid; map++)
 108                 {
 109                         if(map->rid == rid) {
 110                                 map->name = strdup(name);
 111                                 DEBUG(5, ("make_alias_entry: mapping %s (rid 0x%x) to %s\n",
 112                                       map->defaultname, map->rid, map->name));
 113                                 return True;
 114                         }
 115                 }
 116                 return False;
 117         }
 118
 119         for( ; map->rid; map++)
 120         {
 121                 if(!StrCaseCmp(map->name, defaultname)) {
 122                         map->name = strdup(name);
 123                         DEBUG(5, ("make_alias_entry: mapping %s (rid 0x%x) to %s\n",
 124                               map->defaultname, map->rid, map->name));
 125                         return True;
 126                 }
 127         }
 128         return False;
 129 }
 130
 131 /*******************************************************************
 132   reset wk map to default values
 133  *******************************************************************/
 134 static void reset_wk_map(rid_name *map)
 135 {
 136         for( ; map->rid; map++)
 137         {
 138                 if(map->name != NULL && map->name != map->defaultname)
 139                         free(map->name);
 140                 map->name = map->defaultname;
 141         }
 142 }
 143
 144 /*******************************************************************
 145   reset all wk maps
 146  *******************************************************************/
 147 static void reset_wk_maps(void)
 148 {
 149         DEBUG(4, ("reset_wk_maps: Initializing maps\n"));
 150         reset_wk_map(builtin_alias_rids);
 151         reset_wk_map(domain_user_rids);
 152         reset_wk_map(domain_group_rids);
 153 }
 154
 155 /*******************************************************************
 156   Load builtin alias map
 157  *******************************************************************/
 158 static BOOL load_wk_rid_map(void)
 159 {
 160         static int map_initialized = 0;
 161         static time_t builtin_rid_file_last_modified = (time_t)0;
 162         char *builtin_rid_file = lp_builtinrid_file();
 163
 164         FILE *fp;
 165         char *s;
 166         pstring buf;
 167
 168         if (!map_initialized)
 169         {
 170                 reset_wk_maps();
 171                 map_initialized = 1;
 172         }
 173
 174         if (!*builtin_rid_file)
 175         {
 176                 return False;
 177         }
 178
 179         fp = open_file_if_modified(builtin_rid_file, "r", &builtin_rid_file_last_modified);
 180         if(!fp)
 181         {
 182                 DEBUG(0,("load_wk_rid_map: can't open name map %s. Error was %s\n",
 183                           builtin_rid_file, strerror(errno)));
 184                  return False;
 185         }
 186
 187         reset_wk_maps();
 188         DEBUG(4,("load_wk_rid_map: Scanning builtin rid map %s\n",builtin_rid_file));
 189
 190         while ((s = fgets_slash(buf, sizeof(buf), fp)) != NULL)
 191         {
 192                 pstring defaultname;
 193                 pstring name;
 194
 195                 DEBUG(10,("Read line |%s|\n", s));
 196
 197                 if (!*s || strchr("#;",*s))
 198                         continue;
 199
 200                 if (!next_token(&s,name, "\t\n\r=", sizeof(defaultname)))
 201                         continue;
 202
 203                 if (!next_token(&s,defaultname, "\t\n\r=", sizeof(name)))
 204                         continue;
 205
 206                 trim_string(defaultname, " ", " ");
 207                 trim_string(name, " ", " ");
 208
 209                 if (!*defaultname || !*name)
 210                         continue;
 211
 212                 if(make_alias_entry(builtin_alias_rids, defaultname, name))
 213                         continue;
 214                 if(make_alias_entry(domain_user_rids, defaultname, name))
 215                         continue;
 216                 if(make_alias_entry(domain_group_rids, defaultname, name))
 217                         continue;
 218
 219                 DEBUG(0,("load_wk_rid_map: Unknown alias %s in map %s\n",
 220                          defaultname, builtin_rid_file));
 221         }
 222
 223         fclose(fp);
 224         return True;
 225 }
 226
 227 /*******************************************************************
 228  lookup_wk_group_name
 229  ********************************************************************/
 230 uint32 lookup_wk_group_name(const char *group_name, const char *domain,
 231                                 DOM_SID *sid, uint32 *type)
 232 {
 233         char *grp_name;
 234         int i = -1; /* start do loop at -1 */
 235         uint32 rid;
 236
 237         if (strequal(domain, global_sam_name))
 238         {
 239                 sid_copy(sid, &global_sam_sid);
 240         }
 241         else if (strequal(domain, "BUILTIN"))
 242         {
 243                 sid_copy(sid, global_sid_builtin);
 244         }
 245         else
 246         {
 247                 return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 248         }
 249
 250         load_wk_rid_map();
 251
 252         do /* find, if it exists, a group rid for the group name */
 253         {
 254                 i++;
 255                 rid      = domain_group_rids[i].rid;
 256                 grp_name = domain_group_rids[i].name;
 257
 258                 if (strequal(grp_name, group_name))
 259                 {
 260                         sid_append_rid(sid, rid);
 261                         (*type) = SID_NAME_DOM_GRP;
 262
 263                         return 0x0;
 264                 }
 265
 266         } while (grp_name != NULL);
 267
 268         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 269 }
 270
 271 /*******************************************************************
 272  lookup_wk_user_name
 273  ********************************************************************/
 274 uint32 lookup_wk_user_name(const char *user_name, const char *domain,
 275                                 DOM_SID *sid, uint32 *type)
 276 {
 277         char *usr_name;
 278         int i = -1; /* start do loop at -1 */
 279
 280         if (strequal(domain, global_sam_name))
 281         {
 282                 sid_copy(sid, &global_sam_sid);
 283         }
 284         else if (strequal(domain, "BUILTIN"))
 285         {
 286                 sid_copy(sid, global_sid_builtin);
 287         }
 288         else
 289         {
 290                 return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 291         }
 292
 293         load_wk_rid_map();
 294
 295         do /* find, if it exists, a alias rid for the alias name */
 296         {
 297                 i++;
 298                 usr_name = domain_user_rids[i].name;
 299
 300         } while (usr_name != NULL && !strequal(usr_name, user_name));
 301
 302         if (usr_name != NULL)
 303         {
 304                 sid_append_rid(sid, domain_user_rids[i].rid);
 305                 (*type) = SID_NAME_USER;
 306                 return 0;
 307         }
 308
 309         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 310 }
 311
 312 /*******************************************************************
 313  lookup_builtin_alias_name
 314  ********************************************************************/
 315 uint32 lookup_builtin_alias_name(const char *alias_name, const char *domain,
 316                                 DOM_SID *sid, uint32 *type)
 317 {
 318         char *als_name;
 319         int i = 0;
 320         uint32 rid;
 321
 322         if (strequal(domain, "BUILTIN"))
 323         {
 324                 if (sid != NULL)
 325                 {
 326                         sid_copy(sid, global_sid_builtin);
 327                 }
 328         }
 329         else
 330         {
 331                 return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 332         }
 333
 334         load_wk_rid_map();
 335
 336         do /* find, if it exists, a alias rid for the alias name*/
 337         {
 338                 rid      = builtin_alias_rids[i].rid;
 339                 als_name = builtin_alias_rids[i].name;
 340
 341                 if (strequal(als_name, alias_name))
 342                 {
 343                         if (sid != NULL)
 344                         {
 345                                 sid_append_rid(sid, rid);
 346                         }
 347
 348                         if (type != NULL)
 349                         {
 350                                 (*type) = SID_NAME_ALIAS;
 351                         }
 352
 353                         return 0x0;
 354                 }
 355
 356                 i++;
 357
 358         } while (als_name != NULL);
 359
 360         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
 361 }
 362
 363 /*************************************************************
 364  the following functions lookup wk rid's.
 365  these may be unnecessary...
 366 **************************************************************/
 367 static char *lookup_wk_rid(uint32 rid, rid_name *table)
 368 {
 369         load_wk_rid_map();
 370         for( ; table->rid ; table++)
 371         {
 372                 if(table->rid == rid)
 373                 {
 374                         return table->name;
 375                 }
 376         }
 377         return NULL;
 378 }
 379
 380 char *lookup_wk_alias_rid(uint32 rid)
 381 {
 382         return lookup_wk_rid(rid, builtin_alias_rids);
 383 }
 384
 385 char *lookup_wk_user_rid(uint32 rid)
 386 {
 387         return lookup_wk_rid(rid, domain_user_rids);
 388 }
 389
 390 char *lookup_wk_group_rid(uint32 rid)
 391 {
 392         return lookup_wk_rid(rid, domain_group_rids);
 393 }