dsdb-acl: introduce a 'msg' helper variable to acl_modify()
[Samba/gebeck_regimport.git] / source3 / passdb / pdb_smbpasswd.c
blob0703ea4607f161a0097d36db07225f122b8f3077
1 /*
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.
8 *
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)
12 * any later version.
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
17 * more details.
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/>.
23 #include "includes.h"
24 #include "passdb.h"
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"
31 #undef DBGC_CLASS
32 #define DBGC_CLASS DBGC_PASSDB
34 /*
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
40 struct smb_passwd
42 uint32 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 */
58 FILE *pw_file;
60 /* formerly static variables */
61 struct smb_passwd pw_buf;
62 fstring user_name;
63 unsigned char smbpwd[16];
64 unsigned char smbntpwd[16];
66 /* retrive-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)
80 gotalarm = 1;
83 /***************************************************************
84 Lock or unlock a fd for a known lock type. Abandon after waitsecs
85 seconds.
86 ****************************************************************/
88 static bool do_file_lock(int fd, int waitsecs, int type)
90 struct flock lock;
91 int ret;
92 void (*oldsig_handler)(int);
94 gotalarm = 0;
95 oldsig_handler = CatchSignal(SIGALRM, gotalarm_sig);
97 lock.l_type = type;
98 lock.l_whence = SEEK_SET;
99 lock.l_start = 0;
100 lock.l_len = 1;
101 lock.l_pid = 0;
103 alarm(waitsecs);
104 /* Note we must *NOT* use sys_fcntl here ! JRA */
105 ret = fcntl(fd, F_SETLKW, &lock);
106 alarm(0);
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"));
112 return False;
115 return (ret == 0);
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)
124 if (fd < 0) {
125 return False;
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",
131 strerror(errno)));
132 return False;
136 (*plock_depth)++;
138 return True;
141 /***************************************************************
142 Unlock an fd. Abandon after waitsecs seconds.
143 ****************************************************************/
145 static bool pw_file_unlock(int fd, int *plock_depth)
147 bool ret=True;
149 if (fd == 0 || *plock_depth == 0) {
150 return True;
153 if(*plock_depth == 1) {
154 ret = do_file_lock(fd, 5, F_UNLCK);
157 if (*plock_depth > 0) {
158 (*plock_depth)--;
161 if(!ret) {
162 DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
163 strerror(errno)));
165 return ret;
168 /**************************************************************
169 Intialize a smb_passwd struct
170 *************************************************************/
172 static void pdb_init_smb(struct smb_passwd *user)
174 if (user == NULL)
175 return;
176 ZERO_STRUCTP (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)
190 FILE *fp = NULL;
191 const char *open_mode = NULL;
192 int race_loop = 0;
193 int lock_type = F_RDLCK;
195 if (!*pfile) {
196 DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
197 return (NULL);
200 switch(type) {
201 case PWF_READ:
202 open_mode = "rb";
203 lock_type = F_RDLCK;
204 break;
205 case PWF_UPDATE:
206 open_mode = "r+b";
207 lock_type = F_WRLCK;
208 break;
209 case PWF_CREATE:
211 * Ensure atomic file creation.
214 int i, fd = -1;
216 for(i = 0; i < 5; i++) {
217 if((fd = open(pfile, O_CREAT|O_TRUNC|O_EXCL|O_RDWR, 0600))!=-1) {
218 break;
220 usleep(200); /* Spin, spin... */
222 if(fd == -1) {
223 DEBUG(0,("startsmbfilepwent_internal: too many race conditions \
224 creating file %s\n", pfile));
225 return NULL;
227 close(fd);
228 open_mode = "r+b";
229 lock_type = F_WRLCK;
230 break;
232 default:
233 DEBUG(10, ("Invalid open mode: %d\n", type));
234 return NULL;
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));
250 } else {
251 DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
252 exist. Couldn't create new one. Error was: %s",
253 pfile, strerror(errno)));
254 return NULL;
256 } else {
257 DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. \
258 Error was: %s\n", pfile, strerror(errno)));
259 return NULL;
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) ));
266 fclose(fp);
267 return NULL;
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) {
276 break;
277 } else {
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);
292 fclose(fp);
293 return NULL;
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);
300 fclose(fp);
301 return NULL;
304 if( sbuf1.st_ex_ino == sbuf2.st_ex_ino) {
305 /* No race. */
306 break;
310 * Race occurred - back off and try again...
313 pw_file_unlock(fileno(fp), lock_depth);
314 fclose(fp);
318 if(race_loop == 5) {
319 DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile));
320 return NULL;
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 */
327 #ifdef HAVE_FCHMOD
328 if(fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
329 #else
330 if(chmod(pfile, S_IRUSR|S_IWUSR) == -1) {
331 #endif
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);
335 fclose(fp);
336 return NULL;
339 /* We have a lock on the file. */
340 return fp;
343 /***************************************************************
344 End enumeration of the smbpasswd list.
345 ****************************************************************/
347 static void endsmbfilepwent(FILE *fp, int *lock_depth)
349 if (!fp) {
350 return;
353 pw_file_unlock(fileno(fp), lock_depth);
354 fclose(fp);
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;
369 char linebuf[256];
370 int c;
371 unsigned char *p;
372 long uidval;
373 size_t linebuf_len;
374 char *status;
376 if(fp == NULL) {
377 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
378 return NULL;
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.
387 status = linebuf;
388 while (status && !feof(fp)) {
389 linebuf[0] = '\0';
391 status = fgets(linebuf, 256, fp);
392 if (status == NULL && ferror(fp)) {
393 return NULL;
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) {
401 continue;
404 if (linebuf[linebuf_len - 1] != '\n') {
405 c = '\0';
406 while (!ferror(fp) && !feof(fp)) {
407 c = fgetc(fp);
408 if (c == '\n') {
409 break;
412 } else {
413 linebuf[linebuf_len - 1] = '\0';
416 #ifdef DEBUG_PASSWORD
417 DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf));
418 #endif
419 if ((linebuf[0] == 0) && feof(fp)) {
420 DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
421 break;
425 * The line we have should be of the form :-
427 * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
428 * ignored....
430 * or,
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"));
441 continue;
443 p = (unsigned char *) strchr_m(linebuf, ':');
444 if (p == NULL) {
445 DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
446 continue;
449 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
450 user_name[PTR_DIFF(p, linebuf)] = '\0';
452 /* Get smb uid. */
454 p++; /* Go past ':' */
456 if(*p == '-') {
457 DEBUG(0, ("getsmbfilepwent: user name %s has a negative uid.\n", user_name));
458 continue;
461 if (!isdigit(*p)) {
462 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (uid not number)\n",
463 user_name));
464 continue;
467 uidval = atoi((char *) p);
469 while (*p && isdigit(*p)) {
470 p++;
473 if (*p != ':') {
474 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no : after uid)\n",
475 user_name));
476 continue;
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.
488 /* Skip the ':' */
489 p++;
491 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
492 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (passwd too short)\n",
493 user_name ));
494 continue;
497 if (p[32] != ':') {
498 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no terminating :)\n",
499 user_name));
500 continue;
503 if (strnequal((char *) p, "NO PASSWORD", 11)) {
504 pw_buf->smb_passwd = NULL;
505 pw_buf->acct_ctrl |= ACB_PWNOTREQ;
506 } else {
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;
513 } else {
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
522 * available.
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",
536 user_name, uidval));
538 if (*p == '[') {
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. */
548 if(end_p) {
549 p = end_p + 1;
551 if(*p == ':') {
552 p++;
553 if(*p && (strncasecmp_m((char *)p, "LCT-", 4)==0)) {
554 int i;
555 p += 4;
556 for(i = 0; i < 8; i++) {
557 if(p[i] == '\0' || !isxdigit(p[i])) {
558 break;
561 if(i == 8) {
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);
571 } else {
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;
584 return pw_buf;
587 DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
588 return NULL;
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;
598 char *new_entry;
599 char *p;
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",
606 newpwd->smb_name ));
607 return NULL;
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);
614 p+=strlen(p);
615 *p = ':';
616 p++;
618 pdb_sethexpwd(p, newpwd->smb_nt_passwd, newpwd->acct_ctrl);
619 p+=strlen(p);
620 *p = ':';
621 p++;
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);
628 return new_entry;
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;
640 FILE *fp = NULL;
641 int wr_len;
642 int fd;
643 size_t new_entry_length;
644 char *new_entry;
645 off_t offpos;
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);
655 if (fp == NULL) {
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.
679 fd = fileno(fp);
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);
686 return result;
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));
701 #endif
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);
716 free(new_entry);
717 return result;
720 free(new_entry);
721 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
722 return NT_STATUS_OK;
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. */
737 fstring user_name;
739 char *status;
740 char linebuf[256];
741 char readbuf[1024];
742 int c;
743 fstring ascii_p16;
744 fstring encode_bits;
745 unsigned char *p = NULL;
746 size_t linebuf_len = 0;
747 FILE *fp;
748 int lockfd;
749 const char *pfile = smbpasswd_state->smbpasswd_file;
750 bool found_entry = False;
751 bool got_pass_last_set_time = False;
753 off_t pwd_seekpos = 0;
755 int i;
756 int wr_len;
757 int fd;
759 if (!*pfile) {
760 DEBUG(0, ("No SMB password file set\n"));
761 return False;
763 DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
765 fp = fopen(pfile, "r+");
767 if (fp == NULL) {
768 DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
769 return False;
771 /* Set a buffer to do more efficient reads */
772 setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
774 lockfd = fileno(fp);
776 if (!pw_file_lock(lockfd, F_WRLCK, 5, &smbpasswd_state->pw_file_lock_depth)) {
777 DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile));
778 fclose(fp);
779 return False;
782 /* Make sure it is only rw by the owner */
783 chmod(pfile, 0600);
785 /* We have a write lock on the file. */
787 * Scan the file, a line at a time and check if the name matches.
789 status = linebuf;
790 while (status && !feof(fp)) {
791 pwd_seekpos = ftell(fp);
793 linebuf[0] = '\0';
795 status = fgets(linebuf, sizeof(linebuf), fp);
796 if (status == NULL && ferror(fp)) {
797 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
798 fclose(fp);
799 return False;
803 * Check if the string is terminated with a newline - if not
804 * then we must keep reading and discard until we get one.
806 linebuf_len = strlen(linebuf);
807 if (linebuf[linebuf_len - 1] != '\n') {
808 c = '\0';
809 while (!ferror(fp) && !feof(fp)) {
810 c = fgetc(fp);
811 if (c == '\n') {
812 break;
815 } else {
816 linebuf[linebuf_len - 1] = '\0';
819 #ifdef DEBUG_PASSWORD
820 DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf));
821 #endif
823 if ((linebuf[0] == 0) && feof(fp)) {
824 DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
825 break;
829 * The line we have should be of the form :-
831 * username:uid:[32hex bytes]:....other flags presently
832 * ignored....
834 * or,
836 * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
838 * if Windows NT compatible passwords are also present.
841 if (linebuf[0] == '#' || linebuf[0] == '\0') {
842 DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
843 continue;
846 p = (unsigned char *) strchr_m(linebuf, ':');
848 if (p == NULL) {
849 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
850 continue;
853 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
854 user_name[PTR_DIFF(p, linebuf)] = '\0';
855 if (strequal(user_name, pwd->smb_name)) {
856 found_entry = True;
857 break;
861 if (!found_entry) {
862 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
863 fclose(fp);
865 DEBUG(2, ("Cannot update entry for user %s, as they don't exist in the smbpasswd file!\n",
866 pwd->smb_name));
867 return False;
870 DEBUG(6, ("mod_smbfilepwd_entry: entry exists for user %s\n", pwd->smb_name));
872 /* User name matches - get uid and password */
873 p++; /* Go past ':' */
875 if (!isdigit(*p)) {
876 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (uid not number)\n",
877 pwd->smb_name));
878 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
879 fclose(fp);
880 return False;
883 while (*p && isdigit(*p)) {
884 p++;
886 if (*p != ':') {
887 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no : after uid)\n",
888 pwd->smb_name));
889 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
890 fclose(fp);
891 return False;
895 * Now get the password value - this should be 32 hex digits
896 * which are the ascii representations of a 16 byte string.
897 * Get two at a time and put them into the password.
899 p++;
901 /* Record exact password position */
902 pwd_seekpos += PTR_DIFF(p, linebuf);
904 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
905 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
906 pwd->smb_name));
907 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
908 fclose(fp);
909 return (False);
912 if (p[32] != ':') {
913 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
914 pwd->smb_name));
915 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
916 fclose(fp);
917 return False;
920 /* Now check if the NT compatible password is available. */
921 p += 33; /* Move to the first character of the line after the lanman password. */
922 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
923 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
924 pwd->smb_name));
925 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
926 fclose(fp);
927 return (False);
930 if (p[32] != ':') {
931 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
932 pwd->smb_name));
933 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
934 fclose(fp);
935 return False;
939 * Now check if the account info and the password last
940 * change time is available.
942 p += 33; /* Move to the first character of the line after the NT password. */
944 if (*p == '[') {
945 i = 0;
946 encode_bits[i++] = *p++;
947 while((linebuf_len > PTR_DIFF(p, linebuf)) && (*p != ']')) {
948 encode_bits[i++] = *p++;
951 encode_bits[i++] = ']';
952 encode_bits[i++] = '\0';
954 if(i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
956 * We are using a new format, space padded
957 * acct ctrl field. Encode the given acct ctrl
958 * bits into it.
960 fstrcpy(encode_bits, pdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
961 } else {
962 DEBUG(0,("mod_smbfilepwd_entry: Using old smbpasswd format for user %s. \
963 This is no longer supported.!\n", pwd->smb_name));
964 DEBUG(0,("mod_smbfilepwd_entry: No changes made, failing.!\n"));
965 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
966 fclose(fp);
967 return False;
970 /* Go past the ']' */
971 if(linebuf_len > PTR_DIFF(p, linebuf)) {
972 p++;
975 if((linebuf_len > PTR_DIFF(p, linebuf)) && (*p == ':')) {
976 p++;
978 /* We should be pointing at the LCT entry. */
979 if((linebuf_len > (PTR_DIFF(p, linebuf) + 13)) && (strncasecmp_m((char *)p, "LCT-", 4) == 0)) {
980 p += 4;
981 for(i = 0; i < 8; i++) {
982 if(p[i] == '\0' || !isxdigit(p[i])) {
983 break;
986 if(i == 8) {
988 * p points at 8 characters of hex digits -
989 * read into a time_t as the seconds since
990 * 1970 that the password was last changed.
992 got_pass_last_set_time = True;
993 } /* i == 8 */
994 } /* *p && strncasecmp_m() */
995 } /* p == ':' */
996 } /* p == '[' */
998 /* Entry is correctly formed. */
1000 /* Create the 32 byte representation of the new p16 */
1001 pdb_sethexpwd(ascii_p16, pwd->smb_passwd, pwd->acct_ctrl);
1003 /* Add on the NT md4 hash */
1004 ascii_p16[32] = ':';
1005 wr_len = 66;
1006 pdb_sethexpwd(ascii_p16+33, pwd->smb_nt_passwd, pwd->acct_ctrl);
1007 ascii_p16[65] = ':';
1008 ascii_p16[66] = '\0'; /* null-terminate the string so that strlen works */
1010 /* Add on the account info bits and the time of last password change. */
1011 if(got_pass_last_set_time) {
1012 slprintf(&ascii_p16[strlen(ascii_p16)],
1013 sizeof(ascii_p16)-(strlen(ascii_p16)+1),
1014 "%s:LCT-%08X:",
1015 encode_bits, (uint32_t)pwd->pass_last_set_time );
1016 wr_len = strlen(ascii_p16);
1019 #ifdef DEBUG_PASSWORD
1020 DEBUG(100,("mod_smbfilepwd_entry: "));
1021 dump_data(100, (uint8 *)ascii_p16, wr_len);
1022 #endif
1024 if(wr_len > sizeof(linebuf)) {
1025 DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len+1));
1026 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1027 fclose(fp);
1028 return (False);
1032 * Do an atomic write into the file at the position defined by
1033 * seekpos.
1036 /* The mod user write needs to be atomic - so get the fd from
1037 the fp and do a raw write() call.
1040 fd = fileno(fp);
1042 if (lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
1043 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1044 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1045 fclose(fp);
1046 return False;
1049 /* Sanity check - ensure the areas we are writing are framed by ':' */
1050 if (read(fd, linebuf, wr_len+1) != wr_len+1) {
1051 DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile));
1052 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1053 fclose(fp);
1054 return False;
1057 if ((linebuf[0] != ':') || (linebuf[wr_len] != ':')) {
1058 DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile));
1059 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1060 fclose(fp);
1061 return False;
1064 if (lseek(fd, pwd_seekpos, SEEK_SET) != pwd_seekpos) {
1065 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1066 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1067 fclose(fp);
1068 return False;
1071 if (write(fd, ascii_p16, wr_len) != wr_len) {
1072 DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile));
1073 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1074 fclose(fp);
1075 return False;
1078 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1079 fclose(fp);
1080 return True;
1083 /************************************************************************
1084 Routine to delete an entry in the smbpasswd file by name.
1085 *************************************************************************/
1087 static bool del_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state, const char *name)
1089 const char *pfile = smbpasswd_state->smbpasswd_file;
1090 char *pfile2 = NULL;
1091 struct smb_passwd *pwd = NULL;
1092 FILE *fp = NULL;
1093 FILE *fp_write = NULL;
1094 int pfile2_lockdepth = 0;
1096 pfile2 = talloc_asprintf(talloc_tos(),
1097 "%s.%u",
1098 pfile, (unsigned)getpid());
1099 if (!pfile2) {
1100 return false;
1104 * Open the smbpassword file - for update. It needs to be update
1105 * as we need any other processes to wait until we have replaced
1106 * it.
1109 if((fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth)) == NULL) {
1110 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1111 return False;
1115 * Create the replacement password file.
1117 if((fp_write = startsmbfilepwent(pfile2, PWF_CREATE, &pfile2_lockdepth)) == NULL) {
1118 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1119 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1120 return False;
1124 * Scan the file, a line at a time and check if the name matches.
1127 while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1128 char *new_entry;
1129 size_t new_entry_length;
1131 if (strequal(name, pwd->smb_name)) {
1132 DEBUG(10, ("del_smbfilepwd_entry: found entry with "
1133 "name %s - deleting it.\n", name));
1134 continue;
1138 * We need to copy the entry out into the second file.
1141 if((new_entry = format_new_smbpasswd_entry(pwd)) == NULL) {
1142 DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
1143 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1144 unlink(pfile2);
1145 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1146 endsmbfilepwent(fp_write, &pfile2_lockdepth);
1147 return False;
1150 new_entry_length = strlen(new_entry);
1152 if(fwrite(new_entry, 1, new_entry_length, fp_write) != new_entry_length) {
1153 DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
1154 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1155 unlink(pfile2);
1156 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1157 endsmbfilepwent(fp_write, &pfile2_lockdepth);
1158 free(new_entry);
1159 return False;
1162 free(new_entry);
1166 * Ensure pfile2 is flushed before rename.
1169 if(fflush(fp_write) != 0) {
1170 DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2, strerror(errno)));
1171 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1172 endsmbfilepwent(fp_write,&pfile2_lockdepth);
1173 return False;
1177 * Do an atomic rename - then release the locks.
1180 if(rename(pfile2,pfile) != 0) {
1181 unlink(pfile2);
1184 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1185 endsmbfilepwent(fp_write,&pfile2_lockdepth);
1186 return True;
1189 /*********************************************************************
1190 Create a smb_passwd struct from a struct samu.
1191 We will not allocate any new memory. The smb_passwd struct
1192 should only stay around as long as the struct samu does.
1193 ********************************************************************/
1195 static bool build_smb_pass (struct smb_passwd *smb_pw, const struct samu *sampass)
1197 uint32_t rid;
1199 if (sampass == NULL)
1200 return False;
1201 ZERO_STRUCTP(smb_pw);
1203 if (!IS_SAM_DEFAULT(sampass, PDB_USERSID)) {
1204 rid = pdb_get_user_rid(sampass);
1206 /* If the user specified a RID, make sure its able to be both stored and retreived */
1207 if (rid == DOMAIN_RID_GUEST) {
1208 struct passwd *passwd = Get_Pwnam_alloc(NULL, lp_guestaccount());
1209 if (!passwd) {
1210 DEBUG(0, ("Could not find guest account via Get_Pwnam_alloc()! (%s)\n", lp_guestaccount()));
1211 return False;
1213 smb_pw->smb_userid=passwd->pw_uid;
1214 TALLOC_FREE(passwd);
1215 } else if (algorithmic_pdb_rid_is_user(rid)) {
1216 smb_pw->smb_userid=algorithmic_pdb_user_rid_to_uid(rid);
1217 } else {
1218 DEBUG(0,("build_sam_pass: Failing attempt to store user with non-uid based user RID. \n"));
1219 return False;
1223 smb_pw->smb_name=(const char*)pdb_get_username(sampass);
1225 smb_pw->smb_passwd=pdb_get_lanman_passwd(sampass);
1226 smb_pw->smb_nt_passwd=pdb_get_nt_passwd(sampass);
1228 smb_pw->acct_ctrl=pdb_get_acct_ctrl(sampass);
1229 smb_pw->pass_last_set_time=pdb_get_pass_last_set_time(sampass);
1231 return True;
1234 /*********************************************************************
1235 Create a struct samu from a smb_passwd struct
1236 ********************************************************************/
1238 static bool build_sam_account(struct smbpasswd_privates *smbpasswd_state,
1239 struct samu *sam_pass, const struct smb_passwd *pw_buf)
1241 struct passwd *pwfile;
1243 if ( !sam_pass ) {
1244 DEBUG(5,("build_sam_account: struct samu is NULL\n"));
1245 return False;
1248 /* verify the user account exists */
1250 if ( !(pwfile = Get_Pwnam_alloc(NULL, pw_buf->smb_name )) ) {
1251 DEBUG(0,("build_sam_account: smbpasswd database is corrupt! username %s with uid "
1252 "%u is not in unix passwd database!\n", pw_buf->smb_name, pw_buf->smb_userid));
1253 return False;
1256 if ( !NT_STATUS_IS_OK( samu_set_unix(sam_pass, pwfile )) )
1257 return False;
1259 TALLOC_FREE(pwfile);
1261 /* set remaining fields */
1263 if (!pdb_set_nt_passwd (sam_pass, pw_buf->smb_nt_passwd, PDB_SET))
1264 return False;
1265 if (!pdb_set_lanman_passwd (sam_pass, pw_buf->smb_passwd, PDB_SET))
1266 return False;
1267 pdb_set_acct_ctrl (sam_pass, pw_buf->acct_ctrl, PDB_SET);
1268 pdb_set_pass_last_set_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1269 pdb_set_pass_can_change_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1271 return True;
1274 /*****************************************************************
1275 Functions to be implemented by the new passdb API
1276 ****************************************************************/
1278 /****************************************************************
1279 Search smbpasswd file by iterating over the entries. Do not
1280 call getpwnam() for unix account information until we have found
1281 the correct entry
1282 ***************************************************************/
1284 static NTSTATUS smbpasswd_getsampwnam(struct pdb_methods *my_methods,
1285 struct samu *sam_acct, const char *username)
1287 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1288 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1289 struct smb_passwd *smb_pw;
1290 FILE *fp = NULL;
1292 DEBUG(10, ("getsampwnam (smbpasswd): search by name: %s\n", username));
1294 /* startsmbfilepwent() is used here as we don't want to lookup
1295 the UNIX account in the local system password file until
1296 we have a match. */
1297 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1299 if (fp == NULL) {
1300 DEBUG(0, ("Unable to open passdb database.\n"));
1301 return nt_status;
1304 while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL)&& (!strequal(smb_pw->smb_name, username)) )
1305 /* do nothing....another loop */ ;
1307 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1310 /* did we locate the username in smbpasswd */
1311 if (smb_pw == NULL)
1312 return nt_status;
1314 DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1316 if (!sam_acct) {
1317 DEBUG(10,("getsampwnam (smbpasswd): struct samu is NULL\n"));
1318 return nt_status;
1321 /* now build the struct samu */
1322 if (!build_sam_account(smbpasswd_state, sam_acct, smb_pw))
1323 return nt_status;
1325 /* success */
1326 return NT_STATUS_OK;
1329 static NTSTATUS smbpasswd_getsampwsid(struct pdb_methods *my_methods, struct samu *sam_acct, const struct dom_sid *sid)
1331 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1332 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1333 struct smb_passwd *smb_pw;
1334 FILE *fp = NULL;
1335 uint32_t rid;
1337 DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n",
1338 sid_string_dbg(sid)));
1340 if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
1341 return NT_STATUS_UNSUCCESSFUL;
1343 /* More special case 'guest account' hacks... */
1344 if (rid == DOMAIN_RID_GUEST) {
1345 const char *guest_account = lp_guestaccount();
1346 if (!(guest_account && *guest_account)) {
1347 DEBUG(1, ("Guest account not specfied!\n"));
1348 return nt_status;
1350 return smbpasswd_getsampwnam(my_methods, sam_acct, guest_account);
1353 /* Open the sam password file - not for update. */
1354 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1356 if (fp == NULL) {
1357 DEBUG(0, ("Unable to open passdb database.\n"));
1358 return nt_status;
1361 while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL) && (algorithmic_pdb_uid_to_user_rid(smb_pw->smb_userid) != rid) )
1362 /* do nothing */ ;
1364 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1367 /* did we locate the username in smbpasswd */
1368 if (smb_pw == NULL)
1369 return nt_status;
1371 DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1373 if (!sam_acct) {
1374 DEBUG(10,("getsampwrid: (smbpasswd) struct samu is NULL\n"));
1375 return nt_status;
1378 /* now build the struct samu */
1379 if (!build_sam_account (smbpasswd_state, sam_acct, smb_pw))
1380 return nt_status;
1382 /* build_sam_account might change the SID on us, if the name was for the guest account */
1383 if (NT_STATUS_IS_OK(nt_status) && !dom_sid_equal(pdb_get_user_sid(sam_acct), sid)) {
1384 DEBUG(1, ("looking for user with sid %s instead returned %s "
1385 "for account %s!?!\n", sid_string_dbg(sid),
1386 sid_string_dbg(pdb_get_user_sid(sam_acct)),
1387 pdb_get_username(sam_acct)));
1388 return NT_STATUS_NO_SUCH_USER;
1391 /* success */
1392 return NT_STATUS_OK;
1395 static NTSTATUS smbpasswd_add_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1397 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1398 struct smb_passwd smb_pw;
1400 /* convert the struct samu */
1401 if (!build_smb_pass(&smb_pw, sampass)) {
1402 return NT_STATUS_UNSUCCESSFUL;
1405 /* add the entry */
1406 return add_smbfilepwd_entry(smbpasswd_state, &smb_pw);
1409 static NTSTATUS smbpasswd_update_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1411 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1412 struct smb_passwd smb_pw;
1414 /* convert the struct samu */
1415 if (!build_smb_pass(&smb_pw, sampass)) {
1416 DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
1417 return NT_STATUS_UNSUCCESSFUL;
1420 /* update the entry */
1421 if(!mod_smbfilepwd_entry(smbpasswd_state, &smb_pw)) {
1422 DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
1423 return NT_STATUS_UNSUCCESSFUL;
1426 return NT_STATUS_OK;
1429 static NTSTATUS smbpasswd_delete_sam_account (struct pdb_methods *my_methods, struct samu *sampass)
1431 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1433 const char *username = pdb_get_username(sampass);
1435 if (del_smbfilepwd_entry(smbpasswd_state, username))
1436 return NT_STATUS_OK;
1438 return NT_STATUS_UNSUCCESSFUL;
1441 static NTSTATUS smbpasswd_rename_sam_account (struct pdb_methods *my_methods,
1442 struct samu *old_acct,
1443 const char *newname)
1445 char *rename_script = NULL;
1446 struct samu *new_acct = NULL;
1447 bool interim_account = False;
1448 TALLOC_CTX *ctx = talloc_tos();
1449 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
1451 if (!*(lp_renameuser_script(talloc_tos())))
1452 goto done;
1454 if ( !(new_acct = samu_new( NULL )) ) {
1455 return NT_STATUS_NO_MEMORY;
1458 if ( !pdb_copy_sam_account( new_acct, old_acct )
1459 || !pdb_set_username(new_acct, newname, PDB_CHANGED))
1461 goto done;
1464 ret = smbpasswd_add_sam_account(my_methods, new_acct);
1465 if (!NT_STATUS_IS_OK(ret))
1466 goto done;
1468 interim_account = True;
1470 /* rename the posix user */
1471 rename_script = lp_renameuser_script(ctx);
1472 if (!rename_script) {
1473 ret = NT_STATUS_NO_MEMORY;
1474 goto done;
1477 if (*rename_script) {
1478 int rename_ret;
1480 rename_script = talloc_string_sub2(ctx,
1481 rename_script,
1482 "%unew",
1483 newname,
1484 true,
1485 false,
1486 true);
1487 if (!rename_script) {
1488 ret = NT_STATUS_NO_MEMORY;
1489 goto done;
1491 rename_script = talloc_string_sub2(ctx,
1492 rename_script,
1493 "%uold",
1494 pdb_get_username(old_acct),
1495 true,
1496 false,
1497 true);
1498 if (!rename_script) {
1499 ret = NT_STATUS_NO_MEMORY;
1500 goto done;
1503 rename_ret = smbrun(rename_script, NULL);
1505 DEBUG(rename_ret ? 0 : 3,("Running the command `%s' gave %d\n", rename_script, rename_ret));
1507 if (rename_ret == 0) {
1508 smb_nscd_flush_user_cache();
1511 if (rename_ret)
1512 goto done;
1513 } else {
1514 goto done;
1517 smbpasswd_delete_sam_account(my_methods, old_acct);
1518 interim_account = False;
1520 done:
1521 /* cleanup */
1522 if (interim_account)
1523 smbpasswd_delete_sam_account(my_methods, new_acct);
1525 if (new_acct)
1526 TALLOC_FREE(new_acct);
1528 return (ret);
1531 static uint32_t smbpasswd_capabilities(struct pdb_methods *methods)
1533 return 0;
1536 static void free_private_data(void **vp)
1538 struct smbpasswd_privates **privates = (struct smbpasswd_privates**)vp;
1540 endsmbfilepwent((*privates)->pw_file, &((*privates)->pw_file_lock_depth));
1542 *privates = NULL;
1543 /* No need to free any further, as it is talloc()ed */
1546 struct smbpasswd_search_state {
1547 uint32_t acct_flags;
1549 struct samr_displayentry *entries;
1550 uint32_t num_entries;
1551 ssize_t array_size;
1552 uint32_t current;
1555 static void smbpasswd_search_end(struct pdb_search *search)
1557 struct smbpasswd_search_state *state = talloc_get_type_abort(
1558 search->private_data, struct smbpasswd_search_state);
1559 TALLOC_FREE(state);
1562 static bool smbpasswd_search_next_entry(struct pdb_search *search,
1563 struct samr_displayentry *entry)
1565 struct smbpasswd_search_state *state = talloc_get_type_abort(
1566 search->private_data, struct smbpasswd_search_state);
1568 if (state->current == state->num_entries) {
1569 return false;
1572 entry->idx = state->entries[state->current].idx;
1573 entry->rid = state->entries[state->current].rid;
1574 entry->acct_flags = state->entries[state->current].acct_flags;
1576 entry->account_name = talloc_strdup(
1577 search, state->entries[state->current].account_name);
1578 entry->fullname = talloc_strdup(
1579 search, state->entries[state->current].fullname);
1580 entry->description = talloc_strdup(
1581 search, state->entries[state->current].description);
1583 if ((entry->account_name == NULL) || (entry->fullname == NULL)
1584 || (entry->description == NULL)) {
1585 DEBUG(0, ("talloc_strdup failed\n"));
1586 return false;
1589 state->current += 1;
1590 return true;
1593 static bool smbpasswd_search_users(struct pdb_methods *methods,
1594 struct pdb_search *search,
1595 uint32_t acct_flags)
1597 struct smbpasswd_privates *smbpasswd_state =
1598 (struct smbpasswd_privates*)methods->private_data;
1600 struct smbpasswd_search_state *search_state;
1601 struct smb_passwd *pwd;
1602 FILE *fp;
1604 search_state = talloc_zero(search, struct smbpasswd_search_state);
1605 if (search_state == NULL) {
1606 DEBUG(0, ("talloc failed\n"));
1607 return false;
1609 search_state->acct_flags = acct_flags;
1611 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ,
1612 &smbpasswd_state->pw_file_lock_depth);
1614 if (fp == NULL) {
1615 DEBUG(10, ("Unable to open smbpasswd file.\n"));
1616 TALLOC_FREE(search_state);
1617 return false;
1620 while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1621 struct samr_displayentry entry;
1622 struct samu *user;
1624 if ((acct_flags != 0)
1625 && ((acct_flags & pwd->acct_ctrl) == 0)) {
1626 continue;
1629 user = samu_new(talloc_tos());
1630 if (user == NULL) {
1631 DEBUG(0, ("samu_new failed\n"));
1632 break;
1635 if (!build_sam_account(smbpasswd_state, user, pwd)) {
1636 /* Already got debug msgs... */
1637 break;
1640 ZERO_STRUCT(entry);
1642 entry.acct_flags = pdb_get_acct_ctrl(user);
1643 sid_peek_rid(pdb_get_user_sid(user), &entry.rid);
1644 entry.account_name = talloc_strdup(
1645 search_state, pdb_get_username(user));
1646 entry.fullname = talloc_strdup(
1647 search_state, pdb_get_fullname(user));
1648 entry.description = talloc_strdup(
1649 search_state, pdb_get_acct_desc(user));
1651 TALLOC_FREE(user);
1653 if ((entry.account_name == NULL) || (entry.fullname == NULL)
1654 || (entry.description == NULL)) {
1655 DEBUG(0, ("talloc_strdup failed\n"));
1656 break;
1659 ADD_TO_LARGE_ARRAY(search_state, struct samr_displayentry,
1660 entry, &search_state->entries,
1661 &search_state->num_entries,
1662 &search_state->array_size);
1665 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1667 search->private_data = search_state;
1668 search->next_entry = smbpasswd_search_next_entry;
1669 search->search_end = smbpasswd_search_end;
1671 return true;
1674 static NTSTATUS pdb_init_smbpasswd( struct pdb_methods **pdb_method, const char *location )
1676 NTSTATUS nt_status;
1677 struct smbpasswd_privates *privates;
1679 if ( !NT_STATUS_IS_OK(nt_status = make_pdb_method( pdb_method )) ) {
1680 return nt_status;
1683 (*pdb_method)->name = "smbpasswd";
1685 (*pdb_method)->getsampwnam = smbpasswd_getsampwnam;
1686 (*pdb_method)->getsampwsid = smbpasswd_getsampwsid;
1687 (*pdb_method)->add_sam_account = smbpasswd_add_sam_account;
1688 (*pdb_method)->update_sam_account = smbpasswd_update_sam_account;
1689 (*pdb_method)->delete_sam_account = smbpasswd_delete_sam_account;
1690 (*pdb_method)->rename_sam_account = smbpasswd_rename_sam_account;
1691 (*pdb_method)->search_users = smbpasswd_search_users;
1693 (*pdb_method)->capabilities = smbpasswd_capabilities;
1695 /* Setup private data and free function */
1697 if ( !(privates = talloc_zero( *pdb_method, struct smbpasswd_privates )) ) {
1698 DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
1699 return NT_STATUS_NO_MEMORY;
1702 /* Store some config details */
1704 if (location) {
1705 privates->smbpasswd_file = talloc_strdup(*pdb_method, location);
1706 } else {
1707 privates->smbpasswd_file = talloc_strdup(*pdb_method, lp_smb_passwd_file());
1710 if (!privates->smbpasswd_file) {
1711 DEBUG(0, ("talloc_strdp() failed for storing smbpasswd location!\n"));
1712 return NT_STATUS_NO_MEMORY;
1715 (*pdb_method)->private_data = privates;
1717 (*pdb_method)->free_private_data = free_private_data;
1719 return NT_STATUS_OK;
1722 NTSTATUS pdb_smbpasswd_init(void)
1724 return smb_register_passdb(PASSDB_INTERFACE_VERSION, "smbpasswd", pdb_init_smbpasswd);