?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbldap: Fix typo in debug message.
[Samba.git] / source / libnet / libnet_samsync_ldif.c
blobc89fedc2a3582f77d2aa6ea25714e1b02bf133e6
1 /*
2 Unix SMB/CIFS implementation.
3 dump the remote SAM using rpc samsync operations
4
5 Copyright (C) Andrew Tridgell 2002
6 Copyright (C) Tim Potter 2001,2002
7 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
8 Modified by Volker Lendecke 2002
9 Copyright (C) Jeremy Allison 2005.
10 Copyright (C) Guenther Deschner 2008.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "libnet/libnet_samsync.h"
28
29 /* uid's and gid's for writing deltas to ldif */
30 static uint32 ldif_gid = 999;
31 static uint32 ldif_uid = 999;
32
33 /* Structure for mapping accounts to groups */
34 /* Array element is the group rid */
35 typedef struct _groupmap {
36 uint32_t rid;
37 uint32_t gidNumber;
38 const char *sambaSID;
39 const char *group_dn;
40 } GROUPMAP;
41
42 typedef struct _accountmap {
43 uint32_t rid;
44 const char *cn;
45 } ACCOUNTMAP;
46
47 struct samsync_ldif_context {
48 GROUPMAP *groupmap;
49 ACCOUNTMAP *accountmap;
50 bool initialized;
51 const char *add_template;
52 const char *mod_template;
53 char *add_name;
54 char *mod_name;
55 FILE *add_file;
56 FILE *mod_file;
57 FILE *ldif_file;
58 const char *suffix;
59 int num_alloced;
60 };
61
62 /****************************************************************
63 ****************************************************************/
64
65 static NTSTATUS populate_ldap_for_ldif(const char *sid,
66 const char *suffix,
67 const char *builtin_sid,
68 FILE *add_fd)
69 {
70 const char *user_suffix, *group_suffix, *machine_suffix, *idmap_suffix;
71 char *user_attr=NULL, *group_attr=NULL;
72 char *suffix_attr;
73 int len;
74
75 /* Get the suffix attribute */
76 suffix_attr = sstring_sub(suffix, '=', ',');
77 if (suffix_attr == NULL) {
78 len = strlen(suffix);
79 suffix_attr = (char*)SMB_MALLOC(len+1);
80 memcpy(suffix_attr, suffix, len);
81 suffix_attr[len] = '\0';
82 }
83
84 /* Write the base */
85 fprintf(add_fd, "# %s\n", suffix);
86 fprintf(add_fd, "dn: %s\n", suffix);
87 fprintf(add_fd, "objectClass: dcObject\n");
88 fprintf(add_fd, "objectClass: organization\n");
89 fprintf(add_fd, "o: %s\n", suffix_attr);
90 fprintf(add_fd, "dc: %s\n", suffix_attr);
91 fprintf(add_fd, "\n");
92 fflush(add_fd);
93
94 user_suffix = lp_ldap_user_suffix();
95 if (user_suffix == NULL) {
96 SAFE_FREE(suffix_attr);
97 return NT_STATUS_NO_MEMORY;
98 }
99 /* If it exists and is distinct from other containers,
100 Write the Users entity */
101 if (*user_suffix && strcmp(user_suffix, suffix)) {
102 user_attr = sstring_sub(lp_ldap_user_suffix(), '=', ',');
103 fprintf(add_fd, "# %s\n", user_suffix);
104 fprintf(add_fd, "dn: %s\n", user_suffix);
105 fprintf(add_fd, "objectClass: organizationalUnit\n");
106 fprintf(add_fd, "ou: %s\n", user_attr);
107 fprintf(add_fd, "\n");
108 fflush(add_fd);
109 }
110
111
112 group_suffix = lp_ldap_group_suffix();
113 if (group_suffix == NULL) {
114 SAFE_FREE(suffix_attr);
115 SAFE_FREE(user_attr);
116 return NT_STATUS_NO_MEMORY;
117 }
118 /* If it exists and is distinct from other containers,
119 Write the Groups entity */
120 if (*group_suffix && strcmp(group_suffix, suffix)) {
121 group_attr = sstring_sub(lp_ldap_group_suffix(), '=', ',');
122 fprintf(add_fd, "# %s\n", group_suffix);
123 fprintf(add_fd, "dn: %s\n", group_suffix);
124 fprintf(add_fd, "objectClass: organizationalUnit\n");
125 fprintf(add_fd, "ou: %s\n", group_attr);
126 fprintf(add_fd, "\n");
127 fflush(add_fd);
128 }
129
130 /* If it exists and is distinct from other containers,
131 Write the Computers entity */
132 machine_suffix = lp_ldap_machine_suffix();
133 if (machine_suffix == NULL) {
134 SAFE_FREE(suffix_attr);
135 SAFE_FREE(user_attr);
136 SAFE_FREE(group_attr);
137 return NT_STATUS_NO_MEMORY;
138 }
139 if (*machine_suffix && strcmp(machine_suffix, user_suffix) &&
140 strcmp(machine_suffix, suffix)) {
141 char *machine_ou = NULL;
142 fprintf(add_fd, "# %s\n", machine_suffix);
143 fprintf(add_fd, "dn: %s\n", machine_suffix);
144 fprintf(add_fd, "objectClass: organizationalUnit\n");
145 /* this isn't totally correct as it assumes that
146 there _must_ be an ou. just fixing memleak now. jmcd */
147 machine_ou = sstring_sub(lp_ldap_machine_suffix(), '=', ',');
148 fprintf(add_fd, "ou: %s\n", machine_ou);
149 SAFE_FREE(machine_ou);
150 fprintf(add_fd, "\n");
151 fflush(add_fd);
152 }
153
154 /* If it exists and is distinct from other containers,
155 Write the IdMap entity */
156 idmap_suffix = lp_ldap_idmap_suffix();
157 if (idmap_suffix == NULL) {
158 SAFE_FREE(suffix_attr);
159 SAFE_FREE(user_attr);
160 SAFE_FREE(group_attr);
161 return NT_STATUS_NO_MEMORY;
162 }
163 if (*idmap_suffix &&
164 strcmp(idmap_suffix, user_suffix) &&
165 strcmp(idmap_suffix, suffix)) {
166 char *s;
167 fprintf(add_fd, "# %s\n", idmap_suffix);
168 fprintf(add_fd, "dn: %s\n", idmap_suffix);
169 fprintf(add_fd, "ObjectClass: organizationalUnit\n");
170 s = sstring_sub(lp_ldap_idmap_suffix(), '=', ',');
171 fprintf(add_fd, "ou: %s\n", s);
172 SAFE_FREE(s);
173 fprintf(add_fd, "\n");
174 fflush(add_fd);
175 }
176
177 /* Write the domain entity */
178 fprintf(add_fd, "# %s, %s\n", lp_workgroup(), suffix);
179 fprintf(add_fd, "dn: sambaDomainName=%s,%s\n", lp_workgroup(),
180 suffix);
181 fprintf(add_fd, "objectClass: sambaDomain\n");
182 fprintf(add_fd, "objectClass: sambaUnixIdPool\n");
183 fprintf(add_fd, "sambaDomainName: %s\n", lp_workgroup());
184 fprintf(add_fd, "sambaSID: %s\n", sid);
185 fprintf(add_fd, "uidNumber: %d\n", ++ldif_uid);
186 fprintf(add_fd, "gidNumber: %d\n", ++ldif_gid);
187 fprintf(add_fd, "\n");
188 fflush(add_fd);
189
190 /* Write the Domain Admins entity */
191 fprintf(add_fd, "# Domain Admins, %s, %s\n", group_attr,
192 suffix);
193 fprintf(add_fd, "dn: cn=Domain Admins,ou=%s,%s\n", group_attr,
194 suffix);
195 fprintf(add_fd, "objectClass: posixGroup\n");
196 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
197 fprintf(add_fd, "cn: Domain Admins\n");
198 fprintf(add_fd, "memberUid: Administrator\n");
199 fprintf(add_fd, "description: Netbios Domain Administrators\n");
200 fprintf(add_fd, "gidNumber: 512\n");
201 fprintf(add_fd, "sambaSID: %s-512\n", sid);
202 fprintf(add_fd, "sambaGroupType: 2\n");
203 fprintf(add_fd, "displayName: Domain Admins\n");
204 fprintf(add_fd, "\n");
205 fflush(add_fd);
206
207 /* Write the Domain Users entity */
208 fprintf(add_fd, "# Domain Users, %s, %s\n", group_attr,
209 suffix);
210 fprintf(add_fd, "dn: cn=Domain Users,ou=%s,%s\n", group_attr,
211 suffix);
212 fprintf(add_fd, "objectClass: posixGroup\n");
213 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
214 fprintf(add_fd, "cn: Domain Users\n");
215 fprintf(add_fd, "description: Netbios Domain Users\n");
216 fprintf(add_fd, "gidNumber: 513\n");
217 fprintf(add_fd, "sambaSID: %s-513\n", sid);
218 fprintf(add_fd, "sambaGroupType: 2\n");
219 fprintf(add_fd, "displayName: Domain Users\n");
220 fprintf(add_fd, "\n");
221 fflush(add_fd);
222
223 /* Write the Domain Guests entity */
224 fprintf(add_fd, "# Domain Guests, %s, %s\n", group_attr,
225 suffix);
226 fprintf(add_fd, "dn: cn=Domain Guests,ou=%s,%s\n", group_attr,
227 suffix);
228 fprintf(add_fd, "objectClass: posixGroup\n");
229 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
230 fprintf(add_fd, "cn: Domain Guests\n");
231 fprintf(add_fd, "description: Netbios Domain Guests\n");
232 fprintf(add_fd, "gidNumber: 514\n");
233 fprintf(add_fd, "sambaSID: %s-514\n", sid);
234 fprintf(add_fd, "sambaGroupType: 2\n");
235 fprintf(add_fd, "displayName: Domain Guests\n");
236 fprintf(add_fd, "\n");
237 fflush(add_fd);
238
239 /* Write the Domain Computers entity */
240 fprintf(add_fd, "# Domain Computers, %s, %s\n", group_attr,
241 suffix);
242 fprintf(add_fd, "dn: cn=Domain Computers,ou=%s,%s\n",
243 group_attr, suffix);
244 fprintf(add_fd, "objectClass: posixGroup\n");
245 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
246 fprintf(add_fd, "gidNumber: 515\n");
247 fprintf(add_fd, "cn: Domain Computers\n");
248 fprintf(add_fd, "description: Netbios Domain Computers accounts\n");
249 fprintf(add_fd, "sambaSID: %s-515\n", sid);
250 fprintf(add_fd, "sambaGroupType: 2\n");
251 fprintf(add_fd, "displayName: Domain Computers\n");
252 fprintf(add_fd, "\n");
253 fflush(add_fd);
254
255 /* Write the Admininistrators Groups entity */
256 fprintf(add_fd, "# Administrators, %s, %s\n", group_attr,
257 suffix);
258 fprintf(add_fd, "dn: cn=Administrators,ou=%s,%s\n", group_attr,
259 suffix);
260 fprintf(add_fd, "objectClass: posixGroup\n");
261 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
262 fprintf(add_fd, "gidNumber: 544\n");
263 fprintf(add_fd, "cn: Administrators\n");
264 fprintf(add_fd, "description: Netbios Domain Members can fully administer the computer/sambaDomainName\n");
265 fprintf(add_fd, "sambaSID: %s-544\n", builtin_sid);
266 fprintf(add_fd, "sambaGroupType: 5\n");
267 fprintf(add_fd, "displayName: Administrators\n");
268 fprintf(add_fd, "\n");
269
270 /* Write the Print Operator entity */
271 fprintf(add_fd, "# Print Operators, %s, %s\n", group_attr,
272 suffix);
273 fprintf(add_fd, "dn: cn=Print Operators,ou=%s,%s\n",
274 group_attr, suffix);
275 fprintf(add_fd, "objectClass: posixGroup\n");
276 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
277 fprintf(add_fd, "gidNumber: 550\n");
278 fprintf(add_fd, "cn: Print Operators\n");
279 fprintf(add_fd, "description: Netbios Domain Print Operators\n");
280 fprintf(add_fd, "sambaSID: %s-550\n", builtin_sid);
281 fprintf(add_fd, "sambaGroupType: 5\n");
282 fprintf(add_fd, "displayName: Print Operators\n");
283 fprintf(add_fd, "\n");
284 fflush(add_fd);
285
286 /* Write the Backup Operators entity */
287 fprintf(add_fd, "# Backup Operators, %s, %s\n", group_attr,
288 suffix);
289 fprintf(add_fd, "dn: cn=Backup Operators,ou=%s,%s\n",
290 group_attr, suffix);
291 fprintf(add_fd, "objectClass: posixGroup\n");
292 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
293 fprintf(add_fd, "gidNumber: 551\n");
294 fprintf(add_fd, "cn: Backup Operators\n");
295 fprintf(add_fd, "description: Netbios Domain Members can bypass file security to back up files\n");
296 fprintf(add_fd, "sambaSID: %s-551\n", builtin_sid);
297 fprintf(add_fd, "sambaGroupType: 5\n");
298 fprintf(add_fd, "displayName: Backup Operators\n");
299 fprintf(add_fd, "\n");
300 fflush(add_fd);
301
302 /* Write the Replicators entity */
303 fprintf(add_fd, "# Replicators, %s, %s\n", group_attr, suffix);
304 fprintf(add_fd, "dn: cn=Replicators,ou=%s,%s\n", group_attr,
305 suffix);
306 fprintf(add_fd, "objectClass: posixGroup\n");
307 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
308 fprintf(add_fd, "gidNumber: 552\n");
309 fprintf(add_fd, "cn: Replicators\n");
310 fprintf(add_fd, "description: Netbios Domain Supports file replication in a sambaDomainName\n");
311 fprintf(add_fd, "sambaSID: %s-552\n", builtin_sid);
312 fprintf(add_fd, "sambaGroupType: 5\n");
313 fprintf(add_fd, "displayName: Replicators\n");
314 fprintf(add_fd, "\n");
315 fflush(add_fd);
316
317 /* Deallocate memory, and return */
318 SAFE_FREE(suffix_attr);
319 SAFE_FREE(user_attr);
320 SAFE_FREE(group_attr);
321 return NT_STATUS_OK;
322 }
323
324 /****************************************************************
325 ****************************************************************/
326
327 static NTSTATUS map_populate_groups(TALLOC_CTX *mem_ctx,
328 GROUPMAP *groupmap,
329 ACCOUNTMAP *accountmap,
330 const char *sid,
331 const char *suffix,
332 const char *builtin_sid)
333 {
334 char *group_attr = sstring_sub(lp_ldap_group_suffix(), '=', ',');
335
336 /* Map the groups created by populate_ldap_for_ldif */
337 groupmap[0].rid = 512;
338 groupmap[0].gidNumber = 512;
339 groupmap[0].sambaSID = talloc_asprintf(mem_ctx, "%s-512", sid);
340 groupmap[0].group_dn = talloc_asprintf(mem_ctx,
341 "cn=Domain Admins,ou=%s,%s", group_attr, suffix);
342 NT_STATUS_HAVE_NO_MEMORY(groupmap[0].sambaSID);
343 NT_STATUS_HAVE_NO_MEMORY(groupmap[0].group_dn);
344
345 accountmap[0].rid = 512;
346 accountmap[0].cn = talloc_strdup(mem_ctx, "Domain Admins");
347 NT_STATUS_HAVE_NO_MEMORY(accountmap[0].cn);
348
349 groupmap[1].rid = 513;
350 groupmap[1].gidNumber = 513;
351 groupmap[1].sambaSID = talloc_asprintf(mem_ctx, "%s-513", sid);
352 groupmap[1].group_dn = talloc_asprintf(mem_ctx,
353 "cn=Domain Users,ou=%s,%s", group_attr, suffix);
354 NT_STATUS_HAVE_NO_MEMORY(groupmap[1].sambaSID);
355 NT_STATUS_HAVE_NO_MEMORY(groupmap[1].group_dn);
356
357 accountmap[1].rid = 513;
358 accountmap[1].cn = talloc_strdup(mem_ctx, "Domain Users");
359 NT_STATUS_HAVE_NO_MEMORY(accountmap[1].cn);
360
361 groupmap[2].rid = 514;
362 groupmap[2].gidNumber = 514;
363 groupmap[2].sambaSID = talloc_asprintf(mem_ctx, "%s-514", sid);
364 groupmap[2].group_dn = talloc_asprintf(mem_ctx,
365 "cn=Domain Guests,ou=%s,%s", group_attr, suffix);
366 NT_STATUS_HAVE_NO_MEMORY(groupmap[2].sambaSID);
367 NT_STATUS_HAVE_NO_MEMORY(groupmap[2].group_dn);
368
369 accountmap[2].rid = 514;
370 accountmap[2].cn = talloc_strdup(mem_ctx, "Domain Guests");
371 NT_STATUS_HAVE_NO_MEMORY(accountmap[2].cn);
372
373 groupmap[3].rid = 515;
374 groupmap[3].gidNumber = 515;
375 groupmap[3].sambaSID = talloc_asprintf(mem_ctx, "%s-515", sid);
376 groupmap[3].group_dn = talloc_asprintf(mem_ctx,
377 "cn=Domain Computers,ou=%s,%s", group_attr, suffix);
378 NT_STATUS_HAVE_NO_MEMORY(groupmap[3].sambaSID);
379 NT_STATUS_HAVE_NO_MEMORY(groupmap[3].group_dn);
380
381 accountmap[3].rid = 515;
382 accountmap[3].cn = talloc_strdup(mem_ctx, "Domain Computers");
383 NT_STATUS_HAVE_NO_MEMORY(accountmap[3].cn);
384
385 groupmap[4].rid = 544;
386 groupmap[4].gidNumber = 544;
387 groupmap[4].sambaSID = talloc_asprintf(mem_ctx, "%s-544", builtin_sid);
388 groupmap[4].group_dn = talloc_asprintf(mem_ctx,
389 "cn=Administrators,ou=%s,%s", group_attr, suffix);
390 NT_STATUS_HAVE_NO_MEMORY(groupmap[4].sambaSID);
391 NT_STATUS_HAVE_NO_MEMORY(groupmap[4].group_dn);
392
393 accountmap[4].rid = 515;
394 accountmap[4].cn = talloc_strdup(mem_ctx, "Administrators");
395 NT_STATUS_HAVE_NO_MEMORY(accountmap[4].cn);
396
397 groupmap[5].rid = 550;
398 groupmap[5].gidNumber = 550;
399 groupmap[5].sambaSID = talloc_asprintf(mem_ctx, "%s-550", builtin_sid);
400 groupmap[5].group_dn = talloc_asprintf(mem_ctx,
401 "cn=Print Operators,ou=%s,%s", group_attr, suffix);
402 NT_STATUS_HAVE_NO_MEMORY(groupmap[5].sambaSID);
403 NT_STATUS_HAVE_NO_MEMORY(groupmap[5].group_dn);
404
405 accountmap[5].rid = 550;
406 accountmap[5].cn = talloc_strdup(mem_ctx, "Print Operators");
407 NT_STATUS_HAVE_NO_MEMORY(accountmap[5].cn);
408
409 groupmap[6].rid = 551;
410 groupmap[6].gidNumber = 551;
411 groupmap[6].sambaSID = talloc_asprintf(mem_ctx, "%s-551", builtin_sid);
412 groupmap[6].group_dn = talloc_asprintf(mem_ctx,
413 "cn=Backup Operators,ou=%s,%s", group_attr, suffix);
414 NT_STATUS_HAVE_NO_MEMORY(groupmap[6].sambaSID);
415 NT_STATUS_HAVE_NO_MEMORY(groupmap[6].group_dn);
416
417 accountmap[6].rid = 551;
418 accountmap[6].cn = talloc_strdup(mem_ctx, "Backup Operators");
419 NT_STATUS_HAVE_NO_MEMORY(accountmap[6].cn);
420
421 groupmap[7].rid = 552;
422 groupmap[7].gidNumber = 552;
423 groupmap[7].sambaSID = talloc_asprintf(mem_ctx, "%s-552", builtin_sid);
424 groupmap[7].group_dn = talloc_asprintf(mem_ctx,
425 "cn=Replicators,ou=%s,%s", group_attr, suffix);
426 NT_STATUS_HAVE_NO_MEMORY(groupmap[7].sambaSID);
427 NT_STATUS_HAVE_NO_MEMORY(groupmap[7].group_dn);
428
429 accountmap[7].rid = 551;
430 accountmap[7].cn = talloc_strdup(mem_ctx, "Replicators");
431 NT_STATUS_HAVE_NO_MEMORY(accountmap[7].cn);
432
433 SAFE_FREE(group_attr);
434
435 return NT_STATUS_OK;
436 }
437
438 /*
439 * This is a crap routine, but I think it's the quickest way to solve the
440 * UTF8->base64 problem.
441 */
442
443 static int fprintf_attr(FILE *add_fd, const char *attr_name,
444 const char *fmt, ...)
445 {
446 va_list ap;
447 char *value, *p, *base64;
448 DATA_BLOB base64_blob;
449 bool do_base64 = false;
450 int res;
451
452 va_start(ap, fmt);
453 value = talloc_vasprintf(NULL, fmt, ap);
454 va_end(ap);
455
456 SMB_ASSERT(value != NULL);
457
458 for (p=value; *p; p++) {
459 if (*p & 0x80) {
460 do_base64 = true;
461 break;
462 }
463 }
464
465 if (!do_base64) {
466 bool only_whitespace = true;
467 for (p=value; *p; p++) {
468 /*
469 * I know that this not multibyte safe, but we break
470 * on the first non-whitespace character anyway.
471 */
472 if (!isspace(*p)) {
473 only_whitespace = false;
474 break;
475 }
476 }
477 if (only_whitespace) {
478 do_base64 = true;
479 }
480 }
481
482 if (!do_base64) {
483 res = fprintf(add_fd, "%s: %s\n", attr_name, value);
484 TALLOC_FREE(value);
485 return res;
486 }
487
488 base64_blob.data = (unsigned char *)value;
489 base64_blob.length = strlen(value);
490
491 base64 = base64_encode_data_blob(value, base64_blob);
492 SMB_ASSERT(base64 != NULL);
493
494 res = fprintf(add_fd, "%s:: %s\n", attr_name, base64);
495 TALLOC_FREE(value);
496 return res;
497 }
498
499 /****************************************************************
500 ****************************************************************/
501
502 static NTSTATUS fetch_group_info_to_ldif(TALLOC_CTX *mem_ctx,
503 struct netr_DELTA_GROUP *r,
504 GROUPMAP *groupmap,
505 FILE *add_fd,
506 const char *sid,
507 const char *suffix)
508 {
509 const char *groupname = r->group_name.string;
510 uint32 grouptype = 0, g_rid = 0;
511 char *group_attr = sstring_sub(lp_ldap_group_suffix(), '=', ',');
512
513 /* Set up the group type (always 2 for group info) */
514 grouptype = 2;
515
516 /* These groups are entered by populate_ldap_for_ldif */
517 if (strcmp(groupname, "Domain Admins") == 0 ||
518 strcmp(groupname, "Domain Users") == 0 ||
519 strcmp(groupname, "Domain Guests") == 0 ||
520 strcmp(groupname, "Domain Computers") == 0 ||
521 strcmp(groupname, "Administrators") == 0 ||
522 strcmp(groupname, "Print Operators") == 0 ||
523 strcmp(groupname, "Backup Operators") == 0 ||
524 strcmp(groupname, "Replicators") == 0) {
525 SAFE_FREE(group_attr);
526 return NT_STATUS_OK;
527 } else {
528 /* Increment the gid for the new group */
529 ldif_gid++;
530 }
531
532 /* Map the group rid, gid, and dn */
533 g_rid = r->rid;
534 groupmap->rid = g_rid;
535 groupmap->gidNumber = ldif_gid;
536 groupmap->sambaSID = talloc_asprintf(mem_ctx, "%s-%d", sid, g_rid);
537 groupmap->group_dn = talloc_asprintf(mem_ctx,
538 "cn=%s,ou=%s,%s", groupname, group_attr, suffix);
539 NT_STATUS_HAVE_NO_MEMORY(groupmap->sambaSID);
540 NT_STATUS_HAVE_NO_MEMORY(groupmap->group_dn);
541
542 /* Write the data to the temporary add ldif file */
543 fprintf(add_fd, "# %s, %s, %s\n", groupname, group_attr,
544 suffix);
545 fprintf_attr(add_fd, "dn", "cn=%s,ou=%s,%s", groupname, group_attr,
546 suffix);
547 fprintf(add_fd, "objectClass: posixGroup\n");
548 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
549 fprintf_attr(add_fd, "cn", "%s", groupname);
550 fprintf(add_fd, "gidNumber: %d\n", ldif_gid);
551 fprintf(add_fd, "sambaSID: %s\n", groupmap->sambaSID);
552 fprintf(add_fd, "sambaGroupType: %d\n", grouptype);
553 fprintf_attr(add_fd, "displayName", "%s", groupname);
554 fprintf(add_fd, "\n");
555 fflush(add_fd);
556
557 SAFE_FREE(group_attr);
558 /* Return */
559 return NT_STATUS_OK;
560 }
561
562 /****************************************************************
563 ****************************************************************/
564
565 static NTSTATUS fetch_account_info_to_ldif(TALLOC_CTX *mem_ctx,
566 struct netr_DELTA_USER *r,
567 GROUPMAP *groupmap,
568 ACCOUNTMAP *accountmap,
569 FILE *add_fd,
570 const char *sid,
571 const char *suffix,
572 int alloced)
573 {
574 fstring username, logonscript, homedrive, homepath = "", homedir = "";
575 fstring hex_nt_passwd, hex_lm_passwd;
576 fstring description, profilepath, fullname, sambaSID;
577 uchar lm_passwd[16], nt_passwd[16];
578 char *flags, *user_rdn;
579 const char *ou;
580 const char* nopasswd = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
581 static uchar zero_buf[16];
582 uint32 rid = 0, group_rid = 0, gidNumber = 0;
583 time_t unix_time;
584 int i;
585
586 /* Get the username */
587 fstrcpy(username, r->account_name.string);
588
589 /* Get the rid */
590 rid = r->rid;
591
592 /* Map the rid and username for group member info later */
593 accountmap->rid = rid;
594 accountmap->cn = talloc_strdup(mem_ctx, username);
595 NT_STATUS_HAVE_NO_MEMORY(accountmap->cn);
596
597 /* Get the home directory */
598 if (r->acct_flags & ACB_NORMAL) {
599 fstrcpy(homedir, r->home_directory.string);
600 if (!*homedir) {
601 snprintf(homedir, sizeof(homedir), "/home/%s", username);
602 } else {
603 snprintf(homedir, sizeof(homedir), "/nobodyshomedir");
604 }
605 ou = lp_ldap_user_suffix();
606 } else {
607 ou = lp_ldap_machine_suffix();
608 snprintf(homedir, sizeof(homedir), "/machinehomedir");
609 }
610
611 /* Get the logon script */
612 fstrcpy(logonscript, r->logon_script.string);
613
614 /* Get the home drive */
615 fstrcpy(homedrive, r->home_drive.string);
616
617 /* Get the home path */
618 fstrcpy(homepath, r->home_directory.string);
619
620 /* Get the description */
621 fstrcpy(description, r->description.string);
622
623 /* Get the display name */
624 fstrcpy(fullname, r->full_name.string);
625
626 /* Get the profile path */
627 fstrcpy(profilepath, r->profile_path.string);
628
629 /* Get lm and nt password data */
630 if (memcmp(r->lmpassword.hash, zero_buf, 16) != 0) {
631 sam_pwd_hash(r->rid, r->lmpassword.hash, lm_passwd, 0);
632 pdb_sethexpwd(hex_lm_passwd, lm_passwd, r->acct_flags);
633 } else {
634 pdb_sethexpwd(hex_lm_passwd, NULL, 0);
635 }
636 if (memcmp(r->ntpassword.hash, zero_buf, 16) != 0) {
637 sam_pwd_hash(r->rid, r->ntpassword.hash, nt_passwd, 0);
638 pdb_sethexpwd(hex_nt_passwd, nt_passwd, r->acct_flags);
639 } else {
640 pdb_sethexpwd(hex_nt_passwd, NULL, 0);
641 }
642 unix_time = nt_time_to_unix(r->last_password_change);
643
644 /* Increment the uid for the new user */
645 ldif_uid++;
646
647 /* Set up group id and sambaSID for the user */
648 group_rid = r->primary_gid;
649 for (i=0; i<alloced; i++) {
650 if (groupmap[i].rid == group_rid) break;
651 }
652 if (i == alloced){
653 DEBUG(1, ("Could not find rid %d in groupmap array\n",
654 group_rid));
655 return NT_STATUS_UNSUCCESSFUL;
656 }
657 gidNumber = groupmap[i].gidNumber;
658 snprintf(sambaSID, sizeof(sambaSID), groupmap[i].sambaSID);
659
660 /* Set up sambaAcctFlags */
661 flags = pdb_encode_acct_ctrl(r->acct_flags,
662 NEW_PW_FORMAT_SPACE_PADDED_LEN);
663
664 /* Add the user to the temporary add ldif file */
665 /* this isn't quite right...we can't assume there's just OU=. jmcd */
666 user_rdn = sstring_sub(ou, '=', ',');
667 fprintf(add_fd, "# %s, %s, %s\n", username, user_rdn, suffix);
668 fprintf_attr(add_fd, "dn", "uid=%s,ou=%s,%s", username, user_rdn,
669 suffix);
670 SAFE_FREE(user_rdn);
671 fprintf(add_fd, "ObjectClass: top\n");
672 fprintf(add_fd, "objectClass: inetOrgPerson\n");
673 fprintf(add_fd, "objectClass: posixAccount\n");
674 fprintf(add_fd, "objectClass: shadowAccount\n");
675 fprintf(add_fd, "objectClass: sambaSamAccount\n");
676 fprintf_attr(add_fd, "cn", "%s", username);
677 fprintf_attr(add_fd, "sn", "%s", username);
678 fprintf_attr(add_fd, "uid", "%s", username);
679 fprintf(add_fd, "uidNumber: %d\n", ldif_uid);
680 fprintf(add_fd, "gidNumber: %d\n", gidNumber);
681 fprintf_attr(add_fd, "homeDirectory", "%s", homedir);
682 if (*homepath)
683 fprintf_attr(add_fd, "sambaHomePath", "%s", homepath);
684 if (*homedrive)
685 fprintf_attr(add_fd, "sambaHomeDrive", "%s", homedrive);
686 if (*logonscript)
687 fprintf_attr(add_fd, "sambaLogonScript", "%s", logonscript);
688 fprintf(add_fd, "loginShell: %s\n",
689 ((r->acct_flags & ACB_NORMAL) ?
690 "/bin/bash" : "/bin/false"));
691 fprintf(add_fd, "gecos: System User\n");
692 if (*description)
693 fprintf_attr(add_fd, "description", "%s", description);
694 fprintf(add_fd, "sambaSID: %s-%d\n", sid, rid);
695 fprintf(add_fd, "sambaPrimaryGroupSID: %s\n", sambaSID);
696 if(*fullname)
697 fprintf_attr(add_fd, "displayName", "%s", fullname);
698 if(*profilepath)
699 fprintf_attr(add_fd, "sambaProfilePath", "%s", profilepath);
700 if (strcmp(nopasswd, hex_lm_passwd) != 0)
701 fprintf(add_fd, "sambaLMPassword: %s\n", hex_lm_passwd);
702 if (strcmp(nopasswd, hex_nt_passwd) != 0)
703 fprintf(add_fd, "sambaNTPassword: %s\n", hex_nt_passwd);
704 fprintf(add_fd, "sambaPwdLastSet: %d\n", (int)unix_time);
705 fprintf(add_fd, "sambaAcctFlags: %s\n", flags);
706 fprintf(add_fd, "\n");
707 fflush(add_fd);
708
709 /* Return */
710 return NT_STATUS_OK;
711 }
712
713 /****************************************************************
714 ****************************************************************/
715
716 static NTSTATUS fetch_alias_info_to_ldif(TALLOC_CTX *mem_ctx,
717 struct netr_DELTA_ALIAS *r,
718 GROUPMAP *groupmap,
719 FILE *add_fd,
720 const char *sid,
721 const char *suffix,
722 enum netr_SamDatabaseID database_id)
723 {
724 fstring aliasname, description;
725 uint32 grouptype = 0, g_rid = 0;
726 char *group_attr = sstring_sub(lp_ldap_group_suffix(), '=', ',');
727
728 /* Get the alias name */
729 fstrcpy(aliasname, r->alias_name.string);
730
731 /* Get the alias description */
732 fstrcpy(description, r->description.string);
733
734 /* Set up the group type */
735 switch (database_id) {
736 case SAM_DATABASE_DOMAIN:
737 grouptype = 4;
738 break;
739 case SAM_DATABASE_BUILTIN:
740 grouptype = 5;
741 break;
742 default:
743 grouptype = 4;
744 break;
745 }
746
747 /*
748 These groups are entered by populate_ldap_for_ldif
749 Note that populate creates a group called Relicators,
750 but NT returns a group called Replicator
751 */
752 if (strcmp(aliasname, "Domain Admins") == 0 ||
753 strcmp(aliasname, "Domain Users") == 0 ||
754 strcmp(aliasname, "Domain Guests") == 0 ||
755 strcmp(aliasname, "Domain Computers") == 0 ||
756 strcmp(aliasname, "Administrators") == 0 ||
757 strcmp(aliasname, "Print Operators") == 0 ||
758 strcmp(aliasname, "Backup Operators") == 0 ||
759 strcmp(aliasname, "Replicator") == 0) {
760 SAFE_FREE(group_attr);
761 return NT_STATUS_OK;
762 } else {
763 /* Increment the gid for the new group */
764 ldif_gid++;
765 }
766
767 /* Map the group rid and gid */
768 g_rid = r->rid;
769 groupmap->gidNumber = ldif_gid;
770 groupmap->sambaSID = talloc_asprintf(mem_ctx, "%s-%d", sid, g_rid);
771 NT_STATUS_HAVE_NO_MEMORY(groupmap->sambaSID);
772
773 /* Write the data to the temporary add ldif file */
774 fprintf(add_fd, "# %s, %s, %s\n", aliasname, group_attr,
775 suffix);
776 fprintf_attr(add_fd, "dn", "cn=%s,ou=%s,%s", aliasname, group_attr,
777 suffix);
778 fprintf(add_fd, "objectClass: posixGroup\n");
779 fprintf(add_fd, "objectClass: sambaGroupMapping\n");
780 fprintf(add_fd, "cn: %s\n", aliasname);
781 fprintf(add_fd, "gidNumber: %d\n", ldif_gid);
782 fprintf(add_fd, "sambaSID: %s\n", groupmap->sambaSID);
783 fprintf(add_fd, "sambaGroupType: %d\n", grouptype);
784 fprintf_attr(add_fd, "displayName", "%s", aliasname);
785 if (description[0])
786 fprintf_attr(add_fd, "description", "%s", description);
787 fprintf(add_fd, "\n");
788 fflush(add_fd);
789
790 SAFE_FREE(group_attr);
791 /* Return */
792 return NT_STATUS_OK;
793 }
794
795 /****************************************************************
796 ****************************************************************/
797
798 static NTSTATUS fetch_groupmem_info_to_ldif(struct netr_DELTA_GROUP_MEMBER *r,
799 uint32_t id_rid,
800 GROUPMAP *groupmap,
801 ACCOUNTMAP *accountmap,
802 FILE *mod_fd, int alloced)
803 {
804 fstring group_dn;
805 uint32 group_rid = 0, rid = 0;
806 int i, j, k;
807
808 /* Get the dn for the group */
809 if (r->num_rids > 0) {
810 group_rid = id_rid;
811 for (j=0; j<alloced; j++) {
812 if (groupmap[j].rid == group_rid) break;
813 }
814 if (j == alloced){
815 DEBUG(1, ("Could not find rid %d in groupmap array\n",
816 group_rid));
817 return NT_STATUS_UNSUCCESSFUL;
818 }
819 snprintf(group_dn, sizeof(group_dn), "%s", groupmap[j].group_dn);
820 fprintf(mod_fd, "dn: %s\n", group_dn);
821
822 /* Get the cn for each member */
823 for (i=0; i < r->num_rids; i++) {
824 rid = r->rids[i];
825 for (k=0; k<alloced; k++) {
826 if (accountmap[k].rid == rid) break;
827 }
828 if (k == alloced){
829 DEBUG(1, ("Could not find rid %d in "
830 "accountmap array\n", rid));
831 return NT_STATUS_UNSUCCESSFUL;
832 }
833 fprintf(mod_fd, "memberUid: %s\n", accountmap[k].cn);
834 }
835 fprintf(mod_fd, "\n");
836 }
837 fflush(mod_fd);
838
839 /* Return */
840 return NT_STATUS_OK;
841 }
842
843 /****************************************************************
844 ****************************************************************/
845
846 static NTSTATUS ldif_init_context(TALLOC_CTX *mem_ctx,
847 enum netr_SamDatabaseID database_id,
848 const char *ldif_filename,
849 const char *domain_sid_str,
850 struct samsync_ldif_context **ctx)
851 {
852 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
853 struct samsync_ldif_context *r;
854 const char *add_template = "/tmp/add.ldif.XXXXXX";
855 const char *mod_template = "/tmp/mod.ldif.XXXXXX";
856 const char *builtin_sid = "S-1-5-32";
857
858 /* Get other smb.conf data */
859 if (!(lp_workgroup()) || !*(lp_workgroup())) {
860 DEBUG(0,("workgroup missing from smb.conf--exiting\n"));
861 exit(1);
862 }
863
864 /* Get the ldap suffix */
865 if (!(lp_ldap_suffix()) || !*(lp_ldap_suffix())) {
866 DEBUG(0,("ldap suffix missing from smb.conf--exiting\n"));
867 exit(1);
868 }
869
870 if (*ctx && (*ctx)->initialized) {
871 return NT_STATUS_OK;
872 }
873
874 r = TALLOC_ZERO_P(mem_ctx, struct samsync_ldif_context);
875 NT_STATUS_HAVE_NO_MEMORY(r);
876
877 /* Get the ldap suffix */
878 r->suffix = lp_ldap_suffix();
879
880 /* Ensure we have an output file */
881 if (ldif_filename) {
882 r->ldif_file = fopen(ldif_filename, "a");
883 } else {
884 r->ldif_file = stdout;
885 }
886
887 if (!r->ldif_file) {
888 fprintf(stderr, "Could not open %s\n", ldif_filename);
889 DEBUG(1, ("Could not open %s\n", ldif_filename));
890 status = NT_STATUS_UNSUCCESSFUL;
891 goto done;
892 }
893
894 r->add_template = talloc_strdup(mem_ctx, add_template);
895 r->mod_template = talloc_strdup(mem_ctx, mod_template);
896 if (!r->add_template || !r->mod_template) {
897 status = NT_STATUS_NO_MEMORY;
898 goto done;
899 }
900
901 r->add_name = talloc_strdup(mem_ctx, add_template);
902 r->mod_name = talloc_strdup(mem_ctx, mod_template);
903 if (!r->add_name || !r->mod_name) {
904 status = NT_STATUS_NO_MEMORY;
905 goto done;
906 }
907
908 /* Open the add and mod ldif files */
909 if (!(r->add_file = fdopen(smb_mkstemp(r->add_name),"w"))) {
910 DEBUG(1, ("Could not open %s\n", r->add_name));
911 status = NT_STATUS_UNSUCCESSFUL;
912 goto done;
913 }
914 if (!(r->mod_file = fdopen(smb_mkstemp(r->mod_name),"w"))) {
915 DEBUG(1, ("Could not open %s\n", r->mod_name));
916 status = NT_STATUS_UNSUCCESSFUL;
917 goto done;
918 }
919
920 /* Allocate initial memory for groupmap and accountmap arrays */
921 r->groupmap = TALLOC_ZERO_ARRAY(mem_ctx, GROUPMAP, 8);
922 r->accountmap = TALLOC_ZERO_ARRAY(mem_ctx, ACCOUNTMAP, 8);
923 if (r->groupmap == NULL || r->accountmap == NULL) {
924 DEBUG(1,("GROUPMAP talloc failed\n"));
925 status = NT_STATUS_NO_MEMORY;
926 goto done;
927 }
928
929 /* Remember how many we malloced */
930 r->num_alloced = 8;
931
932 /* Initial database population */
933 if (database_id == SAM_DATABASE_DOMAIN) {
934
935 status = populate_ldap_for_ldif(domain_sid_str,
936 r->suffix,
937 builtin_sid,
938 r->add_file);
939 if (!NT_STATUS_IS_OK(status)) {
940 goto done;
941 }
942
943 status = map_populate_groups(mem_ctx,
944 r->groupmap,
945 r->accountmap,
946 domain_sid_str,
947 r->suffix,
948 builtin_sid);
949 if (!NT_STATUS_IS_OK(status)) {
950 goto done;
951 }
952 }
953
954 r->initialized = true;
955
956 *ctx = r;
957
958 return NT_STATUS_OK;
959 done:
960 TALLOC_FREE(r);
961 return status;
962 }
963
964 /****************************************************************
965 ****************************************************************/
966
967 static void ldif_free_context(struct samsync_ldif_context *r)
968 {
969 if (!r) {
970 return;
971 }
972
973 /* Close and delete the ldif files */
974 if (r->add_file) {
975 fclose(r->add_file);
976 }
977
978 if ((r->add_name != NULL) &&
979 strcmp(r->add_name, r->add_template) && (unlink(r->add_name))) {
980 DEBUG(1,("unlink(%s) failed, error was (%s)\n",
981 r->add_name, strerror(errno)));
982 }
983
984 if (r->mod_file) {
985 fclose(r->mod_file);
986 }
987
988 if ((r->mod_name != NULL) &&
989 strcmp(r->mod_name, r->mod_template) && (unlink(r->mod_name))) {
990 DEBUG(1,("unlink(%s) failed, error was (%s)\n",
991 r->mod_name, strerror(errno)));
992 }
993
994 if (r->ldif_file && (r->ldif_file != stdout)) {
995 fclose(r->ldif_file);
996 }
997
998 TALLOC_FREE(r);
999 }
1000
1001 /****************************************************************
1002 ****************************************************************/
1003
1004 static void ldif_write_output(enum netr_SamDatabaseID database_id,
1005 struct samsync_ldif_context *l)
1006 {
1007 /* Write ldif data to the user's file */
1008 if (database_id == SAM_DATABASE_DOMAIN) {
1009 fprintf(l->ldif_file,
1010 "# SAM_DATABASE_DOMAIN: ADD ENTITIES\n");
1011 fprintf(l->ldif_file,
1012 "# =================================\n\n");
1013 fflush(l->ldif_file);
1014 } else if (database_id == SAM_DATABASE_BUILTIN) {
1015 fprintf(l->ldif_file,
1016 "# SAM_DATABASE_BUILTIN: ADD ENTITIES\n");
1017 fprintf(l->ldif_file,
1018 "# ==================================\n\n");
1019 fflush(l->ldif_file);
1020 }
1021 fseek(l->add_file, 0, SEEK_SET);
1022 transfer_file(fileno(l->add_file), fileno(l->ldif_file), (size_t) -1);
1023
1024 if (database_id == SAM_DATABASE_DOMAIN) {
1025 fprintf(l->ldif_file,
1026 "# SAM_DATABASE_DOMAIN: MODIFY ENTITIES\n");
1027 fprintf(l->ldif_file,
1028 "# ====================================\n\n");
1029 fflush(l->ldif_file);
1030 } else if (database_id == SAM_DATABASE_BUILTIN) {
1031 fprintf(l->ldif_file,
1032 "# SAM_DATABASE_BUILTIN: MODIFY ENTITIES\n");
1033 fprintf(l->ldif_file,
1034 "# =====================================\n\n");
1035 fflush(l->ldif_file);
1036 }
1037 fseek(l->mod_file, 0, SEEK_SET);
1038 transfer_file(fileno(l->mod_file), fileno(l->ldif_file), (size_t) -1);
1039 }
1040
1041 /****************************************************************
1042 ****************************************************************/
1043
1044 static NTSTATUS fetch_sam_entry_ldif(TALLOC_CTX *mem_ctx,
1045 enum netr_SamDatabaseID database_id,
1046 struct netr_DELTA_ENUM *r,
1047 struct samsync_context *ctx,
1048 uint32_t *a_index,
1049 uint32_t *g_index)
1050 {
1051 union netr_DELTA_UNION u = r->delta_union;
1052 union netr_DELTA_ID_UNION id = r->delta_id_union;
1053 struct samsync_ldif_context *l =
1054 talloc_get_type_abort(ctx->private_data, struct samsync_ldif_context);
1055
1056 switch (r->delta_type) {
1057 case NETR_DELTA_DOMAIN:
1058 break;
1059
1060 case NETR_DELTA_GROUP:
1061 fetch_group_info_to_ldif(mem_ctx,
1062 u.group,
1063 &l->groupmap[*g_index],
1064 l->add_file,
1065 ctx->domain_sid_str,
1066 l->suffix);
1067 (*g_index)++;
1068 break;
1069
1070 case NETR_DELTA_USER:
1071 fetch_account_info_to_ldif(mem_ctx,
1072 u.user,
1073 l->groupmap,
1074 &l->accountmap[*a_index],
1075 l->add_file,
1076 ctx->domain_sid_str,
1077 l->suffix,
1078 l->num_alloced);
1079 (*a_index)++;
1080 break;
1081
1082 case NETR_DELTA_ALIAS:
1083 fetch_alias_info_to_ldif(mem_ctx,
1084 u.alias,
1085 &l->groupmap[*g_index],
1086 l->add_file,
1087 ctx->domain_sid_str,
1088 l->suffix,
1089 database_id);
1090 (*g_index)++;
1091 break;
1092
1093 case NETR_DELTA_GROUP_MEMBER:
1094 fetch_groupmem_info_to_ldif(u.group_member,
1095 id.rid,
1096 l->groupmap,
1097 l->accountmap,
1098 l->mod_file,
1099 l->num_alloced);
1100 break;
1101
1102 case NETR_DELTA_ALIAS_MEMBER:
1103 case NETR_DELTA_POLICY:
1104 case NETR_DELTA_ACCOUNT:
1105 case NETR_DELTA_TRUSTED_DOMAIN:
1106 case NETR_DELTA_SECRET:
1107 case NETR_DELTA_RENAME_GROUP:
1108 case NETR_DELTA_RENAME_USER:
1109 case NETR_DELTA_RENAME_ALIAS:
1110 case NETR_DELTA_DELETE_GROUP:
1111 case NETR_DELTA_DELETE_USER:
1112 case NETR_DELTA_MODIFY_COUNT:
1113 default:
1114 break;
1115 } /* end of switch */
1116
1117 return NT_STATUS_OK;
1118 }
1119
1120 /****************************************************************
1121 ****************************************************************/
1122
1123 static NTSTATUS ldif_realloc_maps(TALLOC_CTX *mem_ctx,
1124 struct samsync_ldif_context *l,
1125 uint32_t num_entries)
1126 {
1127 /* Re-allocate memory for groupmap and accountmap arrays */
1128 l->groupmap = TALLOC_REALLOC_ARRAY(mem_ctx,
1129 l->groupmap,
1130 GROUPMAP,
1131 num_entries + l->num_alloced);
1132
1133 l->accountmap = TALLOC_REALLOC_ARRAY(mem_ctx,
1134 l->accountmap,
1135 ACCOUNTMAP,
1136 num_entries + l->num_alloced);
1137
1138 if (l->groupmap == NULL || l->accountmap == NULL) {
1139 DEBUG(1,("GROUPMAP talloc failed\n"));
1140 return NT_STATUS_NO_MEMORY;
1141 }
1142
1143 /* Initialize the new records */
1144 memset(&(l->groupmap[l->num_alloced]), 0,
1145 sizeof(GROUPMAP) * num_entries);
1146 memset(&(l->accountmap[l->num_alloced]), 0,
1147 sizeof(ACCOUNTMAP) * num_entries);
1148
1149 /* Remember how many we alloced this time */
1150 l->num_alloced += num_entries;
1151
1152 return NT_STATUS_OK;
1153 }
1154
1155 /****************************************************************
1156 ****************************************************************/
1157
1158 NTSTATUS fetch_sam_entries_ldif(TALLOC_CTX *mem_ctx,
1159 enum netr_SamDatabaseID database_id,
1160 struct netr_DELTA_ENUM_ARRAY *r,
1161 bool last_query,
1162 struct samsync_context *ctx)
1163 {
1164 NTSTATUS status;
1165 int i;
1166 uint32_t g_index = 0, a_index = 0;
1167 struct samsync_ldif_context *ldif_ctx =
1168 (struct samsync_ldif_context *)ctx->private_data;
1169
1170 status = ldif_init_context(mem_ctx,
1171 database_id,
1172 ctx->output_filename,
1173 ctx->domain_sid_str,
1174 &ldif_ctx);
1175 if (!NT_STATUS_IS_OK(status)) {
1176 goto failed;
1177 }
1178
1179 ctx->private_data = ldif_ctx;
1180
1181 status = ldif_realloc_maps(mem_ctx, ldif_ctx, r->num_deltas);
1182 if (!NT_STATUS_IS_OK(status)) {
1183 goto failed;
1184 }
1185
1186 for (i = 0; i < r->num_deltas; i++) {
1187 status = fetch_sam_entry_ldif(mem_ctx, database_id,
1188 &r->delta_enum[i], ctx,
1189 &a_index, &g_index);
1190 if (!NT_STATUS_IS_OK(status)) {
1191 goto failed;
1192 }
1193 }
1194
1195 /* This was the last query */
1196 if (last_query) {
1197 ldif_write_output(database_id, ldif_ctx);
1198 if (ldif_ctx->ldif_file != stdout) {
1199 ctx->result_message = talloc_asprintf(mem_ctx,
1200 "Vampired %d accounts and %d groups to %s",
1201 a_index, g_index, ctx->output_filename);
1202 }
1203 ldif_free_context(ldif_ctx);
1204 ctx->private_data = NULL;
1205 }
1206
1207 return NT_STATUS_OK;
1208
1209 failed:
1210 ldif_free_context(ldif_ctx);
1211 ctx->private_data = NULL;
1212
1213 return status;
1214 }
Samba GIT mirror