?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[GLUE] Rsync SAMBA_3_0 SVN r25598 in order to create the v3-0-test branch.
[Samba.git] / source / passdb / pdb_tdb.c
blobe9beaa053682a1ef95847c9da0edf9ac7fee7109
1 /*
2 * Unix SMB/CIFS implementation.
3 * SMB parameters and setup
4 * Copyright (C) Andrew Tridgell 1992-1998
5 * Copyright (C) Simo Sorce 2000-2003
6 * Copyright (C) Gerald Carter 2000-2006
7 * Copyright (C) Jeremy Allison 2001
8 * Copyright (C) Andrew Bartlett 2002
9 * Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
10 *
11 * This program is free software; you can redistribute it and/or modify it under
12 * the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * more details.
20 *
21 * You should have received a copy of the GNU General Public License along with
22 * this program; if not, write to the Free Software Foundation, Inc., 675
23 * Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27
28 #if 0 /* when made a module use this */
29
30 static int tdbsam_debug_level = DBGC_ALL;
31 #undef DBGC_CLASS
32 #define DBGC_CLASS tdbsam_debug_level
33
34 #else
35
36 #undef DBGC_CLASS
37 #define DBGC_CLASS DBGC_PASSDB
38
39 #endif
40
41 #define TDBSAM_VERSION 3 /* Most recent TDBSAM version */
42 #define TDBSAM_VERSION_STRING "INFO/version"
43 #define PASSDB_FILE_NAME "passdb.tdb"
44 #define USERPREFIX "USER_"
45 #define RIDPREFIX "RID_"
46 #define PRIVPREFIX "PRIV_"
47
48 struct pwent_list {
49 struct pwent_list *prev, *next;
50 TDB_DATA key;
51 };
52 static struct pwent_list *tdbsam_pwent_list;
53 static BOOL pwent_initialized;
54
55 /* GLOBAL TDB SAM CONTEXT */
56
57 static TDB_CONTEXT *tdbsam;
58 static int ref_count = 0;
59 static pstring tdbsam_filename;
60
61 /**********************************************************************
62 Marshall/unmarshall struct samu structs.
63 *********************************************************************/
64
65 #define TDB_FORMAT_STRING_V0 "ddddddBBBBBBBBBBBBddBBwdwdBwwd"
66 #define TDB_FORMAT_STRING_V1 "dddddddBBBBBBBBBBBBddBBwdwdBwwd"
67 #define TDB_FORMAT_STRING_V2 "dddddddBBBBBBBBBBBBddBBBwwdBwwd"
68
69 /*********************************************************************
70 *********************************************************************/
71
72 static BOOL init_sam_from_buffer_v0(struct samu *sampass, uint8 *buf, uint32 buflen)
73 {
74
75 /* times are stored as 32bit integer
76 take care on system with 64bit wide time_t
77 --SSS */
78 uint32 logon_time,
79 logoff_time,
80 kickoff_time,
81 pass_last_set_time,
82 pass_can_change_time,
83 pass_must_change_time;
84 char *username = NULL;
85 char *domain = NULL;
86 char *nt_username = NULL;
87 char *dir_drive = NULL;
88 char *unknown_str = NULL;
89 char *munged_dial = NULL;
90 char *fullname = NULL;
91 char *homedir = NULL;
92 char *logon_script = NULL;
93 char *profile_path = NULL;
94 char *acct_desc = NULL;
95 char *workstations = NULL;
96 uint32 username_len, domain_len, nt_username_len,
97 dir_drive_len, unknown_str_len, munged_dial_len,
98 fullname_len, homedir_len, logon_script_len,
99 profile_path_len, acct_desc_len, workstations_len;
100
101 uint32 user_rid, group_rid, remove_me, hours_len, unknown_6;
102 uint16 acct_ctrl, logon_divs;
103 uint16 bad_password_count, logon_count;
104 uint8 *hours = NULL;
105 uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
106 uint32 len = 0;
107 uint32 lm_pw_len, nt_pw_len, hourslen;
108 BOOL ret = True;
109
110 if(sampass == NULL || buf == NULL) {
111 DEBUG(0, ("init_sam_from_buffer_v0: NULL parameters found!\n"));
112 return False;
113 }
114
115 /* TDB_FORMAT_STRING_V0 "ddddddBBBBBBBBBBBBddBBwdwdBwwd" */
116
117 /* unpack the buffer into variables */
118 len = tdb_unpack ((char *)buf, buflen, TDB_FORMAT_STRING_V0,
119 &logon_time, /* d */
120 &logoff_time, /* d */
121 &kickoff_time, /* d */
122 &pass_last_set_time, /* d */
123 &pass_can_change_time, /* d */
124 &pass_must_change_time, /* d */
125 &username_len, &username, /* B */
126 &domain_len, &domain, /* B */
127 &nt_username_len, &nt_username, /* B */
128 &fullname_len, &fullname, /* B */
129 &homedir_len, &homedir, /* B */
130 &dir_drive_len, &dir_drive, /* B */
131 &logon_script_len, &logon_script, /* B */
132 &profile_path_len, &profile_path, /* B */
133 &acct_desc_len, &acct_desc, /* B */
134 &workstations_len, &workstations, /* B */
135 &unknown_str_len, &unknown_str, /* B */
136 &munged_dial_len, &munged_dial, /* B */
137 &user_rid, /* d */
138 &group_rid, /* d */
139 &lm_pw_len, &lm_pw_ptr, /* B */
140 &nt_pw_len, &nt_pw_ptr, /* B */
141 &acct_ctrl, /* w */
142 &remove_me, /* remove on the next TDB_FORMAT upgarde */ /* d */
143 &logon_divs, /* w */
144 &hours_len, /* d */
145 &hourslen, &hours, /* B */
146 &bad_password_count, /* w */
147 &logon_count, /* w */
148 &unknown_6); /* d */
149
150 if (len == (uint32) -1) {
151 ret = False;
152 goto done;
153 }
154
155 pdb_set_logon_time(sampass, logon_time, PDB_SET);
156 pdb_set_logoff_time(sampass, logoff_time, PDB_SET);
157 pdb_set_kickoff_time(sampass, kickoff_time, PDB_SET);
158 pdb_set_pass_can_change_time(sampass, pass_can_change_time, PDB_SET);
159 pdb_set_pass_must_change_time(sampass, pass_must_change_time, PDB_SET);
160 pdb_set_pass_last_set_time(sampass, pass_last_set_time, PDB_SET);
161
162 pdb_set_username(sampass, username, PDB_SET);
163 pdb_set_domain(sampass, domain, PDB_SET);
164 pdb_set_nt_username(sampass, nt_username, PDB_SET);
165 pdb_set_fullname(sampass, fullname, PDB_SET);
166
167 if (homedir) {
168 pdb_set_homedir(sampass, homedir, PDB_SET);
169 }
170 else {
171 pdb_set_homedir(sampass,
172 talloc_sub_basic(sampass, username, domain,
173 lp_logon_home()),
174 PDB_DEFAULT);
175 }
176
177 if (dir_drive)
178 pdb_set_dir_drive(sampass, dir_drive, PDB_SET);
179 else {
180 pdb_set_dir_drive(sampass,
181 talloc_sub_basic(sampass, username, domain,
182 lp_logon_drive()),
183 PDB_DEFAULT);
184 }
185
186 if (logon_script)
187 pdb_set_logon_script(sampass, logon_script, PDB_SET);
188 else {
189 pdb_set_logon_script(sampass,
190 talloc_sub_basic(sampass, username, domain,
191 lp_logon_script()),
192 PDB_DEFAULT);
193 }
194
195 if (profile_path) {
196 pdb_set_profile_path(sampass, profile_path, PDB_SET);
197 } else {
198 pdb_set_profile_path(sampass,
199 talloc_sub_basic(sampass, username, domain,
200 lp_logon_path()),
201 PDB_DEFAULT);
202 }
203
204 pdb_set_acct_desc(sampass, acct_desc, PDB_SET);
205 pdb_set_workstations(sampass, workstations, PDB_SET);
206 pdb_set_munged_dial(sampass, munged_dial, PDB_SET);
207
208 if (lm_pw_ptr && lm_pw_len == LM_HASH_LEN) {
209 if (!pdb_set_lanman_passwd(sampass, lm_pw_ptr, PDB_SET)) {
210 ret = False;
211 goto done;
212 }
213 }
214
215 if (nt_pw_ptr && nt_pw_len == NT_HASH_LEN) {
216 if (!pdb_set_nt_passwd(sampass, nt_pw_ptr, PDB_SET)) {
217 ret = False;
218 goto done;
219 }
220 }
221
222 pdb_set_pw_history(sampass, NULL, 0, PDB_SET);
223 pdb_set_user_sid_from_rid(sampass, user_rid, PDB_SET);
224 pdb_set_group_sid_from_rid(sampass, group_rid, PDB_SET);
225 pdb_set_hours_len(sampass, hours_len, PDB_SET);
226 pdb_set_bad_password_count(sampass, bad_password_count, PDB_SET);
227 pdb_set_logon_count(sampass, logon_count, PDB_SET);
228 pdb_set_unknown_6(sampass, unknown_6, PDB_SET);
229 pdb_set_acct_ctrl(sampass, acct_ctrl, PDB_SET);
230 pdb_set_logon_divs(sampass, logon_divs, PDB_SET);
231 pdb_set_hours(sampass, hours, PDB_SET);
232
233 done:
234
235 SAFE_FREE(username);
236 SAFE_FREE(domain);
237 SAFE_FREE(nt_username);
238 SAFE_FREE(fullname);
239 SAFE_FREE(homedir);
240 SAFE_FREE(dir_drive);
241 SAFE_FREE(logon_script);
242 SAFE_FREE(profile_path);
243 SAFE_FREE(acct_desc);
244 SAFE_FREE(workstations);
245 SAFE_FREE(munged_dial);
246 SAFE_FREE(unknown_str);
247 SAFE_FREE(lm_pw_ptr);
248 SAFE_FREE(nt_pw_ptr);
249 SAFE_FREE(hours);
250
251 return ret;
252 }
253
254 /*********************************************************************
255 *********************************************************************/
256
257 static BOOL init_sam_from_buffer_v1(struct samu *sampass, uint8 *buf, uint32 buflen)
258 {
259
260 /* times are stored as 32bit integer
261 take care on system with 64bit wide time_t
262 --SSS */
263 uint32 logon_time,
264 logoff_time,
265 kickoff_time,
266 bad_password_time,
267 pass_last_set_time,
268 pass_can_change_time,
269 pass_must_change_time;
270 char *username = NULL;
271 char *domain = NULL;
272 char *nt_username = NULL;
273 char *dir_drive = NULL;
274 char *unknown_str = NULL;
275 char *munged_dial = NULL;
276 char *fullname = NULL;
277 char *homedir = NULL;
278 char *logon_script = NULL;
279 char *profile_path = NULL;
280 char *acct_desc = NULL;
281 char *workstations = NULL;
282 uint32 username_len, domain_len, nt_username_len,
283 dir_drive_len, unknown_str_len, munged_dial_len,
284 fullname_len, homedir_len, logon_script_len,
285 profile_path_len, acct_desc_len, workstations_len;
286
287 uint32 user_rid, group_rid, remove_me, hours_len, unknown_6;
288 uint16 acct_ctrl, logon_divs;
289 uint16 bad_password_count, logon_count;
290 uint8 *hours = NULL;
291 uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
292 uint32 len = 0;
293 uint32 lm_pw_len, nt_pw_len, hourslen;
294 BOOL ret = True;
295
296 if(sampass == NULL || buf == NULL) {
297 DEBUG(0, ("init_sam_from_buffer_v1: NULL parameters found!\n"));
298 return False;
299 }
300
301 /* TDB_FORMAT_STRING_V1 "dddddddBBBBBBBBBBBBddBBwdwdBwwd" */
302
303 /* unpack the buffer into variables */
304 len = tdb_unpack ((char *)buf, buflen, TDB_FORMAT_STRING_V1,
305 &logon_time, /* d */
306 &logoff_time, /* d */
307 &kickoff_time, /* d */
308 /* Change from V0 is addition of bad_password_time field. */
309 &bad_password_time, /* d */
310 &pass_last_set_time, /* d */
311 &pass_can_change_time, /* d */
312 &pass_must_change_time, /* d */
313 &username_len, &username, /* B */
314 &domain_len, &domain, /* B */
315 &nt_username_len, &nt_username, /* B */
316 &fullname_len, &fullname, /* B */
317 &homedir_len, &homedir, /* B */
318 &dir_drive_len, &dir_drive, /* B */
319 &logon_script_len, &logon_script, /* B */
320 &profile_path_len, &profile_path, /* B */
321 &acct_desc_len, &acct_desc, /* B */
322 &workstations_len, &workstations, /* B */
323 &unknown_str_len, &unknown_str, /* B */
324 &munged_dial_len, &munged_dial, /* B */
325 &user_rid, /* d */
326 &group_rid, /* d */
327 &lm_pw_len, &lm_pw_ptr, /* B */
328 &nt_pw_len, &nt_pw_ptr, /* B */
329 &acct_ctrl, /* w */
330 &remove_me, /* d */
331 &logon_divs, /* w */
332 &hours_len, /* d */
333 &hourslen, &hours, /* B */
334 &bad_password_count, /* w */
335 &logon_count, /* w */
336 &unknown_6); /* d */
337
338 if (len == (uint32) -1) {
339 ret = False;
340 goto done;
341 }
342
343 pdb_set_logon_time(sampass, logon_time, PDB_SET);
344 pdb_set_logoff_time(sampass, logoff_time, PDB_SET);
345 pdb_set_kickoff_time(sampass, kickoff_time, PDB_SET);
346
347 /* Change from V0 is addition of bad_password_time field. */
348 pdb_set_bad_password_time(sampass, bad_password_time, PDB_SET);
349 pdb_set_pass_can_change_time(sampass, pass_can_change_time, PDB_SET);
350 pdb_set_pass_must_change_time(sampass, pass_must_change_time, PDB_SET);
351 pdb_set_pass_last_set_time(sampass, pass_last_set_time, PDB_SET);
352
353 pdb_set_username(sampass, username, PDB_SET);
354 pdb_set_domain(sampass, domain, PDB_SET);
355 pdb_set_nt_username(sampass, nt_username, PDB_SET);
356 pdb_set_fullname(sampass, fullname, PDB_SET);
357
358 if (homedir) {
359 pdb_set_homedir(sampass, homedir, PDB_SET);
360 }
361 else {
362 pdb_set_homedir(sampass,
363 talloc_sub_basic(sampass, username, domain,
364 lp_logon_home()),
365 PDB_DEFAULT);
366 }
367
368 if (dir_drive)
369 pdb_set_dir_drive(sampass, dir_drive, PDB_SET);
370 else {
371 pdb_set_dir_drive(sampass,
372 talloc_sub_basic(sampass, username, domain,
373 lp_logon_drive()),
374 PDB_DEFAULT);
375 }
376
377 if (logon_script)
378 pdb_set_logon_script(sampass, logon_script, PDB_SET);
379 else {
380 pdb_set_logon_script(sampass,
381 talloc_sub_basic(sampass, username, domain,
382 lp_logon_script()),
383 PDB_DEFAULT);
384 }
385
386 if (profile_path) {
387 pdb_set_profile_path(sampass, profile_path, PDB_SET);
388 } else {
389 pdb_set_profile_path(sampass,
390 talloc_sub_basic(sampass, username, domain,
391 lp_logon_path()),
392 PDB_DEFAULT);
393 }
394
395 pdb_set_acct_desc(sampass, acct_desc, PDB_SET);
396 pdb_set_workstations(sampass, workstations, PDB_SET);
397 pdb_set_munged_dial(sampass, munged_dial, PDB_SET);
398
399 if (lm_pw_ptr && lm_pw_len == LM_HASH_LEN) {
400 if (!pdb_set_lanman_passwd(sampass, lm_pw_ptr, PDB_SET)) {
401 ret = False;
402 goto done;
403 }
404 }
405
406 if (nt_pw_ptr && nt_pw_len == NT_HASH_LEN) {
407 if (!pdb_set_nt_passwd(sampass, nt_pw_ptr, PDB_SET)) {
408 ret = False;
409 goto done;
410 }
411 }
412
413 pdb_set_pw_history(sampass, NULL, 0, PDB_SET);
414
415 pdb_set_user_sid_from_rid(sampass, user_rid, PDB_SET);
416 pdb_set_group_sid_from_rid(sampass, group_rid, PDB_SET);
417 pdb_set_hours_len(sampass, hours_len, PDB_SET);
418 pdb_set_bad_password_count(sampass, bad_password_count, PDB_SET);
419 pdb_set_logon_count(sampass, logon_count, PDB_SET);
420 pdb_set_unknown_6(sampass, unknown_6, PDB_SET);
421 pdb_set_acct_ctrl(sampass, acct_ctrl, PDB_SET);
422 pdb_set_logon_divs(sampass, logon_divs, PDB_SET);
423 pdb_set_hours(sampass, hours, PDB_SET);
424
425 done:
426
427 SAFE_FREE(username);
428 SAFE_FREE(domain);
429 SAFE_FREE(nt_username);
430 SAFE_FREE(fullname);
431 SAFE_FREE(homedir);
432 SAFE_FREE(dir_drive);
433 SAFE_FREE(logon_script);
434 SAFE_FREE(profile_path);
435 SAFE_FREE(acct_desc);
436 SAFE_FREE(workstations);
437 SAFE_FREE(munged_dial);
438 SAFE_FREE(unknown_str);
439 SAFE_FREE(lm_pw_ptr);
440 SAFE_FREE(nt_pw_ptr);
441 SAFE_FREE(hours);
442
443 return ret;
444 }
445
446 BOOL init_sam_from_buffer_v2(struct samu *sampass, uint8 *buf, uint32 buflen)
447 {
448
449 /* times are stored as 32bit integer
450 take care on system with 64bit wide time_t
451 --SSS */
452 uint32 logon_time,
453 logoff_time,
454 kickoff_time,
455 bad_password_time,
456 pass_last_set_time,
457 pass_can_change_time,
458 pass_must_change_time;
459 char *username = NULL;
460 char *domain = NULL;
461 char *nt_username = NULL;
462 char *dir_drive = NULL;
463 char *unknown_str = NULL;
464 char *munged_dial = NULL;
465 char *fullname = NULL;
466 char *homedir = NULL;
467 char *logon_script = NULL;
468 char *profile_path = NULL;
469 char *acct_desc = NULL;
470 char *workstations = NULL;
471 uint32 username_len, domain_len, nt_username_len,
472 dir_drive_len, unknown_str_len, munged_dial_len,
473 fullname_len, homedir_len, logon_script_len,
474 profile_path_len, acct_desc_len, workstations_len;
475
476 uint32 user_rid, group_rid, hours_len, unknown_6;
477 uint16 acct_ctrl, logon_divs;
478 uint16 bad_password_count, logon_count;
479 uint8 *hours = NULL;
480 uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL, *nt_pw_hist_ptr = NULL;
481 uint32 len = 0;
482 uint32 lm_pw_len, nt_pw_len, nt_pw_hist_len, hourslen;
483 uint32 pwHistLen = 0;
484 BOOL ret = True;
485 fstring tmpstring;
486 BOOL expand_explicit = lp_passdb_expand_explicit();
487
488 if(sampass == NULL || buf == NULL) {
489 DEBUG(0, ("init_sam_from_buffer_v2: NULL parameters found!\n"));
490 return False;
491 }
492
493 /* TDB_FORMAT_STRING_V2 "dddddddBBBBBBBBBBBBddBBBwwdBwwd" */
494
495 /* unpack the buffer into variables */
496 len = tdb_unpack ((char *)buf, buflen, TDB_FORMAT_STRING_V2,
497 &logon_time, /* d */
498 &logoff_time, /* d */
499 &kickoff_time, /* d */
500 &bad_password_time, /* d */
501 &pass_last_set_time, /* d */
502 &pass_can_change_time, /* d */
503 &pass_must_change_time, /* d */
504 &username_len, &username, /* B */
505 &domain_len, &domain, /* B */
506 &nt_username_len, &nt_username, /* B */
507 &fullname_len, &fullname, /* B */
508 &homedir_len, &homedir, /* B */
509 &dir_drive_len, &dir_drive, /* B */
510 &logon_script_len, &logon_script, /* B */
511 &profile_path_len, &profile_path, /* B */
512 &acct_desc_len, &acct_desc, /* B */
513 &workstations_len, &workstations, /* B */
514 &unknown_str_len, &unknown_str, /* B */
515 &munged_dial_len, &munged_dial, /* B */
516 &user_rid, /* d */
517 &group_rid, /* d */
518 &lm_pw_len, &lm_pw_ptr, /* B */
519 &nt_pw_len, &nt_pw_ptr, /* B */
520 /* Change from V1 is addition of password history field. */
521 &nt_pw_hist_len, &nt_pw_hist_ptr, /* B */
522 &acct_ctrl, /* w */
523 /* Also "remove_me" field was removed. */
524 &logon_divs, /* w */
525 &hours_len, /* d */
526 &hourslen, &hours, /* B */
527 &bad_password_count, /* w */
528 &logon_count, /* w */
529 &unknown_6); /* d */
530
531 if (len == (uint32) -1) {
532 ret = False;
533 goto done;
534 }
535
536 pdb_set_logon_time(sampass, logon_time, PDB_SET);
537 pdb_set_logoff_time(sampass, logoff_time, PDB_SET);
538 pdb_set_kickoff_time(sampass, kickoff_time, PDB_SET);
539 pdb_set_bad_password_time(sampass, bad_password_time, PDB_SET);
540 pdb_set_pass_can_change_time(sampass, pass_can_change_time, PDB_SET);
541 pdb_set_pass_must_change_time(sampass, pass_must_change_time, PDB_SET);
542 pdb_set_pass_last_set_time(sampass, pass_last_set_time, PDB_SET);
543
544 pdb_set_username(sampass, username, PDB_SET);
545 pdb_set_domain(sampass, domain, PDB_SET);
546 pdb_set_nt_username(sampass, nt_username, PDB_SET);
547 pdb_set_fullname(sampass, fullname, PDB_SET);
548
549 if (homedir) {
550 fstrcpy( tmpstring, homedir );
551 if (expand_explicit) {
552 standard_sub_basic( username, domain, tmpstring,
553 sizeof(tmpstring) );
554 }
555 pdb_set_homedir(sampass, tmpstring, PDB_SET);
556 }
557 else {
558 pdb_set_homedir(sampass,
559 talloc_sub_basic(sampass, username, domain,
560 lp_logon_home()),
561 PDB_DEFAULT);
562 }
563
564 if (dir_drive)
565 pdb_set_dir_drive(sampass, dir_drive, PDB_SET);
566 else
567 pdb_set_dir_drive(sampass, lp_logon_drive(), PDB_DEFAULT );
568
569 if (logon_script) {
570 fstrcpy( tmpstring, logon_script );
571 if (expand_explicit) {
572 standard_sub_basic( username, domain, tmpstring,
573 sizeof(tmpstring) );
574 }
575 pdb_set_logon_script(sampass, tmpstring, PDB_SET);
576 }
577 else {
578 pdb_set_logon_script(sampass,
579 talloc_sub_basic(sampass, username, domain,
580 lp_logon_script()),
581 PDB_DEFAULT);
582 }
583
584 if (profile_path) {
585 fstrcpy( tmpstring, profile_path );
586 if (expand_explicit) {
587 standard_sub_basic( username, domain, tmpstring,
588 sizeof(tmpstring) );
589 }
590 pdb_set_profile_path(sampass, tmpstring, PDB_SET);
591 }
592 else {
593 pdb_set_profile_path(sampass,
594 talloc_sub_basic(sampass, username, domain,
595 lp_logon_path()),
596 PDB_DEFAULT);
597 }
598
599 pdb_set_acct_desc(sampass, acct_desc, PDB_SET);
600 pdb_set_workstations(sampass, workstations, PDB_SET);
601 pdb_set_munged_dial(sampass, munged_dial, PDB_SET);
602
603 if (lm_pw_ptr && lm_pw_len == LM_HASH_LEN) {
604 if (!pdb_set_lanman_passwd(sampass, lm_pw_ptr, PDB_SET)) {
605 ret = False;
606 goto done;
607 }
608 }
609
610 if (nt_pw_ptr && nt_pw_len == NT_HASH_LEN) {
611 if (!pdb_set_nt_passwd(sampass, nt_pw_ptr, PDB_SET)) {
612 ret = False;
613 goto done;
614 }
615 }
616
617 /* Change from V1 is addition of password history field. */
618 pdb_get_account_policy(AP_PASSWORD_HISTORY, &pwHistLen);
619 if (pwHistLen) {
620 uint8 *pw_hist = SMB_MALLOC_ARRAY(uint8, pwHistLen * PW_HISTORY_ENTRY_LEN);
621 if (!pw_hist) {
622 ret = False;
623 goto done;
624 }
625 memset(pw_hist, '\0', pwHistLen * PW_HISTORY_ENTRY_LEN);
626 if (nt_pw_hist_ptr && nt_pw_hist_len) {
627 int i;
628 SMB_ASSERT((nt_pw_hist_len % PW_HISTORY_ENTRY_LEN) == 0);
629 nt_pw_hist_len /= PW_HISTORY_ENTRY_LEN;
630 for (i = 0; (i < pwHistLen) && (i < nt_pw_hist_len); i++) {
631 memcpy(&pw_hist[i*PW_HISTORY_ENTRY_LEN],
632 &nt_pw_hist_ptr[i*PW_HISTORY_ENTRY_LEN],
633 PW_HISTORY_ENTRY_LEN);
634 }
635 }
636 if (!pdb_set_pw_history(sampass, pw_hist, pwHistLen, PDB_SET)) {
637 SAFE_FREE(pw_hist);
638 ret = False;
639 goto done;
640 }
641 SAFE_FREE(pw_hist);
642 } else {
643 pdb_set_pw_history(sampass, NULL, 0, PDB_SET);
644 }
645
646 pdb_set_user_sid_from_rid(sampass, user_rid, PDB_SET);
647 pdb_set_group_sid_from_rid(sampass, group_rid, PDB_SET);
648 pdb_set_hours_len(sampass, hours_len, PDB_SET);
649 pdb_set_bad_password_count(sampass, bad_password_count, PDB_SET);
650 pdb_set_logon_count(sampass, logon_count, PDB_SET);
651 pdb_set_unknown_6(sampass, unknown_6, PDB_SET);
652 pdb_set_acct_ctrl(sampass, acct_ctrl, PDB_SET);
653 pdb_set_logon_divs(sampass, logon_divs, PDB_SET);
654 pdb_set_hours(sampass, hours, PDB_SET);
655
656 done:
657
658 SAFE_FREE(username);
659 SAFE_FREE(domain);
660 SAFE_FREE(nt_username);
661 SAFE_FREE(fullname);
662 SAFE_FREE(homedir);
663 SAFE_FREE(dir_drive);
664 SAFE_FREE(logon_script);
665 SAFE_FREE(profile_path);
666 SAFE_FREE(acct_desc);
667 SAFE_FREE(workstations);
668 SAFE_FREE(munged_dial);
669 SAFE_FREE(unknown_str);
670 SAFE_FREE(lm_pw_ptr);
671 SAFE_FREE(nt_pw_ptr);
672 SAFE_FREE(nt_pw_hist_ptr);
673 SAFE_FREE(hours);
674
675 return ret;
676 }
677
678
679 /**********************************************************************
680 Intialize a struct samu struct from a BYTE buffer of size len
681 *********************************************************************/
682
683 static BOOL init_sam_from_buffer(struct samu *sampass, uint8 *buf, uint32 buflen)
684 {
685 return init_sam_from_buffer_v3(sampass, buf, buflen);
686 }
687
688 /**********************************************************************
689 Intialize a BYTE buffer from a struct samu struct
690 *********************************************************************/
691
692 static uint32 init_buffer_from_sam (uint8 **buf, struct samu *sampass, BOOL size_only)
693 {
694 return init_buffer_from_sam_v3(buf, sampass, size_only);
695 }
696
697 /**********************************************************************
698 Intialize a BYTE buffer from a struct samu struct
699 *********************************************************************/
700
701 static BOOL tdbsam_convert(int32 from)
702 {
703 const char *vstring = TDBSAM_VERSION_STRING;
704 const char *prefix = USERPREFIX;
705 TDB_DATA data, key, old_key;
706 uint8 *buf = NULL;
707 BOOL ret;
708
709 /* handle a Samba upgrade */
710 tdb_lock_bystring(tdbsam, vstring);
711
712 /* Enumerate all records and convert them */
713 key = tdb_firstkey(tdbsam);
714
715 while (key.dptr) {
716
717 /* skip all non-USER entries (eg. RIDs) */
718 while ((key.dsize != 0) && (strncmp(key.dptr, prefix, strlen (prefix)))) {
719 old_key = key;
720 /* increment to next in line */
721 key = tdb_nextkey(tdbsam, key);
722 SAFE_FREE(old_key.dptr);
723 }
724
725 if (key.dptr) {
726 struct samu *user = NULL;
727
728 /* read from tdbsam */
729 data = tdb_fetch(tdbsam, key);
730 if (!data.dptr) {
731 DEBUG(0,("tdbsam_convert: database entry not found: %s.\n",key.dptr));
732 return False;
733 }
734
735 /* unpack the buffer from the former format */
736 if ( !(user = samu_new( NULL )) ) {
737 DEBUG(0,("tdbsam_convert: samu_new() failed!\n"));
738 SAFE_FREE( data.dptr );
739 return False;
740 }
741 DEBUG(10,("tdbsam_convert: Try unpacking a record with (key:%s) (version:%d)\n", key.dptr, from));
742 switch (from) {
743 case 0:
744 ret = init_sam_from_buffer_v0(user, (uint8 *)data.dptr, data.dsize);
745 break;
746 case 1:
747 ret = init_sam_from_buffer_v1(user, (uint8 *)data.dptr, data.dsize);
748 break;
749 case 2:
750 ret = init_sam_from_buffer_v2(user, (uint8 *)data.dptr, data.dsize);
751 break;
752 case 3:
753 ret = init_sam_from_buffer_v3(user, (uint8 *)data.dptr, data.dsize);
754 break;
755 default:
756 /* unknown tdbsam version */
757 ret = False;
758 }
759 if (!ret) {
760 DEBUG(0,("tdbsam_convert: Bad struct samu entry returned from TDB (key:%s) (version:%d)\n", key.dptr, from));
761 SAFE_FREE(data.dptr);
762 TALLOC_FREE(user );
763 return False;
764 }
765
766 /* We're finished with the old data. */
767 SAFE_FREE(data.dptr);
768
769 /* pack from the buffer into the new format */
770
771 DEBUG(10,("tdbsam_convert: Try packing a record (key:%s) (version:%d)\n", key.dptr, from));
772 data.dsize = init_buffer_from_sam (&buf, user, False);
773 TALLOC_FREE(user );
774
775 if ( data.dsize == -1 ) {
776 DEBUG(0,("tdbsam_convert: cannot pack the struct samu into the new format\n"));
777 return False;
778 }
779 data.dptr = (char *)buf;
780
781 /* Store the buffer inside the TDBSAM */
782 if (tdb_store(tdbsam, key, data, TDB_MODIFY) != TDB_SUCCESS) {
783 DEBUG(0,("tdbsam_convert: cannot store the struct samu (key:%s) in new format\n",key.dptr));
784 SAFE_FREE(data.dptr);
785 return False;
786 }
787
788 SAFE_FREE(data.dptr);
789
790 /* increment to next in line */
791 old_key = key;
792 key = tdb_nextkey(tdbsam, key);
793 SAFE_FREE(old_key.dptr);
794 }
795
796 }
797
798
799 /* upgrade finished */
800 tdb_store_int32(tdbsam, vstring, TDBSAM_VERSION);
801 tdb_unlock_bystring(tdbsam, vstring);
802
803 return(True);
804 }
805
806 /*********************************************************************
807 Open the tdbsam file based on the absolute path specified.
808 Uses a reference count to allow multiple open calls.
809 *********************************************************************/
810
811 static BOOL tdbsam_open( const char *name )
812 {
813 int32 version;
814
815 /* check if we are already open */
816
817 if ( tdbsam ) {
818 ref_count++;
819 DEBUG(8,("tdbsam_open: Incrementing open reference count. Ref count is now %d\n",
820 ref_count));
821 return True;
822 }
823
824 SMB_ASSERT( ref_count == 0 );
825
826 /* Try to open tdb passwd. Create a new one if necessary */
827
828 if (!(tdbsam = tdb_open_log(name, 0, TDB_DEFAULT, O_CREAT|O_RDWR, 0600))) {
829 DEBUG(0, ("tdbsam_open: Failed to open/create TDB passwd [%s]\n", name));
830 return False;
831 }
832
833 /* set the initial reference count - must be done before tdbsam_convert
834 as that calls tdbsam_open()/tdbsam_close(). */
835
836 ref_count = 1;
837
838 /* Check the version */
839 version = tdb_fetch_int32( tdbsam, TDBSAM_VERSION_STRING );
840
841 if (version == -1) {
842 version = 0; /* Version not found, assume version 0 */
843 }
844
845 /* Compare the version */
846 if (version > TDBSAM_VERSION) {
847 /* Version more recent than the latest known */
848 DEBUG(0, ("tdbsam_open: unknown version => %d\n", version));
849 tdb_close( tdbsam );
850 ref_count = 0;
851 return False;
852 }
853
854
855 if ( version < TDBSAM_VERSION ) {
856 DEBUG(1, ("tdbsam_open: Converting version %d database to version %d.\n",
857 version, TDBSAM_VERSION));
858
859 if ( !tdbsam_convert(version) ) {
860 DEBUG(0, ("tdbsam_open: Error when trying to convert tdbsam [%s]\n",name));
861 tdb_close(tdbsam);
862 ref_count = 0;
863 return False;
864 }
865
866 DEBUG(3, ("TDBSAM converted successfully.\n"));
867 }
868
869 DEBUG(4,("tdbsam_open: successfully opened %s\n", name ));
870
871 return True;
872 }
873
874 /****************************************************************************
875 wrapper atound tdb_close() to handle the reference count
876 ****************************************************************************/
877
878 void tdbsam_close( void )
879 {
880 ref_count--;
881
882 DEBUG(8,("tdbsam_close: Reference count is now %d.\n", ref_count));
883
884 SMB_ASSERT(ref_count >= 0 );
885
886 if ( ref_count == 0 ) {
887 tdb_close( tdbsam );
888 tdbsam = NULL;
889 }
890
891 return;
892 }
893
894 /****************************************************************************
895 creates a list of user keys
896 ****************************************************************************/
897
898 static int tdbsam_traverse_setpwent(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
899 {
900 const char *prefix = USERPREFIX;
901 int prefixlen = strlen (prefix);
902 struct pwent_list *ptr;
903
904 if ( strncmp(key.dptr, prefix, prefixlen) == 0 ) {
905 if ( !(ptr=SMB_MALLOC_P(struct pwent_list)) ) {
906 DEBUG(0,("tdbsam_traverse_setpwent: Failed to malloc new entry for list\n"));
907
908 /* just return 0 and let the traversal continue */
909 return 0;
910 }
911 ZERO_STRUCTP(ptr);
912
913 /* save a copy of the key */
914
915 ptr->key.dptr = (char *)memdup( key.dptr, key.dsize );
916 if (!ptr->key.dptr) {
917 DEBUG(0,("tdbsam_traverse_setpwent: memdup failed\n"));
918 /* just return 0 and let the traversal continue */
919 SAFE_FREE(ptr);
920 return 0;
921 }
922
923 ptr->key.dsize = key.dsize;
924
925 DLIST_ADD( tdbsam_pwent_list, ptr );
926
927 }
928
929 return 0;
930 }
931
932 /***************************************************************
933 Open the TDB passwd database for SAM account enumeration.
934 Save a list of user keys for iteration.
935 ****************************************************************/
936
937 static NTSTATUS tdbsam_setsampwent(struct pdb_methods *my_methods, BOOL update, uint32 acb_mask)
938 {
939 if ( !tdbsam_open( tdbsam_filename ) ) {
940 DEBUG(0,("tdbsam_getsampwnam: failed to open %s!\n", tdbsam_filename));
941 return NT_STATUS_ACCESS_DENIED;
942 }
943
944 tdb_traverse( tdbsam, tdbsam_traverse_setpwent, NULL );
945 pwent_initialized = True;
946
947 return NT_STATUS_OK;
948 }
949
950
951 /***************************************************************
952 End enumeration of the TDB passwd list.
953 ****************************************************************/
954
955 static void tdbsam_endsampwent(struct pdb_methods *my_methods)
956 {
957 struct pwent_list *ptr, *ptr_next;
958
959 /* close the tdb only if we have a valid pwent state */
960
961 if ( pwent_initialized ) {
962 DEBUG(7, ("endtdbpwent: closed sam database.\n"));
963 tdbsam_close();
964 }
965
966 /* clear out any remaining entries in the list */
967
968 for ( ptr=tdbsam_pwent_list; ptr; ptr = ptr_next ) {
969 ptr_next = ptr->next;
970 DLIST_REMOVE( tdbsam_pwent_list, ptr );
971 SAFE_FREE( ptr->key.dptr);
972 SAFE_FREE( ptr );
973 }
974
975 pwent_initialized = False;
976 }
977
978 /*****************************************************************
979 Get one struct samu from the TDB (next in line)
980 *****************************************************************/
981
982 static NTSTATUS tdbsam_getsampwent(struct pdb_methods *my_methods, struct samu *user)
983 {
984 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
985 TDB_DATA data;
986 struct pwent_list *pkey;
987
988 if ( !user ) {
989 DEBUG(0,("tdbsam_getsampwent: struct samu is NULL.\n"));
990 return nt_status;
991 }
992
993 if ( !tdbsam_pwent_list ) {
994 DEBUG(4,("tdbsam_getsampwent: end of list\n"));
995 return nt_status;
996 }
997
998 /* pull the next entry */
999
1000 pkey = tdbsam_pwent_list;
1001 DLIST_REMOVE( tdbsam_pwent_list, pkey );
1002
1003 data = tdb_fetch(tdbsam, pkey->key);
1004
1005 SAFE_FREE( pkey->key.dptr);
1006 SAFE_FREE( pkey);
1007
1008 if ( !data.dptr ) {
1009 DEBUG(5,("pdb_getsampwent: database entry not found. Was the user deleted?\n"));
1010 return nt_status;
1011 }
1012
1013 if ( !init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize) ) {
1014 DEBUG(0,("pdb_getsampwent: Bad struct samu entry returned from TDB!\n"));
1015 }
1016
1017 SAFE_FREE( data.dptr );
1018
1019 return NT_STATUS_OK;
1020 }
1021
1022 /******************************************************************
1023 Lookup a name in the SAM TDB
1024 ******************************************************************/
1025
1026 static NTSTATUS tdbsam_getsampwnam (struct pdb_methods *my_methods, struct samu *user, const char *sname)
1027 {
1028 TDB_DATA data, key;
1029 fstring keystr;
1030 fstring name;
1031
1032 if ( !user ) {
1033 DEBUG(0,("pdb_getsampwnam: struct samu is NULL.\n"));
1034 return NT_STATUS_NO_MEMORY;
1035 }
1036
1037 /* Data is stored in all lower-case */
1038 fstrcpy(name, sname);
1039 strlower_m(name);
1040
1041 /* set search key */
1042 slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
1043 key.dptr = keystr;
1044 key.dsize = strlen(keystr) + 1;
1045
1046 /* open the database */
1047
1048 if ( !tdbsam_open( tdbsam_filename ) ) {
1049 DEBUG(0,("tdbsam_getsampwnam: failed to open %s!\n", tdbsam_filename));
1050 return NT_STATUS_ACCESS_DENIED;
1051 }
1052
1053 /* get the record */
1054
1055 data = tdb_fetch(tdbsam, key);
1056 if (!data.dptr) {
1057 DEBUG(5,("pdb_getsampwnam (TDB): error fetching database.\n"));
1058 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam)));
1059 DEBUGADD(5, (" Key: %s\n", keystr));
1060 tdbsam_close();
1061 return NT_STATUS_NO_SUCH_USER;
1062 }
1063
1064 /* unpack the buffer */
1065
1066 if (!init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize)) {
1067 DEBUG(0,("pdb_getsampwent: Bad struct samu entry returned from TDB!\n"));
1068 SAFE_FREE(data.dptr);
1069 tdbsam_close();
1070 return NT_STATUS_NO_MEMORY;
1071 }
1072
1073 /* success */
1074
1075 SAFE_FREE(data.dptr);
1076 tdbsam_close();
1077
1078 return NT_STATUS_OK;
1079 }
1080
1081 /***************************************************************************
1082 Search by rid
1083 **************************************************************************/
1084
1085 static NTSTATUS tdbsam_getsampwrid (struct pdb_methods *my_methods, struct samu *user, uint32 rid)
1086 {
1087 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1088 TDB_DATA data, key;
1089 fstring keystr;
1090 fstring name;
1091
1092 if ( !user ) {
1093 DEBUG(0,("pdb_getsampwrid: struct samu is NULL.\n"));
1094 return nt_status;
1095 }
1096
1097 /* set search key */
1098
1099 slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
1100 key.dptr = keystr;
1101 key.dsize = strlen (keystr) + 1;
1102
1103 /* open the database */
1104
1105 if ( !tdbsam_open( tdbsam_filename ) ) {
1106 DEBUG(0,("tdbsam_getsampwnam: failed to open %s!\n", tdbsam_filename));
1107 return NT_STATUS_ACCESS_DENIED;
1108 }
1109
1110 /* get the record */
1111
1112 data = tdb_fetch (tdbsam, key);
1113 if (!data.dptr) {
1114 DEBUG(5,("pdb_getsampwrid (TDB): error looking up RID %d by key %s.\n", rid, keystr));
1115 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam)));
1116 nt_status = NT_STATUS_UNSUCCESSFUL;
1117 goto done;
1118 }
1119
1120 fstrcpy(name, data.dptr);
1121 SAFE_FREE(data.dptr);
1122
1123 nt_status = tdbsam_getsampwnam (my_methods, user, name);
1124
1125 done:
1126 /* cleanup */
1127
1128 tdbsam_close();
1129
1130 return nt_status;
1131 }
1132
1133 static NTSTATUS tdbsam_getsampwsid(struct pdb_methods *my_methods, struct samu * user, const DOM_SID *sid)
1134 {
1135 uint32 rid;
1136
1137 if ( !sid_peek_check_rid(get_global_sam_sid(), sid, &rid) )
1138 return NT_STATUS_UNSUCCESSFUL;
1139
1140 return tdbsam_getsampwrid(my_methods, user, rid);
1141 }
1142
1143 static BOOL tdb_delete_samacct_only( struct samu *sam_pass )
1144 {
1145 TDB_DATA key;
1146 fstring keystr;
1147 fstring name;
1148
1149 fstrcpy(name, pdb_get_username(sam_pass));
1150 strlower_m(name);
1151
1152 /* set the search key */
1153
1154 slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
1155 key.dptr = keystr;
1156 key.dsize = strlen (keystr) + 1;
1157
1158 /* it's outaa here! 8^) */
1159
1160 if (tdb_delete(tdbsam, key) != TDB_SUCCESS) {
1161 DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
1162 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam)));
1163 return False;
1164 }
1165
1166 return True;
1167 }
1168
1169 /***************************************************************************
1170 Delete a struct samu records for the username and RID key
1171 ****************************************************************************/
1172
1173 static NTSTATUS tdbsam_delete_sam_account(struct pdb_methods *my_methods, struct samu *sam_pass)
1174 {
1175 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1176 TDB_DATA key;
1177 fstring keystr;
1178 uint32 rid;
1179 fstring name;
1180
1181 /* open the database */
1182
1183 if ( !tdbsam_open( tdbsam_filename ) ) {
1184 DEBUG(0,("tdbsam_delete_sam_account: failed to open %s!\n",
1185 tdbsam_filename));
1186 return NT_STATUS_ACCESS_DENIED;
1187 }
1188
1189 fstrcpy(name, pdb_get_username(sam_pass));
1190 strlower_m(name);
1191
1192 /* set the search key */
1193
1194 slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
1195 key.dptr = keystr;
1196 key.dsize = strlen (keystr) + 1;
1197
1198 rid = pdb_get_user_rid(sam_pass);
1199
1200 /* it's outaa here! 8^) */
1201
1202 if ( tdb_delete(tdbsam, key) != TDB_SUCCESS ) {
1203 DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
1204 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam)));
1205 nt_status = NT_STATUS_UNSUCCESSFUL;
1206 goto done;
1207 }
1208
1209 /* set the search key */
1210
1211 slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
1212 key.dptr = keystr;
1213 key.dsize = strlen (keystr) + 1;
1214
1215 /* it's outaa here! 8^) */
1216
1217 if ( tdb_delete(tdbsam, key) != TDB_SUCCESS ) {
1218 DEBUG(5, ("Error deleting entry from tdb rid database!\n"));
1219 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam)));
1220 nt_status = NT_STATUS_UNSUCCESSFUL;
1221 goto done;
1222 }
1223
1224 nt_status = NT_STATUS_OK;
1225
1226 done:
1227 tdbsam_close();
1228
1229 return nt_status;
1230 }
1231
1232
1233 /***************************************************************************
1234 Update the TDB SAM account record only
1235 Assumes that the tdbsam is already open
1236 ****************************************************************************/
1237 static BOOL tdb_update_samacct_only( struct samu* newpwd, int flag )
1238 {
1239 TDB_DATA key, data;
1240 uint8 *buf = NULL;
1241 fstring keystr;
1242 fstring name;
1243 BOOL ret = True;
1244
1245 /* copy the struct samu struct into a BYTE buffer for storage */
1246
1247 if ( (data.dsize=init_buffer_from_sam (&buf, newpwd, False)) == -1 ) {
1248 DEBUG(0,("tdb_update_sam: ERROR - Unable to copy struct samu info BYTE buffer!\n"));
1249 ret = False;
1250 goto done;
1251 }
1252 data.dptr = (char *)buf;
1253
1254 fstrcpy(name, pdb_get_username(newpwd));
1255 strlower_m(name);
1256
1257 DEBUG(5, ("Storing %saccount %s with RID %d\n",
1258 flag == TDB_INSERT ? "(new) " : "", name,
1259 pdb_get_user_rid(newpwd)));
1260
1261 /* setup the USER index key */
1262 slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
1263 key.dptr = keystr;
1264 key.dsize = strlen(keystr) + 1;
1265
1266 /* add the account */
1267
1268 if ( tdb_store(tdbsam, key, data, flag) != TDB_SUCCESS ) {
1269 DEBUG(0, ("Unable to modify passwd TDB!"));
1270 DEBUGADD(0, (" Error: %s", tdb_errorstr(tdbsam)));
1271 DEBUGADD(0, (" occured while storing the main record (%s)\n",
1272 keystr));
1273 ret = False;
1274 goto done;
1275 }
1276
1277 done:
1278 /* cleanup */
1279 SAFE_FREE(buf);
1280
1281 return ret;
1282 }
1283
1284 /***************************************************************************
1285 Update the TDB SAM RID record only
1286 Assumes that the tdbsam is already open
1287 ****************************************************************************/
1288 static BOOL tdb_update_ridrec_only( struct samu* newpwd, int flag )
1289 {
1290 TDB_DATA key, data;
1291 fstring keystr;
1292 fstring name;
1293
1294 fstrcpy(name, pdb_get_username(newpwd));
1295 strlower_m(name);
1296
1297 /* setup RID data */
1298 data.dsize = strlen(name) + 1;
1299 data.dptr = name;
1300
1301 /* setup the RID index key */
1302 slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, pdb_get_user_rid(newpwd));
1303 key.dptr = keystr;
1304 key.dsize = strlen (keystr) + 1;
1305
1306 /* add the reference */
1307 if (tdb_store(tdbsam, key, data, flag) != TDB_SUCCESS) {
1308 DEBUG(0, ("Unable to modify TDB passwd !"));
1309 DEBUGADD(0, (" Error: %s\n", tdb_errorstr(tdbsam)));
1310 DEBUGADD(0, (" occured while storing the RID index (%s)\n", keystr));
1311 return False;
1312 }
1313
1314 return True;
1315
1316 }
1317
1318 /***************************************************************************
1319 Update the TDB SAM
1320 ****************************************************************************/
1321
1322 static BOOL tdb_update_sam(struct pdb_methods *my_methods, struct samu* newpwd, int flag)
1323 {
1324 BOOL result = True;
1325
1326 /* invalidate the existing TDB iterator if it is open */
1327
1328 tdbsam_endsampwent( my_methods );
1329
1330 #if 0
1331 if ( !pdb_get_group_rid(newpwd) ) {
1332 DEBUG (0,("tdb_update_sam: Failing to store a struct samu for [%s] "
1333 "without a primary group RID\n", pdb_get_username(newpwd)));
1334 return False;
1335 }
1336 #endif
1337
1338 if (!pdb_get_user_rid(newpwd)) {
1339 DEBUG(0,("tdb_update_sam: struct samu (%s) with no RID!\n", pdb_get_username(newpwd)));
1340 return False;
1341 }
1342
1343 /* open the database */
1344
1345 if ( !tdbsam_open( tdbsam_filename ) ) {
1346 DEBUG(0,("tdbsam_getsampwnam: failed to open %s!\n", tdbsam_filename));
1347 return False;
1348 }
1349
1350 if ( !tdb_update_samacct_only(newpwd, flag) || !tdb_update_ridrec_only(newpwd, flag)) {
1351 result = False;
1352 }
1353
1354 /* cleanup */
1355
1356 tdbsam_close();
1357
1358 return result;
1359 }
1360
1361 /***************************************************************************
1362 Modifies an existing struct samu
1363 ****************************************************************************/
1364
1365 static NTSTATUS tdbsam_update_sam_account (struct pdb_methods *my_methods, struct samu *newpwd)
1366 {
1367 if ( !tdb_update_sam(my_methods, newpwd, TDB_MODIFY) )
1368 return NT_STATUS_UNSUCCESSFUL;
1369
1370 return NT_STATUS_OK;
1371 }
1372
1373 /***************************************************************************
1374 Adds an existing struct samu
1375 ****************************************************************************/
1376
1377 static NTSTATUS tdbsam_add_sam_account (struct pdb_methods *my_methods, struct samu *newpwd)
1378 {
1379 if ( !tdb_update_sam(my_methods, newpwd, TDB_INSERT) )
1380 return NT_STATUS_UNSUCCESSFUL;
1381
1382 return NT_STATUS_OK;
1383 }
1384
1385 /***************************************************************************
1386 Renames a struct samu
1387 - check for the posix user/rename user script
1388 - Add and lock the new user record
1389 - rename the posix user
1390 - rewrite the rid->username record
1391 - delete the old user
1392 - unlock the new user record
1393 ***************************************************************************/
1394 static NTSTATUS tdbsam_rename_sam_account(struct pdb_methods *my_methods,
1395 struct samu *old_acct,
1396 const char *newname)
1397 {
1398 struct samu *new_acct = NULL;
1399 pstring rename_script;
1400 BOOL interim_account = False;
1401 int rename_ret;
1402 fstring oldname_lower;
1403 fstring newname_lower;
1404
1405 /* can't do anything without an external script */
1406
1407 pstrcpy(rename_script, lp_renameuser_script() );
1408 if ( ! *rename_script ) {
1409 return NT_STATUS_ACCESS_DENIED;
1410 }
1411
1412 /* invalidate the existing TDB iterator if it is open */
1413
1414 tdbsam_endsampwent( my_methods );
1415
1416 if ( !(new_acct = samu_new( NULL )) ) {
1417 return NT_STATUS_NO_MEMORY;
1418 }
1419
1420 if ( !pdb_copy_sam_account(new_acct, old_acct)
1421 || !pdb_set_username(new_acct, newname, PDB_CHANGED))
1422 {
1423 TALLOC_FREE(new_acct );
1424 return NT_STATUS_NO_MEMORY;
1425 }
1426
1427 /* open the database */
1428
1429 if ( !tdbsam_open( tdbsam_filename ) ) {
1430 DEBUG(0,("tdbsam_getsampwnam: failed to open %s!\n", tdbsam_filename));
1431 TALLOC_FREE(new_acct );
1432 return NT_STATUS_ACCESS_DENIED;
1433 }
1434
1435 /* add the new account and lock it */
1436
1437 if ( !tdb_update_samacct_only(new_acct, TDB_INSERT) ) {
1438 goto done;
1439 }
1440
1441 interim_account = True;
1442
1443 if ( tdb_lock_bystring_with_timeout(tdbsam, newname, 30) == -1 ) {
1444 goto done;
1445 }
1446
1447 /* Rename the posix user. Follow the semantics of _samr_create_user()
1448 so that we lower case the posix name but preserve the case in passdb */
1449
1450 fstrcpy( oldname_lower, pdb_get_username(old_acct) );
1451 strlower_m( oldname_lower );
1452
1453 fstrcpy( newname_lower, newname );
1454 strlower_m( newname_lower );
1455
1456 string_sub2(rename_script, "%unew", newname_lower, sizeof(pstring),
1457 True, False, True);
1458 string_sub2(rename_script, "%uold", oldname_lower, sizeof(pstring),
1459 True, False, True);
1460 rename_ret = smbrun(rename_script, NULL);
1461
1462 DEBUG(rename_ret ? 0 : 3,("Running the command `%s' gave %d\n", rename_script, rename_ret));
1463
1464 if (rename_ret == 0) {
1465 smb_nscd_flush_user_cache();
1466 }
1467
1468 if (rename_ret) {
1469 goto done;
1470 }
1471
1472 /* rewrite the rid->username record */
1473
1474 if ( !tdb_update_ridrec_only( new_acct, TDB_MODIFY) ) {
1475 goto done;
1476 }
1477 interim_account = False;
1478 tdb_unlock_bystring( tdbsam, newname );
1479
1480 tdb_delete_samacct_only( old_acct );
1481
1482 tdbsam_close();
1483
1484 TALLOC_FREE(new_acct );
1485 return NT_STATUS_OK;
1486
1487 done:
1488 /* cleanup */
1489 if (interim_account) {
1490 tdb_unlock_bystring(tdbsam, newname);
1491 tdb_delete_samacct_only(new_acct);
1492 }
1493
1494 tdbsam_close();
1495
1496 if (new_acct)
1497 TALLOC_FREE(new_acct);
1498
1499 return NT_STATUS_ACCESS_DENIED;
1500 }
1501
1502 static BOOL tdbsam_rid_algorithm(struct pdb_methods *methods)
1503 {
1504 return False;
1505 }
1506
1507 /*
1508 * Historically, winbind was responsible for allocating RIDs, so the next RID
1509 * value was stored in winbindd_idmap.tdb. It has been moved to passdb now,
1510 * but for compatibility reasons we still keep the the next RID counter in
1511 * winbindd_idmap.tdb.
1512 */
1513
1514 /*****************************************************************************
1515 Initialise idmap database. For now (Dec 2005) this is a copy of the code in
1516 sam/idmap_tdb.c. Maybe at a later stage we can remove that capability from
1517 winbind completely and store the RID counter in passdb.tdb.
1518
1519 Dont' fully initialize with the HWM values, if it's new, we're only
1520 interested in the RID counter.
1521 *****************************************************************************/
1522
1523 static BOOL init_idmap_tdb(TDB_CONTEXT *tdb)
1524 {
1525 int32 version;
1526
1527 if (tdb_lock_bystring(tdb, "IDMAP_VERSION") != 0) {
1528 DEBUG(0, ("Could not lock IDMAP_VERSION\n"));
1529 return False;
1530 }
1531
1532 version = tdb_fetch_int32(tdb, "IDMAP_VERSION");
1533
1534 if (version == -1) {
1535 /* No key found, must be a new db */
1536 if (tdb_store_int32(tdb, "IDMAP_VERSION",
1537 IDMAP_VERSION) != 0) {
1538 DEBUG(0, ("Could not store IDMAP_VERSION\n"));
1539 tdb_unlock_bystring(tdb, "IDMAP_VERSION");
1540 return False;
1541 }
1542 version = IDMAP_VERSION;
1543 }
1544
1545 if (version != IDMAP_VERSION) {
1546 DEBUG(0, ("Expected IDMAP_VERSION=%d, found %d. Please "
1547 "start winbind once\n", IDMAP_VERSION, version));
1548 tdb_unlock_bystring(tdb, "IDMAP_VERSION");
1549 return False;
1550 }
1551
1552 tdb_unlock_bystring(tdb, "IDMAP_VERSION");
1553 return True;
1554 }
1555
1556 static BOOL tdbsam_new_rid(struct pdb_methods *methods, uint32 *prid)
1557 {
1558 TDB_CONTEXT *tdb;
1559 uint32 rid;
1560 BOOL ret = False;
1561
1562 tdb = tdb_open_log(lock_path("winbindd_idmap.tdb"), 0,
1563 TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
1564
1565 if (tdb == NULL) {
1566 DEBUG(1, ("Could not open idmap: %s\n", strerror(errno)));
1567 goto done;
1568 }
1569
1570 if (!init_idmap_tdb(tdb)) {
1571 DEBUG(1, ("Could not init idmap\n"));
1572 goto done;
1573 }
1574
1575 rid = BASE_RID; /* Default if not set */
1576
1577 if (!tdb_change_uint32_atomic(tdb, "RID_COUNTER", &rid, 1)) {
1578 DEBUG(3, ("tdbsam_new_rid: Failed to increase RID_COUNTER\n"));
1579 goto done;
1580 }
1581
1582 *prid = rid;
1583 ret = True;
1584
1585 done:
1586 if ((tdb != NULL) && (tdb_close(tdb) != 0)) {
1587 smb_panic("tdb_close(idmap_tdb) failed\n");
1588 }
1589
1590 return ret;
1591 }
1592
1593 /*********************************************************************
1594 Initialize the tdb sam backend. Setup the dispath table of methods,
1595 open the tdb, etc...
1596 *********************************************************************/
1597
1598 static NTSTATUS pdb_init_tdbsam(struct pdb_methods **pdb_method, const char *location)
1599 {
1600 NTSTATUS nt_status;
1601 pstring tdbfile;
1602 const char *pfile = location;
1603
1604 if (!NT_STATUS_IS_OK(nt_status = make_pdb_method( pdb_method ))) {
1605 return nt_status;
1606 }
1607
1608 (*pdb_method)->name = "tdbsam";
1609
1610 (*pdb_method)->setsampwent = tdbsam_setsampwent;
1611 (*pdb_method)->endsampwent = tdbsam_endsampwent;
1612 (*pdb_method)->getsampwent = tdbsam_getsampwent;
1613 (*pdb_method)->getsampwnam = tdbsam_getsampwnam;
1614 (*pdb_method)->getsampwsid = tdbsam_getsampwsid;
1615 (*pdb_method)->add_sam_account = tdbsam_add_sam_account;
1616 (*pdb_method)->update_sam_account = tdbsam_update_sam_account;
1617 (*pdb_method)->delete_sam_account = tdbsam_delete_sam_account;
1618 (*pdb_method)->rename_sam_account = tdbsam_rename_sam_account;
1619
1620 (*pdb_method)->rid_algorithm = tdbsam_rid_algorithm;
1621 (*pdb_method)->new_rid = tdbsam_new_rid;
1622
1623 /* save the path for later */
1624
1625 if ( !location ) {
1626 pstr_sprintf( tdbfile, "%s/%s", lp_private_dir(), PASSDB_FILE_NAME );
1627 pfile = tdbfile;
1628 }
1629 pstrcpy( tdbsam_filename, pfile );
1630
1631 /* no private data */
1632
1633 (*pdb_method)->private_data = NULL;
1634 (*pdb_method)->free_private_data = NULL;
1635
1636 return NT_STATUS_OK;
1637 }
1638
1639 NTSTATUS pdb_tdbsam_init(void)
1640 {
1641 return smb_register_passdb(PASSDB_INTERFACE_VERSION, "tdbsam", pdb_init_tdbsam);
1642 }
Samba GIT mirror