?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-scripts: Move connection tracking to 10.interface
[samba4-gss.git] / source3 / passdb / pdb_smbpasswd.c
blob1296a32167dfd68b883ea4e4ba680910b7cefed9
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.
13 *
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.
18 *
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/>.
21 */
22
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"
30 #include "lib/util/string_wrappers.h"
31
32 #undef DBGC_CLASS
33 #define DBGC_CLASS DBGC_PASSDB
34
35 /*
36 smb_passwd is analogous to sam_passwd used everywhere
37 else. However, smb_passwd is limited to the information
38 stored by an smbpasswd entry
39 */
40
41 struct smb_passwd
42 {
43 uint32_t smb_userid; /* this is actually the unix uid_t */
44 const char *smb_name; /* username string */
45
46 const unsigned char *smb_passwd; /* Null if no password */
47 const unsigned char *smb_nt_passwd; /* Null if no password */
48
49 uint16_t acct_ctrl; /* account info (ACB_xxxx bit-mask) */
50 time_t pass_last_set_time; /* password last set time */
51 };
52
53 struct smbpasswd_privates
54 {
55 /* used for maintain locks on the smbpasswd file */
56 int pw_file_lock_depth;
57
58 /* Global File pointer */
59 FILE *pw_file;
60
61 /* formerly static variables */
62 struct smb_passwd pw_buf;
63 fstring user_name;
64 unsigned char smbpwd[16];
65 unsigned char smbntpwd[16];
66
67 /* retrieve-once info */
68 const char *smbpasswd_file;
69 };
70
71 enum pwf_access_type { PWF_READ, PWF_UPDATE, PWF_CREATE };
72
73 static SIG_ATOMIC_T gotalarm;
74
75 /***************************************************************
76 Signal function to tell us we timed out.
77 ****************************************************************/
78
79 static void gotalarm_sig(int signum)
80 {
81 gotalarm = 1;
82 }
83
84 /***************************************************************
85 Lock or unlock a fd for a known lock type. Abandon after waitsecs
86 seconds.
87 ****************************************************************/
88
89 static bool do_file_lock(int fd, int waitsecs, int type)
90 {
91 struct flock lock;
92 int ret;
93 void (*oldsig_handler)(int);
94
95 gotalarm = 0;
96 oldsig_handler = CatchSignal(SIGALRM, gotalarm_sig);
97
98 lock.l_type = type;
99 lock.l_whence = SEEK_SET;
100 lock.l_start = 0;
101 lock.l_len = 1;
102 lock.l_pid = 0;
103
104 alarm(waitsecs);
105 /* Note we must *NOT* use sys_fcntl here ! JRA */
106 ret = fcntl(fd, F_SETLKW, &lock);
107 alarm(0);
108 CatchSignal(SIGALRM, oldsig_handler);
109
110 if (gotalarm && ret == -1) {
111 DEBUG(0, ("do_file_lock: failed to %s file.\n",
112 type == F_UNLCK ? "unlock" : "lock"));
113 return False;
114 }
115
116 return (ret == 0);
117 }
118
119 /***************************************************************
120 Lock an fd. Abandon after waitsecs seconds.
121 ****************************************************************/
122
123 static bool pw_file_lock(int fd, int type, int secs, int *plock_depth)
124 {
125 if (fd < 0) {
126 return False;
127 }
128
129 if(*plock_depth == 0) {
130 if (!do_file_lock(fd, secs, type)) {
131 DEBUG(10,("pw_file_lock: locking file failed, error = %s.\n",
132 strerror(errno)));
133 return False;
134 }
135 }
136
137 (*plock_depth)++;
138
139 return True;
140 }
141
142 /***************************************************************
143 Unlock an fd. Abandon after waitsecs seconds.
144 ****************************************************************/
145
146 static bool pw_file_unlock(int fd, int *plock_depth)
147 {
148 bool ret=True;
149
150 if (fd == 0 || *plock_depth == 0) {
151 return True;
152 }
153
154 if(*plock_depth == 1) {
155 ret = do_file_lock(fd, 5, F_UNLCK);
156 }
157
158 if (*plock_depth > 0) {
159 (*plock_depth)--;
160 }
161
162 if(!ret) {
163 DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
164 strerror(errno)));
165 }
166 return ret;
167 }
168
169 /**************************************************************
170 Initialize a smb_passwd struct
171 *************************************************************/
172
173 static void pdb_init_smb(struct smb_passwd *user)
174 {
175 if (user == NULL)
176 return;
177 ZERO_STRUCTP (user);
178
179 user->pass_last_set_time = (time_t)0;
180 }
181
182 /***************************************************************
183 Internal fn to enumerate the smbpasswd list. Returns a void pointer
184 to ensure no modification outside this module. Checks for atomic
185 rename of smbpasswd file on update or create once the lock has
186 been granted to prevent race conditions. JRA.
187 ****************************************************************/
188
189 static FILE *startsmbfilepwent(const char *pfile, enum pwf_access_type type, int *lock_depth)
190 {
191 FILE *fp = NULL;
192 const char *open_mode = NULL;
193 int race_loop = 0;
194 int lock_type = F_RDLCK;
195 struct stat st;
196
197 if (!*pfile) {
198 DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
199 return (NULL);
200 }
201
202 switch(type) {
203 case PWF_READ:
204 open_mode = "rb";
205 lock_type = F_RDLCK;
206 break;
207 case PWF_UPDATE:
208 open_mode = "r+b";
209 lock_type = F_WRLCK;
210 break;
211 case PWF_CREATE:
212 /*
213 * Ensure atomic file creation.
214 */
215 {
216 int i, fd = -1;
217
218 for(i = 0; i < 5; i++) {
219 if((fd = open(pfile, O_CREAT|O_TRUNC|O_EXCL|O_RDWR, 0600))!=-1) {
220 break;
221 }
222 usleep(200); /* Spin, spin... */
223 }
224 if(fd == -1) {
225 DEBUG(0,("startsmbfilepwent_internal: too many race conditions \
226 creating file %s\n", pfile));
227 return NULL;
228 }
229 close(fd);
230 open_mode = "r+b";
231 lock_type = F_WRLCK;
232 break;
233 }
234 default:
235 DEBUG(10, ("Invalid open mode: %d\n", type));
236 return NULL;
237 }
238
239 for(race_loop = 0; race_loop < 5; race_loop++) {
240 DEBUG(10, ("startsmbfilepwent_internal: opening file %s\n", pfile));
241
242 if((fp = fopen(pfile, open_mode)) == NULL) {
243
244 /*
245 * If smbpasswd file doesn't exist, then create new one. This helps to avoid
246 * confusing error msg when adding user account first time.
247 */
248 if (errno == ENOENT) {
249 if ((fp = fopen(pfile, "a+")) != NULL) {
250 DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
251 exist. File successfully created.\n", pfile));
252 } else {
253 DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
254 exist. Couldn't create new one. Error was: %s\n",
255 pfile, strerror(errno)));
256 return NULL;
257 }
258 } else {
259 DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. \
260 Error was: %s\n", pfile, strerror(errno)));
261 return NULL;
262 }
263 }
264
265 if (!pw_file_lock(fileno(fp), lock_type, 5, lock_depth)) {
266 DEBUG(0, ("startsmbfilepwent_internal: unable to lock file %s. \
267 Error was %s\n", pfile, strerror(errno) ));
268 fclose(fp);
269 return NULL;
270 }
271
272 /*
273 * Only check for replacement races on update or create.
274 * For read we don't mind if the data is one record out of date.
275 */
276
277 if(type == PWF_READ) {
278 break;
279 } else {
280 SMB_STRUCT_STAT sbuf1, sbuf2;
281
282 /*
283 * Avoid the potential race condition between the open and the lock
284 * by doing a stat on the filename and an fstat on the fd. If the
285 * two inodes differ then someone did a rename between the open and
286 * the lock. Back off and try the open again. Only do this 5 times to
287 * prevent infinite loops. JRA.
288 */
289
290 if (sys_stat(pfile, &sbuf1, false) != 0) {
291 DEBUG(0, ("startsmbfilepwent_internal: unable to stat file %s. \
292 Error was %s\n", pfile, strerror(errno)));
293 pw_file_unlock(fileno(fp), lock_depth);
294 fclose(fp);
295 return NULL;
296 }
297
298 if (sys_fstat(fileno(fp), &sbuf2, false) != 0) {
299 DEBUG(0, ("startsmbfilepwent_internal: unable to fstat file %s. \
300 Error was %s\n", pfile, strerror(errno)));
301 pw_file_unlock(fileno(fp), lock_depth);
302 fclose(fp);
303 return NULL;
304 }
305
306 if( sbuf1.st_ex_ino == sbuf2.st_ex_ino) {
307 /* No race. */
308 break;
309 }
310
311 /*
312 * Race occurred - back off and try again...
313 */
314
315 pw_file_unlock(fileno(fp), lock_depth);
316 fclose(fp);
317 }
318 }
319
320 if(race_loop == 5) {
321 DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile));
322 return NULL;
323 }
324
325 /* Set a buffer to do more efficient reads */
326 setvbuf(fp, (char *)NULL, _IOFBF, 1024);
327
328 /* Ensure we have a valid stat. */
329 if (fstat(fileno(fp), &st) != 0) {
330 DBG_ERR("Unable to fstat file %s. Error was %s\n",
331 pfile,
332 strerror(errno));
333 pw_file_unlock(fileno(fp), lock_depth);
334 fclose(fp);
335 return NULL;
336 }
337
338 /* If file has invalid permissions != 0600, then [f]chmod(). */
339 if ((st.st_mode & 0777) != (S_IRUSR|S_IWUSR)) {
340 DBG_WARNING("file %s has invalid permissions 0%o should "
341 "be 0600.\n",
342 pfile,
343 (unsigned int)st.st_mode & 0777);
344 /* Make sure it is only rw by the owner */
345 #ifdef HAVE_FCHMOD
346 if (fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
347 #else
348 if (chmod(pfile, S_IRUSR|S_IWUSR) == -1) {
349 #endif
350 DBG_ERR("Failed to set 0600 permissions on password file %s. "
351 "Error was %s\n.",
352 pfile,
353 strerror(errno));
354 pw_file_unlock(fileno(fp), lock_depth);
355 fclose(fp);
356 return NULL;
357 }
358 }
359
360 /* We have a lock on the file. */
361 return fp;
362 }
363
364 /***************************************************************
365 End enumeration of the smbpasswd list.
366 ****************************************************************/
367
368 static void endsmbfilepwent(FILE *fp, int *lock_depth)
369 {
370 if (!fp) {
371 return;
372 }
373
374 pw_file_unlock(fileno(fp), lock_depth);
375 fclose(fp);
376 DEBUG(7, ("endsmbfilepwent_internal: closed password file.\n"));
377 }
378
379 /*************************************************************************
380 Routine to return the next entry in the smbpasswd list.
381 *************************************************************************/
382
383 static struct smb_passwd *getsmbfilepwent(struct smbpasswd_privates *smbpasswd_state, FILE *fp)
384 {
385 /* Static buffers we will return. */
386 struct smb_passwd *pw_buf = &smbpasswd_state->pw_buf;
387 char *user_name = smbpasswd_state->user_name;
388 unsigned char *smbpwd = smbpasswd_state->smbpwd;
389 unsigned char *smbntpwd = smbpasswd_state->smbntpwd;
390 char linebuf[256];
391 unsigned char *p;
392 long uidval;
393 size_t linebuf_len;
394 char *status;
395
396 if(fp == NULL) {
397 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
398 return NULL;
399 }
400
401 pdb_init_smb(pw_buf);
402 pw_buf->acct_ctrl = ACB_NORMAL;
403
404 /*
405 * Scan the file, a line at a time and check if the name matches.
406 */
407 status = linebuf;
408 while (status && !feof(fp)) {
409 linebuf[0] = '\0';
410
411 status = fgets(linebuf, 256, fp);
412 if (status == NULL && ferror(fp)) {
413 return NULL;
414 }
415
416 /*
417 * Check if the string is terminated with a newline - if not
418 * then we must keep reading and discard until we get one.
419 */
420 if ((linebuf_len = strlen(linebuf)) == 0) {
421 continue;
422 }
423
424 if (linebuf[linebuf_len - 1] != '\n') {
425 while (!ferror(fp) && !feof(fp)) {
426 int c;
427 c = fgetc(fp);
428 if (c == '\n') {
429 break;
430 }
431 }
432 } else {
433 linebuf[linebuf_len - 1] = '\0';
434 }
435
436 #ifdef DEBUG_PASSWORD
437 DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf));
438 #endif
439 if ((linebuf[0] == 0) && feof(fp)) {
440 DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
441 break;
442 }
443
444 /*
445 * The line we have should be of the form :-
446 *
447 * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
448 * ignored....
449 *
450 * or,
451 *
452 * username:uid:32hex bytes:32hex bytes:[Account type]:LCT-12345678....ignored....
453 *
454 * if Windows NT compatible passwords are also present.
455 * [Account type] is an ascii encoding of the type of account.
456 * LCT-(8 hex digits) is the time_t value of the last change time.
457 */
458
459 if (linebuf[0] == '#' || linebuf[0] == '\0') {
460 DEBUG(6, ("getsmbfilepwent: skipping comment or blank line\n"));
461 continue;
462 }
463 p = (unsigned char *) strchr_m(linebuf, ':');
464 if (p == NULL) {
465 DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
466 continue;
467 }
468
469 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
470 user_name[PTR_DIFF(p, linebuf)] = '\0';
471
472 /* Get smb uid. */
473
474 p++; /* Go past ':' */
475
476 if(*p == '-') {
477 DEBUG(0, ("getsmbfilepwent: user name %s has a negative uid.\n", user_name));
478 continue;
479 }
480
481 if (!isdigit(*p)) {
482 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (uid not number)\n",
483 user_name));
484 continue;
485 }
486
487 uidval = atoi((char *) p);
488
489 while (*p && isdigit(*p)) {
490 p++;
491 }
492
493 if (*p != ':') {
494 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no : after uid)\n",
495 user_name));
496 continue;
497 }
498
499 pw_buf->smb_name = user_name;
500 pw_buf->smb_userid = uidval;
501
502 /*
503 * Now get the password value - this should be 32 hex digits
504 * which are the ascii representations of a 16 byte string.
505 * Get two at a time and put them into the password.
506 */
507
508 /* Skip the ':' */
509 p++;
510
511 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
512 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (passwd too short)\n",
513 user_name ));
514 continue;
515 }
516
517 if (p[32] != ':') {
518 DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no terminating :)\n",
519 user_name));
520 continue;
521 }
522
523 if (strnequal((char *) p, "NO PASSWORD", 11)) {
524 pw_buf->smb_passwd = NULL;
525 pw_buf->acct_ctrl |= ACB_PWNOTREQ;
526 } else {
527 if (*p == '*' || *p == 'X') {
528 /* NULL LM password */
529 pw_buf->smb_passwd = NULL;
530 DEBUG(10, ("getsmbfilepwent: LM password for user %s invalidated\n", user_name));
531 } else if (pdb_gethexpwd((char *)p, smbpwd)) {
532 pw_buf->smb_passwd = smbpwd;
533 } else {
534 pw_buf->smb_passwd = NULL;
535 DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry for user %s \
536 (non hex chars)\n", user_name));
537 }
538 }
539
540 /*
541 * Now check if the NT compatible password is
542 * available.
543 */
544 pw_buf->smb_nt_passwd = NULL;
545 p += 33; /* Move to the first character of the line after the lanman password. */
546 if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
547 if (*p != '*' && *p != 'X') {
548 if(pdb_gethexpwd((char *)p,smbntpwd)) {
549 pw_buf->smb_nt_passwd = smbntpwd;
550 }
551 }
552 p += 33; /* Move to the first character of the line after the NT password. */
553 }
554
555 DEBUG(5,("getsmbfilepwent: returning passwd entry for user %s, uid %ld\n",
556 user_name, uidval));
557
558 if (*p == '[') {
559 unsigned char *end_p = (unsigned char *)strchr_m((char *)p, ']');
560 pw_buf->acct_ctrl = pdb_decode_acct_ctrl((char*)p);
561
562 /* Must have some account type set. */
563 if(pw_buf->acct_ctrl == 0) {
564 pw_buf->acct_ctrl = ACB_NORMAL;
565 }
566
567 /* Now try and get the last change time. */
568 if(end_p) {
569 p = end_p + 1;
570 }
571 if(*p == ':') {
572 p++;
573 if(*p && (strncasecmp_m((char *)p, "LCT-", 4)==0)) {
574 int i;
575 p += 4;
576 for(i = 0; i < 8; i++) {
577 if(p[i] == '\0' || !isxdigit(p[i])) {
578 break;
579 }
580 }
581 if(i == 8) {
582 /*
583 * p points at 8 characters of hex digits -
584 * read into a time_t as the seconds since
585 * 1970 that the password was last changed.
586 */
587 pw_buf->pass_last_set_time = (time_t)strtol((char *)p, NULL, 16);
588 }
589 }
590 }
591 } else {
592 /* 'Old' style file. Fake up based on user name. */
593 /*
594 * Currently trust accounts are kept in the same
595 * password file as 'normal accounts'. If this changes
596 * we will have to fix this code. JRA.
597 */
598 if(pw_buf->smb_name[strlen(pw_buf->smb_name) - 1] == '$') {
599 pw_buf->acct_ctrl &= ~ACB_NORMAL;
600 pw_buf->acct_ctrl |= ACB_WSTRUST;
601 }
602 }
603
604 return pw_buf;
605 }
606
607 DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
608 return NULL;
609 }
610
611 /************************************************************************
612 Create a new smbpasswd entry - malloced space returned.
613 *************************************************************************/
614
615 static char *format_new_smbpasswd_entry(const struct smb_passwd *newpwd)
616 {
617 int new_entry_length;
618 char *new_entry;
619 char *p;
620
621 new_entry_length = strlen(newpwd->smb_name) + 1 + 15 + 1 + 32 + 1 + 32 + 1 +
622 NEW_PW_FORMAT_SPACE_PADDED_LEN + 1 + 13 + 2;
623
624 if((new_entry = (char *)SMB_MALLOC( new_entry_length )) == NULL) {
625 DEBUG(0, ("format_new_smbpasswd_entry: Malloc failed adding entry for user %s.\n",
626 newpwd->smb_name ));
627 return NULL;
628 }
629
630 slprintf(new_entry, new_entry_length - 1, "%s:%u:", newpwd->smb_name, (unsigned)newpwd->smb_userid);
631
632 p = new_entry+strlen(new_entry);
633 pdb_sethexpwd(p, newpwd->smb_passwd, newpwd->acct_ctrl);
634 p+=strlen(p);
635 *p = ':';
636 p++;
637
638 pdb_sethexpwd(p, newpwd->smb_nt_passwd, newpwd->acct_ctrl);
639 p+=strlen(p);
640 *p = ':';
641 p++;
642
643 /* Add the account encoding and the last change time. */
644 slprintf((char *)p, new_entry_length - 1 - (p - new_entry), "%s:LCT-%08X:\n",
645 pdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN),
646 (uint32_t)newpwd->pass_last_set_time);
647
648 return new_entry;
649 }
650
651 /************************************************************************
652 Routine to add an entry to the smbpasswd file.
653 *************************************************************************/
654
655 static NTSTATUS add_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state,
656 struct smb_passwd *newpwd)
657 {
658 const char *pfile = smbpasswd_state->smbpasswd_file;
659 struct smb_passwd *pwd = NULL;
660 FILE *fp = NULL;
661 int wr_len;
662 int fd;
663 size_t new_entry_length;
664 char *new_entry;
665 off_t offpos;
666
667 /* Open the smbpassword file - for update. */
668 fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth);
669
670 if (fp == NULL && errno == ENOENT) {
671 /* Try again - create. */
672 fp = startsmbfilepwent(pfile, PWF_CREATE, &smbpasswd_state->pw_file_lock_depth);
673 }
674
675 if (fp == NULL) {
676 DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
677 return map_nt_error_from_unix(errno);
678 }
679
680 /*
681 * Scan the file, a line at a time and check if the name matches.
682 */
683
684 while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
685 if (strequal(newpwd->smb_name, pwd->smb_name)) {
686 DEBUG(0, ("add_smbfilepwd_entry: entry with name %s already exists\n", pwd->smb_name));
687 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
688 return NT_STATUS_USER_EXISTS;
689 }
690 }
691
692 /* Ok - entry doesn't exist. We can add it */
693
694 /* Create a new smb passwd entry and set it to the given password. */
695 /*
696 * The add user write needs to be atomic - so get the fd from
697 * the fp and do a raw write() call.
698 */
699 fd = fileno(fp);
700
701 if((offpos = lseek(fd, 0, SEEK_END)) == -1) {
702 NTSTATUS result = map_nt_error_from_unix(errno);
703 DEBUG(0, ("add_smbfilepwd_entry(lseek): Failed to add entry for user %s to file %s. \
704 Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
705 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
706 return result;
707 }
708
709 if((new_entry = format_new_smbpasswd_entry(newpwd)) == NULL) {
710 DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
711 Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
712 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
713 return NT_STATUS_NO_MEMORY;
714 }
715
716 new_entry_length = strlen(new_entry);
717
718 #ifdef DEBUG_PASSWORD
719 DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d made line |%s|",
720 fd, (int)new_entry_length, new_entry));
721 #endif
722
723 if ((wr_len = write(fd, new_entry, new_entry_length)) != new_entry_length) {
724 NTSTATUS result = map_nt_error_from_unix(errno);
725 DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
726 Error was %s\n", wr_len, newpwd->smb_name, pfile, strerror(errno)));
727
728 /* Remove the entry we just wrote. */
729 if(ftruncate(fd, offpos) == -1) {
730 DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
731 Error was %s. Password file may be corrupt ! Please examine by hand !\n",
732 newpwd->smb_name, strerror(errno)));
733 }
734
735 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
736 free(new_entry);
737 return result;
738 }
739
740 free(new_entry);
741 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
742 return NT_STATUS_OK;
743 }
744
745 /************************************************************************
746 Routine to search the smbpasswd file for an entry matching the username.
747 and then modify its password entry. We can't use the startsmbpwent()/
748 getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
749 in the actual file to decide how much room we have to write data.
750 override = False, normal
751 override = True, override XXXXXXXX'd out password or NO PASS
752 ************************************************************************/
753
754 static bool mod_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state, const struct smb_passwd* pwd)
755 {
756 /* Static buffers we will return. */
757 fstring user_name;
758
759 char *status;
760 #define LINEBUF_SIZE 255
761 char linebuf[LINEBUF_SIZE + 1];
762 char readbuf[1024];
763 char ascii_p16[FSTRING_LEN + 20];
764 fstring encode_bits;
765 unsigned char *p = NULL;
766 size_t linebuf_len = 0;
767 FILE *fp;
768 int lockfd;
769 const char *pfile = smbpasswd_state->smbpasswd_file;
770 bool found_entry = False;
771 bool got_pass_last_set_time = False;
772
773 off_t pwd_seekpos = 0;
774
775 int i;
776 int wr_len;
777 int fd;
778
779 if (!*pfile) {
780 DEBUG(0, ("No SMB password file set\n"));
781 return False;
782 }
783 DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
784
785 fp = fopen(pfile, "r+");
786
787 if (fp == NULL) {
788 DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
789 return False;
790 }
791 /* Set a buffer to do more efficient reads */
792 setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
793
794 lockfd = fileno(fp);
795
796 if (!pw_file_lock(lockfd, F_WRLCK, 5, &smbpasswd_state->pw_file_lock_depth)) {
797 DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile));
798 fclose(fp);
799 return False;
800 }
801
802 /* Make sure it is only rw by the owner */
803 chmod(pfile, 0600);
804
805 /* We have a write lock on the file. */
806 /*
807 * Scan the file, a line at a time and check if the name matches.
808 */
809 status = linebuf;
810 while (status && !feof(fp)) {
811 pwd_seekpos = ftell(fp);
812
813 linebuf[0] = '\0';
814
815 status = fgets(linebuf, LINEBUF_SIZE, fp);
816 if (status == NULL && ferror(fp)) {
817 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
818 fclose(fp);
819 return False;
820 }
821
822 /*
823 * Check if the string is terminated with a newline - if not
824 * then we must keep reading and discard until we get one.
825 */
826 linebuf_len = strlen(linebuf);
827 if (linebuf[linebuf_len - 1] != '\n') {
828 while (!ferror(fp) && !feof(fp)) {
829 int c;
830 c = fgetc(fp);
831 if (c == '\n') {
832 break;
833 }
834 }
835 } else {
836 linebuf[linebuf_len - 1] = '\0';
837 }
838
839 #ifdef DEBUG_PASSWORD
840 DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf));
841 #endif
842
843 if ((linebuf[0] == 0) && feof(fp)) {
844 DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
845 break;
846 }
847
848 /*
849 * The line we have should be of the form :-
850 *
851 * username:uid:[32hex bytes]:....other flags presently
852 * ignored....
853 *
854 * or,
855 *
856 * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
857 *
858 * if Windows NT compatible passwords are also present.
859 */
860
861 if (linebuf[0] == '#' || linebuf[0] == '\0') {
862 DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
863 continue;
864 }
865
866 p = (unsigned char *) strchr_m(linebuf, ':');
867
868 if (p == NULL) {
869 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
870 continue;
871 }
872
873 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
874 user_name[PTR_DIFF(p, linebuf)] = '\0';
875 if (strequal(user_name, pwd->smb_name)) {
876 found_entry = True;
877 break;
878 }
879 }
880
881 if (!found_entry) {
882 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
883 fclose(fp);
884
885 DEBUG(2, ("Cannot update entry for user %s, as they don't exist in the smbpasswd file!\n",
886 pwd->smb_name));
887 return False;
888 }
889
890 DEBUG(6, ("mod_smbfilepwd_entry: entry exists for user %s\n", pwd->smb_name));
891
892 /* User name matches - get uid and password */
893 p++; /* Go past ':' */
894
895 if (!isdigit(*p)) {
896 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (uid not number)\n",
897 pwd->smb_name));
898 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
899 fclose(fp);
900 return False;
901 }
902
903 while (*p && isdigit(*p)) {
904 p++;
905 }
906 if (*p != ':') {
907 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no : after uid)\n",
908 pwd->smb_name));
909 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
910 fclose(fp);
911 return False;
912 }
913
914 /*
915 * Now get the password value - this should be 32 hex digits
916 * which are the ascii representations of a 16 byte string.
917 * Get two at a time and put them into the password.
918 */
919 p++;
920
921 /* Record exact password position */
922 pwd_seekpos += PTR_DIFF(p, linebuf);
923
924 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
925 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
926 pwd->smb_name));
927 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
928 fclose(fp);
929 return (False);
930 }
931
932 if (p[32] != ':') {
933 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
934 pwd->smb_name));
935 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
936 fclose(fp);
937 return False;
938 }
939
940 /* Now check if the NT compatible password is available. */
941 p += 33; /* Move to the first character of the line after the lanman password. */
942 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
943 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
944 pwd->smb_name));
945 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
946 fclose(fp);
947 return (False);
948 }
949
950 if (p[32] != ':') {
951 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
952 pwd->smb_name));
953 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
954 fclose(fp);
955 return False;
956 }
957
958 /*
959 * Now check if the account info and the password last
960 * change time is available.
961 */
962 p += 33; /* Move to the first character of the line after the NT password. */
963
964 if (*p == '[') {
965 i = 0;
966 encode_bits[i++] = *p++;
967 while((linebuf_len > PTR_DIFF(p, linebuf)) && (*p != ']')) {
968 encode_bits[i++] = *p++;
969 }
970
971 encode_bits[i++] = ']';
972 encode_bits[i++] = '\0';
973
974 if(i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
975 /*
976 * We are using a new format, space padded
977 * acct ctrl field. Encode the given acct ctrl
978 * bits into it.
979 */
980 fstrcpy(encode_bits, pdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
981 } else {
982 DEBUG(0,("mod_smbfilepwd_entry: Using old smbpasswd format for user %s. \
983 This is no longer supported.!\n", pwd->smb_name));
984 DEBUG(0,("mod_smbfilepwd_entry: No changes made, failing.!\n"));
985 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
986 fclose(fp);
987 return False;
988 }
989
990 /* Go past the ']' */
991 if(linebuf_len > PTR_DIFF(p, linebuf)) {
992 p++;
993 }
994
995 if((linebuf_len > PTR_DIFF(p, linebuf)) && (*p == ':')) {
996 p++;
997
998 /* We should be pointing at the LCT entry. */
999 if((linebuf_len > (PTR_DIFF(p, linebuf) + 13)) && (strncasecmp_m((char *)p, "LCT-", 4) == 0)) {
1000 p += 4;
1001 for(i = 0; i < 8; i++) {
1002 if(p[i] == '\0' || !isxdigit(p[i])) {
1003 break;
1004 }
1005 }
1006 if(i == 8) {
1007 /*
1008 * p points at 8 characters of hex digits -
1009 * read into a time_t as the seconds since
1010 * 1970 that the password was last changed.
1011 */
1012 got_pass_last_set_time = True;
1013 } /* i == 8 */
1014 } /* *p && strncasecmp_m() */
1015 } /* p == ':' */
1016 } /* p == '[' */
1017
1018 /* Entry is correctly formed. */
1019
1020 /* Create the 32 byte representation of the new p16 */
1021 pdb_sethexpwd(ascii_p16, pwd->smb_passwd, pwd->acct_ctrl);
1022
1023 /* Add on the NT md4 hash */
1024 ascii_p16[32] = ':';
1025 wr_len = 66;
1026 pdb_sethexpwd(ascii_p16+33, pwd->smb_nt_passwd, pwd->acct_ctrl);
1027 ascii_p16[65] = ':';
1028 ascii_p16[66] = '\0'; /* null-terminate the string so that strlen works */
1029
1030 /* Add on the account info bits and the time of last password change. */
1031 if(got_pass_last_set_time) {
1032 slprintf(&ascii_p16[strlen(ascii_p16)],
1033 sizeof(ascii_p16)-(strlen(ascii_p16)+1),
1034 "%s:LCT-%08X:",
1035 encode_bits, (uint32_t)pwd->pass_last_set_time );
1036 wr_len = strlen(ascii_p16);
1037 }
1038
1039 #ifdef DEBUG_PASSWORD
1040 DEBUG(100,("mod_smbfilepwd_entry: "));
1041 dump_data(100, (uint8_t *)ascii_p16, wr_len);
1042 #endif
1043
1044 if(wr_len > LINEBUF_SIZE) {
1045 DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len+1));
1046 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1047 fclose(fp);
1048 return (False);
1049 }
1050
1051 /*
1052 * Do an atomic write into the file at the position defined by
1053 * seekpos.
1054 */
1055
1056 /* The mod user write needs to be atomic - so get the fd from
1057 the fp and do a raw write() call.
1058 */
1059
1060 fd = fileno(fp);
1061
1062 if (lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
1063 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1064 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1065 fclose(fp);
1066 return False;
1067 }
1068
1069 /* Sanity check - ensure the areas we are writing are framed by ':' */
1070 if (read(fd, linebuf, wr_len+1) != wr_len+1) {
1071 DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile));
1072 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1073 fclose(fp);
1074 return False;
1075 }
1076
1077 if ((linebuf[0] != ':') || (linebuf[wr_len] != ':')) {
1078 DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile));
1079 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1080 fclose(fp);
1081 return False;
1082 }
1083
1084 if (lseek(fd, pwd_seekpos, SEEK_SET) != pwd_seekpos) {
1085 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1086 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1087 fclose(fp);
1088 return False;
1089 }
1090
1091 if (write(fd, ascii_p16, wr_len) != wr_len) {
1092 DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile));
1093 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1094 fclose(fp);
1095 return False;
1096 }
1097
1098 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1099 fclose(fp);
1100 return True;
1101 }
1102
1103 /************************************************************************
1104 Routine to delete an entry in the smbpasswd file by name.
1105 *************************************************************************/
1106
1107 static bool del_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state, const char *name)
1108 {
1109 const char *pfile = smbpasswd_state->smbpasswd_file;
1110 char *pfile2 = NULL;
1111 struct smb_passwd *pwd = NULL;
1112 FILE *fp = NULL;
1113 FILE *fp_write = NULL;
1114 int pfile2_lockdepth = 0;
1115
1116 pfile2 = talloc_asprintf(talloc_tos(),
1117 "%s.%u",
1118 pfile, (unsigned)getpid());
1119 if (!pfile2) {
1120 return false;
1121 }
1122
1123 /*
1124 * Open the smbpassword file - for update. It needs to be update
1125 * as we need any other processes to wait until we have replaced
1126 * it.
1127 */
1128
1129 if((fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth)) == NULL) {
1130 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1131 return False;
1132 }
1133
1134 /*
1135 * Create the replacement password file.
1136 */
1137 if((fp_write = startsmbfilepwent(pfile2, PWF_CREATE, &pfile2_lockdepth)) == NULL) {
1138 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1139 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1140 return False;
1141 }
1142
1143 /*
1144 * Scan the file, a line at a time and check if the name matches.
1145 */
1146
1147 while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1148 char *new_entry;
1149 size_t new_entry_length;
1150
1151 if (strequal(name, pwd->smb_name)) {
1152 DEBUG(10, ("del_smbfilepwd_entry: found entry with "
1153 "name %s - deleting it.\n", name));
1154 continue;
1155 }
1156
1157 /*
1158 * We need to copy the entry out into the second file.
1159 */
1160
1161 if((new_entry = format_new_smbpasswd_entry(pwd)) == NULL) {
1162 DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
1163 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1164 unlink(pfile2);
1165 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1166 endsmbfilepwent(fp_write, &pfile2_lockdepth);
1167 return False;
1168 }
1169
1170 new_entry_length = strlen(new_entry);
1171
1172 if(fwrite(new_entry, 1, new_entry_length, fp_write) != new_entry_length) {
1173 DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
1174 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1175 unlink(pfile2);
1176 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1177 endsmbfilepwent(fp_write, &pfile2_lockdepth);
1178 free(new_entry);
1179 return False;
1180 }
1181
1182 free(new_entry);
1183 }
1184
1185 /*
1186 * Ensure pfile2 is flushed before rename.
1187 */
1188
1189 if(fflush(fp_write) != 0) {
1190 DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2, strerror(errno)));
1191 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1192 endsmbfilepwent(fp_write,&pfile2_lockdepth);
1193 return False;
1194 }
1195
1196 /*
1197 * Do an atomic rename - then release the locks.
1198 */
1199
1200 if(rename(pfile2,pfile) != 0) {
1201 unlink(pfile2);
1202 }
1203
1204 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1205 endsmbfilepwent(fp_write,&pfile2_lockdepth);
1206 return True;
1207 }
1208
1209 /*********************************************************************
1210 Create a smb_passwd struct from a struct samu.
1211 We will not allocate any new memory. The smb_passwd struct
1212 should only stay around as long as the struct samu does.
1213 ********************************************************************/
1214
1215 static bool build_smb_pass (struct smb_passwd *smb_pw, const struct samu *sampass)
1216 {
1217 uint32_t rid;
1218
1219 if (sampass == NULL)
1220 return False;
1221 ZERO_STRUCTP(smb_pw);
1222
1223 if (!IS_SAM_DEFAULT(sampass, PDB_USERSID)) {
1224 rid = pdb_get_user_rid(sampass);
1225
1226 /* If the user specified a RID, make sure its able to be both stored and retrieved */
1227 if (rid == DOMAIN_RID_GUEST) {
1228 struct passwd *passwd = Get_Pwnam_alloc(NULL, lp_guest_account());
1229 if (!passwd) {
1230 DEBUG(0, ("Could not find guest account via Get_Pwnam_alloc()! (%s)\n", lp_guest_account()));
1231 return False;
1232 }
1233 smb_pw->smb_userid=passwd->pw_uid;
1234 TALLOC_FREE(passwd);
1235 } else if (algorithmic_pdb_rid_is_user(rid)) {
1236 smb_pw->smb_userid=algorithmic_pdb_user_rid_to_uid(rid);
1237 } else {
1238 DEBUG(0,("build_sam_pass: Failing attempt to store user with non-uid based user RID. \n"));
1239 return False;
1240 }
1241 }
1242
1243 smb_pw->smb_name=(const char*)pdb_get_username(sampass);
1244
1245 smb_pw->smb_passwd=pdb_get_lanman_passwd(sampass);
1246 smb_pw->smb_nt_passwd=pdb_get_nt_passwd(sampass);
1247
1248 smb_pw->acct_ctrl=pdb_get_acct_ctrl(sampass);
1249 smb_pw->pass_last_set_time=pdb_get_pass_last_set_time(sampass);
1250
1251 return True;
1252 }
1253
1254 /*********************************************************************
1255 Create a struct samu from a smb_passwd struct
1256 ********************************************************************/
1257
1258 static bool build_sam_account(struct smbpasswd_privates *smbpasswd_state,
1259 struct samu *sam_pass, const struct smb_passwd *pw_buf)
1260 {
1261 struct passwd *pwfile;
1262
1263 if ( !sam_pass ) {
1264 DEBUG(5,("build_sam_account: struct samu is NULL\n"));
1265 return False;
1266 }
1267
1268 /* verify the user account exists */
1269
1270 if ( !(pwfile = Get_Pwnam_alloc(NULL, pw_buf->smb_name )) ) {
1271 DEBUG(0,("build_sam_account: smbpasswd database is corrupt! username %s with uid "
1272 "%u is not in unix passwd database!\n", pw_buf->smb_name, pw_buf->smb_userid));
1273 return False;
1274 }
1275
1276 if ( !NT_STATUS_IS_OK( samu_set_unix(sam_pass, pwfile )) )
1277 return False;
1278
1279 TALLOC_FREE(pwfile);
1280
1281 /* set remaining fields */
1282
1283 if (!pdb_set_nt_passwd (sam_pass, pw_buf->smb_nt_passwd, PDB_SET))
1284 return False;
1285 if (!pdb_set_lanman_passwd (sam_pass, pw_buf->smb_passwd, PDB_SET))
1286 return False;
1287 pdb_set_acct_ctrl (sam_pass, pw_buf->acct_ctrl, PDB_SET);
1288 pdb_set_pass_last_set_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1289 pdb_set_pass_can_change_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1290
1291 return True;
1292 }
1293
1294 /*****************************************************************
1295 Functions to be implemented by the new passdb API
1296 ****************************************************************/
1297
1298 /****************************************************************
1299 Search smbpasswd file by iterating over the entries. Do not
1300 call getpwnam() for unix account information until we have found
1301 the correct entry
1302 ***************************************************************/
1303
1304 static NTSTATUS smbpasswd_getsampwnam(struct pdb_methods *my_methods,
1305 struct samu *sam_acct, const char *username)
1306 {
1307 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1308 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1309 struct smb_passwd *smb_pw;
1310 FILE *fp = NULL;
1311
1312 DEBUG(10, ("getsampwnam (smbpasswd): search by name: %s\n", username));
1313
1314 /* startsmbfilepwent() is used here as we don't want to lookup
1315 the UNIX account in the local system password file until
1316 we have a match. */
1317 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1318
1319 if (fp == NULL) {
1320 DEBUG(0, ("Unable to open passdb database.\n"));
1321 return nt_status;
1322 }
1323
1324 while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL)&& (!strequal(smb_pw->smb_name, username)) )
1325 /* do nothing....another loop */ ;
1326
1327 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1328
1329
1330 /* did we locate the username in smbpasswd */
1331 if (smb_pw == NULL)
1332 return nt_status;
1333
1334 DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1335
1336 if (!sam_acct) {
1337 DEBUG(10,("getsampwnam (smbpasswd): struct samu is NULL\n"));
1338 return nt_status;
1339 }
1340
1341 /* now build the struct samu */
1342 if (!build_sam_account(smbpasswd_state, sam_acct, smb_pw))
1343 return nt_status;
1344
1345 /* success */
1346 return NT_STATUS_OK;
1347 }
1348
1349 static NTSTATUS smbpasswd_getsampwsid(struct pdb_methods *my_methods, struct samu *sam_acct, const struct dom_sid *sid)
1350 {
1351 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1352 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1353 struct smb_passwd *smb_pw;
1354 struct dom_sid_buf buf;
1355 FILE *fp = NULL;
1356 uint32_t rid;
1357
1358 DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n",
1359 dom_sid_str_buf(sid, &buf)));
1360
1361 if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
1362 return NT_STATUS_UNSUCCESSFUL;
1363
1364 /* More special case 'guest account' hacks... */
1365 if (rid == DOMAIN_RID_GUEST) {
1366 const char *guest_account = lp_guest_account();
1367 if (!(guest_account && *guest_account)) {
1368 DEBUG(1, ("Guest account not specified!\n"));
1369 return nt_status;
1370 }
1371 return smbpasswd_getsampwnam(my_methods, sam_acct, guest_account);
1372 }
1373
1374 /* Open the sam password file - not for update. */
1375 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1376
1377 if (fp == NULL) {
1378 DEBUG(0, ("Unable to open passdb database.\n"));
1379 return nt_status;
1380 }
1381
1382 while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL) && (algorithmic_pdb_uid_to_user_rid(smb_pw->smb_userid) != rid) )
1383 /* do nothing */ ;
1384
1385 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1386
1387
1388 /* did we locate the username in smbpasswd */
1389 if (smb_pw == NULL)
1390 return nt_status;
1391
1392 DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1393
1394 if (!sam_acct) {
1395 DEBUG(10,("getsampwrid: (smbpasswd) struct samu is NULL\n"));
1396 return nt_status;
1397 }
1398
1399 /* now build the struct samu */
1400 if (!build_sam_account (smbpasswd_state, sam_acct, smb_pw))
1401 return nt_status;
1402
1403 /* build_sam_account might change the SID on us, if the name was for the guest account */
1404 if (NT_STATUS_IS_OK(nt_status) && !dom_sid_equal(pdb_get_user_sid(sam_acct), sid)) {
1405 struct dom_sid_buf buf1, buf2;
1406 DEBUG(1, ("looking for user with sid %s instead returned %s "
1407 "for account %s!?!\n",
1408 dom_sid_str_buf(sid, &buf1),
1409 dom_sid_str_buf(pdb_get_user_sid(sam_acct), &buf2),
1410 pdb_get_username(sam_acct)));
1411 return NT_STATUS_NO_SUCH_USER;
1412 }
1413
1414 /* success */
1415 return NT_STATUS_OK;
1416 }
1417
1418 static NTSTATUS smbpasswd_add_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1419 {
1420 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1421 struct smb_passwd smb_pw;
1422
1423 /* convert the struct samu */
1424 if (!build_smb_pass(&smb_pw, sampass)) {
1425 return NT_STATUS_UNSUCCESSFUL;
1426 }
1427
1428 /* add the entry */
1429 return add_smbfilepwd_entry(smbpasswd_state, &smb_pw);
1430 }
1431
1432 static NTSTATUS smbpasswd_update_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1433 {
1434 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1435 struct smb_passwd smb_pw;
1436
1437 /* convert the struct samu */
1438 if (!build_smb_pass(&smb_pw, sampass)) {
1439 DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
1440 return NT_STATUS_UNSUCCESSFUL;
1441 }
1442
1443 /* update the entry */
1444 if(!mod_smbfilepwd_entry(smbpasswd_state, &smb_pw)) {
1445 DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
1446 return NT_STATUS_UNSUCCESSFUL;
1447 }
1448
1449 return NT_STATUS_OK;
1450 }
1451
1452 static NTSTATUS smbpasswd_delete_sam_account (struct pdb_methods *my_methods, struct samu *sampass)
1453 {
1454 struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1455
1456 const char *username = pdb_get_username(sampass);
1457
1458 if (del_smbfilepwd_entry(smbpasswd_state, username))
1459 return NT_STATUS_OK;
1460
1461 return NT_STATUS_UNSUCCESSFUL;
1462 }
1463
1464 static NTSTATUS smbpasswd_rename_sam_account (struct pdb_methods *my_methods,
1465 struct samu *old_acct,
1466 const char *newname)
1467 {
1468 const struct loadparm_substitution *lp_sub =
1469 loadparm_s3_global_substitution();
1470 char *rename_script = NULL;
1471 struct samu *new_acct = NULL;
1472 bool interim_account = False;
1473 TALLOC_CTX *ctx = talloc_tos();
1474 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
1475
1476 if (!*(lp_rename_user_script(talloc_tos(), lp_sub)))
1477 goto done;
1478
1479 if ( !(new_acct = samu_new( NULL )) ) {
1480 return NT_STATUS_NO_MEMORY;
1481 }
1482
1483 if ( !pdb_copy_sam_account( new_acct, old_acct )
1484 || !pdb_set_username(new_acct, newname, PDB_CHANGED))
1485 {
1486 goto done;
1487 }
1488
1489 ret = smbpasswd_add_sam_account(my_methods, new_acct);
1490 if (!NT_STATUS_IS_OK(ret))
1491 goto done;
1492
1493 interim_account = True;
1494
1495 /* rename the posix user */
1496 rename_script = lp_rename_user_script(ctx, lp_sub);
1497 if (!rename_script) {
1498 ret = NT_STATUS_NO_MEMORY;
1499 goto done;
1500 }
1501
1502 if (*rename_script) {
1503 int rename_ret;
1504
1505 rename_script = talloc_string_sub2(ctx,
1506 rename_script,
1507 "%unew",
1508 newname,
1509 true,
1510 false,
1511 true);
1512 if (!rename_script) {
1513 ret = NT_STATUS_NO_MEMORY;
1514 goto done;
1515 }
1516 rename_script = talloc_string_sub2(ctx,
1517 rename_script,
1518 "%uold",
1519 pdb_get_username(old_acct),
1520 true,
1521 false,
1522 true);
1523 if (!rename_script) {
1524 ret = NT_STATUS_NO_MEMORY;
1525 goto done;
1526 }
1527
1528 rename_ret = smbrun(rename_script, NULL, NULL);
1529
1530 DEBUG(rename_ret ? 0 : 3,("Running the command `%s' gave %d\n", rename_script, rename_ret));
1531
1532 if (rename_ret == 0) {
1533 smb_nscd_flush_user_cache();
1534 }
1535
1536 if (rename_ret)
1537 goto done;
1538 } else {
1539 goto done;
1540 }
1541
1542 smbpasswd_delete_sam_account(my_methods, old_acct);
1543 interim_account = False;
1544
1545 done:
1546 /* cleanup */
1547 if (interim_account)
1548 smbpasswd_delete_sam_account(my_methods, new_acct);
1549
1550 if (new_acct)
1551 TALLOC_FREE(new_acct);
1552
1553 return (ret);
1554 }
1555
1556 static uint32_t smbpasswd_capabilities(struct pdb_methods *methods)
1557 {
1558 return 0;
1559 }
1560
1561 static void free_private_data(void **vp)
1562 {
1563 struct smbpasswd_privates **privates = (struct smbpasswd_privates**)vp;
1564
1565 endsmbfilepwent((*privates)->pw_file, &((*privates)->pw_file_lock_depth));
1566
1567 *privates = NULL;
1568 /* No need to free any further, as it is talloc()ed */
1569 }
1570
1571 struct smbpasswd_search_state {
1572 uint32_t acct_flags;
1573
1574 struct samr_displayentry *entries;
1575 uint32_t num_entries;
1576 ssize_t array_size;
1577 uint32_t current;
1578 };
1579
1580 static void smbpasswd_search_end(struct pdb_search *search)
1581 {
1582 struct smbpasswd_search_state *state = talloc_get_type_abort(
1583 search->private_data, struct smbpasswd_search_state);
1584 TALLOC_FREE(state);
1585 }
1586
1587 static bool smbpasswd_search_next_entry(struct pdb_search *search,
1588 struct samr_displayentry *entry)
1589 {
1590 struct smbpasswd_search_state *state = talloc_get_type_abort(
1591 search->private_data, struct smbpasswd_search_state);
1592
1593 if (state->current == state->num_entries) {
1594 return false;
1595 }
1596
1597 entry->idx = state->entries[state->current].idx;
1598 entry->rid = state->entries[state->current].rid;
1599 entry->acct_flags = state->entries[state->current].acct_flags;
1600
1601 entry->account_name = talloc_strdup(
1602 search, state->entries[state->current].account_name);
1603 entry->fullname = talloc_strdup(
1604 search, state->entries[state->current].fullname);
1605 entry->description = talloc_strdup(
1606 search, state->entries[state->current].description);
1607
1608 if ((entry->account_name == NULL) || (entry->fullname == NULL)
1609 || (entry->description == NULL)) {
1610 DBG_ERR("talloc_strdup failed\n");
1611 return false;
1612 }
1613
1614 state->current += 1;
1615 return true;
1616 }
1617
1618 static bool smbpasswd_search_users(struct pdb_methods *methods,
1619 struct pdb_search *search,
1620 uint32_t acct_flags)
1621 {
1622 struct smbpasswd_privates *smbpasswd_state =
1623 (struct smbpasswd_privates*)methods->private_data;
1624
1625 struct smbpasswd_search_state *search_state;
1626 struct smb_passwd *pwd;
1627 FILE *fp;
1628
1629 search_state = talloc_zero(search, struct smbpasswd_search_state);
1630 if (search_state == NULL) {
1631 DEBUG(0, ("talloc failed\n"));
1632 return false;
1633 }
1634 search_state->acct_flags = acct_flags;
1635
1636 fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ,
1637 &smbpasswd_state->pw_file_lock_depth);
1638
1639 if (fp == NULL) {
1640 DEBUG(10, ("Unable to open smbpasswd file.\n"));
1641 TALLOC_FREE(search_state);
1642 return false;
1643 }
1644
1645 while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1646 struct samr_displayentry entry;
1647 struct samu *user;
1648
1649 if ((acct_flags != 0)
1650 && ((acct_flags & pwd->acct_ctrl) == 0)) {
1651 continue;
1652 }
1653
1654 user = samu_new(talloc_tos());
1655 if (user == NULL) {
1656 DEBUG(0, ("samu_new failed\n"));
1657 break;
1658 }
1659
1660 if (!build_sam_account(smbpasswd_state, user, pwd)) {
1661 /* Already got debug msgs... */
1662 break;
1663 }
1664
1665 ZERO_STRUCT(entry);
1666
1667 entry.acct_flags = pdb_get_acct_ctrl(user);
1668 sid_peek_rid(pdb_get_user_sid(user), &entry.rid);
1669 entry.account_name = talloc_strdup(
1670 search_state, pdb_get_username(user));
1671 entry.fullname = talloc_strdup(
1672 search_state, pdb_get_fullname(user));
1673 entry.description = talloc_strdup(
1674 search_state, pdb_get_acct_desc(user));
1675
1676 TALLOC_FREE(user);
1677
1678 if ((entry.account_name == NULL) || (entry.fullname == NULL)
1679 || (entry.description == NULL)) {
1680 DBG_ERR("talloc_strdup failed\n");
1681 break;
1682 }
1683
1684 ADD_TO_LARGE_ARRAY(search_state, struct samr_displayentry,
1685 entry, &search_state->entries,
1686 &search_state->num_entries,
1687 &search_state->array_size);
1688 }
1689
1690 endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1691
1692 search->private_data = search_state;
1693 search->next_entry = smbpasswd_search_next_entry;
1694 search->search_end = smbpasswd_search_end;
1695
1696 return true;
1697 }
1698
1699 static NTSTATUS pdb_init_smbpasswd( struct pdb_methods **pdb_method, const char *location )
1700 {
1701 NTSTATUS nt_status;
1702 struct smbpasswd_privates *privates;
1703
1704 if ( !NT_STATUS_IS_OK(nt_status = make_pdb_method( pdb_method )) ) {
1705 return nt_status;
1706 }
1707
1708 (*pdb_method)->name = "smbpasswd";
1709
1710 (*pdb_method)->getsampwnam = smbpasswd_getsampwnam;
1711 (*pdb_method)->getsampwsid = smbpasswd_getsampwsid;
1712 (*pdb_method)->add_sam_account = smbpasswd_add_sam_account;
1713 (*pdb_method)->update_sam_account = smbpasswd_update_sam_account;
1714 (*pdb_method)->delete_sam_account = smbpasswd_delete_sam_account;
1715 (*pdb_method)->rename_sam_account = smbpasswd_rename_sam_account;
1716 (*pdb_method)->search_users = smbpasswd_search_users;
1717
1718 (*pdb_method)->capabilities = smbpasswd_capabilities;
1719
1720 /* Setup private data and free function */
1721
1722 if ( !(privates = talloc_zero( *pdb_method, struct smbpasswd_privates )) ) {
1723 DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
1724 return NT_STATUS_NO_MEMORY;
1725 }
1726
1727 /* Store some config details */
1728
1729 if (location) {
1730 privates->smbpasswd_file = talloc_strdup(*pdb_method, location);
1731 } else {
1732 privates->smbpasswd_file = talloc_strdup(*pdb_method, lp_smb_passwd_file());
1733 }
1734
1735 if (!privates->smbpasswd_file) {
1736 DEBUG(0, ("talloc_strdp() failed for storing smbpasswd location!\n"));
1737 return NT_STATUS_NO_MEMORY;
1738 }
1739
1740 (*pdb_method)->private_data = privates;
1741
1742 (*pdb_method)->free_private_data = free_private_data;
1743
1744 return NT_STATUS_OK;
1745 }
1746
1747 NTSTATUS pdb_smbpasswd_init(TALLOC_CTX *ctx)
1748 {
1749 return smb_register_passdb(PASSDB_INTERFACE_VERSION, "smbpasswd", pdb_init_smbpasswd);
1750 }
GSS-enabled samba4