source3/sam/get_set_account.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SAM_ACCOUNT_HANDLE access routines
   4    Copyright (C) Andrew Bartlett                        2002
   5    Copyright (C) Stefan (metze) Metzmacher              2002
   6    Copyright (C) Jelmer Vernooij                        2002
   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
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_SAM
  27
  28 NTSTATUS sam_get_account_domain_sid(const SAM_ACCOUNT_HANDLE *sampass, const DOM_SID **sid)
  29 {
  30         NTSTATUS status;
  31         SAM_DOMAIN_HANDLE *domain;
  32         SAM_ASSERT(!sampass || !sid);
  33
  34         if (!NT_STATUS_IS_OK(status = sam_get_account_domain(sampass, &domain))){
  35                 DEBUG(0, ("sam_get_account_domain_sid: Can't get domain for account\n"));
  36                 return status;
  37         }
  38
  39         return sam_get_domain_sid(domain, sid);
  40 }
  41
  42 NTSTATUS sam_get_account_domain_name(const SAM_ACCOUNT_HANDLE *sampass, const char **domain_name)
  43 {
  44         NTSTATUS status;
  45         SAM_DOMAIN_HANDLE *domain;
  46         SAM_ASSERT(sampass && domain_name);
  47
  48         if (!NT_STATUS_IS_OK(status = sam_get_account_domain(sampass, &domain))){
  49                 DEBUG(0, ("sam_get_account_domain_name: Can't get domain for account\n"));
  50                 return status;
  51         }
  52
  53         return sam_get_domain_name(domain, domain_name);
  54 }
  55
  56 NTSTATUS sam_get_account_acct_ctrl(const SAM_ACCOUNT_HANDLE *sampass, uint16 *acct_ctrl)
  57 {
  58         SAM_ASSERT(sampass && acct_ctrl);
  59
  60         *acct_ctrl = sampass->private.acct_ctrl;
  61
  62         return NT_STATUS_OK;
  63 }
  64
  65 NTSTATUS sam_get_account_logon_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *logon_time)
  66 {
  67         SAM_ASSERT(sampass && logon_time) ;
  68
  69         *logon_time = sampass->private.logon_time;
  70
  71         return NT_STATUS_OK;
  72 }
  73
  74 NTSTATUS sam_get_account_logoff_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *logoff_time)
  75 {
  76         SAM_ASSERT(sampass && logoff_time) ;
  77
  78         *logoff_time = sampass->private.logoff_time;
  79
  80         return NT_STATUS_OK;
  81 }
  82
  83 NTSTATUS sam_get_account_kickoff_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *kickoff_time)
  84 {
  85         SAM_ASSERT(sampass && kickoff_time);
  86
  87         *kickoff_time = sampass->private.kickoff_time;
  88
  89         return NT_STATUS_OK;
  90 }
  91
  92 NTSTATUS sam_get_account_pass_last_set_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *pass_last_set_time)
  93 {
  94         SAM_ASSERT(sampass && pass_last_set_time);
  95
  96         *pass_last_set_time = sampass->private.pass_last_set_time;
  97
  98         return NT_STATUS_OK;
  99 }
 100
 101 NTSTATUS sam_get_account_pass_can_change_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *pass_can_change_time)
 102 {
 103         SAM_ASSERT(sampass && pass_can_change_time);
 104
 105         *pass_can_change_time = sampass->private.pass_can_change_time;
 106
 107         return NT_STATUS_OK;
 108 }
 109
 110 NTSTATUS sam_get_account_pass_must_change_time(const SAM_ACCOUNT_HANDLE *sampass, NTTIME *pass_must_change_time)
 111 {
 112         SAM_ASSERT(sampass && pass_must_change_time);
 113
 114         *pass_must_change_time = sampass->private.pass_must_change_time;
 115
 116         return NT_STATUS_OK;
 117 }
 118
 119 NTSTATUS sam_get_account_logon_divs(const SAM_ACCOUNT_HANDLE *sampass, uint16 *logon_divs)
 120 {
 121         SAM_ASSERT(sampass && logon_divs);
 122
 123         *logon_divs = sampass->private.logon_divs;
 124
 125         return NT_STATUS_OK;
 126 }
 127
 128 NTSTATUS sam_get_account_hours_len(const SAM_ACCOUNT_HANDLE *sampass, uint32 *hours_len)
 129 {
 130         SAM_ASSERT(sampass && hours_len);
 131
 132         *hours_len = sampass->private.hours_len;
 133
 134         return NT_STATUS_OK;
 135 }
 136
 137 NTSTATUS sam_get_account_hours(const SAM_ACCOUNT_HANDLE *sampass, const uint8 **hours)
 138 {
 139         SAM_ASSERT(sampass && hours);
 140
 141         *hours = sampass->private.hours;
 142
 143         return NT_STATUS_OK;
 144 }
 145
 146 NTSTATUS sam_get_account_nt_pwd(const SAM_ACCOUNT_HANDLE *sampass, DATA_BLOB *nt_pwd)
 147 {
 148         SAM_ASSERT(sampass);
 149
 150         SMB_ASSERT((!sampass->private.nt_pw.data)
 151                    || sampass->private.nt_pw.length == NT_HASH_LEN);
 152
 153         *nt_pwd = sampass->private.nt_pw;
 154
 155         return NT_STATUS_OK;
 156 }
 157
 158 NTSTATUS sam_get_account_lm_pwd(const SAM_ACCOUNT_HANDLE *sampass, DATA_BLOB *lm_pwd)
 159 {
 160         SAM_ASSERT(sampass);
 161
 162         SMB_ASSERT((!sampass->private.lm_pw.data)
 163                    || sampass->private.lm_pw.length == LM_HASH_LEN);
 164
 165         *lm_pwd = sampass->private.lm_pw;
 166
 167         return NT_STATUS_OK;
 168 }
 169
 170 /* Return the plaintext password if known.  Most of the time
 171    it isn't, so don't assume anything magic about this function.
 172
 173    Used to pass the plaintext to sam backends that might
 174    want to store more than just the NTLM hashes.
 175 */
 176
 177 NTSTATUS sam_get_account_plaintext_pwd(const SAM_ACCOUNT_HANDLE *sampass, char **plain_pwd)
 178 {
 179         SAM_ASSERT(sampass && plain_pwd);
 180
 181         *plain_pwd = sampass->private.plaintext_pw;
 182
 183         return NT_STATUS_OK;
 184 }
 185
 186 NTSTATUS sam_get_account_sid(const SAM_ACCOUNT_HANDLE *sampass, const DOM_SID **sid)
 187 {
 188         SAM_ASSERT(sampass);
 189
 190         *sid = &(sampass->private.account_sid);
 191
 192         return NT_STATUS_OK;
 193 }
 194
 195 NTSTATUS sam_get_account_pgroup(const SAM_ACCOUNT_HANDLE *sampass, const DOM_SID **sid)
 196 {
 197         SAM_ASSERT(sampass);
 198
 199         *sid = &(sampass->private.group_sid);
 200
 201         return NT_STATUS_OK;
 202 }
 203
 204 /**
 205  * Get flags showing what is initalised in the SAM_ACCOUNT_HANDLE
 206  * @param sampass the SAM_ACCOUNT_HANDLE in question
 207  * @return the flags indicating the members initialised in the struct.
 208  **/
 209
 210 NTSTATUS sam_get_account_init_flag(const SAM_ACCOUNT_HANDLE *sampass, uint32 *initflag)
 211 {
 212         SAM_ASSERT(sampass);
 213
 214         *initflag = sampass->private.init_flag;
 215
 216         return NT_STATUS_OK;
 217 }
 218
 219 NTSTATUS sam_get_account_name(const SAM_ACCOUNT_HANDLE *sampass, char **account_name)
 220 {
 221         SAM_ASSERT(sampass);
 222
 223         *account_name = sampass->private.account_name;
 224
 225         return NT_STATUS_OK;
 226 }
 227
 228 NTSTATUS sam_get_account_domain(const SAM_ACCOUNT_HANDLE *sampass, SAM_DOMAIN_HANDLE **domain)
 229 {
 230         SAM_ASSERT(sampass);
 231
 232         *domain = sampass->private.domain;
 233
 234         return NT_STATUS_OK;
 235 }
 236
 237 NTSTATUS sam_get_account_fullname(const SAM_ACCOUNT_HANDLE *sampass, char **fullname)
 238 {
 239         SAM_ASSERT(sampass);
 240
 241         *fullname = sampass->private.full_name;
 242
 243         return NT_STATUS_OK;
 244 }
 245
 246 NTSTATUS sam_get_account_homedir(const SAM_ACCOUNT_HANDLE *sampass, char **homedir)
 247 {
 248         SAM_ASSERT(sampass);
 249
 250         *homedir = sampass->private.home_dir;
 251
 252         return NT_STATUS_OK;
 253 }
 254
 255 NTSTATUS sam_get_account_unix_home_dir(const SAM_ACCOUNT_HANDLE *sampass, char **uhomedir)
 256 {
 257         SAM_ASSERT(sampass);
 258
 259         *uhomedir = sampass->private.unix_home_dir;
 260
 261         return NT_STATUS_OK;
 262 }
 263
 264 NTSTATUS sam_get_account_dir_drive(const SAM_ACCOUNT_HANDLE *sampass, char **dirdrive)
 265 {
 266         SAM_ASSERT(sampass);
 267
 268         *dirdrive = sampass->private.dir_drive;
 269
 270         return NT_STATUS_OK;
 271 }
 272
 273 NTSTATUS sam_get_account_logon_script(const SAM_ACCOUNT_HANDLE *sampass, char **logon_script)
 274 {
 275         SAM_ASSERT(sampass);
 276
 277         *logon_script = sampass->private.logon_script;
 278
 279         return NT_STATUS_OK;
 280 }
 281
 282 NTSTATUS sam_get_account_profile_path(const SAM_ACCOUNT_HANDLE *sampass, char **profile_path)
 283 {
 284         SAM_ASSERT(sampass);
 285
 286         *profile_path = sampass->private.profile_path;
 287
 288         return NT_STATUS_OK;
 289 }
 290
 291 NTSTATUS sam_get_account_description(const SAM_ACCOUNT_HANDLE *sampass, char **description)
 292 {
 293         SAM_ASSERT(sampass);
 294
 295         *description = sampass->private.acct_desc;
 296
 297         return NT_STATUS_OK;
 298 }
 299
 300 NTSTATUS sam_get_account_workstations(const SAM_ACCOUNT_HANDLE *sampass, char **workstations)
 301 {
 302         SAM_ASSERT(sampass);
 303
 304         *workstations = sampass->private.workstations;
 305
 306         return NT_STATUS_OK;
 307 }
 308
 309 NTSTATUS sam_get_account_unknown_str(const SAM_ACCOUNT_HANDLE *sampass, char **unknown_str)
 310 {
 311         SAM_ASSERT(sampass);
 312
 313         *unknown_str = sampass->private.unknown_str;
 314
 315         return NT_STATUS_OK;
 316 }
 317
 318 NTSTATUS sam_get_account_munged_dial(const SAM_ACCOUNT_HANDLE *sampass, char **munged_dial)
 319 {
 320         SAM_ASSERT(sampass);
 321
 322         *munged_dial = sampass->private.munged_dial;
 323
 324         return NT_STATUS_OK;
 325 }
 326
 327 NTSTATUS sam_get_account_unknown_1(const SAM_ACCOUNT_HANDLE *sampass, uint32 *unknown1)
 328 {
 329         SAM_ASSERT(sampass && unknown1);
 330
 331         *unknown1 = sampass->private.unknown_1;
 332
 333         return NT_STATUS_OK;
 334 }
 335
 336 NTSTATUS sam_get_account_unknown_2(const SAM_ACCOUNT_HANDLE *sampass, uint32 *unknown2)
 337 {
 338         SAM_ASSERT(sampass && unknown2);
 339
 340         *unknown2 = sampass->private.unknown_2;
 341
 342         return NT_STATUS_OK;
 343 }
 344
 345 NTSTATUS sam_get_account_unknown_3(const SAM_ACCOUNT_HANDLE *sampass, uint32 *unknown3)
 346 {
 347         SAM_ASSERT(sampass && unknown3);
 348
 349         *unknown3 = sampass->private.unknown_3;
 350
 351         return NT_STATUS_OK;
 352 }
 353
 354 /*********************************************************************
 355  Collection of set...() functions for SAM_ACCOUNT_HANDLE_INFO.
 356  ********************************************************************/
 357
 358 NTSTATUS sam_set_account_acct_ctrl(SAM_ACCOUNT_HANDLE *sampass, uint16 acct_ctrl)
 359 {
 360         SAM_ASSERT(sampass);
 361
 362         sampass->private.acct_ctrl = acct_ctrl;
 363
 364         return NT_STATUS_OK;
 365 }
 366
 367 NTSTATUS sam_set_account_logon_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime, BOOL store)
 368 {
 369         SAM_ASSERT(sampass);
 370
 371         sampass->private.logon_time = mytime;
 372
 373
 374         return NT_STATUS_UNSUCCESSFUL;
 375 }
 376
 377 NTSTATUS sam_set_account_logoff_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime, BOOL store)
 378 {
 379         SAM_ASSERT(sampass);
 380
 381         sampass->private.logoff_time = mytime;
 382
 383         return NT_STATUS_OK;
 384 }
 385
 386 NTSTATUS sam_set_account_kickoff_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime, BOOL store)
 387 {
 388         SAM_ASSERT(sampass);
 389
 390         sampass->private.kickoff_time = mytime;
 391
 392
 393         return NT_STATUS_OK;
 394 }
 395
 396 NTSTATUS sam_set_account_pass_can_change_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime, BOOL store)
 397 {
 398         SAM_ASSERT(sampass);
 399
 400         sampass->private.pass_can_change_time = mytime;
 401
 402
 403         return NT_STATUS_OK;
 404 }
 405
 406 NTSTATUS sam_set_account_pass_must_change_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime, BOOL store)
 407 {
 408         SAM_ASSERT(sampass);
 409
 410         sampass->private.pass_must_change_time = mytime;
 411
 412         return NT_STATUS_OK;
 413 }
 414
 415 NTSTATUS sam_set_account_pass_last_set_time(SAM_ACCOUNT_HANDLE *sampass, NTTIME mytime)
 416 {
 417         SAM_ASSERT(sampass);
 418
 419         sampass->private.pass_last_set_time = mytime;
 420
 421         return NT_STATUS_OK;
 422 }
 423
 424 NTSTATUS sam_set_account_hours_len(SAM_ACCOUNT_HANDLE *sampass, uint32 len)
 425 {
 426         SAM_ASSERT(sampass);
 427
 428         sampass->private.hours_len = len;
 429         return NT_STATUS_OK;
 430 }
 431
 432 NTSTATUS sam_set_account_logon_divs(SAM_ACCOUNT_HANDLE *sampass, uint16 hours)
 433 {
 434         SAM_ASSERT(sampass);
 435
 436         sampass->private.logon_divs = hours;
 437         return NT_STATUS_OK;
 438 }
 439
 440 /**
 441  * Set flags showing what is initalised in the SAM_ACCOUNT_HANDLE
 442  * @param sampass the SAM_ACCOUNT_HANDLE in question
 443  * @param flag The *new* flag to be set.  Old flags preserved
 444  *             this flag is only added.
 445  **/
 446
 447 NTSTATUS sam_set_account_init_flag(SAM_ACCOUNT_HANDLE *sampass, uint32 flag)
 448 {
 449         SAM_ASSERT(sampass);
 450
 451         sampass->private.init_flag |= flag;
 452
 453         return NT_STATUS_OK;
 454 }
 455
 456 NTSTATUS sam_set_account_sid(SAM_ACCOUNT_HANDLE *sampass, const DOM_SID *u_sid)
 457 {
 458         SAM_ASSERT(sampass && u_sid);
 459
 460         sid_copy(&sampass->private.account_sid, u_sid);
 461
 462         DEBUG(10, ("sam_set_account_sid: setting account sid %s\n",
 463                     sid_string_static(&sampass->private.account_sid)));
 464
 465         return NT_STATUS_OK;
 466 }
 467
 468 NTSTATUS sam_set_account_sid_from_string(SAM_ACCOUNT_HANDLE *sampass, const char *u_sid)
 469 {
 470         DOM_SID new_sid;
 471         SAM_ASSERT(sampass && u_sid);
 472
 473         DEBUG(10, ("sam_set_account_sid_from_string: setting account sid %s\n",
 474                    u_sid));
 475
 476         if (!string_to_sid(&new_sid, u_sid)) {
 477                 DEBUG(1, ("sam_set_account_sid_from_string: %s isn't a valid SID!\n", u_sid));
 478                 return NT_STATUS_UNSUCCESSFUL;
 479         }
 480
 481         if (!NT_STATUS_IS_OK(sam_set_account_sid(sampass, &new_sid))) {
 482                 DEBUG(1, ("sam_set_account_sid_from_string: could not set sid %s on SAM_ACCOUNT_HANDLE!\n", u_sid));
 483                 return NT_STATUS_UNSUCCESSFUL;
 484         }
 485
 486         return NT_STATUS_OK;
 487 }
 488
 489 NTSTATUS sam_set_account_pgroup_sid(SAM_ACCOUNT_HANDLE *sampass, const DOM_SID *g_sid)
 490 {
 491         SAM_ASSERT(sampass && g_sid);
 492
 493         sid_copy(&sampass->private.group_sid, g_sid);
 494
 495         DEBUG(10, ("sam_set_group_sid: setting group sid %s\n",
 496                     sid_string_static(&sampass->private.group_sid)));
 497
 498         return NT_STATUS_OK;
 499 }
 500
 501 NTSTATUS sam_set_account_pgroup_string(SAM_ACCOUNT_HANDLE *sampass, const char *g_sid)
 502 {
 503         DOM_SID new_sid;
 504         SAM_ASSERT(sampass && g_sid);
 505
 506         DEBUG(10, ("sam_set_group_sid_from_string: setting group sid %s\n",
 507                    g_sid));
 508
 509         if (!string_to_sid(&new_sid, g_sid)) {
 510                 DEBUG(1, ("sam_set_group_sid_from_string: %s isn't a valid SID!\n", g_sid));
 511                 return NT_STATUS_UNSUCCESSFUL;
 512         }
 513
 514         if (!NT_STATUS_IS_OK(sam_set_account_pgroup_sid(sampass, &new_sid))) {
 515                 DEBUG(1, ("sam_set_group_sid_from_string: could not set sid %s on SAM_ACCOUNT_HANDLE!\n", g_sid));
 516                 return NT_STATUS_UNSUCCESSFUL;
 517         }
 518         return NT_STATUS_OK;
 519 }
 520
 521 /*********************************************************************
 522  Set the domain name.
 523  ********************************************************************/
 524
 525 NTSTATUS sam_set_account_domain(SAM_ACCOUNT_HANDLE *sampass, SAM_DOMAIN_HANDLE *domain)
 526 {
 527         SAM_ASSERT(sampass);
 528
 529         sampass->private.domain = domain;
 530
 531         return NT_STATUS_OK;
 532 }
 533
 534 /*********************************************************************
 535  Set the account's NT name.
 536  ********************************************************************/
 537
 538 NTSTATUS sam_set_account_name(SAM_ACCOUNT_HANDLE *sampass, const char *account_name)
 539 {
 540         SAM_ASSERT(sampass);
 541
 542         DEBUG(10, ("sam_set_account_name: setting nt account_name %s, was %s\n", account_name, sampass->private.account_name));
 543
 544         sampass->private.account_name = talloc_strdup(sampass->mem_ctx, account_name);
 545
 546         return NT_STATUS_OK;
 547 }
 548
 549 /*********************************************************************
 550  Set the account's full name.
 551  ********************************************************************/
 552
 553 NTSTATUS sam_set_account_fullname(SAM_ACCOUNT_HANDLE *sampass, const char *full_name)
 554 {
 555         SAM_ASSERT(sampass);
 556
 557         DEBUG(10, ("sam_set_account_fullname: setting full name %s, was %s\n", full_name, sampass->private.full_name));
 558
 559         sampass->private.full_name = talloc_strdup(sampass->mem_ctx, full_name);
 560
 561         return NT_STATUS_OK;
 562 }
 563
 564 /*********************************************************************
 565  Set the account's logon script.
 566  ********************************************************************/
 567
 568 NTSTATUS sam_set_account_logon_script(SAM_ACCOUNT_HANDLE *sampass, const char *logon_script, BOOL store)
 569 {
 570         SAM_ASSERT(sampass);
 571
 572         DEBUG(10, ("sam_set_logon_script: from %s to %s\n", logon_script, sampass->private.logon_script));
 573
 574         sampass->private.logon_script = talloc_strdup(sampass->mem_ctx, logon_script);
 575
 576
 577         return NT_STATUS_OK;
 578 }
 579
 580 /*********************************************************************
 581  Set the account's profile path.
 582  ********************************************************************/
 583
 584 NTSTATUS sam_set_account_profile_path(SAM_ACCOUNT_HANDLE *sampass, const char *profile_path, BOOL store)
 585 {
 586         SAM_ASSERT(sampass);
 587
 588         DEBUG(10, ("sam_set_profile_path: setting profile path %s, was %s\n", profile_path, sampass->private.profile_path));
 589
 590         sampass->private.profile_path = talloc_strdup(sampass->mem_ctx, profile_path);
 591
 592         return NT_STATUS_OK;
 593 }
 594
 595 /*********************************************************************
 596  Set the account's directory drive.
 597  ********************************************************************/
 598
 599 NTSTATUS sam_set_account_dir_drive(SAM_ACCOUNT_HANDLE *sampass, const char *dir_drive, BOOL store)
 600 {
 601         SAM_ASSERT(sampass);
 602
 603         DEBUG(10, ("sam_set_dir_drive: setting dir drive %s, was %s\n", dir_drive,
 604                         sampass->private.dir_drive));
 605
 606         sampass->private.dir_drive = talloc_strdup(sampass->mem_ctx, dir_drive);
 607
 608         return NT_STATUS_OK;
 609 }
 610
 611 /*********************************************************************
 612  Set the account's home directory.
 613  ********************************************************************/
 614
 615 NTSTATUS sam_set_account_homedir(SAM_ACCOUNT_HANDLE *sampass, const char *home_dir, BOOL store)
 616 {
 617         SAM_ASSERT(sampass);
 618
 619         DEBUG(10, ("sam_set_homedir: setting home dir %s, was %s\n", home_dir,
 620                 sampass->private.home_dir));
 621
 622         sampass->private.home_dir = talloc_strdup(sampass->mem_ctx, home_dir);
 623
 624         return NT_STATUS_OK;
 625 }
 626
 627 /*********************************************************************
 628  Set the account's unix home directory.
 629  ********************************************************************/
 630
 631 NTSTATUS sam_set_account_unix_homedir(SAM_ACCOUNT_HANDLE *sampass, const char *unix_home_dir)
 632 {
 633         SAM_ASSERT(sampass);
 634
 635         DEBUG(10, ("sam_set_unix_homedir: setting home dir %s, was %s\n", unix_home_dir,
 636                 sampass->private.unix_home_dir));
 637
 638         sampass->private.unix_home_dir = talloc_strdup(sampass->mem_ctx, unix_home_dir);
 639
 640         return NT_STATUS_OK;
 641 }
 642
 643 /*********************************************************************
 644  Set the account's account description.
 645  ********************************************************************/
 646
 647 NTSTATUS sam_set_account_acct_desc(SAM_ACCOUNT_HANDLE *sampass, const char *acct_desc)
 648 {
 649         SAM_ASSERT(sampass);
 650
 651         sampass->private.acct_desc = talloc_strdup(sampass->mem_ctx, acct_desc);
 652
 653         return NT_STATUS_OK;
 654 }
 655
 656 /*********************************************************************
 657  Set the account's workstation allowed list.
 658  ********************************************************************/
 659
 660 NTSTATUS sam_set_account_workstations(SAM_ACCOUNT_HANDLE *sampass, const char *workstations)
 661 {
 662         SAM_ASSERT(sampass);
 663
 664         DEBUG(10, ("sam_set_workstations: setting workstations %s, was %s\n", workstations,
 665                         sampass->private.workstations));
 666
 667         sampass->private.workstations = talloc_strdup(sampass->mem_ctx, workstations);
 668
 669         return NT_STATUS_OK;
 670 }
 671
 672 /*********************************************************************
 673  Set the account's 'unknown_str', whatever the heck this actually is...
 674  ********************************************************************/
 675
 676 NTSTATUS sam_set_account_unknown_str(SAM_ACCOUNT_HANDLE *sampass, const char *unknown_str)
 677 {
 678         SAM_ASSERT(sampass);
 679
 680         sampass->private.unknown_str = talloc_strdup(sampass->mem_ctx, unknown_str);
 681
 682         return NT_STATUS_OK;
 683 }
 684
 685 /*********************************************************************
 686  Set the account's dial string.
 687  ********************************************************************/
 688
 689 NTSTATUS sam_set_account_munged_dial(SAM_ACCOUNT_HANDLE *sampass, const char *munged_dial)
 690 {
 691         SAM_ASSERT(sampass);
 692
 693         sampass->private.munged_dial = talloc_strdup(sampass->mem_ctx, munged_dial);
 694
 695         return NT_STATUS_OK;
 696 }
 697
 698 /*********************************************************************
 699  Set the account's NT hash.
 700  ********************************************************************/
 701
 702 NTSTATUS sam_set_account_nt_pwd(SAM_ACCOUNT_HANDLE *sampass, const DATA_BLOB data)
 703 {
 704         SAM_ASSERT(sampass);
 705
 706         sampass->private.nt_pw = data;
 707
 708         return NT_STATUS_OK;
 709 }
 710
 711 /*********************************************************************
 712  Set the account's LM hash.
 713  ********************************************************************/
 714
 715 NTSTATUS sam_set_account_lm_pwd(SAM_ACCOUNT_HANDLE *sampass, const DATA_BLOB data)
 716 {
 717         SAM_ASSERT(sampass);
 718
 719         sampass->private.lm_pw = data;
 720
 721         return NT_STATUS_OK;
 722 }
 723
 724 /*********************************************************************
 725  Set the account's plaintext password only (base procedure, see helper
 726  below)
 727  ********************************************************************/
 728
 729 NTSTATUS sam_set_account_plaintext_pwd(SAM_ACCOUNT_HANDLE *sampass, const char *plain_pwd)
 730 {
 731         SAM_ASSERT(sampass);
 732
 733         sampass->private.plaintext_pw = talloc_strdup(sampass->mem_ctx, plain_pwd);
 734
 735         return NT_STATUS_OK;
 736 }
 737
 738 NTSTATUS sam_set_account_unknown_1(SAM_ACCOUNT_HANDLE *sampass, uint32 unkn)
 739 {
 740         SAM_ASSERT(sampass);
 741
 742         sampass->private.unknown_1 = unkn;
 743
 744         return NT_STATUS_OK;
 745 }
 746
 747 NTSTATUS sam_set_account_unknown_2(SAM_ACCOUNT_HANDLE *sampass, uint32 unkn)
 748 {
 749         SAM_ASSERT(sampass);
 750
 751         sampass->private.unknown_2 = unkn;
 752
 753         return NT_STATUS_OK;
 754 }
 755
 756 NTSTATUS sam_set_account_unknown_3(SAM_ACCOUNT_HANDLE *sampass, uint32 unkn)
 757 {
 758         SAM_ASSERT(sampass);
 759
 760         sampass->private.unknown_3 = unkn;
 761         return NT_STATUS_OK;
 762 }
 763
 764 NTSTATUS sam_set_account_hours(SAM_ACCOUNT_HANDLE *sampass, const uint8 *hours)
 765 {
 766         SAM_ASSERT(sampass);
 767
 768         if (!hours) {
 769                 memset ((char *)sampass->private.hours, 0, MAX_HOURS_LEN);
 770                 return NT_STATUS_OK;
 771         }
 772
 773         memcpy(sampass->private.hours, hours, MAX_HOURS_LEN);
 774
 775         return NT_STATUS_OK;
 776 }
 777
 778 /* Helpful interfaces to the above */
 779
 780 /*********************************************************************
 781  Sets the last changed times and must change times for a normal
 782  password change.
 783  ********************************************************************/
 784
 785 NTSTATUS sam_set_account_pass_changed_now(SAM_ACCOUNT_HANDLE *sampass)
 786 {
 787         uint32 expire;
 788         NTTIME temptime;
 789
 790         SAM_ASSERT(sampass);
 791
 792         unix_to_nt_time(&temptime, time(NULL));
 793         if (!NT_STATUS_IS_OK(sam_set_account_pass_last_set_time(sampass, temptime)))
 794                 return NT_STATUS_UNSUCCESSFUL;
 795
 796         if (!account_policy_get(AP_MAX_PASSWORD_AGE, &expire)
 797             || (expire==(uint32)-1)) {
 798
 799                 get_nttime_max(&temptime);
 800                 if (!NT_STATUS_IS_OK(sam_set_account_pass_must_change_time(sampass, temptime, False)))
 801                         return NT_STATUS_UNSUCCESSFUL;
 802
 803         } else {
 804                 /* FIXME: Add expire to temptime */
 805
 806                 if (!NT_STATUS_IS_OK(sam_get_account_pass_last_set_time(sampass,&temptime)) || !NT_STATUS_IS_OK(sam_set_account_pass_must_change_time(sampass, temptime,True)))
 807                         return NT_STATUS_UNSUCCESSFUL;
 808         }
 809
 810         return NT_STATUS_OK;
 811 }
 812
 813 /*********************************************************************
 814  Set the account's PLAINTEXT password.  Used as an interface to the above.
 815  Also sets the last change time to NOW.
 816  ********************************************************************/
 817
 818 NTSTATUS sam_set_account_passwd(SAM_ACCOUNT_HANDLE *sampass, const char *plaintext)
 819 {
 820         DATA_BLOB data;
 821         uchar new_lanman_p16[16];
 822         uchar new_nt_p16[16];
 823
 824         SAM_ASSERT(sampass && plaintext);
 825
 826         nt_lm_owf_gen(plaintext, new_nt_p16, new_lanman_p16);
 827
 828         data = data_blob(new_nt_p16, 16);
 829         if (!NT_STATUS_IS_OK(sam_set_account_nt_pwd(sampass, data)))
 830                 return NT_STATUS_UNSUCCESSFUL;
 831
 832         data = data_blob(new_lanman_p16, 16);
 833
 834         if (!NT_STATUS_IS_OK(sam_set_account_lm_pwd(sampass, data)))
 835                 return NT_STATUS_UNSUCCESSFUL;
 836
 837         if (!NT_STATUS_IS_OK(sam_set_account_plaintext_pwd(sampass, plaintext)))
 838                 return NT_STATUS_UNSUCCESSFUL;
 839
 840         if (!NT_STATUS_IS_OK(sam_set_account_pass_changed_now(sampass)))
 841                 return NT_STATUS_UNSUCCESSFUL;
 842
 843         return NT_STATUS_OK;
 844 }
 845