2 Unix SMB/CIFS implementation.
3 SAM_ACCOUNT 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-2001
7 Copyright (C) Andrew Bartlett 2001-2002
8 Copyright (C) Stefan (metze) Metzmacher 2002
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.
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.
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.
28 #define DBGC_CLASS DBGC_PASSDB
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().
37 #define PDB_NOT_QUITE_NULL ""
39 /*********************************************************************
40 Collection of get...() functions for SAM_ACCOUNT.
41 ********************************************************************/
43 uint16 pdb_get_acct_ctrl (const SAM_ACCOUNT *sampass)
46 return (sampass->private.acct_ctrl);
48 return (ACB_DISABLED);
51 time_t pdb_get_logon_time (const SAM_ACCOUNT *sampass)
54 return (sampass->private.logon_time);
59 time_t pdb_get_logoff_time (const SAM_ACCOUNT *sampass)
62 return (sampass->private.logoff_time);
67 time_t pdb_get_kickoff_time (const SAM_ACCOUNT *sampass)
70 return (sampass->private.kickoff_time);
75 time_t pdb_get_bad_password_time (const SAM_ACCOUNT *sampass)
78 return (sampass->private.bad_password_time);
83 time_t pdb_get_pass_last_set_time (const SAM_ACCOUNT *sampass)
86 return (sampass->private.pass_last_set_time);
91 time_t pdb_get_pass_can_change_time (const SAM_ACCOUNT *sampass)
94 return (sampass->private.pass_can_change_time);
99 time_t pdb_get_pass_must_change_time (const SAM_ACCOUNT *sampass)
102 return (sampass->private.pass_must_change_time);
107 uint16 pdb_get_logon_divs (const SAM_ACCOUNT *sampass)
110 return (sampass->private.logon_divs);
115 uint32 pdb_get_hours_len (const SAM_ACCOUNT *sampass)
118 return (sampass->private.hours_len);
123 const uint8* pdb_get_hours (const SAM_ACCOUNT *sampass)
126 return (sampass->private.hours);
131 const uint8* pdb_get_nt_passwd (const SAM_ACCOUNT *sampass)
134 SMB_ASSERT((!sampass->private.nt_pw.data)
135 || sampass->private.nt_pw.length == NT_HASH_LEN);
136 return ((uint8*)sampass->private.nt_pw.data);
142 const uint8* pdb_get_lanman_passwd (const SAM_ACCOUNT *sampass)
145 SMB_ASSERT((!sampass->private.lm_pw.data)
146 || sampass->private.lm_pw.length == LM_HASH_LEN);
147 return ((uint8*)sampass->private.lm_pw.data);
153 const uint8* pdb_get_pw_history (const SAM_ACCOUNT *sampass, uint32 *current_hist_len)
156 SMB_ASSERT((!sampass->private.nt_pw_his.data)
157 || ((sampass->private.nt_pw_his.length % NT_HASH_LEN) == 0));
158 *current_hist_len = sampass->private.nt_pw_his.length / NT_HASH_LEN;
159 return ((uint8*)sampass->private.nt_pw_his.data);
161 *current_hist_len = 0;
166 /* Return the plaintext password if known. Most of the time
167 it isn't, so don't assume anything magic about this function.
169 Used to pass the plaintext to passdb backends that might
170 want to store more than just the NTLM hashes.
172 const char* pdb_get_plaintext_passwd (const SAM_ACCOUNT *sampass)
175 return (sampass->private.plaintext_pw);
180 const DOM_SID *pdb_get_user_sid(const SAM_ACCOUNT *sampass)
183 return &sampass->private.user_sid;
188 const DOM_SID *pdb_get_group_sid(const SAM_ACCOUNT *sampass)
191 return &sampass->private.group_sid;
197 * Get flags showing what is initalised in the SAM_ACCOUNT
198 * @param sampass the SAM_ACCOUNT in question
199 * @return the flags indicating the members initialised in the struct.
202 enum pdb_value_state pdb_get_init_flags (const SAM_ACCOUNT *sampass, enum pdb_elements element)
204 enum pdb_value_state ret = PDB_DEFAULT;
206 if (!sampass || !sampass->private.change_flags || !sampass->private.set_flags)
209 if (bitmap_query(sampass->private.set_flags, element)) {
210 DEBUG(11, ("element %d: SET\n", element));
214 if (bitmap_query(sampass->private.change_flags, element)) {
215 DEBUG(11, ("element %d: CHANGED\n", element));
219 if (ret == PDB_DEFAULT) {
220 DEBUG(11, ("element %d: DEFAULT\n", element));
226 const char* pdb_get_username (const SAM_ACCOUNT *sampass)
229 return (sampass->private.username);
234 const char* pdb_get_domain (const SAM_ACCOUNT *sampass)
237 return (sampass->private.domain);
242 const char* pdb_get_nt_username (const SAM_ACCOUNT *sampass)
245 return (sampass->private.nt_username);
250 const char* pdb_get_fullname (const SAM_ACCOUNT *sampass)
253 return (sampass->private.full_name);
258 const char* pdb_get_homedir (const SAM_ACCOUNT *sampass)
261 return (sampass->private.home_dir);
266 const char* pdb_get_unix_homedir (const SAM_ACCOUNT *sampass)
269 return (sampass->private.unix_home_dir);
274 const char* pdb_get_dir_drive (const SAM_ACCOUNT *sampass)
277 return (sampass->private.dir_drive);
282 const char* pdb_get_logon_script (const SAM_ACCOUNT *sampass)
285 return (sampass->private.logon_script);
290 const char* pdb_get_profile_path (const SAM_ACCOUNT *sampass)
293 return (sampass->private.profile_path);
298 const char* pdb_get_acct_desc (const SAM_ACCOUNT *sampass)
301 return (sampass->private.acct_desc);
306 const char* pdb_get_workstations (const SAM_ACCOUNT *sampass)
309 return (sampass->private.workstations);
314 const char* pdb_get_unknown_str (const SAM_ACCOUNT *sampass)
317 return (sampass->private.unknown_str);
322 const char* pdb_get_munged_dial (const SAM_ACCOUNT *sampass)
325 return (sampass->private.munged_dial);
330 uint32 pdb_get_fields_present (const SAM_ACCOUNT *sampass)
333 return (sampass->private.fields_present);
338 uint16 pdb_get_bad_password_count(const SAM_ACCOUNT *sampass)
341 return (sampass->private.bad_password_count);
346 uint16 pdb_get_logon_count(const SAM_ACCOUNT *sampass)
349 return (sampass->private.logon_count);
354 uint32 pdb_get_unknown_6 (const SAM_ACCOUNT *sampass)
357 return (sampass->private.unknown_6);
362 void *pdb_get_backend_private_data (const SAM_ACCOUNT *sampass, const struct pdb_methods *my_methods)
364 if (sampass && my_methods == sampass->private.backend_private_methods)
365 return sampass->private.backend_private_data;
370 /*********************************************************************
371 Collection of set...() functions for SAM_ACCOUNT.
372 ********************************************************************/
374 BOOL pdb_set_acct_ctrl (SAM_ACCOUNT *sampass, uint16 acct_ctrl, enum pdb_value_state flag)
379 sampass->private.acct_ctrl = acct_ctrl;
381 return pdb_set_init_flags(sampass, PDB_ACCTCTRL, flag);
384 BOOL pdb_set_logon_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
389 sampass->private.logon_time = mytime;
391 return pdb_set_init_flags(sampass, PDB_LOGONTIME, flag);
394 BOOL pdb_set_logoff_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
399 sampass->private.logoff_time = mytime;
401 return pdb_set_init_flags(sampass, PDB_LOGOFFTIME, flag);
404 BOOL pdb_set_kickoff_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
409 sampass->private.kickoff_time = mytime;
411 return pdb_set_init_flags(sampass, PDB_KICKOFFTIME, flag);
414 BOOL pdb_set_bad_password_time (SAM_ACCOUNT *sampass, time_t mytime,
415 enum pdb_value_state flag)
420 sampass->private.bad_password_time = mytime;
422 return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_TIME, flag);
425 BOOL pdb_set_pass_can_change_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
430 sampass->private.pass_can_change_time = mytime;
432 return pdb_set_init_flags(sampass, PDB_CANCHANGETIME, flag);
435 BOOL pdb_set_pass_must_change_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
440 sampass->private.pass_must_change_time = mytime;
442 return pdb_set_init_flags(sampass, PDB_MUSTCHANGETIME, flag);
445 BOOL pdb_set_pass_last_set_time (SAM_ACCOUNT *sampass, time_t mytime, enum pdb_value_state flag)
450 sampass->private.pass_last_set_time = mytime;
452 return pdb_set_init_flags(sampass, PDB_PASSLASTSET, flag);
455 BOOL pdb_set_hours_len (SAM_ACCOUNT *sampass, uint32 len, enum pdb_value_state flag)
460 sampass->private.hours_len = len;
462 return pdb_set_init_flags(sampass, PDB_HOURSLEN, flag);
465 BOOL pdb_set_logon_divs (SAM_ACCOUNT *sampass, uint16 hours, enum pdb_value_state flag)
470 sampass->private.logon_divs = hours;
472 return pdb_set_init_flags(sampass, PDB_LOGONDIVS, flag);
476 * Set flags showing what is initalised in the SAM_ACCOUNT
477 * @param sampass the SAM_ACCOUNT in question
478 * @param flag The *new* flag to be set. Old flags preserved
479 * this flag is only added.
482 BOOL pdb_set_init_flags (SAM_ACCOUNT *sampass, enum pdb_elements element, enum pdb_value_state value_flag)
484 if (!sampass || !sampass->mem_ctx)
487 if (!sampass->private.set_flags) {
488 if ((sampass->private.set_flags =
489 bitmap_talloc(sampass->mem_ctx,
491 DEBUG(0,("bitmap_talloc failed\n"));
495 if (!sampass->private.change_flags) {
496 if ((sampass->private.change_flags =
497 bitmap_talloc(sampass->mem_ctx,
499 DEBUG(0,("bitmap_talloc failed\n"));
506 if (!bitmap_set(sampass->private.change_flags, element)) {
507 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
510 if (!bitmap_set(sampass->private.set_flags, element)) {
511 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
514 DEBUG(11, ("element %d -> now CHANGED\n", element));
517 if (!bitmap_clear(sampass->private.change_flags, element)) {
518 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
521 if (!bitmap_set(sampass->private.set_flags, element)) {
522 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
525 DEBUG(10, ("element %d -> now SET\n", element));
529 if (!bitmap_clear(sampass->private.change_flags, element)) {
530 DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
533 if (!bitmap_clear(sampass->private.set_flags, element)) {
534 DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
537 DEBUG(11, ("element %d -> now DEFAULT\n", element));
544 BOOL pdb_set_user_sid (SAM_ACCOUNT *sampass, const DOM_SID *u_sid, enum pdb_value_state flag)
546 if (!sampass || !u_sid)
549 sid_copy(&sampass->private.user_sid, u_sid);
551 DEBUG(10, ("pdb_set_user_sid: setting user sid %s\n",
552 sid_string_static(&sampass->private.user_sid)));
554 return pdb_set_init_flags(sampass, PDB_USERSID, flag);
557 BOOL pdb_set_user_sid_from_string (SAM_ACCOUNT *sampass, fstring u_sid, enum pdb_value_state flag)
561 if (!sampass || !u_sid)
564 DEBUG(10, ("pdb_set_user_sid_from_string: setting user sid %s\n",
567 if (!string_to_sid(&new_sid, u_sid)) {
568 DEBUG(1, ("pdb_set_user_sid_from_string: %s isn't a valid SID!\n", u_sid));
572 if (!pdb_set_user_sid(sampass, &new_sid, flag)) {
573 DEBUG(1, ("pdb_set_user_sid_from_string: could not set sid %s on SAM_ACCOUNT!\n", u_sid));
580 BOOL pdb_set_group_sid (SAM_ACCOUNT *sampass, const DOM_SID *g_sid, enum pdb_value_state flag)
582 if (!sampass || !g_sid)
585 sid_copy(&sampass->private.group_sid, g_sid);
587 DEBUG(10, ("pdb_set_group_sid: setting group sid %s\n",
588 sid_string_static(&sampass->private.group_sid)));
590 return pdb_set_init_flags(sampass, PDB_GROUPSID, flag);
593 BOOL pdb_set_group_sid_from_string (SAM_ACCOUNT *sampass, fstring g_sid, enum pdb_value_state flag)
596 if (!sampass || !g_sid)
599 DEBUG(10, ("pdb_set_group_sid_from_string: setting group sid %s\n",
602 if (!string_to_sid(&new_sid, g_sid)) {
603 DEBUG(1, ("pdb_set_group_sid_from_string: %s isn't a valid SID!\n", g_sid));
607 if (!pdb_set_group_sid(sampass, &new_sid, flag)) {
608 DEBUG(1, ("pdb_set_group_sid_from_string: could not set sid %s on SAM_ACCOUNT!\n", g_sid));
614 /*********************************************************************
615 Set the user's UNIX name.
616 ********************************************************************/
618 BOOL pdb_set_username(SAM_ACCOUNT *sampass, const char *username, enum pdb_value_state flag)
624 DEBUG(10, ("pdb_set_username: setting username %s, was %s\n", username,
625 (sampass->private.username)?(sampass->private.username):"NULL"));
627 sampass->private.username = talloc_strdup(sampass->mem_ctx, username);
629 if (!sampass->private.username) {
630 DEBUG(0, ("pdb_set_username: talloc_strdup() failed!\n"));
635 sampass->private.username = PDB_NOT_QUITE_NULL;
638 return pdb_set_init_flags(sampass, PDB_USERNAME, flag);
641 /*********************************************************************
643 ********************************************************************/
645 BOOL pdb_set_domain(SAM_ACCOUNT *sampass, const char *domain, enum pdb_value_state flag)
651 DEBUG(10, ("pdb_set_domain: setting domain %s, was %s\n", domain,
652 (sampass->private.domain)?(sampass->private.domain):"NULL"));
654 sampass->private.domain = talloc_strdup(sampass->mem_ctx, domain);
656 if (!sampass->private.domain) {
657 DEBUG(0, ("pdb_set_domain: talloc_strdup() failed!\n"));
662 sampass->private.domain = PDB_NOT_QUITE_NULL;
665 return pdb_set_init_flags(sampass, PDB_DOMAIN, flag);
668 /*********************************************************************
669 Set the user's NT name.
670 ********************************************************************/
672 BOOL pdb_set_nt_username(SAM_ACCOUNT *sampass, const char *nt_username, enum pdb_value_state flag)
678 DEBUG(10, ("pdb_set_nt_username: setting nt username %s, was %s\n", nt_username,
679 (sampass->private.nt_username)?(sampass->private.nt_username):"NULL"));
681 sampass->private.nt_username = talloc_strdup(sampass->mem_ctx, nt_username);
683 if (!sampass->private.nt_username) {
684 DEBUG(0, ("pdb_set_nt_username: talloc_strdup() failed!\n"));
689 sampass->private.nt_username = PDB_NOT_QUITE_NULL;
692 return pdb_set_init_flags(sampass, PDB_NTUSERNAME, flag);
695 /*********************************************************************
696 Set the user's full name.
697 ********************************************************************/
699 BOOL pdb_set_fullname(SAM_ACCOUNT *sampass, const char *full_name, enum pdb_value_state flag)
705 DEBUG(10, ("pdb_set_full_name: setting full name %s, was %s\n", full_name,
706 (sampass->private.full_name)?(sampass->private.full_name):"NULL"));
708 sampass->private.full_name = talloc_strdup(sampass->mem_ctx, full_name);
710 if (!sampass->private.full_name) {
711 DEBUG(0, ("pdb_set_fullname: talloc_strdup() failed!\n"));
716 sampass->private.full_name = PDB_NOT_QUITE_NULL;
719 return pdb_set_init_flags(sampass, PDB_FULLNAME, flag);
722 /*********************************************************************
723 Set the user's logon script.
724 ********************************************************************/
726 BOOL pdb_set_logon_script(SAM_ACCOUNT *sampass, const char *logon_script, enum pdb_value_state flag)
732 DEBUG(10, ("pdb_set_logon_script: setting logon script %s, was %s\n", logon_script,
733 (sampass->private.logon_script)?(sampass->private.logon_script):"NULL"));
735 sampass->private.logon_script = talloc_strdup(sampass->mem_ctx, logon_script);
737 if (!sampass->private.logon_script) {
738 DEBUG(0, ("pdb_set_logon_script: talloc_strdup() failed!\n"));
743 sampass->private.logon_script = PDB_NOT_QUITE_NULL;
746 return pdb_set_init_flags(sampass, PDB_LOGONSCRIPT, flag);
749 /*********************************************************************
750 Set the user's profile path.
751 ********************************************************************/
753 BOOL pdb_set_profile_path (SAM_ACCOUNT *sampass, const char *profile_path, enum pdb_value_state flag)
759 DEBUG(10, ("pdb_set_profile_path: setting profile path %s, was %s\n", profile_path,
760 (sampass->private.profile_path)?(sampass->private.profile_path):"NULL"));
762 sampass->private.profile_path = talloc_strdup(sampass->mem_ctx, profile_path);
764 if (!sampass->private.profile_path) {
765 DEBUG(0, ("pdb_set_profile_path: talloc_strdup() failed!\n"));
770 sampass->private.profile_path = PDB_NOT_QUITE_NULL;
773 return pdb_set_init_flags(sampass, PDB_PROFILE, flag);
776 /*********************************************************************
777 Set the user's directory drive.
778 ********************************************************************/
780 BOOL pdb_set_dir_drive (SAM_ACCOUNT *sampass, const char *dir_drive, enum pdb_value_state flag)
786 DEBUG(10, ("pdb_set_dir_drive: setting dir drive %s, was %s\n", dir_drive,
787 (sampass->private.dir_drive)?(sampass->private.dir_drive):"NULL"));
789 sampass->private.dir_drive = talloc_strdup(sampass->mem_ctx, dir_drive);
791 if (!sampass->private.dir_drive) {
792 DEBUG(0, ("pdb_set_dir_drive: talloc_strdup() failed!\n"));
797 sampass->private.dir_drive = PDB_NOT_QUITE_NULL;
800 return pdb_set_init_flags(sampass, PDB_DRIVE, flag);
803 /*********************************************************************
804 Set the user's home directory.
805 ********************************************************************/
807 BOOL pdb_set_homedir (SAM_ACCOUNT *sampass, const char *home_dir, enum pdb_value_state flag)
813 DEBUG(10, ("pdb_set_homedir: setting home dir %s, was %s\n", home_dir,
814 (sampass->private.home_dir)?(sampass->private.home_dir):"NULL"));
816 sampass->private.home_dir = talloc_strdup(sampass->mem_ctx, home_dir);
818 if (!sampass->private.home_dir) {
819 DEBUG(0, ("pdb_set_home_dir: talloc_strdup() failed!\n"));
824 sampass->private.home_dir = PDB_NOT_QUITE_NULL;
827 return pdb_set_init_flags(sampass, PDB_SMBHOME, flag);
830 /*********************************************************************
831 Set the user's unix home directory.
832 ********************************************************************/
834 BOOL pdb_set_unix_homedir (SAM_ACCOUNT *sampass, const char *unix_home_dir, enum pdb_value_state flag)
840 DEBUG(10, ("pdb_set_unix_homedir: setting home dir %s, was %s\n", unix_home_dir,
841 (sampass->private.unix_home_dir)?(sampass->private.unix_home_dir):"NULL"));
843 sampass->private.unix_home_dir = talloc_strdup(sampass->mem_ctx,
846 if (!sampass->private.unix_home_dir) {
847 DEBUG(0, ("pdb_set_unix_home_dir: talloc_strdup() failed!\n"));
852 sampass->private.unix_home_dir = PDB_NOT_QUITE_NULL;
855 return pdb_set_init_flags(sampass, PDB_UNIXHOMEDIR, flag);
858 /*********************************************************************
859 Set the user's account description.
860 ********************************************************************/
862 BOOL pdb_set_acct_desc (SAM_ACCOUNT *sampass, const char *acct_desc, enum pdb_value_state flag)
868 sampass->private.acct_desc = talloc_strdup(sampass->mem_ctx, acct_desc);
870 if (!sampass->private.acct_desc) {
871 DEBUG(0, ("pdb_set_acct_desc: talloc_strdup() failed!\n"));
876 sampass->private.acct_desc = PDB_NOT_QUITE_NULL;
879 return pdb_set_init_flags(sampass, PDB_ACCTDESC, flag);
882 /*********************************************************************
883 Set the user's workstation allowed list.
884 ********************************************************************/
886 BOOL pdb_set_workstations (SAM_ACCOUNT *sampass, const char *workstations, enum pdb_value_state flag)
892 DEBUG(10, ("pdb_set_workstations: setting workstations %s, was %s\n", workstations,
893 (sampass->private.workstations)?(sampass->private.workstations):"NULL"));
895 sampass->private.workstations = talloc_strdup(sampass->mem_ctx, workstations);
897 if (!sampass->private.workstations) {
898 DEBUG(0, ("pdb_set_workstations: talloc_strdup() failed!\n"));
903 sampass->private.workstations = PDB_NOT_QUITE_NULL;
906 return pdb_set_init_flags(sampass, PDB_WORKSTATIONS, flag);
909 /*********************************************************************
910 Set the user's 'unknown_str', whatever the heck this actually is...
911 ********************************************************************/
913 BOOL pdb_set_unknown_str (SAM_ACCOUNT *sampass, const char *unknown_str, enum pdb_value_state flag)
919 sampass->private.unknown_str = talloc_strdup(sampass->mem_ctx, unknown_str);
921 if (!sampass->private.unknown_str) {
922 DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
927 sampass->private.unknown_str = PDB_NOT_QUITE_NULL;
930 return pdb_set_init_flags(sampass, PDB_UNKNOWNSTR, flag);
933 /*********************************************************************
934 Set the user's dial string.
935 ********************************************************************/
937 BOOL pdb_set_munged_dial (SAM_ACCOUNT *sampass, const char *munged_dial, enum pdb_value_state flag)
943 sampass->private.munged_dial = talloc_strdup(sampass->mem_ctx, munged_dial);
945 if (!sampass->private.munged_dial) {
946 DEBUG(0, ("pdb_set_munged_dial: talloc_strdup() failed!\n"));
951 sampass->private.munged_dial = PDB_NOT_QUITE_NULL;
954 return pdb_set_init_flags(sampass, PDB_MUNGEDDIAL, flag);
957 /*********************************************************************
958 Set the user's NT hash.
959 ********************************************************************/
961 BOOL pdb_set_nt_passwd (SAM_ACCOUNT *sampass, const uint8 pwd[NT_HASH_LEN], enum pdb_value_state flag)
966 data_blob_clear_free(&sampass->private.nt_pw);
969 sampass->private.nt_pw = data_blob(pwd, NT_HASH_LEN);
971 sampass->private.nt_pw = data_blob(NULL, 0);
974 return pdb_set_init_flags(sampass, PDB_NTPASSWD, flag);
977 /*********************************************************************
978 Set the user's LM hash.
979 ********************************************************************/
981 BOOL pdb_set_lanman_passwd (SAM_ACCOUNT *sampass, const uint8 pwd[LM_HASH_LEN], enum pdb_value_state flag)
986 data_blob_clear_free(&sampass->private.lm_pw);
989 sampass->private.lm_pw = data_blob(pwd, LM_HASH_LEN);
991 sampass->private.lm_pw = data_blob(NULL, 0);
994 return pdb_set_init_flags(sampass, PDB_LMPASSWD, flag);
997 /*********************************************************************
998 Set the user's password history hash. historyLen is the number of NT_HASH_LEN
999 entries to store in the history - this must match the size of the uint8 array
1001 ********************************************************************/
1003 BOOL pdb_set_pw_history (SAM_ACCOUNT *sampass, const uint8 *pwd, uint32 historyLen, enum pdb_value_state flag)
1008 if (historyLen && pwd){
1009 sampass->private.nt_pw_his = data_blob_talloc(sampass->mem_ctx, pwd, historyLen*NT_HASH_LEN);
1010 if (!sampass->private.nt_pw_his.length) {
1011 DEBUG(0, ("pdb_set_pw_history: data_blob_talloc() failed!\n"));
1015 sampass->private.nt_pw_his = data_blob_talloc(sampass->mem_ctx, NULL, 0);
1018 return pdb_set_init_flags(sampass, PDB_PWHISTORY, flag);
1021 /*********************************************************************
1022 Set the user's plaintext password only (base procedure, see helper
1024 ********************************************************************/
1026 BOOL pdb_set_plaintext_pw_only (SAM_ACCOUNT *sampass, const char *password, enum pdb_value_state flag)
1032 if (sampass->private.plaintext_pw!=NULL)
1033 memset(sampass->private.plaintext_pw,'\0',strlen(sampass->private.plaintext_pw)+1);
1035 sampass->private.plaintext_pw = talloc_strdup(sampass->mem_ctx, password);
1037 if (!sampass->private.plaintext_pw) {
1038 DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
1043 sampass->private.plaintext_pw = NULL;
1046 return pdb_set_init_flags(sampass, PDB_PLAINTEXT_PW, flag);
1049 BOOL pdb_set_fields_present (SAM_ACCOUNT *sampass, uint32 fields_present, enum pdb_value_state flag)
1054 sampass->private.fields_present = fields_present;
1056 return pdb_set_init_flags(sampass, PDB_FIELDS_PRESENT, flag);
1059 BOOL pdb_set_bad_password_count(SAM_ACCOUNT *sampass, uint16 bad_password_count, enum pdb_value_state flag)
1064 sampass->private.bad_password_count = bad_password_count;
1066 return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_COUNT, flag);
1069 BOOL pdb_set_logon_count(SAM_ACCOUNT *sampass, uint16 logon_count, enum pdb_value_state flag)
1074 sampass->private.logon_count = logon_count;
1076 return pdb_set_init_flags(sampass, PDB_LOGON_COUNT, flag);
1079 BOOL pdb_set_unknown_6 (SAM_ACCOUNT *sampass, uint32 unkn, enum pdb_value_state flag)
1084 sampass->private.unknown_6 = unkn;
1086 return pdb_set_init_flags(sampass, PDB_UNKNOWN6, flag);
1089 BOOL pdb_set_hours (SAM_ACCOUNT *sampass, const uint8 *hours, enum pdb_value_state flag)
1095 memset ((char *)sampass->private.hours, 0, MAX_HOURS_LEN);
1099 memcpy (sampass->private.hours, hours, MAX_HOURS_LEN);
1101 return pdb_set_init_flags(sampass, PDB_HOURS, flag);
1104 BOOL pdb_set_backend_private_data (SAM_ACCOUNT *sampass, void *private_data,
1105 void (*free_fn)(void **),
1106 const struct pdb_methods *my_methods,
1107 enum pdb_value_state flag)
1112 if (sampass->private.backend_private_data && sampass->private.backend_private_data_free_fn) {
1113 sampass->private.backend_private_data_free_fn(&sampass->private.backend_private_data);
1116 sampass->private.backend_private_data = private_data;
1117 sampass->private.backend_private_data_free_fn = free_fn;
1118 sampass->private.backend_private_methods = my_methods;
1120 return pdb_set_init_flags(sampass, PDB_BACKEND_PRIVATE_DATA, flag);
1124 /* Helpful interfaces to the above */
1126 /*********************************************************************
1127 Sets the last changed times and must change times for a normal
1129 ********************************************************************/
1131 BOOL pdb_set_pass_changed_now (SAM_ACCOUNT *sampass)
1139 if (!pdb_set_pass_last_set_time (sampass, time(NULL), PDB_CHANGED))
1142 if (!account_policy_get(AP_MAX_PASSWORD_AGE, &expire)
1143 || (expire==(uint32)-1) || (expire == 0)) {
1144 if (!pdb_set_pass_must_change_time (sampass, get_time_t_max(), PDB_CHANGED))
1147 if (!pdb_set_pass_must_change_time (sampass,
1148 pdb_get_pass_last_set_time(sampass)
1149 + expire, PDB_CHANGED))
1153 if (!account_policy_get(AP_MIN_PASSWORD_AGE, &min_age)
1154 || (min_age==(uint32)-1)) {
1155 if (!pdb_set_pass_can_change_time (sampass, 0, PDB_CHANGED))
1158 if (!pdb_set_pass_can_change_time (sampass,
1159 pdb_get_pass_last_set_time(sampass)
1160 + min_age, PDB_CHANGED))
1166 /*********************************************************************
1167 Set the user's PLAINTEXT password. Used as an interface to the above.
1168 Also sets the last change time to NOW.
1169 ********************************************************************/
1171 BOOL pdb_set_plaintext_passwd (SAM_ACCOUNT *sampass, const char *plaintext)
1173 uchar new_lanman_p16[LM_HASH_LEN];
1174 uchar new_nt_p16[NT_HASH_LEN];
1175 uchar current_ntpw_copy[NT_HASH_LEN];
1176 uchar *current_ntpw = NULL;
1178 if (!sampass || !plaintext)
1181 /* Store the current password for history purposes. */
1182 current_ntpw = (uint8 *)pdb_get_nt_passwd(sampass);
1184 memcpy (current_ntpw_copy, current_ntpw, NT_HASH_LEN);
1187 /* Calculate the MD4 hash (NT compatible) of the password */
1188 E_md4hash(plaintext, new_nt_p16);
1190 if (!pdb_set_nt_passwd (sampass, new_nt_p16, PDB_CHANGED))
1193 if (!E_deshash(plaintext, new_lanman_p16)) {
1194 /* E_deshash returns false for 'long' passwords (> 14
1195 DOS chars). This allows us to match Win2k, which
1196 does not store a LM hash for these passwords (which
1197 would reduce the effective password length to 14 */
1199 if (!pdb_set_lanman_passwd (sampass, NULL, PDB_CHANGED))
1202 if (!pdb_set_lanman_passwd (sampass, new_lanman_p16, PDB_CHANGED))
1206 if (!pdb_set_plaintext_pw_only (sampass, plaintext, PDB_CHANGED))
1209 if (!pdb_set_pass_changed_now (sampass))
1212 /* Store the password history. */
1213 if (pdb_get_acct_ctrl(sampass) & ACB_NORMAL) {
1216 account_policy_get(AP_PASSWORD_HISTORY, &pwHistLen);
1217 if (pwHistLen != 0){
1218 uint32 current_history_len;
1219 /* We need to make sure we don't have a race condition here - the
1220 account policy history length can change between when the pw_history
1221 was first loaded into the SAM_ACCOUNT struct and now.... JRA. */
1222 pwhistory = (uchar *)pdb_get_pw_history(sampass, ¤t_history_len);
1224 if (current_history_len != pwHistLen) {
1225 /* After closing and reopening SAM_ACCOUNT the history
1226 values will sync up. We can't do this here. */
1228 /* current_history_len > pwHistLen is not a problem - we
1229 have more history than we need. */
1231 if (current_history_len < pwHistLen) {
1232 /* We only have room for current_history_len entries. */
1233 pwHistLen = current_history_len;
1236 if (pwhistory && current_ntpw && pwHistLen){
1237 if (pwHistLen > 1) {
1238 memmove(&pwhistory[NT_HASH_LEN], pwhistory, (pwHistLen -1)*NT_HASH_LEN );
1240 memcpy(pwhistory, current_ntpw_copy, NT_HASH_LEN);
1241 pdb_set_pw_history(sampass, pwhistory, pwHistLen, PDB_CHANGED);
1243 DEBUG (10,("pdb_get_set.c: pdb_set_plaintext_passwd: pwhistory was NULL!\n"));
1246 /* Set the history length to zero. */
1247 pdb_set_pw_history(sampass, NULL, 0, PDB_CHANGED);
1254 /* check for any PDB_SET/CHANGED field and fill the appropriate mask bit */
1255 uint32 pdb_build_fields_present (SAM_ACCOUNT *sampass)
1257 /* value set to all for testing */