source3/passdb/pdb_get_set.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    struct samu access routines
   4    Copyright (C) Jeremy Allison                 1996-2001
   5    Copyright (C) Luke Kenneth Casson Leighton   1996-1998
   6    Copyright (C) Gerald (Jerry) Carter          2000-2006
   7    Copyright (C) Andrew Bartlett                2001-2002
   8    Copyright (C) Stefan (metze) Metzmacher      2002
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_PASSDB
  29
  30 /**
  31  * @todo Redefine this to NULL, but this changes the API because
  32  *       much of samba assumes that the pdb_get...() funtions
  33  *       return pstrings.  (ie not null-pointers).
  34  *       See also pdb_fill_default_sam().
  35  */
  36
  37 #define PDB_NOT_QUITE_NULL ""
  38
  39 /*********************************************************************
  40  Collection of get...() functions for struct samu.
  41  ********************************************************************/
  42
  43 uint32 pdb_get_acct_ctrl(const struct samu *sampass)
  44 {
  45         return sampass->acct_ctrl;
  46 }
  47
  48 time_t pdb_get_logon_time(const struct samu *sampass)
  49 {
  50         return sampass->logon_time;
  51 }
  52
  53 time_t pdb_get_logoff_time(const struct samu *sampass)
  54 {
  55         return sampass->logoff_time;
  56 }
  57
  58 time_t pdb_get_kickoff_time(const struct samu *sampass)
  59 {
  60         return sampass->kickoff_time;
  61 }
  62
  63 time_t pdb_get_bad_password_time(const struct samu *sampass)
  64 {
  65         return sampass->bad_password_time;
  66 }
  67
  68 time_t pdb_get_pass_last_set_time(const struct samu *sampass)
  69 {
  70         return sampass->pass_last_set_time;
  71 }
  72
  73 time_t pdb_get_pass_can_change_time(const struct samu *sampass)
  74 {
  75         return sampass->pass_can_change_time;
  76 }
  77
  78 time_t pdb_get_pass_must_change_time(const struct samu *sampass)
  79 {
  80         return sampass->pass_must_change_time;
  81 }
  82
  83 uint16 pdb_get_logon_divs(const struct samu *sampass)
  84 {
  85         return sampass->logon_divs;
  86 }
  87
  88 uint32 pdb_get_hours_len(const struct samu *sampass)
  89 {
  90         return sampass->hours_len;
  91 }
  92
  93 const uint8 *pdb_get_hours(const struct samu *sampass)
  94 {
  95         return (sampass->hours);
  96 }
  97
  98 const uint8 *pdb_get_nt_passwd(const struct samu *sampass)
  99 {
 100         SMB_ASSERT((!sampass->nt_pw.data)
 101                    || sampass->nt_pw.length == NT_HASH_LEN);
 102         return (uint8 *)sampass->nt_pw.data;
 103 }
 104
 105 const uint8 *pdb_get_lanman_passwd(const struct samu *sampass)
 106 {
 107         SMB_ASSERT((!sampass->lm_pw.data)
 108                    || sampass->lm_pw.length == LM_HASH_LEN);
 109         return (uint8 *)sampass->lm_pw.data;
 110 }
 111
 112 const uint8 *pdb_get_pw_history(const struct samu *sampass, uint32 *current_hist_len)
 113 {
 114         SMB_ASSERT((!sampass->nt_pw_his.data)
 115            || ((sampass->nt_pw_his.length % PW_HISTORY_ENTRY_LEN) == 0));
 116         *current_hist_len = sampass->nt_pw_his.length / PW_HISTORY_ENTRY_LEN;
 117         return (uint8 *)sampass->nt_pw_his.data;
 118 }
 119
 120 /* Return the plaintext password if known.  Most of the time
 121    it isn't, so don't assume anything magic about this function.
 122
 123    Used to pass the plaintext to passdb backends that might
 124    want to store more than just the NTLM hashes.
 125 */
 126 const char *pdb_get_plaintext_passwd(const struct samu *sampass)
 127 {
 128         return sampass->plaintext_pw;
 129 }
 130
 131 const DOM_SID *pdb_get_user_sid(const struct samu *sampass)
 132 {
 133         return &sampass->user_sid;
 134 }
 135
 136 const DOM_SID *pdb_get_group_sid(struct samu *sampass)
 137 {
 138         DOM_SID *gsid;
 139         struct passwd *pwd;
 140
 141         /* Return the cached group SID if we have that */
 142         if ( sampass->group_sid ) {
 143                 return sampass->group_sid;
 144         }
 145
 146         /* generate the group SID from the user's primary Unix group */
 147
 148         if ( !(gsid  = TALLOC_P( sampass, DOM_SID )) ) {
 149                 return NULL;
 150         }
 151
 152         /* No algorithmic mapping, meaning that we have to figure out the
 153            primary group SID according to group mapping and the user SID must
 154            be a newly allocated one.  We rely on the user's Unix primary gid.
 155            We have no choice but to fail if we can't find it. */
 156
 157         if ( sampass->unix_pw ) {
 158                 pwd = sampass->unix_pw;
 159         } else {
 160                 pwd = getpwnam_alloc( sampass, pdb_get_username(sampass) );
 161         }
 162
 163         if ( !pwd ) {
 164                 DEBUG(0,("pdb_get_group_sid: Failed to find Unix account for %s\n", pdb_get_username(sampass) ));
 165                 return NULL;
 166         }
 167
 168         if ( pdb_gid_to_sid(pwd->pw_gid, gsid) ) {
 169                 enum SID_NAME_USE type = SID_NAME_UNKNOWN;
 170                 TALLOC_CTX *mem_ctx = talloc_init("pdb_get_group_sid");
 171                 BOOL lookup_ret;
 172
 173                 if (!mem_ctx) {
 174                         return NULL;
 175                 }
 176
 177                 /* Now check that it's actually a domain group and not something else */
 178
 179                 lookup_ret = lookup_sid(mem_ctx, gsid, NULL, NULL, &type);
 180
 181                 TALLOC_FREE( mem_ctx );
 182
 183                 if ( lookup_ret && (type == SID_NAME_DOM_GRP) ) {
 184                         sampass->group_sid = gsid;
 185                         return sampass->group_sid;
 186                 }
 187
 188                 DEBUG(3, ("Primary group for user %s is a %s and not a domain group\n",
 189                         pwd->pw_name, sid_type_lookup(type)));
 190         }
 191
 192         /* Just set it to the 'Domain Users' RID of 512 which will
 193            always resolve to a name */
 194
 195         sid_copy( gsid, get_global_sam_sid() );
 196         sid_append_rid( gsid, DOMAIN_GROUP_RID_USERS );
 197
 198         sampass->group_sid = gsid;
 199
 200         return sampass->group_sid;
 201 }
 202
 203 /**
 204  * Get flags showing what is initalised in the struct samu
 205  * @param sampass the struct samu in question
 206  * @return the flags indicating the members initialised in the struct.
 207  **/
 208
 209 enum pdb_value_state pdb_get_init_flags(const struct samu *sampass, enum pdb_elements element)
 210 {
 211         enum pdb_value_state ret = PDB_DEFAULT;
 212
 213         if (!sampass->change_flags || !sampass->set_flags)
 214                 return ret;
 215
 216         if (bitmap_query(sampass->set_flags, element)) {
 217                 DEBUG(11, ("element %d: SET\n", element));
 218                 ret = PDB_SET;
 219         }
 220
 221         if (bitmap_query(sampass->change_flags, element)) {
 222                 DEBUG(11, ("element %d: CHANGED\n", element));
 223                 ret = PDB_CHANGED;
 224         }
 225
 226         if (ret == PDB_DEFAULT) {
 227                 DEBUG(11, ("element %d: DEFAULT\n", element));
 228         }
 229
 230         return ret;
 231 }
 232
 233 const char *pdb_get_username(const struct samu *sampass)
 234 {
 235         return sampass->username;
 236 }
 237
 238 const char *pdb_get_domain(const struct samu *sampass)
 239 {
 240         return sampass->domain;
 241 }
 242
 243 const char *pdb_get_nt_username(const struct samu *sampass)
 244 {
 245         return sampass->nt_username;
 246 }
 247
 248 const char *pdb_get_fullname(const struct samu *sampass)
 249 {
 250         return sampass->full_name;
 251 }
 252
 253 const char *pdb_get_homedir(const struct samu *sampass)
 254 {
 255         return sampass->home_dir;
 256 }
 257
 258 const char *pdb_get_unix_homedir(const struct samu *sampass)
 259 {
 260         if (sampass->unix_pw ) {
 261                 return sampass->unix_pw->pw_dir;
 262         }
 263         return NULL;
 264 }
 265
 266 const char *pdb_get_dir_drive(const struct samu *sampass)
 267 {
 268         return sampass->dir_drive;
 269 }
 270
 271 const char *pdb_get_logon_script(const struct samu *sampass)
 272 {
 273         return sampass->logon_script;
 274 }
 275
 276 const char *pdb_get_profile_path(const struct samu *sampass)
 277 {
 278         return sampass->profile_path;
 279 }
 280
 281 const char *pdb_get_acct_desc(const struct samu *sampass)
 282 {
 283         return sampass->acct_desc;
 284 }
 285
 286 const char *pdb_get_workstations(const struct samu *sampass)
 287 {
 288         return sampass->workstations;
 289 }
 290
 291 const char *pdb_get_unknown_str(const struct samu *sampass)
 292 {
 293         return sampass->unknown_str;
 294 }
 295
 296 const char *pdb_get_munged_dial(const struct samu *sampass)
 297 {
 298         return sampass->munged_dial;
 299 }
 300
 301 uint16 pdb_get_bad_password_count(const struct samu *sampass)
 302 {
 303         return sampass->bad_password_count;
 304 }
 305
 306 uint16 pdb_get_logon_count(const struct samu *sampass)
 307 {
 308         return sampass->logon_count;
 309 }
 310
 311 uint32 pdb_get_unknown_6(const struct samu *sampass)
 312 {
 313         return sampass->unknown_6;
 314 }
 315
 316 void *pdb_get_backend_private_data(const struct samu *sampass, const struct pdb_methods *my_methods)
 317 {
 318         if (my_methods == sampass->backend_private_methods) {
 319                 return sampass->backend_private_data;
 320         } else {
 321                 return NULL;
 322         }
 323 }
 324
 325 /*********************************************************************
 326  Collection of set...() functions for struct samu.
 327  ********************************************************************/
 328
 329 BOOL pdb_set_acct_ctrl(struct samu *sampass, uint32 acct_ctrl, enum pdb_value_state flag)
 330 {
 331         sampass->acct_ctrl = acct_ctrl;
 332         return pdb_set_init_flags(sampass, PDB_ACCTCTRL, flag);
 333 }
 334
 335 BOOL pdb_set_logon_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 336 {
 337         sampass->logon_time = mytime;
 338         return pdb_set_init_flags(sampass, PDB_LOGONTIME, flag);
 339 }
 340
 341 BOOL pdb_set_logoff_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 342 {
 343         sampass->logoff_time = mytime;
 344         return pdb_set_init_flags(sampass, PDB_LOGOFFTIME, flag);
 345 }
 346
 347 BOOL pdb_set_kickoff_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 348 {
 349         sampass->kickoff_time = mytime;
 350         return pdb_set_init_flags(sampass, PDB_KICKOFFTIME, flag);
 351 }
 352
 353 BOOL pdb_set_bad_password_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 354 {
 355         sampass->bad_password_time = mytime;
 356         return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_TIME, flag);
 357 }
 358
 359 BOOL pdb_set_pass_can_change_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 360 {
 361         sampass->pass_can_change_time = mytime;
 362         return pdb_set_init_flags(sampass, PDB_CANCHANGETIME, flag);
 363 }
 364
 365 BOOL pdb_set_pass_must_change_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 366 {
 367         sampass->pass_must_change_time = mytime;
 368         return pdb_set_init_flags(sampass, PDB_MUSTCHANGETIME, flag);
 369 }
 370
 371 BOOL pdb_set_pass_last_set_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag)
 372 {
 373         sampass->pass_last_set_time = mytime;
 374         return pdb_set_init_flags(sampass, PDB_PASSLASTSET, flag);
 375 }
 376
 377 BOOL pdb_set_hours_len(struct samu *sampass, uint32 len, enum pdb_value_state flag)
 378 {
 379         sampass->hours_len = len;
 380         return pdb_set_init_flags(sampass, PDB_HOURSLEN, flag);
 381 }
 382
 383 BOOL pdb_set_logon_divs(struct samu *sampass, uint16 hours, enum pdb_value_state flag)
 384 {
 385         sampass->logon_divs = hours;
 386         return pdb_set_init_flags(sampass, PDB_LOGONDIVS, flag);
 387 }
 388
 389 /**
 390  * Set flags showing what is initalised in the struct samu
 391  * @param sampass the struct samu in question
 392  * @param flag The *new* flag to be set.  Old flags preserved
 393  *             this flag is only added.
 394  **/
 395
 396 BOOL pdb_set_init_flags(struct samu *sampass, enum pdb_elements element, enum pdb_value_state value_flag)
 397 {
 398         if (!sampass->set_flags) {
 399                 if ((sampass->set_flags =
 400                         bitmap_talloc(sampass,
 401                                         PDB_COUNT))==NULL) {
 402                         DEBUG(0,("bitmap_talloc failed\n"));
 403                         return False;
 404                 }
 405         }
 406         if (!sampass->change_flags) {
 407                 if ((sampass->change_flags =
 408                         bitmap_talloc(sampass,
 409                                         PDB_COUNT))==NULL) {
 410                         DEBUG(0,("bitmap_talloc failed\n"));
 411                         return False;
 412                 }
 413         }
 414
 415         switch(value_flag) {
 416                 case PDB_CHANGED:
 417                         if (!bitmap_set(sampass->change_flags, element)) {
 418                                 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
 419                                 return False;
 420                         }
 421                         if (!bitmap_set(sampass->set_flags, element)) {
 422                                 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
 423                                 return False;
 424                         }
 425                         DEBUG(11, ("element %d -> now CHANGED\n", element));
 426                         break;
 427                 case PDB_SET:
 428                         if (!bitmap_clear(sampass->change_flags, element)) {
 429                                 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
 430                                 return False;
 431                         }
 432                         if (!bitmap_set(sampass->set_flags, element)) {
 433                                 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
 434                                 return False;
 435                         }
 436                         DEBUG(11, ("element %d -> now SET\n", element));
 437                         break;
 438                 case PDB_DEFAULT:
 439                 default:
 440                         if (!bitmap_clear(sampass->change_flags, element)) {
 441                                 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
 442                                 return False;
 443                         }
 444                         if (!bitmap_clear(sampass->set_flags, element)) {
 445                                 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
 446                                 return False;
 447                         }
 448                         DEBUG(11, ("element %d -> now DEFAULT\n", element));
 449                         break;
 450         }
 451
 452         return True;
 453 }
 454
 455 BOOL pdb_set_user_sid(struct samu *sampass, const DOM_SID *u_sid, enum pdb_value_state flag)
 456 {
 457         if (!u_sid)
 458                 return False;
 459
 460         sid_copy(&sampass->user_sid, u_sid);
 461
 462         DEBUG(10, ("pdb_set_user_sid: setting user sid %s\n",
 463                     sid_string_static(&sampass->user_sid)));
 464
 465         return pdb_set_init_flags(sampass, PDB_USERSID, flag);
 466 }
 467
 468 BOOL pdb_set_user_sid_from_string(struct samu *sampass, fstring u_sid, enum pdb_value_state flag)
 469 {
 470         DOM_SID new_sid;
 471
 472         if (!u_sid)
 473                 return False;
 474
 475         DEBUG(10, ("pdb_set_user_sid_from_string: setting user sid %s\n",
 476                    u_sid));
 477
 478         if (!string_to_sid(&new_sid, u_sid)) {
 479                 DEBUG(1, ("pdb_set_user_sid_from_string: %s isn't a valid SID!\n", u_sid));
 480                 return False;
 481         }
 482
 483         if (!pdb_set_user_sid(sampass, &new_sid, flag)) {
 484                 DEBUG(1, ("pdb_set_user_sid_from_string: could not set sid %s on struct samu!\n", u_sid));
 485                 return False;
 486         }
 487
 488         return True;
 489 }
 490
 491 /********************************************************************
 492  We never fill this in from a passdb backend but rather set is
 493  based on the user's primary group membership.  However, the
 494  struct samu* is overloaded and reused in domain memship code
 495  as well and built from the NET_USER_INFO_3 or PAC so we
 496  have to allow the explicitly setting of a group SID here.
 497 ********************************************************************/
 498
 499 BOOL pdb_set_group_sid(struct samu *sampass, const DOM_SID *g_sid, enum pdb_value_state flag)
 500 {
 501         gid_t gid;
 502
 503         if (!g_sid)
 504                 return False;
 505
 506         if ( !(sampass->group_sid = TALLOC_P( sampass, DOM_SID )) ) {
 507                 return False;
 508         }
 509
 510         /* if we cannot resolve the SID to gid, then just ignore it and
 511            store DOMAIN_USERS as the primary groupSID */
 512
 513         if ( sid_to_gid( g_sid, &gid ) ) {
 514                 sid_copy(sampass->group_sid, g_sid);
 515         } else {
 516                 sid_copy( sampass->group_sid, get_global_sam_sid() );
 517                 sid_append_rid( sampass->group_sid, DOMAIN_GROUP_RID_USERS );
 518         }
 519
 520         DEBUG(10, ("pdb_set_group_sid: setting group sid %s\n",
 521                 sid_string_static(sampass->group_sid)));
 522
 523         return pdb_set_init_flags(sampass, PDB_GROUPSID, flag);
 524 }
 525
 526 /*********************************************************************
 527  Set the user's UNIX name.
 528  ********************************************************************/
 529
 530 BOOL pdb_set_username(struct samu *sampass, const char *username, enum pdb_value_state flag)
 531 {
 532         if (username) {
 533                 DEBUG(10, ("pdb_set_username: setting username %s, was %s\n", username,
 534                         (sampass->username)?(sampass->username):"NULL"));
 535
 536                 sampass->username = talloc_strdup(sampass, username);
 537
 538                 if (!sampass->username) {
 539                         DEBUG(0, ("pdb_set_username: talloc_strdup() failed!\n"));
 540                         return False;
 541                 }
 542         } else {
 543                 sampass->username = PDB_NOT_QUITE_NULL;
 544         }
 545
 546         return pdb_set_init_flags(sampass, PDB_USERNAME, flag);
 547 }
 548
 549 /*********************************************************************
 550  Set the domain name.
 551  ********************************************************************/
 552
 553 BOOL pdb_set_domain(struct samu *sampass, const char *domain, enum pdb_value_state flag)
 554 {
 555         if (domain) {
 556                 DEBUG(10, ("pdb_set_domain: setting domain %s, was %s\n", domain,
 557                         (sampass->domain)?(sampass->domain):"NULL"));
 558
 559                 sampass->domain = talloc_strdup(sampass, domain);
 560
 561                 if (!sampass->domain) {
 562                         DEBUG(0, ("pdb_set_domain: talloc_strdup() failed!\n"));
 563                         return False;
 564                 }
 565         } else {
 566                 sampass->domain = PDB_NOT_QUITE_NULL;
 567         }
 568
 569         return pdb_set_init_flags(sampass, PDB_DOMAIN, flag);
 570 }
 571
 572 /*********************************************************************
 573  Set the user's NT name.
 574  ********************************************************************/
 575
 576 BOOL pdb_set_nt_username(struct samu *sampass, const char *nt_username, enum pdb_value_state flag)
 577 {
 578         if (nt_username) {
 579                 DEBUG(10, ("pdb_set_nt_username: setting nt username %s, was %s\n", nt_username,
 580                         (sampass->nt_username)?(sampass->nt_username):"NULL"));
 581
 582                 sampass->nt_username = talloc_strdup(sampass, nt_username);
 583
 584                 if (!sampass->nt_username) {
 585                         DEBUG(0, ("pdb_set_nt_username: talloc_strdup() failed!\n"));
 586                         return False;
 587                 }
 588         } else {
 589                 sampass->nt_username = PDB_NOT_QUITE_NULL;
 590         }
 591
 592         return pdb_set_init_flags(sampass, PDB_NTUSERNAME, flag);
 593 }
 594
 595 /*********************************************************************
 596  Set the user's full name.
 597  ********************************************************************/
 598
 599 BOOL pdb_set_fullname(struct samu *sampass, const char *full_name, enum pdb_value_state flag)
 600 {
 601         if (full_name) {
 602                 DEBUG(10, ("pdb_set_full_name: setting full name %s, was %s\n", full_name,
 603                         (sampass->full_name)?(sampass->full_name):"NULL"));
 604
 605                 sampass->full_name = talloc_strdup(sampass, full_name);
 606
 607                 if (!sampass->full_name) {
 608                         DEBUG(0, ("pdb_set_fullname: talloc_strdup() failed!\n"));
 609                         return False;
 610                 }
 611         } else {
 612                 sampass->full_name = PDB_NOT_QUITE_NULL;
 613         }
 614
 615         return pdb_set_init_flags(sampass, PDB_FULLNAME, flag);
 616 }
 617
 618 /*********************************************************************
 619  Set the user's logon script.
 620  ********************************************************************/
 621
 622 BOOL pdb_set_logon_script(struct samu *sampass, const char *logon_script, enum pdb_value_state flag)
 623 {
 624         if (logon_script) {
 625                 DEBUG(10, ("pdb_set_logon_script: setting logon script %s, was %s\n", logon_script,
 626                         (sampass->logon_script)?(sampass->logon_script):"NULL"));
 627
 628                 sampass->logon_script = talloc_strdup(sampass, logon_script);
 629
 630                 if (!sampass->logon_script) {
 631                         DEBUG(0, ("pdb_set_logon_script: talloc_strdup() failed!\n"));
 632                         return False;
 633                 }
 634         } else {
 635                 sampass->logon_script = PDB_NOT_QUITE_NULL;
 636         }
 637
 638         return pdb_set_init_flags(sampass, PDB_LOGONSCRIPT, flag);
 639 }
 640
 641 /*********************************************************************
 642  Set the user's profile path.
 643  ********************************************************************/
 644
 645 BOOL pdb_set_profile_path(struct samu *sampass, const char *profile_path, enum pdb_value_state flag)
 646 {
 647         if (profile_path) {
 648                 DEBUG(10, ("pdb_set_profile_path: setting profile path %s, was %s\n", profile_path,
 649                         (sampass->profile_path)?(sampass->profile_path):"NULL"));
 650
 651                 sampass->profile_path = talloc_strdup(sampass, profile_path);
 652
 653                 if (!sampass->profile_path) {
 654                         DEBUG(0, ("pdb_set_profile_path: talloc_strdup() failed!\n"));
 655                         return False;
 656                 }
 657         } else {
 658                 sampass->profile_path = PDB_NOT_QUITE_NULL;
 659         }
 660
 661         return pdb_set_init_flags(sampass, PDB_PROFILE, flag);
 662 }
 663
 664 /*********************************************************************
 665  Set the user's directory drive.
 666  ********************************************************************/
 667
 668 BOOL pdb_set_dir_drive(struct samu *sampass, const char *dir_drive, enum pdb_value_state flag)
 669 {
 670         if (dir_drive) {
 671                 DEBUG(10, ("pdb_set_dir_drive: setting dir drive %s, was %s\n", dir_drive,
 672                         (sampass->dir_drive)?(sampass->dir_drive):"NULL"));
 673
 674                 sampass->dir_drive = talloc_strdup(sampass, dir_drive);
 675
 676                 if (!sampass->dir_drive) {
 677                         DEBUG(0, ("pdb_set_dir_drive: talloc_strdup() failed!\n"));
 678                         return False;
 679                 }
 680
 681         } else {
 682                 sampass->dir_drive = PDB_NOT_QUITE_NULL;
 683         }
 684
 685         return pdb_set_init_flags(sampass, PDB_DRIVE, flag);
 686 }
 687
 688 /*********************************************************************
 689  Set the user's home directory.
 690  ********************************************************************/
 691
 692 BOOL pdb_set_homedir(struct samu *sampass, const char *home_dir, enum pdb_value_state flag)
 693 {
 694         if (home_dir) {
 695                 DEBUG(10, ("pdb_set_homedir: setting home dir %s, was %s\n", home_dir,
 696                         (sampass->home_dir)?(sampass->home_dir):"NULL"));
 697
 698                 sampass->home_dir = talloc_strdup(sampass, home_dir);
 699
 700                 if (!sampass->home_dir) {
 701                         DEBUG(0, ("pdb_set_home_dir: talloc_strdup() failed!\n"));
 702                         return False;
 703                 }
 704         } else {
 705                 sampass->home_dir = PDB_NOT_QUITE_NULL;
 706         }
 707
 708         return pdb_set_init_flags(sampass, PDB_SMBHOME, flag);
 709 }
 710
 711 /*********************************************************************
 712  Set the user's account description.
 713  ********************************************************************/
 714
 715 BOOL pdb_set_acct_desc(struct samu *sampass, const char *acct_desc, enum pdb_value_state flag)
 716 {
 717         if (acct_desc) {
 718                 sampass->acct_desc = talloc_strdup(sampass, acct_desc);
 719
 720                 if (!sampass->acct_desc) {
 721                         DEBUG(0, ("pdb_set_acct_desc: talloc_strdup() failed!\n"));
 722                         return False;
 723                 }
 724         } else {
 725                 sampass->acct_desc = PDB_NOT_QUITE_NULL;
 726         }
 727
 728         return pdb_set_init_flags(sampass, PDB_ACCTDESC, flag);
 729 }
 730
 731 /*********************************************************************
 732  Set the user's workstation allowed list.
 733  ********************************************************************/
 734
 735 BOOL pdb_set_workstations(struct samu *sampass, const char *workstations, enum pdb_value_state flag)
 736 {
 737         if (workstations) {
 738                 DEBUG(10, ("pdb_set_workstations: setting workstations %s, was %s\n", workstations,
 739                         (sampass->workstations)?(sampass->workstations):"NULL"));
 740
 741                 sampass->workstations = talloc_strdup(sampass, workstations);
 742
 743                 if (!sampass->workstations) {
 744                         DEBUG(0, ("pdb_set_workstations: talloc_strdup() failed!\n"));
 745                         return False;
 746                 }
 747         } else {
 748                 sampass->workstations = PDB_NOT_QUITE_NULL;
 749         }
 750
 751         return pdb_set_init_flags(sampass, PDB_WORKSTATIONS, flag);
 752 }
 753
 754 /*********************************************************************
 755  Set the user's 'unknown_str', whatever the heck this actually is...
 756  ********************************************************************/
 757
 758 BOOL pdb_set_unknown_str(struct samu *sampass, const char *unknown_str, enum pdb_value_state flag)
 759 {
 760         if (unknown_str) {
 761                 sampass->unknown_str = talloc_strdup(sampass, unknown_str);
 762
 763                 if (!sampass->unknown_str) {
 764                         DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
 765                         return False;
 766                 }
 767         } else {
 768                 sampass->unknown_str = PDB_NOT_QUITE_NULL;
 769         }
 770
 771         return pdb_set_init_flags(sampass, PDB_UNKNOWNSTR, flag);
 772 }
 773
 774 /*********************************************************************
 775  Set the user's dial string.
 776  ********************************************************************/
 777
 778 BOOL pdb_set_munged_dial(struct samu *sampass, const char *munged_dial, enum pdb_value_state flag)
 779 {
 780         if (munged_dial) {
 781                 sampass->munged_dial = talloc_strdup(sampass, munged_dial);
 782
 783                 if (!sampass->munged_dial) {
 784                         DEBUG(0, ("pdb_set_munged_dial: talloc_strdup() failed!\n"));
 785                         return False;
 786                 }
 787         } else {
 788                 sampass->munged_dial = PDB_NOT_QUITE_NULL;
 789         }
 790
 791         return pdb_set_init_flags(sampass, PDB_MUNGEDDIAL, flag);
 792 }
 793
 794 /*********************************************************************
 795  Set the user's NT hash.
 796  ********************************************************************/
 797
 798 BOOL pdb_set_nt_passwd(struct samu *sampass, const uint8 pwd[NT_HASH_LEN], enum pdb_value_state flag)
 799 {
 800         data_blob_clear_free(&sampass->nt_pw);
 801
 802        if (pwd) {
 803                sampass->nt_pw =
 804                        data_blob_talloc(sampass, pwd, NT_HASH_LEN);
 805        } else {
 806                sampass->nt_pw = data_blob(NULL, 0);
 807        }
 808
 809         return pdb_set_init_flags(sampass, PDB_NTPASSWD, flag);
 810 }
 811
 812 /*********************************************************************
 813  Set the user's LM hash.
 814  ********************************************************************/
 815
 816 BOOL pdb_set_lanman_passwd(struct samu *sampass, const uint8 pwd[LM_HASH_LEN], enum pdb_value_state flag)
 817 {
 818         data_blob_clear_free(&sampass->lm_pw);
 819
 820         /* on keep the password if we are allowing LANMAN authentication */
 821
 822         if (pwd && lp_lanman_auth() ) {
 823                 sampass->lm_pw = data_blob_talloc(sampass, pwd, LM_HASH_LEN);
 824         } else {
 825                 sampass->lm_pw = data_blob(NULL, 0);
 826         }
 827
 828         return pdb_set_init_flags(sampass, PDB_LMPASSWD, flag);
 829 }
 830
 831 /*********************************************************************
 832  Set the user's password history hash. historyLen is the number of
 833  PW_HISTORY_SALT_LEN+SALTED_MD5_HASH_LEN length
 834  entries to store in the history - this must match the size of the uint8 array
 835  in pwd.
 836 ********************************************************************/
 837
 838 BOOL pdb_set_pw_history(struct samu *sampass, const uint8 *pwd, uint32 historyLen, enum pdb_value_state flag)
 839 {
 840         if (historyLen && pwd){
 841                 sampass->nt_pw_his = data_blob_talloc(sampass,
 842                                                 pwd, historyLen*PW_HISTORY_ENTRY_LEN);
 843                 if (!sampass->nt_pw_his.length) {
 844                         DEBUG(0, ("pdb_set_pw_history: data_blob_talloc() failed!\n"));
 845                         return False;
 846                 }
 847         } else {
 848                 sampass->nt_pw_his = data_blob_talloc(sampass, NULL, 0);
 849         }
 850
 851         return pdb_set_init_flags(sampass, PDB_PWHISTORY, flag);
 852 }
 853
 854 /*********************************************************************
 855  Set the user's plaintext password only (base procedure, see helper
 856  below)
 857  ********************************************************************/
 858
 859 BOOL pdb_set_plaintext_pw_only(struct samu *sampass, const char *password, enum pdb_value_state flag)
 860 {
 861         if (password) {
 862                 if (sampass->plaintext_pw!=NULL)
 863                         memset(sampass->plaintext_pw,'\0',strlen(sampass->plaintext_pw)+1);
 864
 865                 sampass->plaintext_pw = talloc_strdup(sampass, password);
 866
 867                 if (!sampass->plaintext_pw) {
 868                         DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
 869                         return False;
 870                 }
 871         } else {
 872                 sampass->plaintext_pw = NULL;
 873         }
 874
 875         return pdb_set_init_flags(sampass, PDB_PLAINTEXT_PW, flag);
 876 }
 877
 878 BOOL pdb_set_bad_password_count(struct samu *sampass, uint16 bad_password_count, enum pdb_value_state flag)
 879 {
 880         sampass->bad_password_count = bad_password_count;
 881         return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_COUNT, flag);
 882 }
 883
 884 BOOL pdb_set_logon_count(struct samu *sampass, uint16 logon_count, enum pdb_value_state flag)
 885 {
 886         sampass->logon_count = logon_count;
 887         return pdb_set_init_flags(sampass, PDB_LOGON_COUNT, flag);
 888 }
 889
 890 BOOL pdb_set_unknown_6(struct samu *sampass, uint32 unkn, enum pdb_value_state flag)
 891 {
 892         sampass->unknown_6 = unkn;
 893         return pdb_set_init_flags(sampass, PDB_UNKNOWN6, flag);
 894 }
 895
 896 BOOL pdb_set_hours(struct samu *sampass, const uint8 *hours, enum pdb_value_state flag)
 897 {
 898         if (!hours) {
 899                 memset ((char *)sampass->hours, 0, MAX_HOURS_LEN);
 900         } else {
 901                 memcpy (sampass->hours, hours, MAX_HOURS_LEN);
 902         }
 903
 904         return pdb_set_init_flags(sampass, PDB_HOURS, flag);
 905 }
 906
 907 BOOL pdb_set_backend_private_data(struct samu *sampass, void *private_data,
 908                                    void (*free_fn)(void **),
 909                                    const struct pdb_methods *my_methods,
 910                                    enum pdb_value_state flag)
 911 {
 912         if (sampass->backend_private_data &&
 913             sampass->backend_private_data_free_fn) {
 914                 sampass->backend_private_data_free_fn(
 915                         &sampass->backend_private_data);
 916         }
 917
 918         sampass->backend_private_data = private_data;
 919         sampass->backend_private_data_free_fn = free_fn;
 920         sampass->backend_private_methods = my_methods;
 921
 922         return pdb_set_init_flags(sampass, PDB_BACKEND_PRIVATE_DATA, flag);
 923 }
 924
 925
 926 /* Helpful interfaces to the above */
 927
 928 /*********************************************************************
 929  Sets the last changed times and must change times for a normal
 930  password change.
 931  ********************************************************************/
 932
 933 BOOL pdb_set_pass_changed_now(struct samu *sampass)
 934 {
 935         uint32 expire;
 936         uint32 min_age;
 937
 938         if (!pdb_set_pass_last_set_time (sampass, time(NULL), PDB_CHANGED))
 939                 return False;
 940
 941         if (!pdb_get_account_policy(AP_MAX_PASSWORD_AGE, &expire)
 942             || (expire==(uint32)-1) || (expire == 0)) {
 943                 if (!pdb_set_pass_must_change_time (sampass, get_time_t_max(), PDB_CHANGED))
 944                         return False;
 945         } else {
 946                 if (!pdb_set_pass_must_change_time (sampass,
 947                                                     pdb_get_pass_last_set_time(sampass)
 948                                                     + expire, PDB_CHANGED))
 949                         return False;
 950         }
 951
 952         if (!pdb_get_account_policy(AP_MIN_PASSWORD_AGE, &min_age)
 953             || (min_age==(uint32)-1)) {
 954                 if (!pdb_set_pass_can_change_time (sampass, 0, PDB_CHANGED))
 955                         return False;
 956         } else {
 957                 if (!pdb_set_pass_can_change_time (sampass,
 958                                                     pdb_get_pass_last_set_time(sampass)
 959                                                     + min_age, PDB_CHANGED))
 960                         return False;
 961         }
 962         return True;
 963 }
 964
 965 /*********************************************************************
 966  Set the user's PLAINTEXT password.  Used as an interface to the above.
 967  Also sets the last change time to NOW.
 968  ********************************************************************/
 969
 970 BOOL pdb_set_plaintext_passwd(struct samu *sampass, const char *plaintext)
 971 {
 972         uchar new_lanman_p16[LM_HASH_LEN];
 973         uchar new_nt_p16[NT_HASH_LEN];
 974
 975         if (!plaintext)
 976                 return False;
 977
 978         /* Calculate the MD4 hash (NT compatible) of the password */
 979         E_md4hash(plaintext, new_nt_p16);
 980
 981         if (!pdb_set_nt_passwd (sampass, new_nt_p16, PDB_CHANGED))
 982                 return False;
 983
 984         if (!E_deshash(plaintext, new_lanman_p16)) {
 985                 /* E_deshash returns false for 'long' passwords (> 14
 986                    DOS chars).  This allows us to match Win2k, which
 987                    does not store a LM hash for these passwords (which
 988                    would reduce the effective password length to 14 */
 989
 990                 if (!pdb_set_lanman_passwd (sampass, NULL, PDB_CHANGED))
 991                         return False;
 992         } else {
 993                 if (!pdb_set_lanman_passwd (sampass, new_lanman_p16, PDB_CHANGED))
 994                         return False;
 995         }
 996
 997         if (!pdb_set_plaintext_pw_only (sampass, plaintext, PDB_CHANGED))
 998                 return False;
 999
1000         if (!pdb_set_pass_changed_now (sampass))
1001                 return False;
1002
1003         /* Store the password history. */
1004         if (pdb_get_acct_ctrl(sampass) & ACB_NORMAL) {
1005                 uchar *pwhistory;
1006                 uint32 pwHistLen;
1007                 pdb_get_account_policy(AP_PASSWORD_HISTORY, &pwHistLen);
1008                 if (pwHistLen != 0){
1009                         uint32 current_history_len;
1010                         /* We need to make sure we don't have a race condition here - the
1011                            account policy history length can change between when the pw_history
1012                            was first loaded into the struct samu struct and now.... JRA. */
1013                         pwhistory = (uchar *)pdb_get_pw_history(sampass, &current_history_len);
1014
1015                         if (current_history_len != pwHistLen) {
1016                                 /* After closing and reopening struct samu the history
1017                                         values will sync up. We can't do this here. */
1018
1019                                 /* current_history_len > pwHistLen is not a problem - we
1020                                         have more history than we need. */
1021
1022                                 if (current_history_len < pwHistLen) {
1023                                         /* Ensure we have space for the needed history. */
1024                                         uchar *new_history = TALLOC(sampass,
1025                                                                 pwHistLen*PW_HISTORY_ENTRY_LEN);
1026                                         if (!new_history) {
1027                                                 return False;
1028                                         }
1029
1030                                         /* And copy it into the new buffer. */
1031                                         if (current_history_len) {
1032                                                 memcpy(new_history, pwhistory,
1033                                                         current_history_len*PW_HISTORY_ENTRY_LEN);
1034                                         }
1035                                         /* Clearing out any extra space. */
1036                                         memset(&new_history[current_history_len*PW_HISTORY_ENTRY_LEN],
1037                                                 '\0', (pwHistLen-current_history_len)*PW_HISTORY_ENTRY_LEN);
1038                                         /* Finally replace it. */
1039                                         pwhistory = new_history;
1040                                 }
1041                         }
1042                         if (pwhistory && pwHistLen){
1043                                 /* Make room for the new password in the history list. */
1044                                 if (pwHistLen > 1) {
1045                                         memmove(&pwhistory[PW_HISTORY_ENTRY_LEN],
1046                                                 pwhistory, (pwHistLen -1)*PW_HISTORY_ENTRY_LEN );
1047                                 }
1048                                 /* Create the new salt as the first part of the history entry. */
1049                                 generate_random_buffer(pwhistory, PW_HISTORY_SALT_LEN);
1050
1051                                 /* Generate the md5 hash of the salt+new password as the second
1052                                         part of the history entry. */
1053
1054                                 E_md5hash(pwhistory, new_nt_p16, &pwhistory[PW_HISTORY_SALT_LEN]);
1055                                 pdb_set_pw_history(sampass, pwhistory, pwHistLen, PDB_CHANGED);
1056                         } else {
1057                                 DEBUG (10,("pdb_get_set.c: pdb_set_plaintext_passwd: pwhistory was NULL!\n"));
1058                         }
1059                 } else {
1060                         /* Set the history length to zero. */
1061                         pdb_set_pw_history(sampass, NULL, 0, PDB_CHANGED);
1062                 }
1063         }
1064
1065         return True;
1066 }
1067
1068 /* check for any PDB_SET/CHANGED field and fill the appropriate mask bit */
1069 uint32 pdb_build_fields_present(struct samu *sampass)
1070 {
1071         /* value set to all for testing */
1072         return 0x00ffffff;
1073 }