dceff3643e36a96ba9b5587018f40f346d17464a
[kai/samba-autobuild/.git] / source4 / dsdb / common / util.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Samba utility functions
4
5    Copyright (C) Andrew Tridgell 2004
6    Copyright (C) Volker Lendecke 2004
7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
8    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "events/events.h"
26 #include "ldb.h"
27 #include "ldb_errors.h"
28 #include "../lib/util/util_ldb.h"
29 #include "../lib/crypto/crypto.h"
30 #include "dsdb/samdb/samdb.h"
31 #include "libcli/security/security.h"
32 #include "librpc/gen_ndr/ndr_security.h"
33 #include "librpc/gen_ndr/ndr_misc.h"
34 #include "../libds/common/flags.h"
35 #include "dsdb/common/proto.h"
36 #include "libcli/ldap/ldap_ndr.h"
37 #include "param/param.h"
38 #include "libcli/auth/libcli_auth.h"
39 #include "librpc/gen_ndr/ndr_drsblobs.h"
40 #include "system/locale.h"
41
42 /*
43   search the sam for the specified attributes in a specific domain, filter on
44   objectSid being in domain_sid.
45 */
46 int samdb_search_domain(struct ldb_context *sam_ldb,
47                         TALLOC_CTX *mem_ctx, 
48                         struct ldb_dn *basedn,
49                         struct ldb_message ***res,
50                         const char * const *attrs,
51                         const struct dom_sid *domain_sid,
52                         const char *format, ...)  _PRINTF_ATTRIBUTE(7,8)
53 {
54         va_list ap;
55         int i, count;
56
57         va_start(ap, format);
58         count = gendb_search_v(sam_ldb, mem_ctx, basedn,
59                                res, attrs, format, ap);
60         va_end(ap);
61
62         i=0;
63
64         while (i<count) {
65                 struct dom_sid *entry_sid;
66
67                 entry_sid = samdb_result_dom_sid(mem_ctx, (*res)[i], "objectSid");
68
69                 if ((entry_sid == NULL) ||
70                     (!dom_sid_in_domain(domain_sid, entry_sid))) {
71                         /* Delete that entry from the result set */
72                         (*res)[i] = (*res)[count-1];
73                         count -= 1;
74                         talloc_free(entry_sid);
75                         continue;
76                 }
77                 talloc_free(entry_sid);
78                 i += 1;
79         }
80
81         return count;
82 }
83
84 /*
85   search the sam for a single string attribute in exactly 1 record
86 */
87 const char *samdb_search_string_v(struct ldb_context *sam_ldb,
88                                   TALLOC_CTX *mem_ctx,
89                                   struct ldb_dn *basedn,
90                                   const char *attr_name,
91                                   const char *format, va_list ap) _PRINTF_ATTRIBUTE(5,0)
92 {
93         int count;
94         const char *attrs[2] = { NULL, NULL };
95         struct ldb_message **res = NULL;
96
97         attrs[0] = attr_name;
98
99         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, attrs, format, ap);
100         if (count > 1) {                
101                 DEBUG(1,("samdb: search for %s %s not single valued (count=%d)\n", 
102                          attr_name, format, count));
103         }
104         if (count != 1) {
105                 talloc_free(res);
106                 return NULL;
107         }
108
109         return samdb_result_string(res[0], attr_name, NULL);
110 }
111
112 /*
113   search the sam for a single string attribute in exactly 1 record
114 */
115 const char *samdb_search_string(struct ldb_context *sam_ldb,
116                                 TALLOC_CTX *mem_ctx,
117                                 struct ldb_dn *basedn,
118                                 const char *attr_name,
119                                 const char *format, ...) _PRINTF_ATTRIBUTE(5,6)
120 {
121         va_list ap;
122         const char *str;
123
124         va_start(ap, format);
125         str = samdb_search_string_v(sam_ldb, mem_ctx, basedn, attr_name, format, ap);
126         va_end(ap);
127
128         return str;
129 }
130
131 struct ldb_dn *samdb_search_dn(struct ldb_context *sam_ldb,
132                                TALLOC_CTX *mem_ctx,
133                                struct ldb_dn *basedn,
134                                const char *format, ...) _PRINTF_ATTRIBUTE(4,5)
135 {
136         va_list ap;
137         struct ldb_dn *ret;
138         struct ldb_message **res = NULL;
139         int count;
140
141         va_start(ap, format);
142         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, NULL, format, ap);
143         va_end(ap);
144
145         if (count != 1) return NULL;
146
147         ret = talloc_steal(mem_ctx, res[0]->dn);
148         talloc_free(res);
149
150         return ret;
151 }
152
153 /*
154   search the sam for a dom_sid attribute in exactly 1 record
155 */
156 struct dom_sid *samdb_search_dom_sid(struct ldb_context *sam_ldb,
157                                      TALLOC_CTX *mem_ctx,
158                                      struct ldb_dn *basedn,
159                                      const char *attr_name,
160                                      const char *format, ...) _PRINTF_ATTRIBUTE(5,6)
161 {
162         va_list ap;
163         int count;
164         struct ldb_message **res;
165         const char *attrs[2] = { NULL, NULL };
166         struct dom_sid *sid;
167
168         attrs[0] = attr_name;
169
170         va_start(ap, format);
171         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, attrs, format, ap);
172         va_end(ap);
173         if (count > 1) {                
174                 DEBUG(1,("samdb: search for %s %s not single valued (count=%d)\n", 
175                          attr_name, format, count));
176         }
177         if (count != 1) {
178                 talloc_free(res);
179                 return NULL;
180         }
181         sid = samdb_result_dom_sid(mem_ctx, res[0], attr_name);
182         talloc_free(res);
183         return sid;     
184 }
185
186 /*
187   return the count of the number of records in the sam matching the query
188 */
189 int samdb_search_count(struct ldb_context *sam_ldb,
190                        struct ldb_dn *basedn,
191                        const char *format, ...) _PRINTF_ATTRIBUTE(3,4)
192 {
193         va_list ap;
194         struct ldb_message **res;
195         const char *attrs[] = { NULL };
196         int ret;
197         TALLOC_CTX *tmp_ctx = talloc_new(sam_ldb);
198
199         va_start(ap, format);
200         ret = gendb_search_v(sam_ldb, tmp_ctx, basedn, &res, attrs, format, ap);
201         va_end(ap);
202         talloc_free(tmp_ctx);
203
204         return ret;
205 }
206
207
208 /*
209   search the sam for a single integer attribute in exactly 1 record
210 */
211 uint_t samdb_search_uint(struct ldb_context *sam_ldb,
212                          TALLOC_CTX *mem_ctx,
213                          uint_t default_value,
214                          struct ldb_dn *basedn,
215                          const char *attr_name,
216                          const char *format, ...) _PRINTF_ATTRIBUTE(6,7)
217 {
218         va_list ap;
219         int count;
220         struct ldb_message **res;
221         const char *attrs[2] = { NULL, NULL };
222
223         attrs[0] = attr_name;
224
225         va_start(ap, format);
226         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, attrs, format, ap);
227         va_end(ap);
228
229         if (count != 1) {
230                 return default_value;
231         }
232
233         return samdb_result_uint(res[0], attr_name, default_value);
234 }
235
236 /*
237   search the sam for a single signed 64 bit integer attribute in exactly 1 record
238 */
239 int64_t samdb_search_int64(struct ldb_context *sam_ldb,
240                            TALLOC_CTX *mem_ctx,
241                            int64_t default_value,
242                            struct ldb_dn *basedn,
243                            const char *attr_name,
244                            const char *format, ...) _PRINTF_ATTRIBUTE(6,7)
245 {
246         va_list ap;
247         int count;
248         struct ldb_message **res;
249         const char *attrs[2] = { NULL, NULL };
250
251         attrs[0] = attr_name;
252
253         va_start(ap, format);
254         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, attrs, format, ap);
255         va_end(ap);
256
257         if (count != 1) {
258                 return default_value;
259         }
260
261         return samdb_result_int64(res[0], attr_name, default_value);
262 }
263
264 /*
265   search the sam for multipe records each giving a single string attribute
266   return the number of matches, or -1 on error
267 */
268 int samdb_search_string_multiple(struct ldb_context *sam_ldb,
269                                  TALLOC_CTX *mem_ctx,
270                                  struct ldb_dn *basedn,
271                                  const char ***strs,
272                                  const char *attr_name,
273                                  const char *format, ...) _PRINTF_ATTRIBUTE(6,7)
274 {
275         va_list ap;
276         int count, i;
277         const char *attrs[2] = { NULL, NULL };
278         struct ldb_message **res = NULL;
279
280         attrs[0] = attr_name;
281
282         va_start(ap, format);
283         count = gendb_search_v(sam_ldb, mem_ctx, basedn, &res, attrs, format, ap);
284         va_end(ap);
285
286         if (count <= 0) {
287                 return count;
288         }
289
290         /* make sure its single valued */
291         for (i=0;i<count;i++) {
292                 if (res[i]->num_elements != 1) {
293                         DEBUG(1,("samdb: search for %s %s not single valued\n", 
294                                  attr_name, format));
295                         talloc_free(res);
296                         return -1;
297                 }
298         }
299
300         *strs = talloc_array(mem_ctx, const char *, count+1);
301         if (! *strs) {
302                 talloc_free(res);
303                 return -1;
304         }
305
306         for (i=0;i<count;i++) {
307                 (*strs)[i] = samdb_result_string(res[i], attr_name, NULL);
308         }
309         (*strs)[count] = NULL;
310
311         return count;
312 }
313
314 /*
315   pull a uint from a result set. 
316 */
317 uint_t samdb_result_uint(const struct ldb_message *msg, const char *attr, uint_t default_value)
318 {
319         return ldb_msg_find_attr_as_uint(msg, attr, default_value);
320 }
321
322 /*
323   pull a (signed) int64 from a result set. 
324 */
325 int64_t samdb_result_int64(const struct ldb_message *msg, const char *attr, int64_t default_value)
326 {
327         return ldb_msg_find_attr_as_int64(msg, attr, default_value);
328 }
329
330 /*
331   pull a string from a result set. 
332 */
333 const char *samdb_result_string(const struct ldb_message *msg, const char *attr, 
334                                 const char *default_value)
335 {
336         return ldb_msg_find_attr_as_string(msg, attr, default_value);
337 }
338
339 struct ldb_dn *samdb_result_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const struct ldb_message *msg,
340                                const char *attr, struct ldb_dn *default_value)
341 {
342         struct ldb_dn *ret_dn = ldb_msg_find_attr_as_dn(ldb, mem_ctx, msg, attr);
343         if (!ret_dn) {
344                 return default_value;
345         }
346         return ret_dn;
347 }
348
349 /*
350   pull a rid from a objectSid in a result set. 
351 */
352 uint32_t samdb_result_rid_from_sid(TALLOC_CTX *mem_ctx, const struct ldb_message *msg, 
353                                    const char *attr, uint32_t default_value)
354 {
355         struct dom_sid *sid;
356         uint32_t rid;
357
358         sid = samdb_result_dom_sid(mem_ctx, msg, attr);
359         if (sid == NULL) {
360                 return default_value;
361         }
362         rid = sid->sub_auths[sid->num_auths-1];
363         talloc_free(sid);
364         return rid;
365 }
366
367 /*
368   pull a dom_sid structure from a objectSid in a result set. 
369 */
370 struct dom_sid *samdb_result_dom_sid(TALLOC_CTX *mem_ctx, const struct ldb_message *msg, 
371                                      const char *attr)
372 {
373         const struct ldb_val *v;
374         struct dom_sid *sid;
375         enum ndr_err_code ndr_err;
376         v = ldb_msg_find_ldb_val(msg, attr);
377         if (v == NULL) {
378                 return NULL;
379         }
380         sid = talloc(mem_ctx, struct dom_sid);
381         if (sid == NULL) {
382                 return NULL;
383         }
384         ndr_err = ndr_pull_struct_blob(v, sid, NULL, sid,
385                                        (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
386         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
387                 talloc_free(sid);
388                 return NULL;
389         }
390         return sid;
391 }
392
393 /*
394   pull a guid structure from a objectGUID in a result set. 
395 */
396 struct GUID samdb_result_guid(const struct ldb_message *msg, const char *attr)
397 {
398         const struct ldb_val *v;
399         enum ndr_err_code ndr_err;
400         struct GUID guid;
401         TALLOC_CTX *mem_ctx;
402
403         ZERO_STRUCT(guid);
404
405         v = ldb_msg_find_ldb_val(msg, attr);
406         if (!v) return guid;
407
408         mem_ctx = talloc_named_const(NULL, 0, "samdb_result_guid");
409         if (!mem_ctx) return guid;
410         ndr_err = ndr_pull_struct_blob(v, mem_ctx, NULL, &guid,
411                                        (ndr_pull_flags_fn_t)ndr_pull_GUID);
412         talloc_free(mem_ctx);
413         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
414                 return guid;
415         }
416
417         return guid;
418 }
419
420 /*
421   pull a sid prefix from a objectSid in a result set. 
422   this is used to find the domain sid for a user
423 */
424 struct dom_sid *samdb_result_sid_prefix(TALLOC_CTX *mem_ctx, const struct ldb_message *msg, 
425                                         const char *attr)
426 {
427         struct dom_sid *sid = samdb_result_dom_sid(mem_ctx, msg, attr);
428         if (!sid || sid->num_auths < 1) return NULL;
429         sid->num_auths--;
430         return sid;
431 }
432
433 /*
434   pull a NTTIME in a result set. 
435 */
436 NTTIME samdb_result_nttime(struct ldb_message *msg, const char *attr, NTTIME default_value)
437 {
438         return ldb_msg_find_attr_as_uint64(msg, attr, default_value);
439 }
440
441 /*
442  * Windows stores 0 for lastLogoff.
443  * But when a MS DC return the lastLogoff (as Logoff Time)
444  * it returns 0x7FFFFFFFFFFFFFFF, not returning this value in this case
445  * cause windows 2008 and newer version to fail for SMB requests
446  */
447 NTTIME samdb_result_last_logoff(struct ldb_message *msg)
448 {
449         NTTIME ret = ldb_msg_find_attr_as_uint64(msg, "lastLogoff",0);
450
451         if (ret == 0)
452                 ret = 0x7FFFFFFFFFFFFFFFULL;
453
454         return ret;
455 }
456
457 /*
458  * Windows uses both 0 and 9223372036854775807 (0x7FFFFFFFFFFFFFFFULL) to
459  * indicate an account doesn't expire.
460  *
461  * When Windows initially creates an account, it sets
462  * accountExpires = 9223372036854775807 (0x7FFFFFFFFFFFFFFF).  However,
463  * when changing from an account having a specific expiration date to
464  * that account never expiring, it sets accountExpires = 0.
465  *
466  * Consolidate that logic here to allow clearer logic for account expiry in
467  * the rest of the code.
468  */
469 NTTIME samdb_result_account_expires(struct ldb_message *msg)
470 {
471         NTTIME ret = ldb_msg_find_attr_as_uint64(msg, "accountExpires",
472                                                  0);
473
474         if (ret == 0)
475                 ret = 0x7FFFFFFFFFFFFFFFULL;
476
477         return ret;
478 }
479
480 /*
481   pull a uint64_t from a result set. 
482 */
483 uint64_t samdb_result_uint64(struct ldb_message *msg, const char *attr, uint64_t default_value)
484 {
485         return ldb_msg_find_attr_as_uint64(msg, attr, default_value);
486 }
487
488
489 /*
490   construct the allow_password_change field from the PwdLastSet attribute and the 
491   domain password settings
492 */
493 NTTIME samdb_result_allow_password_change(struct ldb_context *sam_ldb, 
494                                           TALLOC_CTX *mem_ctx, 
495                                           struct ldb_dn *domain_dn, 
496                                           struct ldb_message *msg, 
497                                           const char *attr)
498 {
499         uint64_t attr_time = samdb_result_uint64(msg, attr, 0);
500         int64_t minPwdAge;
501
502         if (attr_time == 0) {
503                 return 0;
504         }
505
506         minPwdAge = samdb_search_int64(sam_ldb, mem_ctx, 0, domain_dn, "minPwdAge", NULL);
507
508         /* yes, this is a -= not a += as minPwdAge is stored as the negative
509            of the number of 100-nano-seconds */
510         attr_time -= minPwdAge;
511
512         return attr_time;
513 }
514
515 /*
516   construct the force_password_change field from the PwdLastSet
517   attribute, the userAccountControl and the domain password settings
518 */
519 NTTIME samdb_result_force_password_change(struct ldb_context *sam_ldb, 
520                                           TALLOC_CTX *mem_ctx, 
521                                           struct ldb_dn *domain_dn, 
522                                           struct ldb_message *msg)
523 {
524         uint64_t attr_time = samdb_result_uint64(msg, "pwdLastSet", 0);
525         uint32_t userAccountControl = samdb_result_uint64(msg, "userAccountControl", 0);
526         int64_t maxPwdAge;
527
528         /* Machine accounts don't expire, and there is a flag for 'no expiry' */
529         if (!(userAccountControl & UF_NORMAL_ACCOUNT)
530             || (userAccountControl & UF_DONT_EXPIRE_PASSWD)) {
531                 return 0x7FFFFFFFFFFFFFFFULL;
532         }
533
534         if (attr_time == 0) {
535                 return 0;
536         }
537
538         maxPwdAge = samdb_search_int64(sam_ldb, mem_ctx, 0, domain_dn, "maxPwdAge", NULL);
539         if (maxPwdAge == 0) {
540                 return 0x7FFFFFFFFFFFFFFFULL;
541         } else {
542                 attr_time -= maxPwdAge;
543         }
544
545         return attr_time;
546 }
547
548 /*
549   pull a samr_Password structutre from a result set. 
550 */
551 struct samr_Password *samdb_result_hash(TALLOC_CTX *mem_ctx, const struct ldb_message *msg, const char *attr)
552 {
553         struct samr_Password *hash = NULL;
554         const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
555         if (val && (val->length >= sizeof(hash->hash))) {
556                 hash = talloc(mem_ctx, struct samr_Password);
557                 memcpy(hash->hash, val->data, MIN(val->length, sizeof(hash->hash)));
558         }
559         return hash;
560 }
561
562 /*
563   pull an array of samr_Password structutres from a result set. 
564 */
565 uint_t samdb_result_hashes(TALLOC_CTX *mem_ctx, const struct ldb_message *msg, 
566                            const char *attr, struct samr_Password **hashes)
567 {
568         uint_t count, i;
569         const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
570
571         *hashes = NULL;
572         if (!val) {
573                 return 0;
574         }
575         count = val->length / 16;
576         if (count == 0) {
577                 return 0;
578         }
579
580         *hashes = talloc_array(mem_ctx, struct samr_Password, count);
581         if (! *hashes) {
582                 return 0;
583         }
584
585         for (i=0;i<count;i++) {
586                 memcpy((*hashes)[i].hash, (i*16)+(char *)val->data, 16);
587         }
588
589         return count;
590 }
591
592 NTSTATUS samdb_result_passwords(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, struct ldb_message *msg, 
593                                 struct samr_Password **lm_pwd, struct samr_Password **nt_pwd) 
594 {
595         struct samr_Password *lmPwdHash, *ntPwdHash;
596         if (nt_pwd) {
597                 int num_nt;
598                 num_nt = samdb_result_hashes(mem_ctx, msg, "unicodePwd", &ntPwdHash);
599                 if (num_nt == 0) {
600                         *nt_pwd = NULL;
601                 } else if (num_nt > 1) {
602                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
603                 } else {
604                         *nt_pwd = &ntPwdHash[0];
605                 }
606         }
607         if (lm_pwd) {
608                 /* Ensure that if we have turned off LM
609                  * authentication, that we never use the LM hash, even
610                  * if we store it */
611                 if (lp_lanman_auth(lp_ctx)) {
612                         int num_lm;
613                         num_lm = samdb_result_hashes(mem_ctx, msg, "dBCSPwd", &lmPwdHash);
614                         if (num_lm == 0) {
615                                 *lm_pwd = NULL;
616                         } else if (num_lm > 1) {
617                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
618                         } else {
619                                 *lm_pwd = &lmPwdHash[0];
620                         }
621                 } else {
622                         *lm_pwd = NULL;
623                 }
624         }
625         return NT_STATUS_OK;
626 }
627
628 /*
629   pull a samr_LogonHours structutre from a result set. 
630 */
631 struct samr_LogonHours samdb_result_logon_hours(TALLOC_CTX *mem_ctx, struct ldb_message *msg, const char *attr)
632 {
633         struct samr_LogonHours hours;
634         const int units_per_week = 168;
635         const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
636         ZERO_STRUCT(hours);
637         hours.bits = talloc_array(mem_ctx, uint8_t, units_per_week);
638         if (!hours.bits) {
639                 return hours;
640         }
641         hours.units_per_week = units_per_week;
642         memset(hours.bits, 0xFF, units_per_week);
643         if (val) {
644                 memcpy(hours.bits, val->data, MIN(val->length, units_per_week));
645         }
646         return hours;
647 }
648
649 /*
650   pull a set of account_flags from a result set. 
651
652   This requires that the attributes: 
653    pwdLastSet
654    userAccountControl
655   be included in 'msg'
656 */
657 uint32_t samdb_result_acct_flags(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, 
658                                  struct ldb_message *msg, struct ldb_dn *domain_dn)
659 {
660         uint32_t userAccountControl = ldb_msg_find_attr_as_uint(msg, "userAccountControl", 0);
661         uint32_t acct_flags = ds_uf2acb(userAccountControl);
662         NTTIME must_change_time;
663         NTTIME now;
664
665         must_change_time = samdb_result_force_password_change(sam_ctx, mem_ctx, 
666                                                               domain_dn, msg);
667
668         /* Test account expire time */
669         unix_to_nt_time(&now, time(NULL));
670         /* check for expired password */
671         if (must_change_time < now) {
672                 acct_flags |= ACB_PW_EXPIRED;
673         }
674         return acct_flags;
675 }
676
677 struct lsa_BinaryString samdb_result_parameters(TALLOC_CTX *mem_ctx,
678                                                 struct ldb_message *msg,
679                                                 const char *attr)
680 {
681         struct lsa_BinaryString s;
682         const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
683
684         ZERO_STRUCT(s);
685
686         if (!val) {
687                 return s;
688         }
689
690         s.array = talloc_array(mem_ctx, uint16_t, val->length/2);
691         if (!s.array) {
692                 return s;
693         }
694         s.length = s.size = val->length/2;
695         memcpy(s.array, val->data, val->length);
696
697         return s;
698 }
699
700 /* Find an attribute, with a particular value */
701
702 /* The current callers of this function expect a very specific
703  * behaviour: In particular, objectClass subclass equivilance is not
704  * wanted.  This means that we should not lookup the schema for the
705  * comparison function */
706 struct ldb_message_element *samdb_find_attribute(struct ldb_context *ldb, 
707                                                  const struct ldb_message *msg, 
708                                                  const char *name, const char *value)
709 {
710         int i;
711         struct ldb_message_element *el = ldb_msg_find_element(msg, name);
712
713         if (!el) {
714                 return NULL;
715         }
716
717         for (i=0;i<el->num_values;i++) {
718                 if (ldb_attr_cmp(value, (char *)el->values[i].data) == 0) {
719                         return el;
720                 }
721         }
722
723         return NULL;
724 }
725
726 int samdb_find_or_add_value(struct ldb_context *ldb, struct ldb_message *msg, const char *name, const char *set_value)
727 {
728         if (samdb_find_attribute(ldb, msg, name, set_value) == NULL) {
729                 return samdb_msg_add_string(ldb, msg, msg, name, set_value);
730         }
731         return LDB_SUCCESS;
732 }
733
734 int samdb_find_or_add_attribute(struct ldb_context *ldb, struct ldb_message *msg, const char *name, const char *set_value)
735 {
736         struct ldb_message_element *el;
737
738         el = ldb_msg_find_element(msg, name);
739         if (el) {
740                 return LDB_SUCCESS;
741         }
742
743         return samdb_msg_add_string(ldb, msg, msg, name, set_value);
744 }
745
746
747
748 /*
749   add a string element to a message
750 */
751 int samdb_msg_add_string(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
752                          const char *attr_name, const char *str)
753 {
754         char *s = talloc_strdup(mem_ctx, str);
755         char *a = talloc_strdup(mem_ctx, attr_name);
756         if (s == NULL || a == NULL) {
757                 return LDB_ERR_OPERATIONS_ERROR;
758         }
759         return ldb_msg_add_string(msg, a, s);
760 }
761
762 /*
763   add a dom_sid element to a message
764 */
765 int samdb_msg_add_dom_sid(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
766                          const char *attr_name, struct dom_sid *sid)
767 {
768         struct ldb_val v;
769         enum ndr_err_code ndr_err;
770
771         ndr_err = ndr_push_struct_blob(&v, mem_ctx, 
772                                        lp_iconv_convenience(ldb_get_opaque(sam_ldb, "loadparm")),
773                                        sid,
774                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
775         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
776                 return -1;
777         }
778         return ldb_msg_add_value(msg, attr_name, &v, NULL);
779 }
780
781
782 /*
783   add a delete element operation to a message
784 */
785 int samdb_msg_add_delete(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
786                          const char *attr_name)
787 {
788         /* we use an empty replace rather than a delete, as it allows for 
789            samdb_replace() to be used everywhere */
790         return ldb_msg_add_empty(msg, attr_name, LDB_FLAG_MOD_REPLACE, NULL);
791 }
792
793 /*
794   add a add attribute value to a message
795 */
796 int samdb_msg_add_addval(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
797                          const char *attr_name, const char *value)
798 {
799         struct ldb_message_element *el;
800         char *a, *v;
801         int ret;
802         a = talloc_strdup(mem_ctx, attr_name);
803         if (a == NULL)
804                 return -1;
805         v = talloc_strdup(mem_ctx, value);
806         if (v == NULL)
807                 return -1;
808         ret = ldb_msg_add_string(msg, a, v);
809         if (ret != 0)
810                 return ret;
811         el = ldb_msg_find_element(msg, a);
812         if (el == NULL)
813                 return -1;
814         el->flags = LDB_FLAG_MOD_ADD;
815         return 0;
816 }
817
818 /*
819   add a delete attribute value to a message
820 */
821 int samdb_msg_add_delval(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
822                          const char *attr_name, const char *value)
823 {
824         struct ldb_message_element *el;
825         char *a, *v;
826         int ret;
827         a = talloc_strdup(mem_ctx, attr_name);
828         if (a == NULL)
829                 return -1;
830         v = talloc_strdup(mem_ctx, value);
831         if (v == NULL)
832                 return -1;
833         ret = ldb_msg_add_string(msg, a, v);
834         if (ret != 0)
835                 return ret;
836         el = ldb_msg_find_element(msg, a);
837         if (el == NULL)
838                 return -1;
839         el->flags = LDB_FLAG_MOD_DELETE;
840         return 0;
841 }
842
843 /*
844   add a int element to a message
845 */
846 int samdb_msg_add_int(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
847                        const char *attr_name, int v)
848 {
849         const char *s = talloc_asprintf(mem_ctx, "%d", v);
850         return samdb_msg_add_string(sam_ldb, mem_ctx, msg, attr_name, s);
851 }
852
853 /*
854   add a uint_t element to a message
855 */
856 int samdb_msg_add_uint(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
857                        const char *attr_name, uint_t v)
858 {
859         const char *s = talloc_asprintf(mem_ctx, "%u", v);
860         return samdb_msg_add_string(sam_ldb, mem_ctx, msg, attr_name, s);
861 }
862
863 /*
864   add a (signed) int64_t element to a message
865 */
866 int samdb_msg_add_int64(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
867                         const char *attr_name, int64_t v)
868 {
869         const char *s = talloc_asprintf(mem_ctx, "%lld", (long long)v);
870         return samdb_msg_add_string(sam_ldb, mem_ctx, msg, attr_name, s);
871 }
872
873 /*
874   add a uint64_t element to a message
875 */
876 int samdb_msg_add_uint64(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
877                         const char *attr_name, uint64_t v)
878 {
879         const char *s = talloc_asprintf(mem_ctx, "%llu", (unsigned long long)v);
880         return samdb_msg_add_string(sam_ldb, mem_ctx, msg, attr_name, s);
881 }
882
883 /*
884   add a samr_Password element to a message
885 */
886 int samdb_msg_add_hash(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
887                        const char *attr_name, struct samr_Password *hash)
888 {
889         struct ldb_val val;
890         val.data = talloc_memdup(mem_ctx, hash->hash, 16);
891         if (!val.data) {
892                 return -1;
893         }
894         val.length = 16;
895         return ldb_msg_add_value(msg, attr_name, &val, NULL);
896 }
897
898 /*
899   add a samr_Password array to a message
900 */
901 int samdb_msg_add_hashes(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
902                          const char *attr_name, struct samr_Password *hashes, uint_t count)
903 {
904         struct ldb_val val;
905         int i;
906         val.data = talloc_array_size(mem_ctx, 16, count);
907         val.length = count*16;
908         if (!val.data) {
909                 return -1;
910         }
911         for (i=0;i<count;i++) {
912                 memcpy(i*16 + (char *)val.data, hashes[i].hash, 16);
913         }
914         return ldb_msg_add_value(msg, attr_name, &val, NULL);
915 }
916
917 /*
918   add a acct_flags element to a message
919 */
920 int samdb_msg_add_acct_flags(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
921                              const char *attr_name, uint32_t v)
922 {
923         return samdb_msg_add_uint(sam_ldb, mem_ctx, msg, attr_name, ds_acb2uf(v));
924 }
925
926 /*
927   add a logon_hours element to a message
928 */
929 int samdb_msg_add_logon_hours(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
930                               const char *attr_name, struct samr_LogonHours *hours)
931 {
932         struct ldb_val val;
933         val.length = hours->units_per_week / 8;
934         val.data = hours->bits;
935         return ldb_msg_add_value(msg, attr_name, &val, NULL);
936 }
937
938 /*
939   add a parameters element to a message
940 */
941 int samdb_msg_add_parameters(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
942                              const char *attr_name, struct lsa_BinaryString *parameters)
943 {
944         struct ldb_val val;
945         val.length = parameters->length * 2;
946         val.data = (uint8_t *)parameters->array;
947         return ldb_msg_add_value(msg, attr_name, &val, NULL);
948 }
949 /*
950   add a general value element to a message
951 */
952 int samdb_msg_add_value(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
953                               const char *attr_name, const struct ldb_val *val)
954 {
955         return ldb_msg_add_value(msg, attr_name, val, NULL);
956 }
957
958 /*
959   sets a general value element to a message
960 */
961 int samdb_msg_set_value(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
962                         const char *attr_name, const struct ldb_val *val)
963 {
964         struct ldb_message_element *el;
965
966         el = ldb_msg_find_element(msg, attr_name);
967         if (el) {
968                 el->num_values = 0;
969         }
970         return ldb_msg_add_value(msg, attr_name, val, NULL);
971 }
972
973 /*
974   set a string element in a message
975 */
976 int samdb_msg_set_string(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
977                          const char *attr_name, const char *str)
978 {
979         struct ldb_message_element *el;
980
981         el = ldb_msg_find_element(msg, attr_name);
982         if (el) {
983                 el->num_values = 0;
984         }
985         return samdb_msg_add_string(sam_ldb, mem_ctx, msg, attr_name, str);
986 }
987
988 /*
989   replace elements in a record
990 */
991 int samdb_replace(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg)
992 {
993         int i;
994
995         /* mark all the message elements as LDB_FLAG_MOD_REPLACE */
996         for (i=0;i<msg->num_elements;i++) {
997                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
998         }
999
1000         /* modify the samdb record */
1001         return ldb_modify(sam_ldb, msg);
1002 }
1003
1004 /*
1005   return a default security descriptor
1006 */
1007 struct security_descriptor *samdb_default_security_descriptor(TALLOC_CTX *mem_ctx)
1008 {
1009         struct security_descriptor *sd;
1010
1011         sd = security_descriptor_initialise(mem_ctx);
1012
1013         return sd;
1014 }
1015
1016 struct ldb_dn *samdb_base_dn(struct ldb_context *sam_ctx) 
1017 {
1018         return ldb_get_default_basedn(sam_ctx);
1019 }
1020
1021 struct ldb_dn *samdb_config_dn(struct ldb_context *sam_ctx) 
1022 {
1023         return ldb_get_config_basedn(sam_ctx);
1024 }
1025
1026 struct ldb_dn *samdb_schema_dn(struct ldb_context *sam_ctx) 
1027 {
1028         return ldb_get_schema_basedn(sam_ctx);
1029 }
1030
1031 struct ldb_dn *samdb_aggregate_schema_dn(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx) 
1032 {
1033         struct ldb_dn *schema_dn = ldb_get_schema_basedn(sam_ctx);
1034         struct ldb_dn *aggregate_dn;
1035         if (!schema_dn) {
1036                 return NULL;
1037         }
1038
1039         aggregate_dn = ldb_dn_copy(mem_ctx, schema_dn);
1040         if (!aggregate_dn) {
1041                 return NULL;
1042         }
1043         if (!ldb_dn_add_child_fmt(aggregate_dn, "CN=Aggregate")) {
1044                 return NULL;
1045         }
1046         return aggregate_dn;
1047 }
1048
1049 struct ldb_dn *samdb_root_dn(struct ldb_context *sam_ctx) 
1050 {
1051         return ldb_get_root_basedn(sam_ctx);
1052 }
1053
1054 struct ldb_dn *samdb_partitions_dn(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx)
1055 {
1056         struct ldb_dn *new_dn;
1057
1058         new_dn = ldb_dn_copy(mem_ctx, samdb_config_dn(sam_ctx));
1059         if ( ! ldb_dn_add_child_fmt(new_dn, "CN=Partitions")) {
1060                 talloc_free(new_dn);
1061                 return NULL;
1062         }
1063         return new_dn;
1064 }
1065
1066 struct ldb_dn *samdb_sites_dn(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx)
1067 {
1068         struct ldb_dn *new_dn;
1069
1070         new_dn = ldb_dn_copy(mem_ctx, samdb_config_dn(sam_ctx));
1071         if ( ! ldb_dn_add_child_fmt(new_dn, "CN=Sites")) {
1072                 talloc_free(new_dn);
1073                 return NULL;
1074         }
1075         return new_dn;
1076 }
1077
1078 /*
1079   work out the domain sid for the current open ldb
1080 */
1081 const struct dom_sid *samdb_domain_sid(struct ldb_context *ldb)
1082 {
1083         TALLOC_CTX *tmp_ctx;
1084         const struct dom_sid *domain_sid;
1085         const char *attrs[] = {
1086                 "objectSid",
1087                 NULL
1088         };
1089         struct ldb_result *res;
1090         int ret;
1091
1092         /* see if we have a cached copy */
1093         domain_sid = (struct dom_sid *)ldb_get_opaque(ldb, "cache.domain_sid");
1094         if (domain_sid) {
1095                 return domain_sid;
1096         }
1097
1098         tmp_ctx = talloc_new(ldb);
1099         if (tmp_ctx == NULL) {
1100                 goto failed;
1101         }
1102
1103         ret = ldb_search(ldb, tmp_ctx, &res, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, attrs, "objectSid=*");
1104
1105         if (ret != LDB_SUCCESS) {
1106                 goto failed;
1107         }
1108
1109         if (res->count != 1) {
1110                 goto failed;
1111         }
1112
1113         domain_sid = samdb_result_dom_sid(tmp_ctx, res->msgs[0], "objectSid");
1114         if (domain_sid == NULL) {
1115                 goto failed;
1116         }
1117
1118         /* cache the domain_sid in the ldb */
1119         if (ldb_set_opaque(ldb, "cache.domain_sid", discard_const_p(struct dom_sid, domain_sid)) != LDB_SUCCESS) {
1120                 goto failed;
1121         }
1122
1123         talloc_steal(ldb, domain_sid);
1124         talloc_free(tmp_ctx);
1125
1126         return domain_sid;
1127
1128 failed:
1129         DEBUG(1,("Failed to find domain_sid for open ldb\n"));
1130         talloc_free(tmp_ctx);
1131         return NULL;
1132 }
1133
1134 bool samdb_set_domain_sid(struct ldb_context *ldb, const struct dom_sid *dom_sid_in)
1135 {
1136         TALLOC_CTX *tmp_ctx;
1137         struct dom_sid *dom_sid_new;
1138         struct dom_sid *dom_sid_old;
1139
1140         /* see if we have a cached copy */
1141         dom_sid_old = talloc_get_type(ldb_get_opaque(ldb, 
1142                                                      "cache.domain_sid"), struct dom_sid);
1143
1144         tmp_ctx = talloc_new(ldb);
1145         if (tmp_ctx == NULL) {
1146                 goto failed;
1147         }
1148
1149         dom_sid_new = dom_sid_dup(tmp_ctx, dom_sid_in);
1150         if (!dom_sid_new) {
1151                 goto failed;
1152         }
1153
1154         /* cache the domain_sid in the ldb */
1155         if (ldb_set_opaque(ldb, "cache.domain_sid", dom_sid_new) != LDB_SUCCESS) {
1156                 goto failed;
1157         }
1158
1159         talloc_steal(ldb, dom_sid_new);
1160         talloc_free(tmp_ctx);
1161         talloc_free(dom_sid_old);
1162
1163         return true;
1164
1165 failed:
1166         DEBUG(1,("Failed to set our own cached domain SID in the ldb!\n"));
1167         talloc_free(tmp_ctx);
1168         return false;
1169 }
1170
1171 /* Obtain the short name of the flexible single master operator
1172  * (FSMO), such as the PDC Emulator */
1173 const char *samdb_result_fsmo_name(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const struct ldb_message *msg, 
1174                              const char *attr)
1175 {
1176         /* Format is cn=NTDS Settings,cn=<NETBIOS name of FSMO>,.... */
1177         struct ldb_dn *fsmo_dn = ldb_msg_find_attr_as_dn(ldb, mem_ctx, msg, attr);
1178         const struct ldb_val *val = ldb_dn_get_component_val(fsmo_dn, 1);
1179         const char *name = ldb_dn_get_component_name(fsmo_dn, 1);
1180
1181         if (!name || (ldb_attr_cmp(name, "cn") != 0)) {
1182                 /* Ensure this matches the format.  This gives us a
1183                  * bit more confidence that a 'cn' value will be a
1184                  * ascii string */
1185                 return NULL;
1186         }
1187         if (val) {
1188                 return (char *)val->data;
1189         }
1190         return NULL;
1191 }
1192
1193 /*
1194   work out the ntds settings dn for the current open ldb
1195 */
1196 struct ldb_dn *samdb_ntds_settings_dn(struct ldb_context *ldb)
1197 {
1198         TALLOC_CTX *tmp_ctx;
1199         const char *root_attrs[] = { "dsServiceName", NULL };
1200         int ret;
1201         struct ldb_result *root_res;
1202         struct ldb_dn *settings_dn;
1203
1204         /* see if we have a cached copy */
1205         settings_dn = (struct ldb_dn *)ldb_get_opaque(ldb, "cache.settings_dn");
1206         if (settings_dn) {
1207                 return settings_dn;
1208         }
1209
1210         tmp_ctx = talloc_new(ldb);
1211         if (tmp_ctx == NULL) {
1212                 goto failed;
1213         }
1214
1215         ret = ldb_search(ldb, tmp_ctx, &root_res, ldb_dn_new(tmp_ctx, ldb, ""), LDB_SCOPE_BASE, root_attrs, NULL);
1216         if (ret) {
1217                 DEBUG(1,("Searching for dsServiceName in rootDSE failed: %s\n", 
1218                          ldb_errstring(ldb)));
1219                 goto failed;
1220         }
1221
1222         if (root_res->count != 1) {
1223                 goto failed;
1224         }
1225
1226         settings_dn = ldb_msg_find_attr_as_dn(ldb, tmp_ctx, root_res->msgs[0], "dsServiceName");
1227
1228         /* cache the domain_sid in the ldb */
1229         if (ldb_set_opaque(ldb, "cache.settings_dn", settings_dn) != LDB_SUCCESS) {
1230                 goto failed;
1231         }
1232
1233         talloc_steal(ldb, settings_dn);
1234         talloc_free(tmp_ctx);
1235
1236         return settings_dn;
1237
1238 failed:
1239         DEBUG(1,("Failed to find our own NTDS Settings DN in the ldb!\n"));
1240         talloc_free(tmp_ctx);
1241         return NULL;
1242 }
1243
1244 /*
1245   work out the ntds settings invocationId for the current open ldb
1246 */
1247 const struct GUID *samdb_ntds_invocation_id(struct ldb_context *ldb)
1248 {
1249         TALLOC_CTX *tmp_ctx;
1250         const char *attrs[] = { "invocationId", NULL };
1251         int ret;
1252         struct ldb_result *res;
1253         struct GUID *invocation_id;
1254
1255         /* see if we have a cached copy */
1256         invocation_id = (struct GUID *)ldb_get_opaque(ldb, "cache.invocation_id");
1257         if (invocation_id) {
1258                 return invocation_id;
1259         }
1260
1261         tmp_ctx = talloc_new(ldb);
1262         if (tmp_ctx == NULL) {
1263                 goto failed;
1264         }
1265
1266         ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
1267         if (ret) {
1268                 goto failed;
1269         }
1270
1271         if (res->count != 1) {
1272                 goto failed;
1273         }
1274
1275         invocation_id = talloc(tmp_ctx, struct GUID);
1276         if (!invocation_id) {
1277                 goto failed;
1278         }
1279
1280         *invocation_id = samdb_result_guid(res->msgs[0], "invocationId");
1281
1282         /* cache the domain_sid in the ldb */
1283         if (ldb_set_opaque(ldb, "cache.invocation_id", invocation_id) != LDB_SUCCESS) {
1284                 goto failed;
1285         }
1286
1287         talloc_steal(ldb, invocation_id);
1288         talloc_free(tmp_ctx);
1289
1290         return invocation_id;
1291
1292 failed:
1293         DEBUG(1,("Failed to find our own NTDS Settings invocationId in the ldb!\n"));
1294         talloc_free(tmp_ctx);
1295         return NULL;
1296 }
1297
1298 bool samdb_set_ntds_invocation_id(struct ldb_context *ldb, const struct GUID *invocation_id_in)
1299 {
1300         TALLOC_CTX *tmp_ctx;
1301         struct GUID *invocation_id_new;
1302         struct GUID *invocation_id_old;
1303
1304         /* see if we have a cached copy */
1305         invocation_id_old = (struct GUID *)ldb_get_opaque(ldb, 
1306                                                          "cache.invocation_id");
1307
1308         tmp_ctx = talloc_new(ldb);
1309         if (tmp_ctx == NULL) {
1310                 goto failed;
1311         }
1312
1313         invocation_id_new = talloc(tmp_ctx, struct GUID);
1314         if (!invocation_id_new) {
1315                 goto failed;
1316         }
1317
1318         *invocation_id_new = *invocation_id_in;
1319
1320         /* cache the domain_sid in the ldb */
1321         if (ldb_set_opaque(ldb, "cache.invocation_id", invocation_id_new) != LDB_SUCCESS) {
1322                 goto failed;
1323         }
1324
1325         talloc_steal(ldb, invocation_id_new);
1326         talloc_free(tmp_ctx);
1327         talloc_free(invocation_id_old);
1328
1329         return true;
1330
1331 failed:
1332         DEBUG(1,("Failed to set our own cached invocationId in the ldb!\n"));
1333         talloc_free(tmp_ctx);
1334         return false;
1335 }
1336
1337 /*
1338   work out the ntds settings objectGUID for the current open ldb
1339 */
1340 const struct GUID *samdb_ntds_objectGUID(struct ldb_context *ldb)
1341 {
1342         TALLOC_CTX *tmp_ctx;
1343         const char *attrs[] = { "objectGUID", NULL };
1344         int ret;
1345         struct ldb_result *res;
1346         struct GUID *ntds_guid;
1347
1348         /* see if we have a cached copy */
1349         ntds_guid = (struct GUID *)ldb_get_opaque(ldb, "cache.ntds_guid");
1350         if (ntds_guid) {
1351                 return ntds_guid;
1352         }
1353
1354         tmp_ctx = talloc_new(ldb);
1355         if (tmp_ctx == NULL) {
1356                 goto failed;
1357         }
1358
1359         ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
1360         if (ret) {
1361                 goto failed;
1362         }
1363
1364         if (res->count != 1) {
1365                 goto failed;
1366         }
1367
1368         ntds_guid = talloc(tmp_ctx, struct GUID);
1369         if (!ntds_guid) {
1370                 goto failed;
1371         }
1372
1373         *ntds_guid = samdb_result_guid(res->msgs[0], "objectGUID");
1374
1375         /* cache the domain_sid in the ldb */
1376         if (ldb_set_opaque(ldb, "cache.ntds_guid", ntds_guid) != LDB_SUCCESS) {
1377                 goto failed;
1378         }
1379
1380         talloc_steal(ldb, ntds_guid);
1381         talloc_free(tmp_ctx);
1382
1383         return ntds_guid;
1384
1385 failed:
1386         DEBUG(1,("Failed to find our own NTDS Settings objectGUID in the ldb!\n"));
1387         talloc_free(tmp_ctx);
1388         return NULL;
1389 }
1390
1391 bool samdb_set_ntds_objectGUID(struct ldb_context *ldb, const struct GUID *ntds_guid_in)
1392 {
1393         TALLOC_CTX *tmp_ctx;
1394         struct GUID *ntds_guid_new;
1395         struct GUID *ntds_guid_old;
1396
1397         /* see if we have a cached copy */
1398         ntds_guid_old = (struct GUID *)ldb_get_opaque(ldb, "cache.ntds_guid");
1399
1400         tmp_ctx = talloc_new(ldb);
1401         if (tmp_ctx == NULL) {
1402                 goto failed;
1403         }
1404
1405         ntds_guid_new = talloc(tmp_ctx, struct GUID);
1406         if (!ntds_guid_new) {
1407                 goto failed;
1408         }
1409
1410         *ntds_guid_new = *ntds_guid_in;
1411
1412         /* cache the domain_sid in the ldb */
1413         if (ldb_set_opaque(ldb, "cache.ntds_guid", ntds_guid_new) != LDB_SUCCESS) {
1414                 goto failed;
1415         }
1416
1417         talloc_steal(ldb, ntds_guid_new);
1418         talloc_free(tmp_ctx);
1419         talloc_free(ntds_guid_old);
1420
1421         return true;
1422
1423 failed:
1424         DEBUG(1,("Failed to set our own cached invocationId in the ldb!\n"));
1425         talloc_free(tmp_ctx);
1426         return false;
1427 }
1428
1429 /*
1430   work out the server dn for the current open ldb
1431 */
1432 struct ldb_dn *samdb_server_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx)
1433 {
1434         return ldb_dn_get_parent(mem_ctx, samdb_ntds_settings_dn(ldb));
1435 }
1436
1437 /*
1438   work out the server dn for the current open ldb
1439 */
1440 struct ldb_dn *samdb_server_site_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx)
1441 {
1442         struct ldb_dn *server_dn;
1443         struct ldb_dn *server_site_dn;
1444
1445         server_dn = samdb_server_dn(ldb, mem_ctx);
1446         if (!server_dn) return NULL;
1447
1448         server_site_dn = ldb_dn_get_parent(mem_ctx, server_dn);
1449
1450         talloc_free(server_dn);
1451         return server_site_dn;
1452 }
1453
1454 const char *samdb_server_site_name(struct ldb_context *ldb, TALLOC_CTX *mem_ctx)
1455 {
1456         const struct ldb_val *val = ldb_dn_get_rdn_val(samdb_server_site_dn(ldb, mem_ctx));
1457
1458         if (val != NULL)
1459                 return (const char *) val->data;
1460         else
1461                 return NULL;
1462 }
1463
1464 /*
1465   work out if we are the PDC for the domain of the current open ldb
1466 */
1467 bool samdb_is_pdc(struct ldb_context *ldb)
1468 {
1469         const char *dom_attrs[] = { "fSMORoleOwner", NULL };
1470         int ret;
1471         struct ldb_result *dom_res;
1472         TALLOC_CTX *tmp_ctx;
1473         bool is_pdc;
1474         struct ldb_dn *pdc;
1475
1476         tmp_ctx = talloc_new(ldb);
1477         if (tmp_ctx == NULL) {
1478                 DEBUG(1, ("talloc_new failed in samdb_is_pdc"));
1479                 return false;
1480         }
1481
1482         ret = ldb_search(ldb, tmp_ctx, &dom_res, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, dom_attrs, NULL);
1483         if (ret) {
1484                 DEBUG(1,("Searching for fSMORoleOwner in %s failed: %s\n", 
1485                          ldb_dn_get_linearized(ldb_get_default_basedn(ldb)), 
1486                          ldb_errstring(ldb)));
1487                 goto failed;
1488         }
1489         if (dom_res->count != 1) {
1490                 goto failed;
1491         }
1492
1493         pdc = ldb_msg_find_attr_as_dn(ldb, tmp_ctx, dom_res->msgs[0], "fSMORoleOwner");
1494
1495         if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), pdc) == 0) {
1496                 is_pdc = true;
1497         } else {
1498                 is_pdc = false;
1499         }
1500
1501         talloc_free(tmp_ctx);
1502
1503         return is_pdc;
1504
1505 failed:
1506         DEBUG(1,("Failed to find if we are the PDC for this ldb\n"));
1507         talloc_free(tmp_ctx);
1508         return false;
1509 }
1510
1511 /*
1512   work out if we are a Global Catalog server for the domain of the current open ldb
1513 */
1514 bool samdb_is_gc(struct ldb_context *ldb)
1515 {
1516         const char *attrs[] = { "options", NULL };
1517         int ret, options;
1518         struct ldb_result *res;
1519         TALLOC_CTX *tmp_ctx;
1520
1521         tmp_ctx = talloc_new(ldb);
1522         if (tmp_ctx == NULL) {
1523                 DEBUG(1, ("talloc_new failed in samdb_is_pdc"));
1524                 return false;
1525         }
1526
1527         /* Query cn=ntds settings,.... */
1528         ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
1529         if (ret) {
1530                 talloc_free(tmp_ctx);
1531                 return false;
1532         }
1533         if (res->count != 1) {
1534                 talloc_free(tmp_ctx);
1535                 return false;
1536         }
1537
1538         options = ldb_msg_find_attr_as_int(res->msgs[0], "options", 0);
1539         talloc_free(tmp_ctx);
1540
1541         /* if options attribute has the 0x00000001 flag set, then enable the global catlog */
1542         if (options & 0x000000001) {
1543                 return true;
1544         }
1545         return false;
1546 }
1547
1548 /* Find a domain object in the parents of a particular DN.  */
1549 int samdb_search_for_parent_domain(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_dn *dn,
1550                                    struct ldb_dn **parent_dn, const char **errstring)
1551 {
1552         TALLOC_CTX *local_ctx;
1553         struct ldb_dn *sdn = dn;
1554         struct ldb_result *res = NULL;
1555         int ret = 0;
1556         const char *attrs[] = { NULL };
1557
1558         local_ctx = talloc_new(mem_ctx);
1559         if (local_ctx == NULL) return LDB_ERR_OPERATIONS_ERROR;
1560
1561         while ((sdn = ldb_dn_get_parent(local_ctx, sdn))) {
1562                 ret = ldb_search(ldb, local_ctx, &res, sdn, LDB_SCOPE_BASE, attrs,
1563                                  "(|(objectClass=domain)(objectClass=builtinDomain))");
1564                 if (ret == LDB_SUCCESS) {
1565                         if (res->count == 1) {
1566                                 break;
1567                         }
1568                 } else {
1569                         break;
1570                 }
1571         }
1572
1573         if (ret != LDB_SUCCESS) {
1574                 *errstring = talloc_asprintf(mem_ctx, "Error searching for parent domain of %s, failed searching for %s: %s",
1575                                              ldb_dn_get_linearized(dn),
1576                                              ldb_dn_get_linearized(sdn),
1577                                              ldb_errstring(ldb));
1578                 talloc_free(local_ctx);
1579                 return ret;
1580         }
1581         if (res->count != 1) {
1582                 *errstring = talloc_asprintf(mem_ctx, "Invalid dn (%s), not child of a domain object",
1583                                              ldb_dn_get_linearized(dn));
1584                 DEBUG(0,(__location__ ": %s\n", *errstring));
1585                 talloc_free(local_ctx);
1586                 return LDB_ERR_CONSTRAINT_VIOLATION;
1587         }
1588
1589         *parent_dn = talloc_steal(mem_ctx, res->msgs[0]->dn);
1590         talloc_free(local_ctx);
1591         return ret;
1592 }
1593
1594
1595 /*
1596  * Performs checks on a user password (plaintext UNIX format - attribute
1597  * "password"). The remaining parameters have to be extracted from the domain
1598  * object in the AD.
1599  *
1600  * Result codes from "enum samr_ValidationStatus" (consider "samr.idl")
1601  */
1602 enum samr_ValidationStatus samdb_check_password(const DATA_BLOB *password,
1603                                                 const uint32_t pwdProperties,
1604                                                 const uint32_t minPwdLength)
1605 {
1606         /* checks if the "minPwdLength" property is satisfied */
1607         if (minPwdLength > password->length)
1608                 return SAMR_VALIDATION_STATUS_PWD_TOO_SHORT;
1609
1610         /* checks the password complexity */
1611         if (((pwdProperties & DOMAIN_PASSWORD_COMPLEX) != 0)
1612                         && (password->data != NULL)
1613                         && (!check_password_quality((const char *) password->data)))
1614                 return SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH;
1615
1616         return SAMR_VALIDATION_STATUS_SUCCESS;
1617 }
1618
1619 /*
1620  * Sets the user password using plaintext UTF16 (attribute "new_password") or
1621  * LM (attribute "lmNewHash") or NT (attribute "ntNewHash") hash. Also pass
1622  * as parameter if it's a user change or not ("userChange"). The "rejectReason"
1623  * gives some more informations if the changed failed.
1624  *
1625  * The caller should have a LDB transaction wrapping this.
1626  *
1627  * Results: NT_STATUS_OK, NT_STATUS_INTERNAL_DB_CORRUPTION,
1628  *   NT_STATUS_INVALID_PARAMETER, NT_STATUS_UNSUCCESSFUL,
1629  *   NT_STATUS_PASSWORD_RESTRICTION
1630  */
1631 NTSTATUS samdb_set_password(struct ldb_context *ctx, TALLOC_CTX *mem_ctx,
1632                             struct ldb_dn *user_dn, struct ldb_dn *domain_dn,
1633                             struct ldb_message *mod,
1634                             const DATA_BLOB *new_password,
1635                             struct samr_Password *param_lmNewHash,
1636                             struct samr_Password *param_ntNewHash,
1637                             bool user_change,
1638                             enum samPwdChangeReason *reject_reason,
1639                             struct samr_DomInfo1 **_dominfo)
1640 {
1641         const char * const user_attrs[] = { "userAccountControl",
1642                                             "lmPwdHistory",
1643                                             "ntPwdHistory", 
1644                                             "dBCSPwd", "unicodePwd", 
1645                                             "objectSid", 
1646                                             "pwdLastSet", NULL };
1647         const char * const domain_attrs[] = { "minPwdLength", "pwdProperties",
1648                                               "pwdHistoryLength",
1649                                               "maxPwdAge", "minPwdAge", NULL };
1650         NTTIME pwdLastSet;
1651         uint32_t minPwdLength, pwdProperties, pwdHistoryLength;
1652         int64_t maxPwdAge, minPwdAge;
1653         uint32_t userAccountControl;
1654         struct samr_Password *sambaLMPwdHistory, *sambaNTPwdHistory,
1655                 *lmPwdHash, *ntPwdHash, *lmNewHash, *ntNewHash;
1656         struct samr_Password local_lmNewHash, local_ntNewHash;
1657         int sambaLMPwdHistory_len, sambaNTPwdHistory_len;
1658         struct dom_sid *domain_sid;
1659         struct ldb_message **res;
1660         bool restrictions;
1661         int count;
1662         time_t now = time(NULL);
1663         NTTIME now_nt;
1664         int i;
1665
1666         /* we need to know the time to compute password age */
1667         unix_to_nt_time(&now_nt, now);
1668
1669         /* pull all the user parameters */
1670         count = gendb_search_dn(ctx, mem_ctx, user_dn, &res, user_attrs);
1671         if (count != 1) {
1672                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1673         }
1674         userAccountControl = samdb_result_uint(res[0], "userAccountControl", 0);
1675         sambaLMPwdHistory_len = samdb_result_hashes(mem_ctx, res[0],
1676                                          "lmPwdHistory", &sambaLMPwdHistory);
1677         sambaNTPwdHistory_len = samdb_result_hashes(mem_ctx, res[0],
1678                                          "ntPwdHistory", &sambaNTPwdHistory);
1679         lmPwdHash = samdb_result_hash(mem_ctx, res[0], "dBCSPwd");
1680         ntPwdHash = samdb_result_hash(mem_ctx, res[0], "unicodePwd");
1681         pwdLastSet = samdb_result_uint64(res[0], "pwdLastSet", 0);
1682
1683         /* Copy parameters */
1684         lmNewHash = param_lmNewHash;
1685         ntNewHash = param_ntNewHash;
1686
1687         /* Only non-trust accounts have restrictions (possibly this
1688          * test is the wrong way around, but I like to be restrictive
1689          * if possible */
1690         restrictions = !(userAccountControl & (UF_INTERDOMAIN_TRUST_ACCOUNT
1691                                                |UF_WORKSTATION_TRUST_ACCOUNT
1692                                                |UF_SERVER_TRUST_ACCOUNT)); 
1693
1694         if (domain_dn != NULL) {
1695                 /* pull the domain parameters */
1696                 count = gendb_search_dn(ctx, mem_ctx, domain_dn, &res,
1697                                                                 domain_attrs);
1698                 if (count != 1) {
1699                         DEBUG(2, ("samdb_set_password: Domain DN %s is invalid, for user %s\n", 
1700                                   ldb_dn_get_linearized(domain_dn),
1701                                   ldb_dn_get_linearized(user_dn)));
1702                         return NT_STATUS_NO_SUCH_DOMAIN;
1703                 }
1704         } else {
1705                 /* work out the domain sid, and pull the domain from there */
1706                 domain_sid = samdb_result_sid_prefix(mem_ctx, res[0],
1707                                                                 "objectSid");
1708                 if (domain_sid == NULL) {
1709                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1710                 }
1711
1712                 count = gendb_search(ctx, mem_ctx, NULL, &res, domain_attrs, 
1713                                 "(objectSid=%s)",
1714                                 ldap_encode_ndr_dom_sid(mem_ctx, domain_sid));
1715                 if (count != 1) {
1716                         DEBUG(2, ("samdb_set_password: Could not find domain to match SID: %s, for user %s\n", 
1717                                   dom_sid_string(mem_ctx, domain_sid),
1718                                   ldb_dn_get_linearized(user_dn)));
1719                         return NT_STATUS_NO_SUCH_DOMAIN;
1720                 }
1721         }
1722
1723         minPwdLength = samdb_result_uint(res[0], "minPwdLength", 0);
1724         pwdProperties = samdb_result_uint(res[0], "pwdProperties", 0);
1725         pwdHistoryLength = samdb_result_uint(res[0], "pwdHistoryLength", 0);
1726         maxPwdAge = samdb_result_int64(res[0], "maxPwdAge", 0);
1727         minPwdAge = samdb_result_int64(res[0], "minPwdAge", 0);
1728
1729         if ((userAccountControl & UF_PASSWD_NOTREQD) != 0) {
1730                 /* see [MS-ADTS] 2.2.15 */
1731                 minPwdLength = 0;
1732         }
1733
1734         if (_dominfo != NULL) {
1735                 struct samr_DomInfo1 *dominfo;
1736                 /* on failure we need to fill in the reject reasons */
1737                 dominfo = talloc(mem_ctx, struct samr_DomInfo1);
1738                 if (dominfo == NULL) {
1739                         return NT_STATUS_NO_MEMORY;
1740                 }
1741                 dominfo->min_password_length     = minPwdLength;
1742                 dominfo->password_properties     = pwdProperties;
1743                 dominfo->password_history_length = pwdHistoryLength;
1744                 dominfo->max_password_age        = maxPwdAge;
1745                 dominfo->min_password_age        = minPwdAge;
1746                 *_dominfo = dominfo;
1747         }
1748
1749         if ((restrictions != 0) && (new_password != 0)) {
1750                 char *new_pass;
1751
1752                 /* checks if the "minPwdLength" property is satisfied */
1753                 if ((restrictions != 0)
1754                         && (minPwdLength > utf16_len_n(
1755                                 new_password->data, new_password->length)/2)) {
1756                         if (reject_reason) {
1757                                 *reject_reason = SAM_PWD_CHANGE_PASSWORD_TOO_SHORT;
1758                         }
1759                         return NT_STATUS_PASSWORD_RESTRICTION;
1760                 }
1761
1762                 /* Create the NT hash */
1763                 mdfour(local_ntNewHash.hash, new_password->data,
1764                                                         new_password->length);
1765
1766                 ntNewHash = &local_ntNewHash;
1767
1768                 /* Only check complexity if we can convert it at all.  Assuming unconvertable passwords are 'strong' */
1769                 if (convert_string_talloc_convenience(mem_ctx,
1770                           lp_iconv_convenience(ldb_get_opaque(ctx, "loadparm")),
1771                           CH_UTF16, CH_UNIX,
1772                           new_password->data, new_password->length,
1773                           (void **)&new_pass, NULL, false)) {
1774
1775                         /* checks the password complexity */
1776                         if ((restrictions != 0)
1777                                 && ((pwdProperties
1778                                         & DOMAIN_PASSWORD_COMPLEX) != 0)
1779                                 && (!check_password_quality(new_pass))) {
1780                                 if (reject_reason) {
1781                                         *reject_reason = SAM_PWD_CHANGE_NOT_COMPLEX;
1782                                 }
1783                                 return NT_STATUS_PASSWORD_RESTRICTION;
1784                         }
1785
1786                         /* compute the new lm hashes (for checking history - case insenitivly!) */
1787                         if (E_deshash(new_pass, local_lmNewHash.hash)) {
1788                                 lmNewHash = &local_lmNewHash;
1789                         }
1790                 }
1791         }
1792
1793         if ((restrictions != 0) && user_change) {
1794                 /* are all password changes disallowed? */
1795                 if ((pwdProperties & DOMAIN_REFUSE_PASSWORD_CHANGE) != 0) {
1796                         if (reject_reason) {
1797                                 *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
1798                         }
1799                         return NT_STATUS_PASSWORD_RESTRICTION;
1800                 }
1801
1802                 /* can this user change the password? */
1803                 if ((userAccountControl & UF_PASSWD_CANT_CHANGE) != 0) {
1804                         if (reject_reason) {
1805                                 *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
1806                         }
1807                         return NT_STATUS_PASSWORD_RESTRICTION;
1808                 }
1809
1810                 /* Password minimum age: yes, this is a minus. The ages are in negative 100nsec units! */
1811                 if (pwdLastSet - minPwdAge > now_nt) {
1812                         if (reject_reason) {
1813                                 *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
1814                         }
1815                         return NT_STATUS_PASSWORD_RESTRICTION;
1816                 }
1817
1818                 /* check the immediately past password */
1819                 if (pwdHistoryLength > 0) {
1820                         if (lmNewHash && lmPwdHash && memcmp(lmNewHash->hash,
1821                                         lmPwdHash->hash, 16) == 0) {
1822                                 if (reject_reason) {
1823                                         *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
1824                                 }
1825                                 return NT_STATUS_PASSWORD_RESTRICTION;
1826                         }
1827                         if (ntNewHash && ntPwdHash && memcmp(ntNewHash->hash,
1828                                         ntPwdHash->hash, 16) == 0) {
1829                                 if (reject_reason) {
1830                                         *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
1831                                 }
1832                                 return NT_STATUS_PASSWORD_RESTRICTION;
1833                         }
1834                 }
1835
1836                 /* check the password history */
1837                 sambaLMPwdHistory_len = MIN(sambaLMPwdHistory_len,
1838                                                         pwdHistoryLength);
1839                 sambaNTPwdHistory_len = MIN(sambaNTPwdHistory_len,
1840                                                         pwdHistoryLength);
1841
1842                 for (i=0; lmNewHash && i<sambaLMPwdHistory_len;i++) {
1843                         if (memcmp(lmNewHash->hash, sambaLMPwdHistory[i].hash,
1844                                         16) == 0) {
1845                                 if (reject_reason) {
1846                                         *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
1847                                 }
1848                                 return NT_STATUS_PASSWORD_RESTRICTION;
1849                         }
1850                 }
1851                 for (i=0; ntNewHash && i<sambaNTPwdHistory_len;i++) {
1852                         if (memcmp(ntNewHash->hash, sambaNTPwdHistory[i].hash,
1853                                          16) == 0) {
1854                                 if (reject_reason) {
1855                                         *reject_reason = SAM_PWD_CHANGE_PWD_IN_HISTORY;
1856                                 }
1857                                 return NT_STATUS_PASSWORD_RESTRICTION;
1858                         }
1859                 }
1860         }
1861
1862 #define CHECK_RET(x) do { if (x != 0) return NT_STATUS_NO_MEMORY; } while(0)
1863
1864         /* the password is acceptable. Start forming the new fields */
1865         if (new_password != NULL) {
1866                 /* if we know the cleartext UTF16 password, then set it.
1867                  * Modules in ldb will set all the appropriate
1868                  * hashes */
1869                 CHECK_RET(ldb_msg_add_value(mod, "clearTextPassword", new_password, NULL));
1870         } else {
1871                 /* We don't have the cleartext, so delete the old one
1872                  * and set what we have of the hashes */
1873                 CHECK_RET(samdb_msg_add_delete(ctx, mem_ctx, mod, "clearTextPassword"));
1874
1875                 if (lmNewHash) {
1876                         CHECK_RET(samdb_msg_add_hash(ctx, mem_ctx, mod, "dBCSPwd", lmNewHash));
1877                 } else {
1878                         CHECK_RET(samdb_msg_add_delete(ctx, mem_ctx, mod, "dBCSPwd"));
1879                 }
1880
1881                 if (ntNewHash) {
1882                         CHECK_RET(samdb_msg_add_hash(ctx, mem_ctx, mod, "unicodePwd", ntNewHash));
1883                 } else {
1884                         CHECK_RET(samdb_msg_add_delete(ctx, mem_ctx, mod, "unicodePwd"));
1885                 }
1886         }
1887
1888         if (reject_reason) {
1889                 *reject_reason = SAM_PWD_CHANGE_NO_ERROR;
1890         }
1891         return NT_STATUS_OK;
1892 }
1893
1894
1895 /*
1896  * Sets the user password using plaintext UTF16 (attribute "new_password") or
1897  * LM (attribute "lmNewHash") or NT (attribute "ntNewHash") hash. Also pass
1898  * as parameter if it's a user change or not ("userChange"). The "rejectReason"
1899  * gives some more informations if the changed failed.
1900  *
1901  * This wrapper function for "samdb_set_password" takes a SID as input rather
1902  * than a user DN.
1903  *
1904  * This call encapsulates a new LDB transaction for changing the password;
1905  * therefore the user hasn't to start a new one.
1906  *
1907  * Results: NT_STATUS_OK, NT_STATUS_INTERNAL_DB_CORRUPTION,
1908  *   NT_STATUS_INVALID_PARAMETER, NT_STATUS_UNSUCCESSFUL,
1909  *   NT_STATUS_PASSWORD_RESTRICTION
1910  */
1911 NTSTATUS samdb_set_password_sid(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
1912                                 const struct dom_sid *user_sid,
1913                                 const DATA_BLOB *new_password,
1914                                 struct samr_Password *lmNewHash, 
1915                                 struct samr_Password *ntNewHash,
1916                                 bool user_change,
1917                                 enum samPwdChangeReason *reject_reason,
1918                                 struct samr_DomInfo1 **_dominfo) 
1919 {
1920         NTSTATUS nt_status;
1921         struct ldb_dn *user_dn;
1922         struct ldb_message *msg;
1923         int ret;
1924
1925         ret = ldb_transaction_start(ldb);
1926         if (ret != LDB_SUCCESS) {
1927                 DEBUG(1, ("Failed to start transaction: %s\n", ldb_errstring(ldb)));
1928                 return NT_STATUS_TRANSACTION_ABORTED;
1929         }
1930
1931         user_dn = samdb_search_dn(ldb, mem_ctx, NULL,
1932                                   "(&(objectSid=%s)(objectClass=user))", 
1933                                   ldap_encode_ndr_dom_sid(mem_ctx, user_sid));
1934         if (!user_dn) {
1935                 ldb_transaction_cancel(ldb);
1936                 DEBUG(3, ("samdb_set_password_sid: SID %s not found in samdb, returning NO_SUCH_USER\n",
1937                           dom_sid_string(mem_ctx, user_sid)));
1938                 return NT_STATUS_NO_SUCH_USER;
1939         }
1940
1941         msg = ldb_msg_new(mem_ctx);
1942         if (msg == NULL) {
1943                 ldb_transaction_cancel(ldb);
1944                 return NT_STATUS_NO_MEMORY;
1945         }
1946
1947         msg->dn = ldb_dn_copy(msg, user_dn);
1948         if (!msg->dn) {
1949                 ldb_transaction_cancel(ldb);
1950                 return NT_STATUS_NO_MEMORY;
1951         }
1952
1953         nt_status = samdb_set_password(ldb, mem_ctx,
1954                                        user_dn, NULL,
1955                                        msg, new_password,
1956                                        lmNewHash, ntNewHash,
1957                                        user_change, /* This is a password set, not change */
1958                                        reject_reason, _dominfo);
1959         if (!NT_STATUS_IS_OK(nt_status)) {
1960                 ldb_transaction_cancel(ldb);
1961                 return nt_status;
1962         }
1963
1964         /* modify the samdb record */
1965         ret = samdb_replace(ldb, mem_ctx, msg);
1966         if (ret != LDB_SUCCESS) {
1967                 ldb_transaction_cancel(ldb);
1968                 return NT_STATUS_ACCESS_DENIED;
1969         }
1970
1971         ret = ldb_transaction_commit(ldb);
1972         if (ret != LDB_SUCCESS) {
1973                 DEBUG(0,("Failed to commit transaction to change password on %s: %s\n",
1974                          ldb_dn_get_linearized(msg->dn),
1975                          ldb_errstring(ldb)));
1976                 return NT_STATUS_TRANSACTION_ABORTED;
1977         }
1978         return NT_STATUS_OK;
1979 }
1980
1981
1982 NTSTATUS samdb_create_foreign_security_principal(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, 
1983                                                  struct dom_sid *sid, struct ldb_dn **ret_dn) 
1984 {
1985         struct ldb_message *msg;
1986         struct ldb_dn *basedn;
1987         const char *sidstr;
1988         int ret;
1989
1990         sidstr = dom_sid_string(mem_ctx, sid);
1991         NT_STATUS_HAVE_NO_MEMORY(sidstr);
1992
1993         /* We might have to create a ForeignSecurityPrincipal, even if this user
1994          * is in our own domain */
1995
1996         msg = ldb_msg_new(mem_ctx);
1997         if (msg == NULL) {
1998                 return NT_STATUS_NO_MEMORY;
1999         }
2000
2001         /* TODO: Hmmm. This feels wrong. How do I find the base dn to
2002          * put the ForeignSecurityPrincipals? d_state->domain_dn does
2003          * not work, this is wrong for the Builtin domain, there's no
2004          * cn=For...,cn=Builtin,dc={BASEDN}.  -- vl
2005          */
2006
2007         basedn = samdb_search_dn(sam_ctx, mem_ctx, NULL,
2008                                  "(&(objectClass=container)(cn=ForeignSecurityPrincipals))");
2009
2010         if (basedn == NULL) {
2011                 DEBUG(0, ("Failed to find DN for "
2012                           "ForeignSecurityPrincipal container\n"));
2013                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2014         }
2015
2016         /* add core elements to the ldb_message for the alias */
2017         msg->dn = ldb_dn_copy(mem_ctx, basedn);
2018         if ( ! ldb_dn_add_child_fmt(msg->dn, "CN=%s", sidstr))
2019                 return NT_STATUS_NO_MEMORY;
2020
2021         samdb_msg_add_string(sam_ctx, mem_ctx, msg,
2022                              "objectClass",
2023                              "foreignSecurityPrincipal");
2024
2025         /* create the alias */
2026         ret = ldb_add(sam_ctx, msg);
2027         if (ret != 0) {
2028                 DEBUG(0,("Failed to create foreignSecurityPrincipal "
2029                          "record %s: %s\n", 
2030                          ldb_dn_get_linearized(msg->dn),
2031                          ldb_errstring(sam_ctx)));
2032                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2033         }
2034         *ret_dn = msg->dn;
2035         return NT_STATUS_OK;
2036 }
2037
2038
2039 /*
2040   Find the DN of a domain, assuming it to be a dotted.dns name
2041 */
2042
2043 struct ldb_dn *samdb_dns_domain_to_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *dns_domain) 
2044 {
2045         int i;
2046         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
2047         const char *binary_encoded;
2048         const char **split_realm;
2049         struct ldb_dn *dn;
2050
2051         if (!tmp_ctx) {
2052                 return NULL;
2053         }
2054
2055         split_realm = (const char **)str_list_make(tmp_ctx, dns_domain, ".");
2056         if (!split_realm) {
2057                 talloc_free(tmp_ctx);
2058                 return NULL;
2059         }
2060         dn = ldb_dn_new(mem_ctx, ldb, NULL);
2061         for (i=0; split_realm[i]; i++) {
2062                 binary_encoded = ldb_binary_encode_string(tmp_ctx, split_realm[i]);
2063                 if (!ldb_dn_add_base_fmt(dn, "dc=%s", binary_encoded)) {
2064                         DEBUG(2, ("Failed to add dc=%s element to DN %s\n",
2065                                   binary_encoded, ldb_dn_get_linearized(dn)));
2066                         talloc_free(tmp_ctx);
2067                         return NULL;
2068                 }
2069         }
2070         if (!ldb_dn_validate(dn)) {
2071                 DEBUG(2, ("Failed to validated DN %s\n",
2072                           ldb_dn_get_linearized(dn)));
2073                 return NULL;
2074         }
2075         return dn;
2076 }
2077 /*
2078   Find the DN of a domain, be it the netbios or DNS name 
2079 */
2080
2081 struct ldb_dn *samdb_domain_to_dn(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, 
2082                                   const char *domain_name) 
2083 {
2084         const char * const domain_ref_attrs[] = {
2085                 "ncName", NULL
2086         };
2087         const char * const domain_ref2_attrs[] = {
2088                 NULL
2089         };
2090         struct ldb_result *res_domain_ref;
2091         char *escaped_domain = ldb_binary_encode_string(mem_ctx, domain_name);
2092         /* find the domain's DN */
2093         int ret_domain = ldb_search(ldb, mem_ctx,
2094                                             &res_domain_ref, 
2095                                             samdb_partitions_dn(ldb, mem_ctx), 
2096                                             LDB_SCOPE_ONELEVEL, 
2097                                             domain_ref_attrs,
2098                                             "(&(nETBIOSName=%s)(objectclass=crossRef))", 
2099                                             escaped_domain);
2100         if (ret_domain != 0) {
2101                 return NULL;
2102         }
2103
2104         if (res_domain_ref->count == 0) {
2105                 ret_domain = ldb_search(ldb, mem_ctx,
2106                                                 &res_domain_ref, 
2107                                                 samdb_dns_domain_to_dn(ldb, mem_ctx, domain_name),
2108                                                 LDB_SCOPE_BASE,
2109                                                 domain_ref2_attrs,
2110                                                 "(objectclass=domain)");
2111                 if (ret_domain != 0) {
2112                         return NULL;
2113                 }
2114
2115                 if (res_domain_ref->count == 1) {
2116                         return res_domain_ref->msgs[0]->dn;
2117                 }
2118                 return NULL;
2119         }
2120
2121         if (res_domain_ref->count > 1) {
2122                 DEBUG(0,("Found %d records matching domain [%s]\n", 
2123                          ret_domain, domain_name));
2124                 return NULL;
2125         }
2126
2127         return samdb_result_dn(ldb, mem_ctx, res_domain_ref->msgs[0], "nCName", NULL);
2128
2129 }
2130
2131
2132 /*
2133   use a GUID to find a DN
2134  */
2135 int dsdb_find_dn_by_guid(struct ldb_context *ldb, 
2136                          TALLOC_CTX *mem_ctx,
2137                          const char *guid_str, struct ldb_dn **dn)
2138 {
2139         int ret;
2140         struct ldb_result *res;
2141         const char *attrs[] = { NULL };
2142         struct ldb_request *search_req;
2143         char *expression;
2144         struct ldb_search_options_control *options;
2145
2146         expression = talloc_asprintf(mem_ctx, "objectGUID=%s", guid_str);
2147         if (!expression) {
2148                 DEBUG(0, (__location__ ": out of memory\n"));
2149                 return LDB_ERR_OPERATIONS_ERROR;
2150         }
2151
2152         res = talloc_zero(mem_ctx, struct ldb_result);
2153         if (!res) {
2154                 DEBUG(0, (__location__ ": out of memory\n"));
2155                 return LDB_ERR_OPERATIONS_ERROR;
2156         }
2157
2158         ret = ldb_build_search_req(&search_req, ldb, mem_ctx,
2159                                    ldb_get_default_basedn(ldb),
2160                                    LDB_SCOPE_SUBTREE,
2161                                    expression, attrs,
2162                                    NULL,
2163                                    res, ldb_search_default_callback,
2164                                    NULL);
2165         if (ret != LDB_SUCCESS) {
2166                 return ret;
2167         }
2168
2169         /* we need to cope with cross-partition links, so search for
2170            the GUID over all partitions */
2171         options = talloc(search_req, struct ldb_search_options_control);
2172         if (options == NULL) {
2173                 DEBUG(0, (__location__ ": out of memory\n"));
2174                 return LDB_ERR_OPERATIONS_ERROR;
2175         }
2176         options->search_options = LDB_SEARCH_OPTION_PHANTOM_ROOT;
2177
2178         ret = ldb_request_add_control(search_req, LDB_CONTROL_EXTENDED_DN_OID, true, NULL);
2179         if (ret != LDB_SUCCESS) {
2180                 return ret;
2181         }
2182
2183         ret = ldb_request_add_control(search_req,
2184                                       LDB_CONTROL_SEARCH_OPTIONS_OID,
2185                                       true, options);
2186         if (ret != LDB_SUCCESS) {
2187                 return ret;
2188         }
2189
2190         ret = ldb_request(ldb, search_req);
2191         if (ret != LDB_SUCCESS) {
2192                 return ret;
2193         }
2194
2195         ret = ldb_wait(search_req->handle, LDB_WAIT_ALL);
2196         if (ret != LDB_SUCCESS) {
2197                 return ret;
2198         }
2199
2200         /* this really should be exactly 1, but there is a bug in the
2201            partitions module that can return two here with the
2202            search_options control set */
2203         if (res->count < 1) {
2204                 return LDB_ERR_NO_SUCH_OBJECT;
2205         }
2206
2207         *dn = res->msgs[0]->dn;
2208
2209         return LDB_SUCCESS;
2210 }
2211
2212 /*
2213   search for attrs on one DN, allowing for deleted objects
2214  */
2215 int dsdb_search_dn_with_deleted(struct ldb_context *ldb,
2216                                 TALLOC_CTX *mem_ctx,
2217                                 struct ldb_result **_res,
2218                                 struct ldb_dn *basedn,
2219                                 const char * const *attrs)
2220 {
2221         int ret;
2222         struct ldb_request *req;
2223         TALLOC_CTX *tmp_ctx;
2224         struct ldb_result *res;
2225
2226         tmp_ctx = talloc_new(mem_ctx);
2227
2228         res = talloc_zero(tmp_ctx, struct ldb_result);
2229         if (!res) {
2230                 return LDB_ERR_OPERATIONS_ERROR;
2231         }
2232
2233         ret = ldb_build_search_req(&req, ldb, tmp_ctx,
2234                                    basedn,
2235                                    LDB_SCOPE_BASE,
2236                                    NULL,
2237                                    attrs,
2238                                    NULL,
2239                                    res,
2240                                    ldb_search_default_callback,
2241                                    NULL);
2242         if (ret != LDB_SUCCESS) {
2243                 talloc_free(tmp_ctx);
2244                 return ret;
2245         }
2246
2247         ret = ldb_request_add_control(req, LDB_CONTROL_SHOW_DELETED_OID, true, NULL);
2248         if (ret != LDB_SUCCESS) {
2249                 return ret;
2250         }
2251
2252         ret = ldb_request(ldb, req);
2253         if (ret == LDB_SUCCESS) {
2254                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
2255         }
2256
2257         talloc_free(req);
2258         *_res = talloc_steal(mem_ctx, res);
2259         return ret;
2260 }
2261
2262
2263 /*
2264   use a DN to find a GUID
2265  */
2266 int dsdb_find_guid_by_dn(struct ldb_context *ldb, 
2267                          struct ldb_dn *dn, struct GUID *guid)
2268 {
2269         int ret;
2270         struct ldb_result *res;
2271         const char *attrs[] = { "objectGUID", NULL };
2272         TALLOC_CTX *tmp_ctx = talloc_new(ldb);
2273
2274         ret = dsdb_search_dn_with_deleted(ldb, tmp_ctx, &res, dn, attrs);
2275         if (ret != LDB_SUCCESS) {
2276                 talloc_free(tmp_ctx);
2277                 return ret;
2278         }
2279         if (res->count < 1) {
2280                 talloc_free(tmp_ctx);
2281                 return LDB_ERR_NO_SUCH_OBJECT;
2282         }
2283         *guid = samdb_result_guid(res->msgs[0], "objectGUID");
2284         talloc_free(tmp_ctx);
2285         return LDB_SUCCESS;
2286 }
2287
2288
2289
2290 /*
2291  adds the given GUID to the given ldb_message. This value is added
2292  for the given attr_name (may be either "objectGUID" or "parentGUID").
2293  */
2294 int dsdb_msg_add_guid(struct ldb_message *msg,
2295                 struct GUID *guid,
2296                 const char *attr_name)
2297 {
2298         int ret;
2299         enum ndr_err_code ndr_err;
2300         struct ldb_val v;
2301
2302         TALLOC_CTX *tmp_ctx =  talloc_init("dsdb_msg_add_guid");
2303
2304         ndr_err = ndr_push_struct_blob(&v, tmp_ctx, NULL,
2305                                        guid,
2306                                        (ndr_push_flags_fn_t)ndr_push_GUID);
2307
2308         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2309                 ret = LDB_ERR_OPERATIONS_ERROR;
2310                 goto done;
2311         }
2312
2313         ret = ldb_msg_add_steal_value(msg, attr_name, &v);
2314         if (ret != LDB_SUCCESS) {
2315                 DEBUG(4,(__location__ ": Failed to add %s to the message\n",
2316                                          attr_name));
2317                 goto done;
2318         }
2319
2320         ret = LDB_SUCCESS;
2321
2322 done:
2323         talloc_free(tmp_ctx);
2324         return ret;
2325
2326 }
2327
2328
2329 /*
2330   use a DN to find a SID
2331  */
2332 int dsdb_find_sid_by_dn(struct ldb_context *ldb, 
2333                         struct ldb_dn *dn, struct dom_sid *sid)
2334 {
2335         int ret;
2336         struct ldb_result *res;
2337         const char *attrs[] = { "objectSID", NULL };
2338         TALLOC_CTX *tmp_ctx = talloc_new(ldb);
2339         struct dom_sid *s;
2340
2341         ZERO_STRUCTP(sid);
2342
2343         ret = dsdb_search_dn_with_deleted(ldb, tmp_ctx, &res, dn, attrs);
2344         if (ret != LDB_SUCCESS) {
2345                 talloc_free(tmp_ctx);
2346                 return ret;
2347         }
2348         if (res->count < 1) {
2349                 talloc_free(tmp_ctx);
2350                 return LDB_ERR_NO_SUCH_OBJECT;
2351         }
2352         s = samdb_result_dom_sid(tmp_ctx, res->msgs[0], "objectSID");
2353         if (s == NULL) {
2354                 talloc_free(tmp_ctx);
2355                 return LDB_ERR_NO_SUCH_OBJECT;
2356         }
2357         *sid = *s;
2358         talloc_free(tmp_ctx);
2359         return LDB_SUCCESS;
2360 }
2361
2362
2363
2364 /*
2365   load a repsFromTo blob list for a given partition GUID
2366   attr must be "repsFrom" or "repsTo"
2367  */
2368 WERROR dsdb_loadreps(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, struct ldb_dn *dn,
2369                      const char *attr, struct repsFromToBlob **r, uint32_t *count)
2370 {
2371         const char *attrs[] = { attr, NULL };
2372         struct ldb_result *res = NULL;
2373         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
2374         int i;
2375         struct ldb_message_element *el;
2376
2377         *r = NULL;
2378         *count = 0;
2379
2380         if (ldb_search(sam_ctx, tmp_ctx, &res, dn, LDB_SCOPE_BASE, attrs, NULL) != LDB_SUCCESS ||
2381             res->count < 1) {
2382                 DEBUG(0,("dsdb_loadreps: failed to read partition object\n"));
2383                 talloc_free(tmp_ctx);
2384                 return WERR_DS_DRA_INTERNAL_ERROR;
2385         }
2386
2387         el = ldb_msg_find_element(res->msgs[0], attr);
2388         if (el == NULL) {
2389                 /* it's OK to be empty */
2390                 talloc_free(tmp_ctx);
2391                 return WERR_OK;
2392         }
2393
2394         *count = el->num_values;
2395         *r = talloc_array(mem_ctx, struct repsFromToBlob, *count);
2396         if (*r == NULL) {
2397                 talloc_free(tmp_ctx);
2398                 return WERR_DS_DRA_INTERNAL_ERROR;
2399         }
2400
2401         for (i=0; i<(*count); i++) {
2402                 enum ndr_err_code ndr_err;
2403                 ndr_err = ndr_pull_struct_blob(&el->values[i], 
2404                                                mem_ctx, lp_iconv_convenience(ldb_get_opaque(sam_ctx, "loadparm")),
2405                                                &(*r)[i], 
2406                                                (ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
2407                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2408                         talloc_free(tmp_ctx);
2409                         return WERR_DS_DRA_INTERNAL_ERROR;
2410                 }
2411         }
2412
2413         talloc_free(tmp_ctx);
2414         
2415         return WERR_OK;
2416 }
2417
2418 /*
2419   save the repsFromTo blob list for a given partition GUID
2420   attr must be "repsFrom" or "repsTo"
2421  */
2422 WERROR dsdb_savereps(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx, struct ldb_dn *dn,
2423                      const char *attr, struct repsFromToBlob *r, uint32_t count)
2424 {
2425         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
2426         struct ldb_message *msg;
2427         struct ldb_message_element *el;
2428         int i;
2429
2430         msg = ldb_msg_new(tmp_ctx);
2431         msg->dn = dn;
2432         if (ldb_msg_add_empty(msg, attr, LDB_FLAG_MOD_REPLACE, &el) != LDB_SUCCESS) {
2433                 goto failed;
2434         }
2435
2436         el->values = talloc_array(msg, struct ldb_val, count);
2437         if (!el->values) {
2438                 goto failed;
2439         }
2440
2441         for (i=0; i<count; i++) {
2442                 struct ldb_val v;
2443                 enum ndr_err_code ndr_err;
2444
2445                 ndr_err = ndr_push_struct_blob(&v, tmp_ctx, lp_iconv_convenience(ldb_get_opaque(sam_ctx, "loadparm")),
2446                                                &r[i], 
2447                                                (ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
2448                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2449                         goto failed;
2450                 }
2451
2452                 el->num_values++;
2453                 el->values[i] = v;
2454         }
2455
2456         if (ldb_modify(sam_ctx, msg) != LDB_SUCCESS) {
2457                 DEBUG(0,("Failed to store %s - %s\n", attr, ldb_errstring(sam_ctx)));
2458                 goto failed;
2459         }
2460
2461         talloc_free(tmp_ctx);
2462         
2463         return WERR_OK;
2464
2465 failed:
2466         talloc_free(tmp_ctx);
2467         return WERR_DS_DRA_INTERNAL_ERROR;
2468 }
2469
2470
2471 /*
2472   load the uSNHighest attribute from the @REPLCHANGED object for a
2473   partition
2474  */
2475 int dsdb_load_partition_usn(struct ldb_context *ldb, struct ldb_dn *dn, uint64_t *uSN)
2476 {
2477         struct ldb_request *req;
2478         int ret;
2479         TALLOC_CTX *tmp_ctx = talloc_new(ldb);
2480         struct dsdb_control_current_partition *p_ctrl;
2481         struct ldb_result *res;
2482
2483         res = talloc_zero(tmp_ctx, struct ldb_result);
2484         if (!res) {
2485                 talloc_free(tmp_ctx);
2486                 return LDB_ERR_OPERATIONS_ERROR;
2487         }
2488
2489         ret = ldb_build_search_req(&req, ldb, tmp_ctx,
2490                                    ldb_dn_new(tmp_ctx, ldb, "@REPLCHANGED"),
2491                                    LDB_SCOPE_BASE,
2492                                    NULL, NULL,
2493                                    NULL,
2494                                    res, ldb_search_default_callback,
2495                                    NULL);
2496         if (ret != LDB_SUCCESS) {
2497                 talloc_free(tmp_ctx);
2498                 return ret;
2499         }
2500
2501         p_ctrl = talloc(req, struct dsdb_control_current_partition);
2502         if (p_ctrl == NULL) {
2503                 talloc_free(res);
2504                 return LDB_ERR_OPERATIONS_ERROR;
2505         }
2506         p_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
2507         p_ctrl->dn = dn;
2508         
2509
2510         ret = ldb_request_add_control(req,
2511                                       DSDB_CONTROL_CURRENT_PARTITION_OID,
2512                                       false, p_ctrl);
2513         if (ret != LDB_SUCCESS) {
2514                 talloc_free(tmp_ctx);
2515                 return ret;
2516         }
2517         
2518         /* Run the new request */
2519         ret = ldb_request(ldb, req);
2520         
2521         if (ret == LDB_SUCCESS) {
2522                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
2523         }
2524
2525         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
2526                 /* it hasn't been created yet, which means
2527                    an implicit value of zero */
2528                 *uSN = 0;
2529                 talloc_free(tmp_ctx);
2530                 return LDB_SUCCESS;
2531         }
2532
2533         if (ret != LDB_SUCCESS) {
2534                 talloc_free(tmp_ctx);
2535                 return ret;
2536         }
2537
2538         if (res->count < 1) {
2539                 *uSN = 0;
2540         } else {
2541                 *uSN = ldb_msg_find_attr_as_uint64(res->msgs[0], "uSNHighest", 0);
2542         }
2543
2544         talloc_free(tmp_ctx);
2545
2546         return LDB_SUCCESS;     
2547 }
2548
2549 /*
2550   save the uSNHighest attribute in the @REPLCHANGED object for a
2551   partition
2552  */
2553 int dsdb_save_partition_usn(struct ldb_context *ldb, struct ldb_dn *dn, uint64_t uSN)
2554 {
2555         struct ldb_request *req;
2556         struct ldb_message *msg;
2557         struct dsdb_control_current_partition *p_ctrl;
2558         int ret;
2559
2560         msg = ldb_msg_new(ldb);
2561         if (msg == NULL) {
2562                 return LDB_ERR_OPERATIONS_ERROR;
2563         }
2564
2565         msg->dn = ldb_dn_new(msg, ldb, "@REPLCHANGED");
2566         if (msg->dn == NULL) {
2567                 talloc_free(msg);
2568                 return LDB_ERR_OPERATIONS_ERROR;
2569         }
2570         
2571         ret = ldb_msg_add_fmt(msg, "uSNHighest", "%llu", (unsigned long long)uSN);
2572         if (ret != LDB_SUCCESS) {
2573                 talloc_free(msg);
2574                 return ret;
2575         }
2576         msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
2577         
2578
2579         p_ctrl = talloc(msg, struct dsdb_control_current_partition);
2580         if (p_ctrl == NULL) {
2581                 talloc_free(msg);
2582                 return LDB_ERR_OPERATIONS_ERROR;
2583         }
2584         p_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
2585         p_ctrl->dn = dn;
2586
2587         ret = ldb_build_mod_req(&req, ldb, msg,
2588                                 msg,
2589                                 NULL,
2590                                 NULL, ldb_op_default_callback,
2591                                 NULL);
2592 again:
2593         if (ret != LDB_SUCCESS) {
2594                 talloc_free(msg);
2595                 return ret;
2596         }
2597         
2598         ret = ldb_request_add_control(req,
2599                                       DSDB_CONTROL_CURRENT_PARTITION_OID,
2600                                       false, p_ctrl);
2601         if (ret != LDB_SUCCESS) {
2602                 talloc_free(msg);
2603                 return ret;
2604         }
2605         
2606         /* Run the new request */
2607         ret = ldb_request(ldb, req);
2608         
2609         if (ret == LDB_SUCCESS) {
2610                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
2611         }
2612         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
2613                 ret = ldb_build_add_req(&req, ldb, msg,
2614                                         msg,
2615                                         NULL,
2616                                         NULL, ldb_op_default_callback,
2617                                         NULL);
2618                 goto again;
2619         }
2620         
2621         talloc_free(msg);
2622         
2623         return ret;
2624 }
2625
2626 int drsuapi_DsReplicaCursor2_compare(const struct drsuapi_DsReplicaCursor2 *c1,
2627                                                    const struct drsuapi_DsReplicaCursor2 *c2)
2628 {
2629         return GUID_compare(&c1->source_dsa_invocation_id, &c2->source_dsa_invocation_id);
2630 }
2631
2632 /*
2633   see if we are a RODC
2634
2635   TODO: This should take a sam_ctx, and lookup the right object (with
2636   a cache)
2637 */
2638 bool samdb_rodc(struct loadparm_context *lp_ctx)
2639 {
2640         return lp_parm_bool(lp_ctx, NULL, "repl", "RODC", false);
2641 }
2642
2643
2644 /*
2645   return NTDS options flags. See MS-ADTS 7.1.1.2.2.1.2.1.1 
2646
2647   flags are DS_NTDS_OPTION_*
2648 */
2649 int samdb_ntds_options(struct ldb_context *ldb, uint32_t *options)
2650 {
2651         TALLOC_CTX *tmp_ctx;
2652         const char *attrs[] = { "options", NULL };
2653         int ret;
2654         struct ldb_result *res;
2655
2656         tmp_ctx = talloc_new(ldb);
2657         if (tmp_ctx == NULL) {
2658                 goto failed;
2659         }
2660
2661         ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
2662         if (ret) {
2663                 goto failed;
2664         }
2665
2666         if (res->count != 1) {
2667                 goto failed;
2668         }
2669
2670         *options = samdb_result_uint(res->msgs[0], "options", 0);
2671
2672         talloc_free(tmp_ctx);
2673
2674         return LDB_SUCCESS;
2675
2676 failed:
2677         DEBUG(1,("Failed to find our own NTDS Settings objectGUID in the ldb!\n"));
2678         talloc_free(tmp_ctx);
2679         return LDB_ERR_NO_SUCH_OBJECT;
2680 }
2681
2682 /*
2683  * Function which generates a "lDAPDisplayName" attribute from a "CN" one.
2684  * Algorithm implemented according to MS-ADTS 3.1.1.2.3.4
2685  */
2686 const char *samdb_cn_to_lDAPDisplayName(TALLOC_CTX *mem_ctx, const char *cn)
2687 {
2688         char **tokens, *ret;
2689         size_t i;
2690
2691         tokens = str_list_make(mem_ctx, cn, " -_");
2692         if (tokens == NULL)
2693                 return NULL;
2694
2695         /* "tolower()" and "toupper()" should also work properly on 0x00 */
2696         tokens[0][0] = tolower(tokens[0][0]);
2697         for (i = 1; i < str_list_length((const char **)tokens); i++)
2698                 tokens[i][0] = toupper(tokens[i][0]);
2699
2700         ret = talloc_strdup(mem_ctx, tokens[0]);
2701         for (i = 1; i < str_list_length((const char **)tokens); i++)
2702                 ret = talloc_asprintf_append_buffer(ret, "%s", tokens[i]);
2703
2704         talloc_free(tokens);
2705
2706         return ret;
2707 }
2708
2709 /*
2710   return domain functional level
2711   returns DS_DOMAIN_FUNCTION_*
2712  */
2713 int dsdb_functional_level(struct ldb_context *ldb)
2714 {
2715         int *domainFunctionality =
2716                 talloc_get_type(ldb_get_opaque(ldb, "domainFunctionality"), int);
2717         if (!domainFunctionality) {
2718                 DEBUG(0,(__location__ ": WARNING: domainFunctionality not setup\n"));
2719                 return DS_DOMAIN_FUNCTION_2000;
2720         }
2721         return *domainFunctionality;
2722 }
2723
2724 /*
2725   return a GUID from a extended DN structure
2726  */
2727 NTSTATUS dsdb_get_extended_dn_guid(struct ldb_dn *dn, struct GUID *guid)
2728 {
2729         const struct ldb_val *v;
2730
2731         v = ldb_dn_get_extended_component(dn, "GUID");
2732         if (v == NULL) {
2733                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2734         }
2735
2736         return GUID_from_ndr_blob(v, guid);
2737 }