2 * Unix SMB/CIFS implementation.
3 * SMB parameters and setup
4 * Copyright (C) Andrew Tridgell 1992-1998
5 * Modified by Jeremy Allison 1995.
6 * Modified by Gerald (Jerry) Carter 2000-2001,2003
7 * Modified by Andrew Bartlett 2002.
9 * This program is free software; you can redistribute it and/or modify it under
10 * the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 3 of the License, or (at your option)
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * You should have received a copy of the GNU General Public License along with
20 * this program; if not, see <http://www.gnu.org/licenses/>.
25 #include "system/passwd.h"
26 #include "system/filesys.h"
27 #include "../librpc/gen_ndr/samr.h"
28 #include "../libcli/security/security.h"
29 #include "passdb/pdb_smbpasswd.h"
32 #define DBGC_CLASS DBGC_PASSDB
35 smb_passwd is analogous to sam_passwd used everywhere
36 else. However, smb_passwd is limited to the information
37 stored by an smbpasswd entry
42 uint32_t smb_userid
; /* this is actually the unix uid_t */
43 const char *smb_name
; /* username string */
45 const unsigned char *smb_passwd
; /* Null if no password */
46 const unsigned char *smb_nt_passwd
; /* Null if no password */
48 uint16_t acct_ctrl
; /* account info (ACB_xxxx bit-mask) */
49 time_t pass_last_set_time
; /* password last set time */
52 struct smbpasswd_privates
54 /* used for maintain locks on the smbpasswd file */
55 int pw_file_lock_depth
;
57 /* Global File pointer */
60 /* formerly static variables */
61 struct smb_passwd pw_buf
;
63 unsigned char smbpwd
[16];
64 unsigned char smbntpwd
[16];
66 /* retrieve-once info */
67 const char *smbpasswd_file
;
70 enum pwf_access_type
{ PWF_READ
, PWF_UPDATE
, PWF_CREATE
};
72 static SIG_ATOMIC_T gotalarm
;
74 /***************************************************************
75 Signal function to tell us we timed out.
76 ****************************************************************/
78 static void gotalarm_sig(int signum
)
83 /***************************************************************
84 Lock or unlock a fd for a known lock type. Abandon after waitsecs
86 ****************************************************************/
88 static bool do_file_lock(int fd
, int waitsecs
, int type
)
92 void (*oldsig_handler
)(int);
95 oldsig_handler
= CatchSignal(SIGALRM
, gotalarm_sig
);
98 lock
.l_whence
= SEEK_SET
;
104 /* Note we must *NOT* use sys_fcntl here ! JRA */
105 ret
= fcntl(fd
, F_SETLKW
, &lock
);
107 CatchSignal(SIGALRM
, oldsig_handler
);
109 if (gotalarm
&& ret
== -1) {
110 DEBUG(0, ("do_file_lock: failed to %s file.\n",
111 type
== F_UNLCK
? "unlock" : "lock"));
118 /***************************************************************
119 Lock an fd. Abandon after waitsecs seconds.
120 ****************************************************************/
122 static bool pw_file_lock(int fd
, int type
, int secs
, int *plock_depth
)
128 if(*plock_depth
== 0) {
129 if (!do_file_lock(fd
, secs
, type
)) {
130 DEBUG(10,("pw_file_lock: locking file failed, error = %s.\n",
141 /***************************************************************
142 Unlock an fd. Abandon after waitsecs seconds.
143 ****************************************************************/
145 static bool pw_file_unlock(int fd
, int *plock_depth
)
149 if (fd
== 0 || *plock_depth
== 0) {
153 if(*plock_depth
== 1) {
154 ret
= do_file_lock(fd
, 5, F_UNLCK
);
157 if (*plock_depth
> 0) {
162 DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
168 /**************************************************************
169 Intialize a smb_passwd struct
170 *************************************************************/
172 static void pdb_init_smb(struct smb_passwd
*user
)
178 user
->pass_last_set_time
= (time_t)0;
181 /***************************************************************
182 Internal fn to enumerate the smbpasswd list. Returns a void pointer
183 to ensure no modification outside this module. Checks for atomic
184 rename of smbpasswd file on update or create once the lock has
185 been granted to prevent race conditions. JRA.
186 ****************************************************************/
188 static FILE *startsmbfilepwent(const char *pfile
, enum pwf_access_type type
, int *lock_depth
)
191 const char *open_mode
= NULL
;
193 int lock_type
= F_RDLCK
;
196 DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
211 * Ensure atomic file creation.
216 for(i
= 0; i
< 5; i
++) {
217 if((fd
= open(pfile
, O_CREAT
|O_TRUNC
|O_EXCL
|O_RDWR
, 0600))!=-1) {
220 usleep(200); /* Spin, spin... */
223 DEBUG(0,("startsmbfilepwent_internal: too many race conditions \
224 creating file %s\n", pfile
));
233 DEBUG(10, ("Invalid open mode: %d\n", type
));
237 for(race_loop
= 0; race_loop
< 5; race_loop
++) {
238 DEBUG(10, ("startsmbfilepwent_internal: opening file %s\n", pfile
));
240 if((fp
= fopen(pfile
, open_mode
)) == NULL
) {
243 * If smbpasswd file doesn't exist, then create new one. This helps to avoid
244 * confusing error msg when adding user account first time.
246 if (errno
== ENOENT
) {
247 if ((fp
= fopen(pfile
, "a+")) != NULL
) {
248 DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
249 exist. File successfully created.\n", pfile
));
251 DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
252 exist. Couldn't create new one. Error was: %s",
253 pfile
, strerror(errno
)));
257 DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. \
258 Error was: %s\n", pfile
, strerror(errno
)));
263 if (!pw_file_lock(fileno(fp
), lock_type
, 5, lock_depth
)) {
264 DEBUG(0, ("startsmbfilepwent_internal: unable to lock file %s. \
265 Error was %s\n", pfile
, strerror(errno
) ));
271 * Only check for replacement races on update or create.
272 * For read we don't mind if the data is one record out of date.
275 if(type
== PWF_READ
) {
278 SMB_STRUCT_STAT sbuf1
, sbuf2
;
281 * Avoid the potential race condition between the open and the lock
282 * by doing a stat on the filename and an fstat on the fd. If the
283 * two inodes differ then someone did a rename between the open and
284 * the lock. Back off and try the open again. Only do this 5 times to
285 * prevent infinate loops. JRA.
288 if (sys_stat(pfile
, &sbuf1
, false) != 0) {
289 DEBUG(0, ("startsmbfilepwent_internal: unable to stat file %s. \
290 Error was %s\n", pfile
, strerror(errno
)));
291 pw_file_unlock(fileno(fp
), lock_depth
);
296 if (sys_fstat(fileno(fp
), &sbuf2
, false) != 0) {
297 DEBUG(0, ("startsmbfilepwent_internal: unable to fstat file %s. \
298 Error was %s\n", pfile
, strerror(errno
)));
299 pw_file_unlock(fileno(fp
), lock_depth
);
304 if( sbuf1
.st_ex_ino
== sbuf2
.st_ex_ino
) {
310 * Race occurred - back off and try again...
313 pw_file_unlock(fileno(fp
), lock_depth
);
319 DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile
));
323 /* Set a buffer to do more efficient reads */
324 setvbuf(fp
, (char *)NULL
, _IOFBF
, 1024);
326 /* Make sure it is only rw by the owner */
328 if(fchmod(fileno(fp
), S_IRUSR
|S_IWUSR
) == -1) {
330 if(chmod(pfile
, S_IRUSR
|S_IWUSR
) == -1) {
332 DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
333 Error was %s\n.", pfile
, strerror(errno
) ));
334 pw_file_unlock(fileno(fp
), lock_depth
);
339 /* We have a lock on the file. */
343 /***************************************************************
344 End enumeration of the smbpasswd list.
345 ****************************************************************/
347 static void endsmbfilepwent(FILE *fp
, int *lock_depth
)
353 pw_file_unlock(fileno(fp
), lock_depth
);
355 DEBUG(7, ("endsmbfilepwent_internal: closed password file.\n"));
358 /*************************************************************************
359 Routine to return the next entry in the smbpasswd list.
360 *************************************************************************/
362 static struct smb_passwd
*getsmbfilepwent(struct smbpasswd_privates
*smbpasswd_state
, FILE *fp
)
364 /* Static buffers we will return. */
365 struct smb_passwd
*pw_buf
= &smbpasswd_state
->pw_buf
;
366 char *user_name
= smbpasswd_state
->user_name
;
367 unsigned char *smbpwd
= smbpasswd_state
->smbpwd
;
368 unsigned char *smbntpwd
= smbpasswd_state
->smbntpwd
;
377 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
381 pdb_init_smb(pw_buf
);
382 pw_buf
->acct_ctrl
= ACB_NORMAL
;
385 * Scan the file, a line at a time and check if the name matches.
388 while (status
&& !feof(fp
)) {
391 status
= fgets(linebuf
, 256, fp
);
392 if (status
== NULL
&& ferror(fp
)) {
397 * Check if the string is terminated with a newline - if not
398 * then we must keep reading and discard until we get one.
400 if ((linebuf_len
= strlen(linebuf
)) == 0) {
404 if (linebuf
[linebuf_len
- 1] != '\n') {
406 while (!ferror(fp
) && !feof(fp
)) {
413 linebuf
[linebuf_len
- 1] = '\0';
416 #ifdef DEBUG_PASSWORD
417 DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf
));
419 if ((linebuf
[0] == 0) && feof(fp
)) {
420 DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
425 * The line we have should be of the form :-
427 * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
432 * username:uid:32hex bytes:32hex bytes:[Account type]:LCT-12345678....ignored....
434 * if Windows NT compatible passwords are also present.
435 * [Account type] is an ascii encoding of the type of account.
436 * LCT-(8 hex digits) is the time_t value of the last change time.
439 if (linebuf
[0] == '#' || linebuf
[0] == '\0') {
440 DEBUG(6, ("getsmbfilepwent: skipping comment or blank line\n"));
443 p
= (unsigned char *) strchr_m(linebuf
, ':');
445 DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
449 strncpy(user_name
, linebuf
, PTR_DIFF(p
, linebuf
));
450 user_name
[PTR_DIFF(p
, linebuf
)] = '\0';
454 p
++; /* Go past ':' */
457 DEBUG(0, ("getsmbfilepwent: user name %s has a negative uid.\n", user_name
));
462 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (uid not number)\n",
467 uidval
= atoi((char *) p
);
469 while (*p
&& isdigit(*p
)) {
474 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no : after uid)\n",
479 pw_buf
->smb_name
= user_name
;
480 pw_buf
->smb_userid
= uidval
;
483 * Now get the password value - this should be 32 hex digits
484 * which are the ascii representations of a 16 byte string.
485 * Get two at a time and put them into the password.
491 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
492 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (passwd too short)\n",
498 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no terminating :)\n",
503 if (strnequal((char *) p
, "NO PASSWORD", 11)) {
504 pw_buf
->smb_passwd
= NULL
;
505 pw_buf
->acct_ctrl
|= ACB_PWNOTREQ
;
507 if (*p
== '*' || *p
== 'X') {
508 /* NULL LM password */
509 pw_buf
->smb_passwd
= NULL
;
510 DEBUG(10, ("getsmbfilepwent: LM password for user %s invalidated\n", user_name
));
511 } else if (pdb_gethexpwd((char *)p
, smbpwd
)) {
512 pw_buf
->smb_passwd
= smbpwd
;
514 pw_buf
->smb_passwd
= NULL
;
515 DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry for user %s \
516 (non hex chars)\n", user_name
));
521 * Now check if the NT compatible password is
524 pw_buf
->smb_nt_passwd
= NULL
;
525 p
+= 33; /* Move to the first character of the line after the lanman password. */
526 if ((linebuf_len
>= (PTR_DIFF(p
, linebuf
) + 33)) && (p
[32] == ':')) {
527 if (*p
!= '*' && *p
!= 'X') {
528 if(pdb_gethexpwd((char *)p
,smbntpwd
)) {
529 pw_buf
->smb_nt_passwd
= smbntpwd
;
532 p
+= 33; /* Move to the first character of the line after the NT password. */
535 DEBUG(5,("getsmbfilepwent: returning passwd entry for user %s, uid %ld\n",
539 unsigned char *end_p
= (unsigned char *)strchr_m((char *)p
, ']');
540 pw_buf
->acct_ctrl
= pdb_decode_acct_ctrl((char*)p
);
542 /* Must have some account type set. */
543 if(pw_buf
->acct_ctrl
== 0) {
544 pw_buf
->acct_ctrl
= ACB_NORMAL
;
547 /* Now try and get the last change time. */
553 if(*p
&& (strncasecmp_m((char *)p
, "LCT-", 4)==0)) {
556 for(i
= 0; i
< 8; i
++) {
557 if(p
[i
] == '\0' || !isxdigit(p
[i
])) {
563 * p points at 8 characters of hex digits -
564 * read into a time_t as the seconds since
565 * 1970 that the password was last changed.
567 pw_buf
->pass_last_set_time
= (time_t)strtol((char *)p
, NULL
, 16);
572 /* 'Old' style file. Fake up based on user name. */
574 * Currently trust accounts are kept in the same
575 * password file as 'normal accounts'. If this changes
576 * we will have to fix this code. JRA.
578 if(pw_buf
->smb_name
[strlen(pw_buf
->smb_name
) - 1] == '$') {
579 pw_buf
->acct_ctrl
&= ~ACB_NORMAL
;
580 pw_buf
->acct_ctrl
|= ACB_WSTRUST
;
587 DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
591 /************************************************************************
592 Create a new smbpasswd entry - malloced space returned.
593 *************************************************************************/
595 static char *format_new_smbpasswd_entry(const struct smb_passwd
*newpwd
)
597 int new_entry_length
;
601 new_entry_length
= strlen(newpwd
->smb_name
) + 1 + 15 + 1 + 32 + 1 + 32 + 1 +
602 NEW_PW_FORMAT_SPACE_PADDED_LEN
+ 1 + 13 + 2;
604 if((new_entry
= (char *)SMB_MALLOC( new_entry_length
)) == NULL
) {
605 DEBUG(0, ("format_new_smbpasswd_entry: Malloc failed adding entry for user %s.\n",
610 slprintf(new_entry
, new_entry_length
- 1, "%s:%u:", newpwd
->smb_name
, (unsigned)newpwd
->smb_userid
);
612 p
= new_entry
+strlen(new_entry
);
613 pdb_sethexpwd(p
, newpwd
->smb_passwd
, newpwd
->acct_ctrl
);
618 pdb_sethexpwd(p
, newpwd
->smb_nt_passwd
, newpwd
->acct_ctrl
);
623 /* Add the account encoding and the last change time. */
624 slprintf((char *)p
, new_entry_length
- 1 - (p
- new_entry
), "%s:LCT-%08X:\n",
625 pdb_encode_acct_ctrl(newpwd
->acct_ctrl
, NEW_PW_FORMAT_SPACE_PADDED_LEN
),
626 (uint32_t)newpwd
->pass_last_set_time
);
631 /************************************************************************
632 Routine to add an entry to the smbpasswd file.
633 *************************************************************************/
635 static NTSTATUS
add_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
,
636 struct smb_passwd
*newpwd
)
638 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
639 struct smb_passwd
*pwd
= NULL
;
643 size_t new_entry_length
;
647 /* Open the smbpassword file - for update. */
648 fp
= startsmbfilepwent(pfile
, PWF_UPDATE
, &smbpasswd_state
->pw_file_lock_depth
);
650 if (fp
== NULL
&& errno
== ENOENT
) {
651 /* Try again - create. */
652 fp
= startsmbfilepwent(pfile
, PWF_CREATE
, &smbpasswd_state
->pw_file_lock_depth
);
656 DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
657 return map_nt_error_from_unix(errno
);
661 * Scan the file, a line at a time and check if the name matches.
664 while ((pwd
= getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) {
665 if (strequal(newpwd
->smb_name
, pwd
->smb_name
)) {
666 DEBUG(0, ("add_smbfilepwd_entry: entry with name %s already exists\n", pwd
->smb_name
));
667 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
668 return NT_STATUS_USER_EXISTS
;
672 /* Ok - entry doesn't exist. We can add it */
674 /* Create a new smb passwd entry and set it to the given password. */
676 * The add user write needs to be atomic - so get the fd from
677 * the fp and do a raw write() call.
681 if((offpos
= lseek(fd
, 0, SEEK_END
)) == -1) {
682 NTSTATUS result
= map_nt_error_from_unix(errno
);
683 DEBUG(0, ("add_smbfilepwd_entry(lseek): Failed to add entry for user %s to file %s. \
684 Error was %s\n", newpwd
->smb_name
, pfile
, strerror(errno
)));
685 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
689 if((new_entry
= format_new_smbpasswd_entry(newpwd
)) == NULL
) {
690 DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
691 Error was %s\n", newpwd
->smb_name
, pfile
, strerror(errno
)));
692 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
693 return NT_STATUS_NO_MEMORY
;
696 new_entry_length
= strlen(new_entry
);
698 #ifdef DEBUG_PASSWORD
699 DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d made line |%s|",
700 fd
, (int)new_entry_length
, new_entry
));
703 if ((wr_len
= write(fd
, new_entry
, new_entry_length
)) != new_entry_length
) {
704 NTSTATUS result
= map_nt_error_from_unix(errno
);
705 DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
706 Error was %s\n", wr_len
, newpwd
->smb_name
, pfile
, strerror(errno
)));
708 /* Remove the entry we just wrote. */
709 if(ftruncate(fd
, offpos
) == -1) {
710 DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
711 Error was %s. Password file may be corrupt ! Please examine by hand !\n",
712 newpwd
->smb_name
, strerror(errno
)));
715 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
721 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
725 /************************************************************************
726 Routine to search the smbpasswd file for an entry matching the username.
727 and then modify its password entry. We can't use the startsmbpwent()/
728 getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
729 in the actual file to decide how much room we have to write data.
730 override = False, normal
731 override = True, override XXXXXXXX'd out password or NO PASS
732 ************************************************************************/
734 static bool mod_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
, const struct smb_passwd
* pwd
)
736 /* Static buffers we will return. */
740 #define LINEBUF_SIZE 255
741 char linebuf
[LINEBUF_SIZE
+ 1];
744 char ascii_p16
[FSTRING_LEN
+ 20];
746 unsigned char *p
= NULL
;
747 size_t linebuf_len
= 0;
750 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
751 bool found_entry
= False
;
752 bool got_pass_last_set_time
= False
;
754 off_t pwd_seekpos
= 0;
761 DEBUG(0, ("No SMB password file set\n"));
764 DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile
));
766 fp
= fopen(pfile
, "r+");
769 DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile
));
772 /* Set a buffer to do more efficient reads */
773 setvbuf(fp
, readbuf
, _IOFBF
, sizeof(readbuf
));
777 if (!pw_file_lock(lockfd
, F_WRLCK
, 5, &smbpasswd_state
->pw_file_lock_depth
)) {
778 DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile
));
783 /* Make sure it is only rw by the owner */
786 /* We have a write lock on the file. */
788 * Scan the file, a line at a time and check if the name matches.
791 while (status
&& !feof(fp
)) {
792 pwd_seekpos
= ftell(fp
);
796 status
= fgets(linebuf
, LINEBUF_SIZE
, fp
);
797 if (status
== NULL
&& ferror(fp
)) {
798 pw_file_unlock(lockfd
, &smbpasswd_state
->pw_file_lock_depth
);
804 * Check if the string is terminated with a newline - if not
805 * then we must keep reading and discard until we get one.
807 linebuf_len
= strlen(linebuf
);
808 if (linebuf
[linebuf_len
- 1] != '\n') {
810 while (!ferror(fp
) && !feof(fp
)) {
817 linebuf
[linebuf_len
- 1] = '\0';
820 #ifdef DEBUG_PASSWORD
821 DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf
));
824 if ((linebuf
[0] == 0) && feof(fp
)) {
825 DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
830 * The line we have should be of the form :-
832 * username:uid:[32hex bytes]:....other flags presently
837 * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
839 * if Windows NT compatible passwords are also present.
842 if (linebuf
[0] == '#' || linebuf
[0] == '\0') {
843 DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
847 p
= (unsigned char *) strchr_m(linebuf
, ':');
850 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
854 strncpy(user_name
, linebuf
, PTR_DIFF(p
, linebuf
));
855 user_name
[PTR_DIFF(p
, linebuf
)] = '\0';
856 if (strequal(user_name
, pwd
->smb_name
)) {
863 pw_file_unlock(lockfd
, &smbpasswd_state
->pw_file_lock_depth
);
866 DEBUG(2, ("Cannot update entry for user %s, as they don't exist in the smbpasswd file!\n",
871 DEBUG(6, ("mod_smbfilepwd_entry: entry exists for user %s\n", pwd
->smb_name
));
873 /* User name matches - get uid and password */
874 p
++; /* Go past ':' */
877 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (uid not number)\n",
879 pw_file_unlock(lockfd
, &smbpasswd_state
->pw_file_lock_depth
);
884 while (*p
&& isdigit(*p
)) {
888 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no : after uid)\n",
890 pw_file_unlock(lockfd
, &smbpasswd_state
->pw_file_lock_depth
);
896 * Now get the password value - this should be 32 hex digits
897 * which are the ascii representations of a 16 byte string.
898 * Get two at a time and put them into the password.
902 /* Record exact password position */
903 pwd_seekpos
+= PTR_DIFF(p
, linebuf
);
905 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
906 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
908 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
914 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
916 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
921 /* Now check if the NT compatible password is available. */
922 p
+= 33; /* Move to the first character of the line after the lanman password. */
923 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
924 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
926 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
932 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
934 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
940 * Now check if the account info and the password last
941 * change time is available.
943 p
+= 33; /* Move to the first character of the line after the NT password. */
947 encode_bits
[i
++] = *p
++;
948 while((linebuf_len
> PTR_DIFF(p
, linebuf
)) && (*p
!= ']')) {
949 encode_bits
[i
++] = *p
++;
952 encode_bits
[i
++] = ']';
953 encode_bits
[i
++] = '\0';
955 if(i
== NEW_PW_FORMAT_SPACE_PADDED_LEN
) {
957 * We are using a new format, space padded
958 * acct ctrl field. Encode the given acct ctrl
961 fstrcpy(encode_bits
, pdb_encode_acct_ctrl(pwd
->acct_ctrl
, NEW_PW_FORMAT_SPACE_PADDED_LEN
));
963 DEBUG(0,("mod_smbfilepwd_entry: Using old smbpasswd format for user %s. \
964 This is no longer supported.!\n", pwd
->smb_name
));
965 DEBUG(0,("mod_smbfilepwd_entry: No changes made, failing.!\n"));
966 pw_file_unlock(lockfd
, &smbpasswd_state
->pw_file_lock_depth
);
971 /* Go past the ']' */
972 if(linebuf_len
> PTR_DIFF(p
, linebuf
)) {
976 if((linebuf_len
> PTR_DIFF(p
, linebuf
)) && (*p
== ':')) {
979 /* We should be pointing at the LCT entry. */
980 if((linebuf_len
> (PTR_DIFF(p
, linebuf
) + 13)) && (strncasecmp_m((char *)p
, "LCT-", 4) == 0)) {
982 for(i
= 0; i
< 8; i
++) {
983 if(p
[i
] == '\0' || !isxdigit(p
[i
])) {
989 * p points at 8 characters of hex digits -
990 * read into a time_t as the seconds since
991 * 1970 that the password was last changed.
993 got_pass_last_set_time
= True
;
995 } /* *p && strncasecmp_m() */
999 /* Entry is correctly formed. */
1001 /* Create the 32 byte representation of the new p16 */
1002 pdb_sethexpwd(ascii_p16
, pwd
->smb_passwd
, pwd
->acct_ctrl
);
1004 /* Add on the NT md4 hash */
1005 ascii_p16
[32] = ':';
1007 pdb_sethexpwd(ascii_p16
+33, pwd
->smb_nt_passwd
, pwd
->acct_ctrl
);
1008 ascii_p16
[65] = ':';
1009 ascii_p16
[66] = '\0'; /* null-terminate the string so that strlen works */
1011 /* Add on the account info bits and the time of last password change. */
1012 if(got_pass_last_set_time
) {
1013 slprintf(&ascii_p16
[strlen(ascii_p16
)],
1014 sizeof(ascii_p16
)-(strlen(ascii_p16
)+1),
1016 encode_bits
, (uint32_t)pwd
->pass_last_set_time
);
1017 wr_len
= strlen(ascii_p16
);
1020 #ifdef DEBUG_PASSWORD
1021 DEBUG(100,("mod_smbfilepwd_entry: "));
1022 dump_data(100, (uint8_t *)ascii_p16
, wr_len
);
1025 if(wr_len
> LINEBUF_SIZE
) {
1026 DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len
+1));
1027 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1033 * Do an atomic write into the file at the position defined by
1037 /* The mod user write needs to be atomic - so get the fd from
1038 the fp and do a raw write() call.
1043 if (lseek(fd
, pwd_seekpos
- 1, SEEK_SET
) != pwd_seekpos
- 1) {
1044 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile
));
1045 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1050 /* Sanity check - ensure the areas we are writing are framed by ':' */
1051 if (read(fd
, linebuf
, wr_len
+1) != wr_len
+1) {
1052 DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile
));
1053 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1058 if ((linebuf
[0] != ':') || (linebuf
[wr_len
] != ':')) {
1059 DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile
));
1060 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1065 if (lseek(fd
, pwd_seekpos
, SEEK_SET
) != pwd_seekpos
) {
1066 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile
));
1067 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1072 if (write(fd
, ascii_p16
, wr_len
) != wr_len
) {
1073 DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile
));
1074 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1079 pw_file_unlock(lockfd
,&smbpasswd_state
->pw_file_lock_depth
);
1084 /************************************************************************
1085 Routine to delete an entry in the smbpasswd file by name.
1086 *************************************************************************/
1088 static bool del_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
, const char *name
)
1090 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
1091 char *pfile2
= NULL
;
1092 struct smb_passwd
*pwd
= NULL
;
1094 FILE *fp_write
= NULL
;
1095 int pfile2_lockdepth
= 0;
1097 pfile2
= talloc_asprintf(talloc_tos(),
1099 pfile
, (unsigned)getpid());
1105 * Open the smbpassword file - for update. It needs to be update
1106 * as we need any other processes to wait until we have replaced
1110 if((fp
= startsmbfilepwent(pfile
, PWF_UPDATE
, &smbpasswd_state
->pw_file_lock_depth
)) == NULL
) {
1111 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile
));
1116 * Create the replacement password file.
1118 if((fp_write
= startsmbfilepwent(pfile2
, PWF_CREATE
, &pfile2_lockdepth
)) == NULL
) {
1119 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile
));
1120 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
1125 * Scan the file, a line at a time and check if the name matches.
1128 while ((pwd
= getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) {
1130 size_t new_entry_length
;
1132 if (strequal(name
, pwd
->smb_name
)) {
1133 DEBUG(10, ("del_smbfilepwd_entry: found entry with "
1134 "name %s - deleting it.\n", name
));
1139 * We need to copy the entry out into the second file.
1142 if((new_entry
= format_new_smbpasswd_entry(pwd
)) == NULL
) {
1143 DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
1144 Error was %s\n", pwd
->smb_name
, pfile2
, strerror(errno
)));
1146 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
1147 endsmbfilepwent(fp_write
, &pfile2_lockdepth
);
1151 new_entry_length
= strlen(new_entry
);
1153 if(fwrite(new_entry
, 1, new_entry_length
, fp_write
) != new_entry_length
) {
1154 DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
1155 Error was %s\n", pwd
->smb_name
, pfile2
, strerror(errno
)));
1157 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
1158 endsmbfilepwent(fp_write
, &pfile2_lockdepth
);
1167 * Ensure pfile2 is flushed before rename.
1170 if(fflush(fp_write
) != 0) {
1171 DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2
, strerror(errno
)));
1172 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
1173 endsmbfilepwent(fp_write
,&pfile2_lockdepth
);
1178 * Do an atomic rename - then release the locks.
1181 if(rename(pfile2
,pfile
) != 0) {
1185 endsmbfilepwent(fp
, &smbpasswd_state
->pw_file_lock_depth
);
1186 endsmbfilepwent(fp_write
,&pfile2_lockdepth
);
1190 /*********************************************************************
1191 Create a smb_passwd struct from a struct samu.
1192 We will not allocate any new memory. The smb_passwd struct
1193 should only stay around as long as the struct samu does.
1194 ********************************************************************/
1196 static bool build_smb_pass (struct smb_passwd
*smb_pw
, const struct samu
*sampass
)
1200 if (sampass
== NULL
)
1202 ZERO_STRUCTP(smb_pw
);
1204 if (!IS_SAM_DEFAULT(sampass
, PDB_USERSID
)) {
1205 rid
= pdb_get_user_rid(sampass
);
1207 /* If the user specified a RID, make sure its able to be both stored and retreived */
1208 if (rid
== DOMAIN_RID_GUEST
) {
1209 struct passwd
*passwd
= Get_Pwnam_alloc(NULL
, lp_guest_account());
1211 DEBUG(0, ("Could not find guest account via Get_Pwnam_alloc()! (%s)\n", lp_guest_account()));
1214 smb_pw
->smb_userid
=passwd
->pw_uid
;
1215 TALLOC_FREE(passwd
);
1216 } else if (algorithmic_pdb_rid_is_user(rid
)) {
1217 smb_pw
->smb_userid
=algorithmic_pdb_user_rid_to_uid(rid
);
1219 DEBUG(0,("build_sam_pass: Failing attempt to store user with non-uid based user RID. \n"));
1224 smb_pw
->smb_name
=(const char*)pdb_get_username(sampass
);
1226 smb_pw
->smb_passwd
=pdb_get_lanman_passwd(sampass
);
1227 smb_pw
->smb_nt_passwd
=pdb_get_nt_passwd(sampass
);
1229 smb_pw
->acct_ctrl
=pdb_get_acct_ctrl(sampass
);
1230 smb_pw
->pass_last_set_time
=pdb_get_pass_last_set_time(sampass
);
1235 /*********************************************************************
1236 Create a struct samu from a smb_passwd struct
1237 ********************************************************************/
1239 static bool build_sam_account(struct smbpasswd_privates
*smbpasswd_state
,
1240 struct samu
*sam_pass
, const struct smb_passwd
*pw_buf
)
1242 struct passwd
*pwfile
;
1245 DEBUG(5,("build_sam_account: struct samu is NULL\n"));
1249 /* verify the user account exists */
1251 if ( !(pwfile
= Get_Pwnam_alloc(NULL
, pw_buf
->smb_name
)) ) {
1252 DEBUG(0,("build_sam_account: smbpasswd database is corrupt! username %s with uid "
1253 "%u is not in unix passwd database!\n", pw_buf
->smb_name
, pw_buf
->smb_userid
));
1257 if ( !NT_STATUS_IS_OK( samu_set_unix(sam_pass
, pwfile
)) )
1260 TALLOC_FREE(pwfile
);
1262 /* set remaining fields */
1264 if (!pdb_set_nt_passwd (sam_pass
, pw_buf
->smb_nt_passwd
, PDB_SET
))
1266 if (!pdb_set_lanman_passwd (sam_pass
, pw_buf
->smb_passwd
, PDB_SET
))
1268 pdb_set_acct_ctrl (sam_pass
, pw_buf
->acct_ctrl
, PDB_SET
);
1269 pdb_set_pass_last_set_time (sam_pass
, pw_buf
->pass_last_set_time
, PDB_SET
);
1270 pdb_set_pass_can_change_time (sam_pass
, pw_buf
->pass_last_set_time
, PDB_SET
);
1275 /*****************************************************************
1276 Functions to be implemented by the new passdb API
1277 ****************************************************************/
1279 /****************************************************************
1280 Search smbpasswd file by iterating over the entries. Do not
1281 call getpwnam() for unix account information until we have found
1283 ***************************************************************/
1285 static NTSTATUS
smbpasswd_getsampwnam(struct pdb_methods
*my_methods
,
1286 struct samu
*sam_acct
, const char *username
)
1288 NTSTATUS nt_status
= NT_STATUS_UNSUCCESSFUL
;
1289 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1290 struct smb_passwd
*smb_pw
;
1293 DEBUG(10, ("getsampwnam (smbpasswd): search by name: %s\n", username
));
1295 /* startsmbfilepwent() is used here as we don't want to lookup
1296 the UNIX account in the local system password file until
1298 fp
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
, PWF_READ
, &(smbpasswd_state
->pw_file_lock_depth
));
1301 DEBUG(0, ("Unable to open passdb database.\n"));
1305 while ( ((smb_pw
=getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
)&& (!strequal(smb_pw
->smb_name
, username
)) )
1306 /* do nothing....another loop */ ;
1308 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1311 /* did we locate the username in smbpasswd */
1315 DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw
->smb_name
));
1318 DEBUG(10,("getsampwnam (smbpasswd): struct samu is NULL\n"));
1322 /* now build the struct samu */
1323 if (!build_sam_account(smbpasswd_state
, sam_acct
, smb_pw
))
1327 return NT_STATUS_OK
;
1330 static NTSTATUS
smbpasswd_getsampwsid(struct pdb_methods
*my_methods
, struct samu
*sam_acct
, const struct dom_sid
*sid
)
1332 NTSTATUS nt_status
= NT_STATUS_UNSUCCESSFUL
;
1333 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1334 struct smb_passwd
*smb_pw
;
1335 struct dom_sid_buf buf
;
1339 DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n",
1340 dom_sid_str_buf(sid
, &buf
)));
1342 if (!sid_peek_check_rid(get_global_sam_sid(), sid
, &rid
))
1343 return NT_STATUS_UNSUCCESSFUL
;
1345 /* More special case 'guest account' hacks... */
1346 if (rid
== DOMAIN_RID_GUEST
) {
1347 const char *guest_account
= lp_guest_account();
1348 if (!(guest_account
&& *guest_account
)) {
1349 DEBUG(1, ("Guest account not specified!\n"));
1352 return smbpasswd_getsampwnam(my_methods
, sam_acct
, guest_account
);
1355 /* Open the sam password file - not for update. */
1356 fp
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
, PWF_READ
, &(smbpasswd_state
->pw_file_lock_depth
));
1359 DEBUG(0, ("Unable to open passdb database.\n"));
1363 while ( ((smb_pw
=getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) && (algorithmic_pdb_uid_to_user_rid(smb_pw
->smb_userid
) != rid
) )
1366 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1369 /* did we locate the username in smbpasswd */
1373 DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw
->smb_name
));
1376 DEBUG(10,("getsampwrid: (smbpasswd) struct samu is NULL\n"));
1380 /* now build the struct samu */
1381 if (!build_sam_account (smbpasswd_state
, sam_acct
, smb_pw
))
1384 /* build_sam_account might change the SID on us, if the name was for the guest account */
1385 if (NT_STATUS_IS_OK(nt_status
) && !dom_sid_equal(pdb_get_user_sid(sam_acct
), sid
)) {
1386 struct dom_sid_buf buf1
, buf2
;
1387 DEBUG(1, ("looking for user with sid %s instead returned %s "
1388 "for account %s!?!\n",
1389 dom_sid_str_buf(sid
, &buf1
),
1390 dom_sid_str_buf(pdb_get_user_sid(sam_acct
), &buf2
),
1391 pdb_get_username(sam_acct
)));
1392 return NT_STATUS_NO_SUCH_USER
;
1396 return NT_STATUS_OK
;
1399 static NTSTATUS
smbpasswd_add_sam_account(struct pdb_methods
*my_methods
, struct samu
*sampass
)
1401 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1402 struct smb_passwd smb_pw
;
1404 /* convert the struct samu */
1405 if (!build_smb_pass(&smb_pw
, sampass
)) {
1406 return NT_STATUS_UNSUCCESSFUL
;
1410 return add_smbfilepwd_entry(smbpasswd_state
, &smb_pw
);
1413 static NTSTATUS
smbpasswd_update_sam_account(struct pdb_methods
*my_methods
, struct samu
*sampass
)
1415 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1416 struct smb_passwd smb_pw
;
1418 /* convert the struct samu */
1419 if (!build_smb_pass(&smb_pw
, sampass
)) {
1420 DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
1421 return NT_STATUS_UNSUCCESSFUL
;
1424 /* update the entry */
1425 if(!mod_smbfilepwd_entry(smbpasswd_state
, &smb_pw
)) {
1426 DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
1427 return NT_STATUS_UNSUCCESSFUL
;
1430 return NT_STATUS_OK
;
1433 static NTSTATUS
smbpasswd_delete_sam_account (struct pdb_methods
*my_methods
, struct samu
*sampass
)
1435 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1437 const char *username
= pdb_get_username(sampass
);
1439 if (del_smbfilepwd_entry(smbpasswd_state
, username
))
1440 return NT_STATUS_OK
;
1442 return NT_STATUS_UNSUCCESSFUL
;
1445 static NTSTATUS
smbpasswd_rename_sam_account (struct pdb_methods
*my_methods
,
1446 struct samu
*old_acct
,
1447 const char *newname
)
1449 char *rename_script
= NULL
;
1450 struct samu
*new_acct
= NULL
;
1451 bool interim_account
= False
;
1452 TALLOC_CTX
*ctx
= talloc_tos();
1453 NTSTATUS ret
= NT_STATUS_UNSUCCESSFUL
;
1455 if (!*(lp_rename_user_script(talloc_tos())))
1458 if ( !(new_acct
= samu_new( NULL
)) ) {
1459 return NT_STATUS_NO_MEMORY
;
1462 if ( !pdb_copy_sam_account( new_acct
, old_acct
)
1463 || !pdb_set_username(new_acct
, newname
, PDB_CHANGED
))
1468 ret
= smbpasswd_add_sam_account(my_methods
, new_acct
);
1469 if (!NT_STATUS_IS_OK(ret
))
1472 interim_account
= True
;
1474 /* rename the posix user */
1475 rename_script
= lp_rename_user_script(ctx
);
1476 if (!rename_script
) {
1477 ret
= NT_STATUS_NO_MEMORY
;
1481 if (*rename_script
) {
1484 rename_script
= talloc_string_sub2(ctx
,
1491 if (!rename_script
) {
1492 ret
= NT_STATUS_NO_MEMORY
;
1495 rename_script
= talloc_string_sub2(ctx
,
1498 pdb_get_username(old_acct
),
1502 if (!rename_script
) {
1503 ret
= NT_STATUS_NO_MEMORY
;
1507 rename_ret
= smbrun(rename_script
, NULL
, NULL
);
1509 DEBUG(rename_ret
? 0 : 3,("Running the command `%s' gave %d\n", rename_script
, rename_ret
));
1511 if (rename_ret
== 0) {
1512 smb_nscd_flush_user_cache();
1521 smbpasswd_delete_sam_account(my_methods
, old_acct
);
1522 interim_account
= False
;
1526 if (interim_account
)
1527 smbpasswd_delete_sam_account(my_methods
, new_acct
);
1530 TALLOC_FREE(new_acct
);
1535 static uint32_t smbpasswd_capabilities(struct pdb_methods
*methods
)
1540 static void free_private_data(void **vp
)
1542 struct smbpasswd_privates
**privates
= (struct smbpasswd_privates
**)vp
;
1544 endsmbfilepwent((*privates
)->pw_file
, &((*privates
)->pw_file_lock_depth
));
1547 /* No need to free any further, as it is talloc()ed */
1550 struct smbpasswd_search_state
{
1551 uint32_t acct_flags
;
1553 struct samr_displayentry
*entries
;
1554 uint32_t num_entries
;
1559 static void smbpasswd_search_end(struct pdb_search
*search
)
1561 struct smbpasswd_search_state
*state
= talloc_get_type_abort(
1562 search
->private_data
, struct smbpasswd_search_state
);
1566 static bool smbpasswd_search_next_entry(struct pdb_search
*search
,
1567 struct samr_displayentry
*entry
)
1569 struct smbpasswd_search_state
*state
= talloc_get_type_abort(
1570 search
->private_data
, struct smbpasswd_search_state
);
1572 if (state
->current
== state
->num_entries
) {
1576 entry
->idx
= state
->entries
[state
->current
].idx
;
1577 entry
->rid
= state
->entries
[state
->current
].rid
;
1578 entry
->acct_flags
= state
->entries
[state
->current
].acct_flags
;
1580 entry
->account_name
= talloc_strdup(
1581 search
, state
->entries
[state
->current
].account_name
);
1582 entry
->fullname
= talloc_strdup(
1583 search
, state
->entries
[state
->current
].fullname
);
1584 entry
->description
= talloc_strdup(
1585 search
, state
->entries
[state
->current
].description
);
1587 if ((entry
->account_name
== NULL
) || (entry
->fullname
== NULL
)
1588 || (entry
->description
== NULL
)) {
1589 DEBUG(0, ("talloc_strdup failed\n"));
1593 state
->current
+= 1;
1597 static bool smbpasswd_search_users(struct pdb_methods
*methods
,
1598 struct pdb_search
*search
,
1599 uint32_t acct_flags
)
1601 struct smbpasswd_privates
*smbpasswd_state
=
1602 (struct smbpasswd_privates
*)methods
->private_data
;
1604 struct smbpasswd_search_state
*search_state
;
1605 struct smb_passwd
*pwd
;
1608 search_state
= talloc_zero(search
, struct smbpasswd_search_state
);
1609 if (search_state
== NULL
) {
1610 DEBUG(0, ("talloc failed\n"));
1613 search_state
->acct_flags
= acct_flags
;
1615 fp
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
, PWF_READ
,
1616 &smbpasswd_state
->pw_file_lock_depth
);
1619 DEBUG(10, ("Unable to open smbpasswd file.\n"));
1620 TALLOC_FREE(search_state
);
1624 while ((pwd
= getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) {
1625 struct samr_displayentry entry
;
1628 if ((acct_flags
!= 0)
1629 && ((acct_flags
& pwd
->acct_ctrl
) == 0)) {
1633 user
= samu_new(talloc_tos());
1635 DEBUG(0, ("samu_new failed\n"));
1639 if (!build_sam_account(smbpasswd_state
, user
, pwd
)) {
1640 /* Already got debug msgs... */
1646 entry
.acct_flags
= pdb_get_acct_ctrl(user
);
1647 sid_peek_rid(pdb_get_user_sid(user
), &entry
.rid
);
1648 entry
.account_name
= talloc_strdup(
1649 search_state
, pdb_get_username(user
));
1650 entry
.fullname
= talloc_strdup(
1651 search_state
, pdb_get_fullname(user
));
1652 entry
.description
= talloc_strdup(
1653 search_state
, pdb_get_acct_desc(user
));
1657 if ((entry
.account_name
== NULL
) || (entry
.fullname
== NULL
)
1658 || (entry
.description
== NULL
)) {
1659 DEBUG(0, ("talloc_strdup failed\n"));
1663 ADD_TO_LARGE_ARRAY(search_state
, struct samr_displayentry
,
1664 entry
, &search_state
->entries
,
1665 &search_state
->num_entries
,
1666 &search_state
->array_size
);
1669 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1671 search
->private_data
= search_state
;
1672 search
->next_entry
= smbpasswd_search_next_entry
;
1673 search
->search_end
= smbpasswd_search_end
;
1678 static NTSTATUS
pdb_init_smbpasswd( struct pdb_methods
**pdb_method
, const char *location
)
1681 struct smbpasswd_privates
*privates
;
1683 if ( !NT_STATUS_IS_OK(nt_status
= make_pdb_method( pdb_method
)) ) {
1687 (*pdb_method
)->name
= "smbpasswd";
1689 (*pdb_method
)->getsampwnam
= smbpasswd_getsampwnam
;
1690 (*pdb_method
)->getsampwsid
= smbpasswd_getsampwsid
;
1691 (*pdb_method
)->add_sam_account
= smbpasswd_add_sam_account
;
1692 (*pdb_method
)->update_sam_account
= smbpasswd_update_sam_account
;
1693 (*pdb_method
)->delete_sam_account
= smbpasswd_delete_sam_account
;
1694 (*pdb_method
)->rename_sam_account
= smbpasswd_rename_sam_account
;
1695 (*pdb_method
)->search_users
= smbpasswd_search_users
;
1697 (*pdb_method
)->capabilities
= smbpasswd_capabilities
;
1699 /* Setup private data and free function */
1701 if ( !(privates
= talloc_zero( *pdb_method
, struct smbpasswd_privates
)) ) {
1702 DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
1703 return NT_STATUS_NO_MEMORY
;
1706 /* Store some config details */
1709 privates
->smbpasswd_file
= talloc_strdup(*pdb_method
, location
);
1711 privates
->smbpasswd_file
= talloc_strdup(*pdb_method
, lp_smb_passwd_file());
1714 if (!privates
->smbpasswd_file
) {
1715 DEBUG(0, ("talloc_strdp() failed for storing smbpasswd location!\n"));
1716 return NT_STATUS_NO_MEMORY
;
1719 (*pdb_method
)->private_data
= privates
;
1721 (*pdb_method
)->free_private_data
= free_private_data
;
1723 return NT_STATUS_OK
;
1726 NTSTATUS
pdb_smbpasswd_init(TALLOC_CTX
*ctx
)
1728 return smb_register_passdb(PASSDB_INTERFACE_VERSION
, "smbpasswd", pdb_init_smbpasswd
);