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
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 2 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, write to the Free Software Foundation, Inc., 675
21 * Mass Ave, Cambridge, MA 02139, USA.
27 #define DBGC_CLASS DBGC_PASSDB
30 smb_passwd is analogous to sam_passwd used everywhere
31 else. However, smb_passwd is limited to the information
32 stored by an smbpasswd entry
37 BOOL smb_userid_set
; /* this is actually the unix uid_t */
38 uint32 smb_userid
; /* this is actually the unix uid_t */
39 const char *smb_name
; /* username string */
41 const unsigned char *smb_passwd
; /* Null if no password */
42 const unsigned char *smb_nt_passwd
; /* Null if no password */
44 uint16 acct_ctrl
; /* account info (ACB_xxxx bit-mask) */
45 time_t pass_last_set_time
; /* password last set time */
48 struct smbpasswd_privates
50 /* used for maintain locks on the smbpasswd file */
51 int pw_file_lock_depth
;
53 /* Global File pointer */
56 /* formerly static variables */
57 struct smb_passwd pw_buf
;
59 unsigned char smbpwd
[16];
60 unsigned char smbntpwd
[16];
62 /* retrive-once info */
63 const char *smbpasswd_file
;
65 BOOL permit_non_unix_accounts
;
68 uid_t high_nua_userid
;
72 enum pwf_access_type
{ PWF_READ
, PWF_UPDATE
, PWF_CREATE
};
74 /***************************************************************
75 Lock an fd. Abandon after waitsecs seconds.
76 ****************************************************************/
78 static BOOL
pw_file_lock(int fd
, int type
, int secs
, int *plock_depth
)
83 if(*plock_depth
== 0) {
84 if (!do_file_lock(fd
, secs
, type
)) {
85 DEBUG(10,("pw_file_lock: locking file failed, error = %s.\n",
96 /***************************************************************
97 Unlock an fd. Abandon after waitsecs seconds.
98 ****************************************************************/
100 static BOOL
pw_file_unlock(int fd
, int *plock_depth
)
104 if (fd
== 0 || *plock_depth
== 0) {
108 if(*plock_depth
== 1)
109 ret
= do_file_lock(fd
, 5, F_UNLCK
);
111 if (*plock_depth
> 0)
115 DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
121 /**************************************************************
122 Intialize a smb_passwd struct
123 *************************************************************/
125 static void pdb_init_smb(struct smb_passwd
*user
)
131 user
->pass_last_set_time
= (time_t)0;
134 /***************************************************************
135 Internal fn to enumerate the smbpasswd list. Returns a void pointer
136 to ensure no modification outside this module. Checks for atomic
137 rename of smbpasswd file on update or create once the lock has
138 been granted to prevent race conditions. JRA.
139 ****************************************************************/
141 static FILE *startsmbfilepwent(const char *pfile
, enum pwf_access_type type
, int *lock_depth
)
144 const char *open_mode
= NULL
;
146 int lock_type
= F_RDLCK
;
149 DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
164 * Ensure atomic file creation.
169 for(i
= 0; i
< 5; i
++) {
170 if((fd
= sys_open(pfile
, O_CREAT
|O_TRUNC
|O_EXCL
|O_RDWR
, 0600))!=-1)
172 sys_usleep(200); /* Spin, spin... */
175 DEBUG(0,("startsmbfilepwent_internal: too many race conditions creating file %s\n", pfile
));
185 for(race_loop
= 0; race_loop
< 5; race_loop
++) {
186 DEBUG(10, ("startsmbfilepwent_internal: opening file %s\n", pfile
));
188 if((fp
= sys_fopen(pfile
, open_mode
)) == NULL
) {
189 DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. Error was %s\n", pfile
, strerror(errno
) ));
193 if (!pw_file_lock(fileno(fp
), lock_type
, 5, lock_depth
)) {
194 DEBUG(0, ("startsmbfilepwent_internal: unable to lock file %s. Error was %s\n", pfile
, strerror(errno
) ));
200 * Only check for replacement races on update or create.
201 * For read we don't mind if the data is one record out of date.
204 if(type
== PWF_READ
) {
207 SMB_STRUCT_STAT sbuf1
, sbuf2
;
210 * Avoid the potential race condition between the open and the lock
211 * by doing a stat on the filename and an fstat on the fd. If the
212 * two inodes differ then someone did a rename between the open and
213 * the lock. Back off and try the open again. Only do this 5 times to
214 * prevent infinate loops. JRA.
217 if (sys_stat(pfile
,&sbuf1
) != 0) {
218 DEBUG(0, ("startsmbfilepwent_internal: unable to stat file %s. Error was %s\n", pfile
, strerror(errno
)));
219 pw_file_unlock(fileno(fp
), lock_depth
);
224 if (sys_fstat(fileno(fp
),&sbuf2
) != 0) {
225 DEBUG(0, ("startsmbfilepwent_internal: unable to fstat file %s. Error was %s\n", pfile
, strerror(errno
)));
226 pw_file_unlock(fileno(fp
), lock_depth
);
231 if( sbuf1
.st_ino
== sbuf2
.st_ino
) {
237 * Race occurred - back off and try again...
240 pw_file_unlock(fileno(fp
), lock_depth
);
246 DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile
));
250 /* Set a buffer to do more efficient reads */
251 setvbuf(fp
, (char *)NULL
, _IOFBF
, 1024);
253 /* Make sure it is only rw by the owner */
254 if(fchmod(fileno(fp
), S_IRUSR
|S_IWUSR
) == -1) {
255 DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
256 Error was %s\n.", pfile
, strerror(errno
) ));
257 pw_file_unlock(fileno(fp
), lock_depth
);
262 /* We have a lock on the file. */
266 /***************************************************************
267 End enumeration of the smbpasswd list.
268 ****************************************************************/
269 static void endsmbfilepwent(FILE *fp
, int *lock_depth
)
275 pw_file_unlock(fileno(fp
), lock_depth
);
277 DEBUG(7, ("endsmbfilepwent_internal: closed password file.\n"));
280 /*************************************************************************
281 Routine to return the next entry in the smbpasswd list.
282 *************************************************************************/
284 static struct smb_passwd
*getsmbfilepwent(struct smbpasswd_privates
*smbpasswd_state
, FILE *fp
)
286 /* Static buffers we will return. */
287 struct smb_passwd
*pw_buf
= &smbpasswd_state
->pw_buf
;
288 char *user_name
= smbpasswd_state
->user_name
;
289 unsigned char *smbpwd
= smbpasswd_state
->smbpwd
;
290 unsigned char *smbntpwd
= smbpasswd_state
->smbntpwd
;
298 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
302 pdb_init_smb(pw_buf
);
304 pw_buf
->acct_ctrl
= ACB_NORMAL
;
307 * Scan the file, a line at a time and check if the name matches.
312 fgets(linebuf
, 256, fp
);
318 * Check if the string is terminated with a newline - if not
319 * then we must keep reading and discard until we get one.
321 if ((linebuf_len
= strlen(linebuf
)) == 0)
324 if (linebuf
[linebuf_len
- 1] != '\n') {
326 while (!ferror(fp
) && !feof(fp
)) {
332 linebuf
[linebuf_len
- 1] = '\0';
334 #ifdef DEBUG_PASSWORD
335 DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf
));
337 if ((linebuf
[0] == 0) && feof(fp
)) {
338 DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
342 * The line we have should be of the form :-
344 * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
349 * username:uid:32hex bytes:32hex bytes:[Account type]:LCT-12345678....ignored....
351 * if Windows NT compatible passwords are also present.
352 * [Account type] is an ascii encoding of the type of account.
353 * LCT-(8 hex digits) is the time_t value of the last change time.
356 if (linebuf
[0] == '#' || linebuf
[0] == '\0') {
357 DEBUG(6, ("getsmbfilepwent: skipping comment or blank line\n"));
360 p
= (unsigned char *) strchr_m(linebuf
, ':');
362 DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
366 * As 256 is shorter than a pstring we don't need to check
367 * length here - if this ever changes....
369 SMB_ASSERT(sizeof(pstring
) > sizeof(linebuf
));
371 strncpy(user_name
, linebuf
, PTR_DIFF(p
, linebuf
));
372 user_name
[PTR_DIFF(p
, linebuf
)] = '\0';
376 p
++; /* Go past ':' */
379 DEBUG(0, ("getsmbfilepwent: uids in the smbpasswd file must not be negative.\n"));
384 DEBUG(0, ("getsmbfilepwent: malformed password entry (uid not number)\n"));
388 uidval
= atoi((char *) p
);
390 while (*p
&& isdigit(*p
))
394 DEBUG(0, ("getsmbfilepwent: malformed password entry (no : after uid)\n"));
398 pw_buf
->smb_name
= user_name
;
399 pw_buf
->smb_userid
= uidval
;
402 * Now get the password value - this should be 32 hex digits
403 * which are the ascii representations of a 16 byte string.
404 * Get two at a time and put them into the password.
410 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
411 DEBUG(0, ("getsmbfilepwent: malformed password entry (passwd too short)\n"));
416 DEBUG(0, ("getsmbfilepwent: malformed password entry (no terminating :)\n"));
420 if (!strncasecmp((char *) p
, "NO PASSWORD", 11)) {
421 pw_buf
->smb_passwd
= NULL
;
422 pw_buf
->acct_ctrl
|= ACB_PWNOTREQ
;
424 if (*p
== '*' || *p
== 'X') {
425 /* NULL LM password */
426 pw_buf
->smb_passwd
= NULL
;
427 DEBUG(10, ("getsmbfilepwent: LM password for user %s invalidated\n", user_name
));
428 } else if (pdb_gethexpwd((char *)p
, smbpwd
)) {
429 pw_buf
->smb_passwd
= smbpwd
;
431 pw_buf
->smb_passwd
= NULL
;
432 DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry (non hex chars)\n"));
437 * Now check if the NT compatible password is
440 pw_buf
->smb_nt_passwd
= NULL
;
442 p
+= 33; /* Move to the first character of the line after
443 the lanman password. */
444 if ((linebuf_len
>= (PTR_DIFF(p
, linebuf
) + 33)) && (p
[32] == ':')) {
445 if (*p
!= '*' && *p
!= 'X') {
446 if(pdb_gethexpwd((char *)p
,smbntpwd
))
447 pw_buf
->smb_nt_passwd
= smbntpwd
;
449 p
+= 33; /* Move to the first character of the line after
453 DEBUG(5,("getsmbfilepwent: returning passwd entry for user %s, uid %ld\n",
458 unsigned char *end_p
= (unsigned char *)strchr_m((char *)p
, ']');
459 pw_buf
->acct_ctrl
= pdb_decode_acct_ctrl((char*)p
);
461 /* Must have some account type set. */
462 if(pw_buf
->acct_ctrl
== 0)
463 pw_buf
->acct_ctrl
= ACB_NORMAL
;
465 /* Now try and get the last change time. */
470 if(*p
&& (StrnCaseCmp((char *)p
, "LCT-", 4)==0)) {
473 for(i
= 0; i
< 8; i
++) {
474 if(p
[i
] == '\0' || !isxdigit(p
[i
]))
479 * p points at 8 characters of hex digits -
480 * read into a time_t as the seconds since
481 * 1970 that the password was last changed.
483 pw_buf
->pass_last_set_time
= (time_t)strtol((char *)p
, NULL
, 16);
488 /* 'Old' style file. Fake up based on user name. */
490 * Currently trust accounts are kept in the same
491 * password file as 'normal accounts'. If this changes
492 * we will have to fix this code. JRA.
494 if(pw_buf
->smb_name
[strlen(pw_buf
->smb_name
) - 1] == '$') {
495 pw_buf
->acct_ctrl
&= ~ACB_NORMAL
;
496 pw_buf
->acct_ctrl
|= ACB_WSTRUST
;
503 DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
507 /************************************************************************
508 Create a new smbpasswd entry - malloced space returned.
509 *************************************************************************/
511 static char *format_new_smbpasswd_entry(const struct smb_passwd
*newpwd
)
513 int new_entry_length
;
517 new_entry_length
= strlen(newpwd
->smb_name
) + 1 + 15 + 1 + 32 + 1 + 32 + 1 + NEW_PW_FORMAT_SPACE_PADDED_LEN
+ 1 + 13 + 2;
519 if((new_entry
= (char *)malloc( new_entry_length
)) == NULL
) {
520 DEBUG(0, ("format_new_smbpasswd_entry: Malloc failed adding entry for user %s.\n", newpwd
->smb_name
));
524 slprintf(new_entry
, new_entry_length
- 1, "%s:%u:", newpwd
->smb_name
, (unsigned)newpwd
->smb_userid
);
526 p
= new_entry
+strlen(new_entry
);
528 pdb_sethexpwd(p
, newpwd
->smb_passwd
, newpwd
->acct_ctrl
);
530 p
+=strlen(p
); *p
= ':'; p
++;
532 pdb_sethexpwd(p
, newpwd
->smb_nt_passwd
, newpwd
->acct_ctrl
);
534 p
+=strlen(p
); *p
= ':'; p
++;
536 /* Add the account encoding and the last change time. */
537 slprintf((char *)p
, new_entry_length
- 1 - (p
- new_entry
), "%s:LCT-%08X:\n",
538 pdb_encode_acct_ctrl(newpwd
->acct_ctrl
, NEW_PW_FORMAT_SPACE_PADDED_LEN
),
539 (uint32
)newpwd
->pass_last_set_time
);
544 /************************************************************************
545 Routine to add an entry to the smbpasswd file.
546 *************************************************************************/
548 static BOOL
add_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
, struct smb_passwd
*newpwd
)
550 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
551 struct smb_passwd
*pwd
= NULL
;
555 size_t new_entry_length
;
558 uint32 max_found_uid
= 0;
560 /* Open the smbpassword file - for update. */
561 fp
= startsmbfilepwent(pfile
, PWF_UPDATE
, &(smbpasswd_state
->pw_file_lock_depth
));
563 if (fp
== NULL
&& errno
== ENOENT
) {
564 /* Try again - create. */
565 fp
= startsmbfilepwent(pfile
, PWF_CREATE
, &(smbpasswd_state
->pw_file_lock_depth
));
569 DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
574 * Scan the file, a line at a time and check if the name matches.
577 while ((pwd
= getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
)
579 if (strequal(newpwd
->smb_name
, pwd
->smb_name
))
581 DEBUG(0, ("add_smbfilepwd_entry: entry with name %s already exists\n", pwd
->smb_name
));
582 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
586 /* Look for a free uid for use in non-unix accounts */
587 if (pwd
->smb_userid
> max_found_uid
) {
588 max_found_uid
= pwd
->smb_userid
;
592 /* Ok - entry doesn't exist. We can add it */
594 /* Account not in /etc/passwd hack!!! */
595 if (!newpwd
->smb_userid_set
) {
596 if (!smbpasswd_state
->permit_non_unix_accounts
) {
597 DEBUG(0, ("add_smbfilepwd_entry: cannot add account %s without unix identity\n", newpwd
->smb_name
));
598 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
602 if (max_found_uid
< smbpasswd_state
->low_nua_userid
) {
603 newpwd
->smb_userid
= smbpasswd_state
->low_nua_userid
;
604 newpwd
->smb_userid_set
= True
;
605 } else if (max_found_uid
>= smbpasswd_state
->high_nua_userid
) {
606 DEBUG(0, ("add_smbfilepwd_entry: cannot add machine %s, no uids are free! \n", newpwd
->smb_name
));
607 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
610 newpwd
->smb_userid
= max_found_uid
+ 1;
611 newpwd
->smb_userid_set
= True
;
616 /* Create a new smb passwd entry and set it to the given password. */
618 * The add user write needs to be atomic - so get the fd from
619 * the fp and do a raw write() call.
623 if((offpos
= sys_lseek(fd
, 0, SEEK_END
)) == -1)
625 DEBUG(0, ("add_smbfilepwd_entry(sys_lseek): Failed to add entry for user %s to file %s. \
626 Error was %s\n", newpwd
->smb_name
, pfile
, strerror(errno
)));
627 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
631 if((new_entry
= format_new_smbpasswd_entry(newpwd
)) == NULL
)
633 DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
634 Error was %s\n", newpwd
->smb_name
, pfile
, strerror(errno
)));
635 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
639 new_entry_length
= strlen(new_entry
);
641 #ifdef DEBUG_PASSWORD
642 DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d made line |%s|",
643 fd
, new_entry_length
, new_entry
));
646 if ((wr_len
= write(fd
, new_entry
, new_entry_length
)) != new_entry_length
)
648 DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
649 Error was %s\n", wr_len
, newpwd
->smb_name
, pfile
, strerror(errno
)));
651 /* Remove the entry we just wrote. */
652 if(sys_ftruncate(fd
, offpos
) == -1)
654 DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
655 Error was %s. Password file may be corrupt ! Please examine by hand !\n",
656 newpwd
->smb_name
, strerror(errno
)));
659 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
665 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
669 /************************************************************************
670 Routine to search the smbpasswd file for an entry matching the username.
671 and then modify its password entry. We can't use the startsmbpwent()/
672 getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
673 in the actual file to decide how much room we have to write data.
674 override = False, normal
675 override = True, override XXXXXXXX'd out password or NO PASS
676 ************************************************************************/
678 static BOOL
mod_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
, const struct smb_passwd
* pwd
)
680 /* Static buffers we will return. */
688 unsigned char *p
= NULL
;
689 size_t linebuf_len
= 0;
692 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
693 BOOL found_entry
= False
;
694 BOOL got_pass_last_set_time
= False
;
696 SMB_OFF_T pwd_seekpos
= 0;
703 DEBUG(0, ("No SMB password file set\n"));
706 DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile
));
708 fp
= sys_fopen(pfile
, "r+");
711 DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile
));
714 /* Set a buffer to do more efficient reads */
715 setvbuf(fp
, readbuf
, _IOFBF
, sizeof(readbuf
));
719 if (!pw_file_lock(lockfd
, F_WRLCK
, 5, &(smbpasswd_state
->pw_file_lock_depth
))) {
720 DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile
));
725 /* Make sure it is only rw by the owner */
728 /* We have a write lock on the file. */
730 * Scan the file, a line at a time and check if the name matches.
733 pwd_seekpos
= sys_ftell(fp
);
737 fgets(linebuf
, sizeof(linebuf
), fp
);
739 pw_file_unlock(lockfd
, &(smbpasswd_state
->pw_file_lock_depth
));
745 * Check if the string is terminated with a newline - if not
746 * then we must keep reading and discard until we get one.
748 linebuf_len
= strlen(linebuf
);
749 if (linebuf
[linebuf_len
- 1] != '\n') {
751 while (!ferror(fp
) && !feof(fp
)) {
758 linebuf
[linebuf_len
- 1] = '\0';
761 #ifdef DEBUG_PASSWORD
762 DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf
));
765 if ((linebuf
[0] == 0) && feof(fp
)) {
766 DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
771 * The line we have should be of the form :-
773 * username:uid:[32hex bytes]:....other flags presently
778 * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
780 * if Windows NT compatible passwords are also present.
783 if (linebuf
[0] == '#' || linebuf
[0] == '\0') {
784 DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
788 p
= (unsigned char *) strchr_m(linebuf
, ':');
791 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
796 * As 256 is shorter than a pstring we don't need to check
797 * length here - if this ever changes....
800 SMB_ASSERT(sizeof(user_name
) > sizeof(linebuf
));
802 strncpy(user_name
, linebuf
, PTR_DIFF(p
, linebuf
));
803 user_name
[PTR_DIFF(p
, linebuf
)] = '\0';
804 if (strequal(user_name
, pwd
->smb_name
)) {
811 pw_file_unlock(lockfd
, &(smbpasswd_state
->pw_file_lock_depth
));
814 DEBUG(2, ("Cannot update entry for user %s, as they don't exist in the smbpasswd file!\n",
819 DEBUG(6, ("mod_smbfilepwd_entry: entry exists\n"));
821 /* User name matches - get uid and password */
822 p
++; /* Go past ':' */
825 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (uid not number)\n"));
826 pw_file_unlock(lockfd
, &(smbpasswd_state
->pw_file_lock_depth
));
831 while (*p
&& isdigit(*p
))
834 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no : after uid)\n"));
835 pw_file_unlock(lockfd
, &(smbpasswd_state
->pw_file_lock_depth
));
841 * Now get the password value - this should be 32 hex digits
842 * which are the ascii representations of a 16 byte string.
843 * Get two at a time and put them into the password.
847 /* Record exact password position */
848 pwd_seekpos
+= PTR_DIFF(p
, linebuf
);
850 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
851 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
852 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
858 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
859 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
864 /* Now check if the NT compatible password is
866 p
+= 33; /* Move to the first character of the line after
867 the lanman password. */
868 if (linebuf_len
< (PTR_DIFF(p
, linebuf
) + 33)) {
869 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
870 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
876 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
877 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
883 * Now check if the account info and the password last
884 * change time is available.
886 p
+= 33; /* Move to the first character of the line after
892 encode_bits
[i
++] = *p
++;
893 while((linebuf_len
> PTR_DIFF(p
, linebuf
)) && (*p
!= ']'))
894 encode_bits
[i
++] = *p
++;
896 encode_bits
[i
++] = ']';
897 encode_bits
[i
++] = '\0';
899 if(i
== NEW_PW_FORMAT_SPACE_PADDED_LEN
) {
901 * We are using a new format, space padded
902 * acct ctrl field. Encode the given acct ctrl
905 fstrcpy(encode_bits
, pdb_encode_acct_ctrl(pwd
->acct_ctrl
, NEW_PW_FORMAT_SPACE_PADDED_LEN
));
907 DEBUG(0,("mod_smbfilepwd_entry: Using old smbpasswd format. This is no longer supported.!\n"));
908 DEBUG(0,("mod_smbfilepwd_entry: No changes made, failing.!\n"));
912 /* Go past the ']' */
913 if(linebuf_len
> PTR_DIFF(p
, linebuf
))
916 if((linebuf_len
> PTR_DIFF(p
, linebuf
)) && (*p
== ':')) {
919 /* We should be pointing at the LCT entry. */
920 if((linebuf_len
> (PTR_DIFF(p
, linebuf
) + 13)) && (StrnCaseCmp((char *)p
, "LCT-", 4) == 0)) {
923 for(i
= 0; i
< 8; i
++) {
924 if(p
[i
] == '\0' || !isxdigit(p
[i
]))
929 * p points at 8 characters of hex digits -
930 * read into a time_t as the seconds since
931 * 1970 that the password was last changed.
933 got_pass_last_set_time
= True
;
935 } /* *p && StrnCaseCmp() */
939 /* Entry is correctly formed. */
941 /* Create the 32 byte representation of the new p16 */
942 pdb_sethexpwd(ascii_p16
, pwd
->smb_passwd
, pwd
->acct_ctrl
);
944 /* Add on the NT md4 hash */
947 pdb_sethexpwd(ascii_p16
+33, pwd
->smb_nt_passwd
, pwd
->acct_ctrl
);
949 ascii_p16
[66] = '\0'; /* null-terminate the string so that strlen works */
951 /* Add on the account info bits and the time of last
954 if(got_pass_last_set_time
) {
955 slprintf(&ascii_p16
[strlen(ascii_p16
)],
956 sizeof(ascii_p16
)-(strlen(ascii_p16
)+1),
958 encode_bits
, (uint32
)pwd
->pass_last_set_time
);
959 wr_len
= strlen(ascii_p16
);
962 #ifdef DEBUG_PASSWORD
963 DEBUG(100,("mod_smbfilepwd_entry: "));
964 dump_data(100, ascii_p16
, wr_len
);
967 if(wr_len
> sizeof(linebuf
)) {
968 DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len
+1));
969 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
975 * Do an atomic write into the file at the position defined by
979 /* The mod user write needs to be atomic - so get the fd from
980 the fp and do a raw write() call.
985 if (sys_lseek(fd
, pwd_seekpos
- 1, SEEK_SET
) != pwd_seekpos
- 1) {
986 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile
));
987 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
992 /* Sanity check - ensure the areas we are writing are framed by ':' */
993 if (read(fd
, linebuf
, wr_len
+1) != wr_len
+1) {
994 DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile
));
995 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
1000 if ((linebuf
[0] != ':') || (linebuf
[wr_len
] != ':')) {
1001 DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile
));
1002 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
1007 if (sys_lseek(fd
, pwd_seekpos
, SEEK_SET
) != pwd_seekpos
) {
1008 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile
));
1009 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
1014 if (write(fd
, ascii_p16
, wr_len
) != wr_len
) {
1015 DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile
));
1016 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
1021 pw_file_unlock(lockfd
,&(smbpasswd_state
->pw_file_lock_depth
));
1026 /************************************************************************
1027 Routine to delete an entry in the smbpasswd file by name.
1028 *************************************************************************/
1030 static BOOL
del_smbfilepwd_entry(struct smbpasswd_privates
*smbpasswd_state
, const char *name
)
1032 const char *pfile
= smbpasswd_state
->smbpasswd_file
;
1034 struct smb_passwd
*pwd
= NULL
;
1036 FILE *fp_write
= NULL
;
1037 int pfile2_lockdepth
= 0;
1039 slprintf(pfile2
, sizeof(pfile2
)-1, "%s.%u", pfile
, (unsigned)sys_getpid() );
1042 * Open the smbpassword file - for update. It needs to be update
1043 * as we need any other processes to wait until we have replaced
1047 if((fp
= startsmbfilepwent(pfile
, PWF_UPDATE
, &(smbpasswd_state
->pw_file_lock_depth
))) == NULL
) {
1048 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile
));
1053 * Create the replacement password file.
1055 if((fp_write
= startsmbfilepwent(pfile2
, PWF_CREATE
, &pfile2_lockdepth
)) == NULL
) {
1056 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile
));
1057 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1062 * Scan the file, a line at a time and check if the name matches.
1065 while ((pwd
= getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) {
1067 size_t new_entry_length
;
1069 if (strequal(name
, pwd
->smb_name
)) {
1070 DEBUG(10, ("add_smbfilepwd_entry: found entry with name %s - deleting it.\n", name
));
1075 * We need to copy the entry out into the second file.
1078 if((new_entry
= format_new_smbpasswd_entry(pwd
)) == NULL
)
1080 DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
1081 Error was %s\n", pwd
->smb_name
, pfile2
, strerror(errno
)));
1083 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1084 endsmbfilepwent(fp_write
, &pfile2_lockdepth
);
1088 new_entry_length
= strlen(new_entry
);
1090 if(fwrite(new_entry
, 1, new_entry_length
, fp_write
) != new_entry_length
)
1092 DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
1093 Error was %s\n", pwd
->smb_name
, pfile2
, strerror(errno
)));
1095 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1096 endsmbfilepwent(fp_write
, &pfile2_lockdepth
);
1105 * Ensure pfile2 is flushed before rename.
1108 if(fflush(fp_write
) != 0)
1110 DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2
, strerror(errno
)));
1111 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1112 endsmbfilepwent(fp_write
,&pfile2_lockdepth
);
1117 * Do an atomic rename - then release the locks.
1120 if(rename(pfile2
,pfile
) != 0) {
1124 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1125 endsmbfilepwent(fp_write
,&pfile2_lockdepth
);
1129 /*********************************************************************
1130 Create a smb_passwd struct from a SAM_ACCOUNT.
1131 We will not allocate any new memory. The smb_passwd struct
1132 should only stay around as long as the SAM_ACCOUNT does.
1133 ********************************************************************/
1134 static BOOL
build_smb_pass (struct smb_passwd
*smb_pw
, const SAM_ACCOUNT
*sampass
)
1138 if (sampass
== NULL
)
1140 ZERO_STRUCTP(smb_pw
);
1142 if (!IS_SAM_DEFAULT(sampass
, PDB_USERSID
)) {
1143 rid
= pdb_get_user_rid(sampass
);
1145 /* If the user specified a RID, make sure its able to be both stored and retreived */
1146 if (rid
== DOMAIN_USER_RID_GUEST
) {
1147 struct passwd
*passwd
= getpwnam_alloc(lp_guestaccount());
1149 DEBUG(0, ("Could not find gest account via getpwnam()! (%s)\n", lp_guestaccount()));
1152 smb_pw
->smb_userid_set
= True
;
1153 smb_pw
->smb_userid
=passwd
->pw_uid
;
1154 passwd_free(&passwd
);
1156 } else if (fallback_pdb_rid_is_user(rid
)) {
1157 smb_pw
->smb_userid_set
= True
;
1158 smb_pw
->smb_userid
=fallback_pdb_user_rid_to_uid(rid
);
1160 DEBUG(0,("build_sam_pass: Failing attempt to store user with non-uid based user RID. \n"));
1165 smb_pw
->smb_name
=(const char*)pdb_get_username(sampass
);
1167 smb_pw
->smb_passwd
=pdb_get_lanman_passwd(sampass
);
1168 smb_pw
->smb_nt_passwd
=pdb_get_nt_passwd(sampass
);
1170 smb_pw
->acct_ctrl
=pdb_get_acct_ctrl(sampass
);
1171 smb_pw
->pass_last_set_time
=pdb_get_pass_last_set_time(sampass
);
1175 * ifdef'out by JFM on 11/29/2001.
1176 * this assertion is no longer valid
1177 * and I don't understand the goal
1178 * and doing the same thing with the group mapping code
1181 * We just have the RID, in which SID is it valid ?
1182 * our domain SID ? well known SID ? local SID ?
1185 if (gid
!= pdb_group_rid_to_gid(pdb_get_group_rid(sampass
))) {
1186 DEBUG(0,("build_sam_pass: Failing attempt to store user with non-gid based primary group RID. \n"));
1187 DEBUG(0,("build_sam_pass: %d %d %d. \n", *gid
, pdb_group_rid_to_gid(pdb_get_group_rid(sampass
)), pdb_get_group_rid(sampass
)));
1195 /*********************************************************************
1196 Create a SAM_ACCOUNT from a smb_passwd struct
1197 ********************************************************************/
1198 static BOOL
build_sam_account(struct smbpasswd_privates
*smbpasswd_state
,
1199 SAM_ACCOUNT
*sam_pass
, const struct smb_passwd
*pw_buf
)
1201 struct passwd
*pwfile
;
1203 if (sam_pass
==NULL
) {
1204 DEBUG(5,("build_sam_account: SAM_ACCOUNT is NULL\n"));
1208 pwfile
= getpwnam_alloc(pw_buf
->smb_name
);
1209 if (pwfile
== NULL
) {
1210 if ((smbpasswd_state
->permit_non_unix_accounts
)
1211 && (pw_buf
->smb_userid
>= smbpasswd_state
->low_nua_userid
)
1212 && (pw_buf
->smb_userid
<= smbpasswd_state
->high_nua_userid
)) {
1214 pdb_set_user_sid_from_rid(sam_pass
, fallback_pdb_uid_to_user_rid (pw_buf
->smb_userid
), PDB_SET
);
1216 /* lkclXXXX this is OBSERVED behaviour by NT PDCs, enforced here.
1218 This was down the bottom for machines, but it looks pretty good as
1219 a general default for non-unix users. --abartlet 2002-01-08
1221 pdb_set_group_sid_from_rid (sam_pass
, DOMAIN_GROUP_RID_USERS
, PDB_SET
);
1222 pdb_set_username (sam_pass
, pw_buf
->smb_name
, PDB_SET
);
1223 pdb_set_domain (sam_pass
, get_global_sam_name(), PDB_DEFAULT
);
1226 DEBUG(0,("build_sam_account: smbpasswd database is corrupt! username %s with uid %u is not in unix passwd database!\n", pw_buf
->smb_name
, pw_buf
->smb_userid
));
1230 if (!NT_STATUS_IS_OK(pdb_fill_sam_pw(sam_pass
, pwfile
))) {
1234 passwd_free(&pwfile
);
1237 pdb_set_nt_passwd (sam_pass
, pw_buf
->smb_nt_passwd
, PDB_SET
);
1238 pdb_set_lanman_passwd (sam_pass
, pw_buf
->smb_passwd
, PDB_SET
);
1239 pdb_set_acct_ctrl (sam_pass
, pw_buf
->acct_ctrl
, PDB_SET
);
1240 pdb_set_pass_last_set_time (sam_pass
, pw_buf
->pass_last_set_time
, PDB_SET
);
1241 pdb_set_pass_can_change_time (sam_pass
, pw_buf
->pass_last_set_time
, PDB_SET
);
1244 /* the smbpasswd format doesn't have a must change time field, so
1245 we can't get this right. The best we can do is to set this to
1246 some time in the future. 21 days seems as reasonable as any other value :)
1248 pdb_set_pass_must_change_time (sam_pass
, pw_buf
->pass_last_set_time
+ MAX_PASSWORD_AGE
, PDB_DEFAULT
);
1253 /*****************************************************************
1254 Functions to be implemented by the new passdb API
1255 ****************************************************************/
1256 static NTSTATUS
smbpasswd_setsampwent (struct pdb_methods
*my_methods
, BOOL update
)
1258 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1260 smbpasswd_state
->pw_file
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
,
1261 update
? PWF_UPDATE
: PWF_READ
,
1262 &(smbpasswd_state
->pw_file_lock_depth
));
1264 /* did we fail? Should we try to create it? */
1265 if (!smbpasswd_state
->pw_file
&& update
&& errno
== ENOENT
)
1268 /* slprintf(msg_str,msg_str_len-1,
1269 "smbpasswd file did not exist - attempting to create it.\n"); */
1270 DEBUG(0,("smbpasswd file did not exist - attempting to create it.\n"));
1271 fp
= sys_fopen(smbpasswd_state
->smbpasswd_file
, "w");
1274 fprintf(fp
, "# Samba SMB password file\n");
1278 smbpasswd_state
->pw_file
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
,
1279 update
? PWF_UPDATE
: PWF_READ
,
1280 &(smbpasswd_state
->pw_file_lock_depth
));
1283 if (smbpasswd_state
->pw_file
!= NULL
)
1284 return NT_STATUS_OK
;
1286 return NT_STATUS_UNSUCCESSFUL
;
1289 static void smbpasswd_endsampwent (struct pdb_methods
*my_methods
)
1291 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1292 endsmbfilepwent(smbpasswd_state
->pw_file
, &(smbpasswd_state
->pw_file_lock_depth
));
1295 /*****************************************************************
1296 ****************************************************************/
1297 static NTSTATUS
smbpasswd_getsampwent(struct pdb_methods
*my_methods
, SAM_ACCOUNT
*user
)
1299 NTSTATUS nt_status
= NT_STATUS_UNSUCCESSFUL
;
1300 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1301 struct smb_passwd
*pw_buf
=NULL
;
1303 DEBUG(5,("pdb_getsampwent\n"));
1306 DEBUG(5,("pdb_getsampwent (smbpasswd): user is NULL\n"));
1308 smb_panic("NULL pointer passed to getsampwent (smbpasswd)\n");
1315 /* do we have an entry? */
1316 pw_buf
= getsmbfilepwent(smbpasswd_state
, smbpasswd_state
->pw_file
);
1320 /* build the SAM_ACCOUNT entry from the smb_passwd struct.
1321 We loop in case the user in the pdb does not exist in
1322 the local system password file */
1323 if (build_sam_account(smbpasswd_state
, user
, pw_buf
))
1327 DEBUG(5,("getsampwent (smbpasswd): done\n"));
1330 return NT_STATUS_OK
;
1334 /****************************************************************
1335 Search smbpasswd file by iterating over the entries. Do not
1336 call getpwnam() for unix account information until we have found
1338 ***************************************************************/
1339 static NTSTATUS
smbpasswd_getsampwnam(struct pdb_methods
*my_methods
,
1340 SAM_ACCOUNT
*sam_acct
, const char *username
)
1342 NTSTATUS nt_status
= NT_STATUS_UNSUCCESSFUL
;
1343 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1344 struct smb_passwd
*smb_pw
;
1347 DEBUG(10, ("getsampwnam (smbpasswd): search by name: %s\n", username
));
1349 /* startsmbfilepwent() is used here as we don't want to lookup
1350 the UNIX account in the local system password file until
1352 fp
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
, PWF_READ
, &(smbpasswd_state
->pw_file_lock_depth
));
1355 DEBUG(0, ("unable to open passdb database.\n"));
1359 while ( ((smb_pw
=getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
)&& (!strequal(smb_pw
->smb_name
, username
)) )
1360 /* do nothing....another loop */ ;
1362 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1365 /* did we locate the username in smbpasswd */
1369 DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw
->smb_name
));
1372 DEBUG(10,("getsampwnam (smbpasswd): SAM_ACCOUNT is NULL\n"));
1374 smb_panic("NULL pointer passed to pdb_getsampwnam\n");
1379 /* now build the SAM_ACCOUNT */
1380 if (!build_sam_account(smbpasswd_state
, sam_acct
, smb_pw
))
1384 return NT_STATUS_OK
;
1387 static NTSTATUS
smbpasswd_getsampwsid(struct pdb_methods
*my_methods
, SAM_ACCOUNT
*sam_acct
, const DOM_SID
*sid
)
1389 NTSTATUS nt_status
= NT_STATUS_UNSUCCESSFUL
;
1390 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1391 struct smb_passwd
*smb_pw
;
1396 DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n", sid_to_string(sid_str
, sid
)));
1398 if (!sid_peek_check_rid(get_global_sam_sid(), sid
, &rid
))
1399 return NT_STATUS_UNSUCCESSFUL
;
1401 /* More special case 'guest account' hacks... */
1402 if (rid
== DOMAIN_USER_RID_GUEST
) {
1403 const char *guest_account
= lp_guestaccount();
1404 if (!(guest_account
&& *guest_account
)) {
1405 DEBUG(1, ("Guest account not specfied!\n"));
1408 return smbpasswd_getsampwnam(my_methods
, sam_acct
, guest_account
);
1411 /* Open the sam password file - not for update. */
1412 fp
= startsmbfilepwent(smbpasswd_state
->smbpasswd_file
, PWF_READ
, &(smbpasswd_state
->pw_file_lock_depth
));
1415 DEBUG(0, ("unable to open passdb database.\n"));
1419 while ( ((smb_pw
=getsmbfilepwent(smbpasswd_state
, fp
)) != NULL
) && (fallback_pdb_uid_to_user_rid(smb_pw
->smb_userid
) != rid
) )
1422 endsmbfilepwent(fp
, &(smbpasswd_state
->pw_file_lock_depth
));
1425 /* did we locate the username in smbpasswd */
1429 DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw
->smb_name
));
1432 DEBUG(10,("getsampwrid: (smbpasswd) SAM_ACCOUNT is NULL\n"));
1434 smb_panic("NULL pointer passed to pdb_getsampwrid\n");
1439 /* now build the SAM_ACCOUNT */
1440 if (!build_sam_account (smbpasswd_state
, sam_acct
, smb_pw
))
1443 /* build_sam_account might change the SID on us, if the name was for the guest account */
1444 if (NT_STATUS_IS_OK(nt_status
) && !sid_equal(pdb_get_user_sid(sam_acct
), sid
)) {
1445 fstring sid_string1
, sid_string2
;
1446 DEBUG(1, ("looking for user with sid %s instead returned %s for account %s!?!\n",
1447 sid_to_string(sid_string1
, sid
), sid_to_string(sid_string2
, pdb_get_user_sid(sam_acct
)), pdb_get_username(sam_acct
)));
1448 return NT_STATUS_NO_SUCH_USER
;
1452 return NT_STATUS_OK
;
1455 static NTSTATUS
smbpasswd_add_sam_account(struct pdb_methods
*my_methods
, SAM_ACCOUNT
*sampass
)
1457 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1458 struct smb_passwd smb_pw
;
1460 /* convert the SAM_ACCOUNT */
1461 if (!build_smb_pass(&smb_pw
, sampass
)) {
1462 return NT_STATUS_UNSUCCESSFUL
;
1466 if(!add_smbfilepwd_entry(smbpasswd_state
, &smb_pw
)) {
1467 return NT_STATUS_UNSUCCESSFUL
;
1470 return NT_STATUS_OK
;
1473 static NTSTATUS
smbpasswd_update_sam_account(struct pdb_methods
*my_methods
, SAM_ACCOUNT
*sampass
)
1475 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1476 struct smb_passwd smb_pw
;
1478 /* convert the SAM_ACCOUNT */
1479 if (!build_smb_pass(&smb_pw
, sampass
)) {
1480 DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
1481 return NT_STATUS_UNSUCCESSFUL
;
1484 /* update the entry */
1485 if(!mod_smbfilepwd_entry(smbpasswd_state
, &smb_pw
)) {
1486 DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
1487 return NT_STATUS_UNSUCCESSFUL
;
1490 return NT_STATUS_OK
;
1493 static NTSTATUS
smbpasswd_delete_sam_account (struct pdb_methods
*my_methods
, SAM_ACCOUNT
*sampass
)
1495 struct smbpasswd_privates
*smbpasswd_state
= (struct smbpasswd_privates
*)my_methods
->private_data
;
1497 const char *username
= pdb_get_username(sampass
);
1499 if (del_smbfilepwd_entry(smbpasswd_state
, username
))
1500 return NT_STATUS_OK
;
1502 return NT_STATUS_UNSUCCESSFUL
;
1505 static void free_private_data(void **vp
)
1507 struct smbpasswd_privates
**privates
= (struct smbpasswd_privates
**)vp
;
1509 endsmbfilepwent((*privates
)->pw_file
, &((*privates
)->pw_file_lock_depth
));
1512 /* No need to free any further, as it is talloc()ed */
1515 static NTSTATUS
pdb_init_smbpasswd(PDB_CONTEXT
*pdb_context
, PDB_METHODS
**pdb_method
, const char *location
)
1518 struct smbpasswd_privates
*privates
;
1520 if (!NT_STATUS_IS_OK(nt_status
= make_pdb_methods(pdb_context
->mem_ctx
, pdb_method
))) {
1524 (*pdb_method
)->name
= "smbpasswd";
1526 (*pdb_method
)->setsampwent
= smbpasswd_setsampwent
;
1527 (*pdb_method
)->endsampwent
= smbpasswd_endsampwent
;
1528 (*pdb_method
)->getsampwent
= smbpasswd_getsampwent
;
1529 (*pdb_method
)->getsampwnam
= smbpasswd_getsampwnam
;
1530 (*pdb_method
)->getsampwsid
= smbpasswd_getsampwsid
;
1531 (*pdb_method
)->add_sam_account
= smbpasswd_add_sam_account
;
1532 (*pdb_method
)->update_sam_account
= smbpasswd_update_sam_account
;
1533 (*pdb_method
)->delete_sam_account
= smbpasswd_delete_sam_account
;
1535 /* Setup private data and free function */
1537 privates
= talloc_zero(pdb_context
->mem_ctx
, sizeof(struct smbpasswd_privates
));
1540 DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
1541 return NT_STATUS_NO_MEMORY
;
1544 /* Store some config details */
1547 privates
->smbpasswd_file
= talloc_strdup(pdb_context
->mem_ctx
, location
);
1549 privates
->smbpasswd_file
= talloc_strdup(pdb_context
->mem_ctx
, lp_smb_passwd_file());
1552 if (!privates
->smbpasswd_file
) {
1553 DEBUG(0, ("talloc_strdp() failed for storing smbpasswd location!\n"));
1554 return NT_STATUS_NO_MEMORY
;
1557 (*pdb_method
)->private_data
= privates
;
1559 (*pdb_method
)->free_private_data
= free_private_data
;
1561 if (lp_idmap_uid(&privates
->low_nua_userid
, &privates
->high_nua_userid
)) {
1562 DEBUG(3, ("idmap uid range defined, non unix accounts enabled\n"));
1563 privates
->permit_non_unix_accounts
= True
;
1566 return NT_STATUS_OK
;
1569 NTSTATUS
pdb_smbpasswd_init(void)
1571 return smb_register_passdb(PASSDB_INTERFACE_VERSION
, "smbpasswd", pdb_init_smbpasswd
);