?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-utils/net_rpc_printer.c: print more info on write error
[Samba/gebeck_regimport.git] / source3 / winbindd / idmap_ad.c
blob65b518074b5f970773a4692b1eafd8d353f1cc70
1 /*
2 * idmap_ad: map between Active Directory and RFC 2307 or "Services for Unix" (SFU) Accounts
3 *
4 * Unix SMB/CIFS implementation.
5 *
6 * Winbind ADS backend functions
7 *
8 * Copyright (C) Andrew Tridgell 2001
9 * Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003
10 * Copyright (C) Gerald (Jerry) Carter 2004-2007
11 * Copyright (C) Luke Howard 2001-2004
12 * Copyright (C) Michael Adam 2008,2010
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 3 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 */
27
28 #include "includes.h"
29 #include "winbindd.h"
30 #include "../libds/common/flags.h"
31 #include "ads.h"
32 #include "libads/ldap_schema.h"
33 #include "nss_info.h"
34 #include "secrets.h"
35 #include "idmap.h"
36 #include "../libcli/ldap/ldap_ndr.h"
37 #include "../libcli/security/security.h"
38
39 #undef DBGC_CLASS
40 #define DBGC_CLASS DBGC_IDMAP
41
42 #define WINBIND_CCACHE_NAME "MEMORY:winbind_ccache"
43
44 #define IDMAP_AD_MAX_IDS 30
45 #define CHECK_ALLOC_DONE(mem) do { \
46 if (!mem) { \
47 DEBUG(0, ("Out of memory!\n")); \
48 ret = NT_STATUS_NO_MEMORY; \
49 goto done; \
50 } \
51 } while (0)
52
53 struct idmap_ad_context {
54 ADS_STRUCT *ads;
55 struct posix_schema *ad_schema;
56 enum wb_posix_mapping ad_map_type; /* WB_POSIX_MAP_UNKNOWN */
57 };
58
59 NTSTATUS init_module(void);
60
61 /************************************************************************
62 ***********************************************************************/
63
64 static ADS_STATUS ad_idmap_cached_connection_internal(struct idmap_domain *dom)
65 {
66 ADS_STRUCT *ads;
67 ADS_STATUS status;
68 bool local = False;
69 fstring dc_name;
70 struct sockaddr_storage dc_ip;
71 struct idmap_ad_context *ctx;
72 char *ldap_server = NULL;
73 char *realm = NULL;
74 struct winbindd_domain *wb_dom;
75
76 DEBUG(10, ("ad_idmap_cached_connection: called for domain '%s'\n",
77 dom->name));
78
79 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
80
81 if (ctx->ads != NULL) {
82
83 time_t expire;
84 time_t now = time(NULL);
85
86 ads = ctx->ads;
87
88 expire = MIN(ads->auth.tgt_expire, ads->auth.tgs_expire);
89
90 /* check for a valid structure */
91 DEBUG(7, ("Current tickets expire in %d seconds (at %d, time is now %d)\n",
92 (uint32)expire-(uint32)now, (uint32) expire, (uint32) now));
93
94 if ( ads->config.realm && (expire > time(NULL))) {
95 return ADS_SUCCESS;
96 } else {
97 /* we own this ADS_STRUCT so make sure it goes away */
98 DEBUG(7,("Deleting expired krb5 credential cache\n"));
99 ads->is_mine = True;
100 ads_destroy( &ads );
101 ads_kdestroy(WINBIND_CCACHE_NAME);
102 ctx->ads = NULL;
103 }
104 }
105
106 if (!local) {
107 /* we don't want this to affect the users ccache */
108 setenv("KRB5CCNAME", WINBIND_CCACHE_NAME, 1);
109 }
110
111 /*
112 * At this point we only have the NetBIOS domain name.
113 * Check if we can get server nam and realm from SAF cache
114 * and the domain list.
115 */
116 ldap_server = saf_fetch(dom->name);
117 DEBUG(10, ("ldap_server from saf cache: '%s'\n", ldap_server?ldap_server:""));
118
119 wb_dom = find_domain_from_name_noinit(dom->name);
120 if (wb_dom == NULL) {
121 DEBUG(10, ("find_domain_from_name_noinit did not find domain '%s'\n",
122 dom->name));
123 realm = NULL;
124 } else {
125 DEBUG(10, ("find_domain_from_name_noinit found realm '%s' for "
126 " domain '%s'\n", wb_dom->alt_name, dom->name));
127 realm = wb_dom->alt_name;
128 }
129
130 if ( (ads = ads_init(realm, dom->name, ldap_server)) == NULL ) {
131 DEBUG(1,("ads_init failed\n"));
132 return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
133 }
134
135 /* the machine acct password might have change - fetch it every time */
136 SAFE_FREE(ads->auth.password);
137 ads->auth.password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
138
139 SAFE_FREE(ads->auth.realm);
140 ads->auth.realm = SMB_STRDUP(lp_realm());
141
142 /* setup server affinity */
143
144 get_dc_name(dom->name, realm, dc_name, &dc_ip );
145
146 status = ads_connect(ads);
147 if (!ADS_ERR_OK(status)) {
148 DEBUG(1, ("ad_idmap_cached_connection_internal: failed to "
149 "connect to AD\n"));
150 ads_destroy(&ads);
151 return status;
152 }
153
154 ads->is_mine = False;
155
156 ctx->ads = ads;
157
158 return ADS_SUCCESS;
159 }
160
161 /************************************************************************
162 ***********************************************************************/
163
164 static ADS_STATUS ad_idmap_cached_connection(struct idmap_domain *dom)
165 {
166 ADS_STATUS status;
167 struct idmap_ad_context * ctx;
168
169 status = ad_idmap_cached_connection_internal(dom);
170 if (!ADS_ERR_OK(status)) {
171 return status;
172 }
173
174 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
175
176 /* if we have a valid ADS_STRUCT and the schema model is
177 defined, then we can return here. */
178
179 if ( ctx->ad_schema ) {
180 return ADS_SUCCESS;
181 }
182
183 /* Otherwise, set the schema model */
184
185 if ( (ctx->ad_map_type == WB_POSIX_MAP_SFU) ||
186 (ctx->ad_map_type == WB_POSIX_MAP_SFU20) ||
187 (ctx->ad_map_type == WB_POSIX_MAP_RFC2307) )
188 {
189 status = ads_check_posix_schema_mapping(
190 ctx, ctx->ads, ctx->ad_map_type, &ctx->ad_schema);
191 if ( !ADS_ERR_OK(status) ) {
192 DEBUG(2,("ad_idmap_cached_connection: Failed to obtain schema details!\n"));
193 }
194 }
195
196 return status;
197 }
198
199 static int idmap_ad_context_destructor(struct idmap_ad_context *ctx)
200 {
201 if (ctx->ads != NULL) {
202 /* we own this ADS_STRUCT so make sure it goes away */
203 ctx->ads->is_mine = True;
204 ads_destroy( &ctx->ads );
205 ctx->ads = NULL;
206 }
207 return 0;
208 }
209
210 /************************************************************************
211 ***********************************************************************/
212
213 static NTSTATUS idmap_ad_initialize(struct idmap_domain *dom)
214 {
215 struct idmap_ad_context *ctx;
216 char *config_option;
217 const char *schema_mode = NULL;
218
219 ctx = talloc_zero(dom, struct idmap_ad_context);
220 if (ctx == NULL) {
221 DEBUG(0, ("Out of memory!\n"));
222 return NT_STATUS_NO_MEMORY;
223 }
224 talloc_set_destructor(ctx, idmap_ad_context_destructor);
225
226 config_option = talloc_asprintf(ctx, "idmap config %s", dom->name);
227 if (config_option == NULL) {
228 DEBUG(0, ("Out of memory!\n"));
229 talloc_free(ctx);
230 return NT_STATUS_NO_MEMORY;
231 }
232
233 /* default map type */
234 ctx->ad_map_type = WB_POSIX_MAP_RFC2307;
235
236 /* schema mode */
237 schema_mode = lp_parm_const_string(-1, config_option, "schema_mode", NULL);
238 if ( schema_mode && schema_mode[0] ) {
239 if ( strequal(schema_mode, "sfu") )
240 ctx->ad_map_type = WB_POSIX_MAP_SFU;
241 else if ( strequal(schema_mode, "sfu20" ) )
242 ctx->ad_map_type = WB_POSIX_MAP_SFU20;
243 else if ( strequal(schema_mode, "rfc2307" ) )
244 ctx->ad_map_type = WB_POSIX_MAP_RFC2307;
245 else
246 DEBUG(0,("idmap_ad_initialize: Unknown schema_mode (%s)\n",
247 schema_mode));
248 }
249
250 dom->private_data = ctx;
251
252 talloc_free(config_option);
253
254 return NT_STATUS_OK;
255 }
256
257 /************************************************************************
258 Search up to IDMAP_AD_MAX_IDS entries in maps for a match.
259 ***********************************************************************/
260
261 static struct id_map *find_map_by_id(struct id_map **maps, enum id_type type, uint32_t id)
262 {
263 int i;
264
265 for (i = 0; maps[i] && i<IDMAP_AD_MAX_IDS; i++) {
266 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
267 return maps[i];
268 }
269 }
270
271 return NULL;
272 }
273
274 /************************************************************************
275 Search up to IDMAP_AD_MAX_IDS entries in maps for a match
276 ***********************************************************************/
277
278 static struct id_map *find_map_by_sid(struct id_map **maps, struct dom_sid *sid)
279 {
280 int i;
281
282 for (i = 0; maps[i] && i<IDMAP_AD_MAX_IDS; i++) {
283 if (dom_sid_equal(maps[i]->sid, sid)) {
284 return maps[i];
285 }
286 }
287
288 return NULL;
289 }
290
291 /************************************************************************
292 ***********************************************************************/
293
294 static NTSTATUS idmap_ad_unixids_to_sids(struct idmap_domain *dom, struct id_map **ids)
295 {
296 NTSTATUS ret;
297 TALLOC_CTX *memctx;
298 struct idmap_ad_context *ctx;
299 ADS_STATUS rc;
300 const char *attrs[] = { "sAMAccountType",
301 "objectSid",
302 NULL, /* uidnumber */
303 NULL, /* gidnumber */
304 NULL };
305 LDAPMessage *res = NULL;
306 LDAPMessage *entry = NULL;
307 char *filter = NULL;
308 int idx = 0;
309 int bidx = 0;
310 int count;
311 int i;
312 char *u_filter = NULL;
313 char *g_filter = NULL;
314
315 /* initialize the status to avoid suprise */
316 for (i = 0; ids[i]; i++) {
317 ids[i]->status = ID_UNKNOWN;
318 }
319
320 /* Only do query if we are online */
321 if (idmap_is_offline()) {
322 return NT_STATUS_FILE_IS_OFFLINE;
323 }
324
325 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
326
327 if ( (memctx = talloc_new(ctx)) == NULL ) {
328 DEBUG(0, ("Out of memory!\n"));
329 return NT_STATUS_NO_MEMORY;
330 }
331
332 rc = ad_idmap_cached_connection(dom);
333 if (!ADS_ERR_OK(rc)) {
334 DEBUG(1, ("ADS uninitialized: %s\n", ads_errstr(rc)));
335 ret = NT_STATUS_UNSUCCESSFUL;
336 /* ret = ads_ntstatus(rc); */
337 goto done;
338 }
339
340 attrs[2] = ctx->ad_schema->posix_uidnumber_attr;
341 attrs[3] = ctx->ad_schema->posix_gidnumber_attr;
342
343 again:
344 bidx = idx;
345 for (i = 0; (i < IDMAP_AD_MAX_IDS) && ids[idx]; i++, idx++) {
346 switch (ids[idx]->xid.type) {
347 case ID_TYPE_UID:
348 if ( ! u_filter) {
349 u_filter = talloc_asprintf(memctx, "(&(|"
350 "(sAMAccountType=%d)"
351 "(sAMAccountType=%d)"
352 "(sAMAccountType=%d))(|",
353 ATYPE_NORMAL_ACCOUNT,
354 ATYPE_WORKSTATION_TRUST,
355 ATYPE_INTERDOMAIN_TRUST);
356 }
357 u_filter = talloc_asprintf_append_buffer(u_filter, "(%s=%lu)",
358 ctx->ad_schema->posix_uidnumber_attr,
359 (unsigned long)ids[idx]->xid.id);
360 CHECK_ALLOC_DONE(u_filter);
361 break;
362
363 case ID_TYPE_GID:
364 if ( ! g_filter) {
365 g_filter = talloc_asprintf(memctx, "(&(|"
366 "(sAMAccountType=%d)"
367 "(sAMAccountType=%d))(|",
368 ATYPE_SECURITY_GLOBAL_GROUP,
369 ATYPE_SECURITY_LOCAL_GROUP);
370 }
371 g_filter = talloc_asprintf_append_buffer(g_filter, "(%s=%lu)",
372 ctx->ad_schema->posix_gidnumber_attr,
373 (unsigned long)ids[idx]->xid.id);
374 CHECK_ALLOC_DONE(g_filter);
375 break;
376
377 default:
378 DEBUG(3, ("Error: mapping requested but Unknown ID type\n"));
379 ids[idx]->status = ID_UNKNOWN;
380 continue;
381 }
382 }
383 filter = talloc_asprintf(memctx, "(|");
384 CHECK_ALLOC_DONE(filter);
385 if ( u_filter) {
386 filter = talloc_asprintf_append_buffer(filter, "%s))", u_filter);
387 CHECK_ALLOC_DONE(filter);
388 TALLOC_FREE(u_filter);
389 }
390 if ( g_filter) {
391 filter = talloc_asprintf_append_buffer(filter, "%s))", g_filter);
392 CHECK_ALLOC_DONE(filter);
393 TALLOC_FREE(g_filter);
394 }
395 filter = talloc_asprintf_append_buffer(filter, ")");
396 CHECK_ALLOC_DONE(filter);
397
398 rc = ads_search_retry(ctx->ads, &res, filter, attrs);
399 if (!ADS_ERR_OK(rc)) {
400 DEBUG(1, ("ERROR: ads search returned: %s\n", ads_errstr(rc)));
401 ret = NT_STATUS_UNSUCCESSFUL;
402 goto done;
403 }
404
405 if ( (count = ads_count_replies(ctx->ads, res)) == 0 ) {
406 DEBUG(10, ("No IDs found\n"));
407 }
408
409 entry = res;
410 for (i = 0; (i < count) && entry; i++) {
411 struct dom_sid sid;
412 enum id_type type;
413 struct id_map *map;
414 uint32_t id;
415 uint32_t atype;
416
417 if (i == 0) { /* first entry */
418 entry = ads_first_entry(ctx->ads, entry);
419 } else { /* following ones */
420 entry = ads_next_entry(ctx->ads, entry);
421 }
422
423 if ( !entry ) {
424 DEBUG(2, ("ERROR: Unable to fetch ldap entries from results\n"));
425 break;
426 }
427
428 /* first check if the SID is present */
429 if (!ads_pull_sid(ctx->ads, entry, "objectSid", &sid)) {
430 DEBUG(2, ("Could not retrieve SID from entry\n"));
431 continue;
432 }
433
434 /* get type */
435 if (!ads_pull_uint32(ctx->ads, entry, "sAMAccountType", &atype)) {
436 DEBUG(1, ("could not get SAM account type\n"));
437 continue;
438 }
439
440 switch (atype & 0xF0000000) {
441 case ATYPE_SECURITY_GLOBAL_GROUP:
442 case ATYPE_SECURITY_LOCAL_GROUP:
443 type = ID_TYPE_GID;
444 break;
445 case ATYPE_NORMAL_ACCOUNT:
446 case ATYPE_WORKSTATION_TRUST:
447 case ATYPE_INTERDOMAIN_TRUST:
448 type = ID_TYPE_UID;
449 break;
450 default:
451 DEBUG(1, ("unrecognized SAM account type %08x\n", atype));
452 continue;
453 }
454
455 if (!ads_pull_uint32(ctx->ads, entry, (type==ID_TYPE_UID) ?
456 ctx->ad_schema->posix_uidnumber_attr :
457 ctx->ad_schema->posix_gidnumber_attr,
458 &id))
459 {
460 DEBUG(1, ("Could not get unix ID\n"));
461 continue;
462 }
463
464 if (!idmap_unix_id_is_in_range(id, dom)) {
465 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
466 id, dom->low_id, dom->high_id));
467 continue;
468 }
469
470 map = find_map_by_id(&ids[bidx], type, id);
471 if (!map) {
472 DEBUG(2, ("WARNING: couldn't match result with requested ID\n"));
473 continue;
474 }
475
476 sid_copy(map->sid, &sid);
477
478 /* mapped */
479 map->status = ID_MAPPED;
480
481 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
482 (unsigned long)map->xid.id,
483 map->xid.type));
484 }
485
486 if (res) {
487 ads_msgfree(ctx->ads, res);
488 }
489
490 if (ids[idx]) { /* still some values to map */
491 goto again;
492 }
493
494 ret = NT_STATUS_OK;
495
496 /* mark all unknown/expired ones as unmapped */
497 for (i = 0; ids[i]; i++) {
498 if (ids[i]->status != ID_MAPPED)
499 ids[i]->status = ID_UNMAPPED;
500 }
501
502 done:
503 talloc_free(memctx);
504 return ret;
505 }
506
507 /************************************************************************
508 ***********************************************************************/
509
510 static NTSTATUS idmap_ad_sids_to_unixids(struct idmap_domain *dom, struct id_map **ids)
511 {
512 NTSTATUS ret;
513 TALLOC_CTX *memctx;
514 struct idmap_ad_context *ctx;
515 ADS_STATUS rc;
516 const char *attrs[] = { "sAMAccountType",
517 "objectSid",
518 NULL, /* attr_uidnumber */
519 NULL, /* attr_gidnumber */
520 NULL };
521 LDAPMessage *res = NULL;
522 LDAPMessage *entry = NULL;
523 char *filter = NULL;
524 int idx = 0;
525 int bidx = 0;
526 int count;
527 int i;
528 char *sidstr;
529
530 /* initialize the status to avoid suprise */
531 for (i = 0; ids[i]; i++) {
532 ids[i]->status = ID_UNKNOWN;
533 }
534
535 /* Only do query if we are online */
536 if (idmap_is_offline()) {
537 return NT_STATUS_FILE_IS_OFFLINE;
538 }
539
540 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
541
542 if ( (memctx = talloc_new(ctx)) == NULL ) {
543 DEBUG(0, ("Out of memory!\n"));
544 return NT_STATUS_NO_MEMORY;
545 }
546
547 rc = ad_idmap_cached_connection(dom);
548 if (!ADS_ERR_OK(rc)) {
549 DEBUG(1, ("ADS uninitialized: %s\n", ads_errstr(rc)));
550 ret = NT_STATUS_UNSUCCESSFUL;
551 /* ret = ads_ntstatus(rc); */
552 goto done;
553 }
554
555 if (ctx->ad_schema == NULL) {
556 DEBUG(0, ("haven't got ctx->ad_schema ! \n"));
557 ret = NT_STATUS_UNSUCCESSFUL;
558 goto done;
559 }
560
561 attrs[2] = ctx->ad_schema->posix_uidnumber_attr;
562 attrs[3] = ctx->ad_schema->posix_gidnumber_attr;
563
564 again:
565 filter = talloc_asprintf(memctx, "(&(|"
566 "(sAMAccountType=%d)(sAMAccountType=%d)(sAMAccountType=%d)" /* user account types */
567 "(sAMAccountType=%d)(sAMAccountType=%d)" /* group account types */
568 ")(|",
569 ATYPE_NORMAL_ACCOUNT, ATYPE_WORKSTATION_TRUST, ATYPE_INTERDOMAIN_TRUST,
570 ATYPE_SECURITY_GLOBAL_GROUP, ATYPE_SECURITY_LOCAL_GROUP);
571
572 CHECK_ALLOC_DONE(filter);
573
574 bidx = idx;
575 for (i = 0; (i < IDMAP_AD_MAX_IDS) && ids[idx]; i++, idx++) {
576
577 ids[idx]->status = ID_UNKNOWN;
578
579 sidstr = ldap_encode_ndr_dom_sid(talloc_tos(), ids[idx]->sid);
580 filter = talloc_asprintf_append_buffer(filter, "(objectSid=%s)", sidstr);
581
582 TALLOC_FREE(sidstr);
583 CHECK_ALLOC_DONE(filter);
584 }
585 filter = talloc_asprintf_append_buffer(filter, "))");
586 CHECK_ALLOC_DONE(filter);
587 DEBUG(10, ("Filter: [%s]\n", filter));
588
589 rc = ads_search_retry(ctx->ads, &res, filter, attrs);
590 if (!ADS_ERR_OK(rc)) {
591 DEBUG(1, ("ERROR: ads search returned: %s\n", ads_errstr(rc)));
592 ret = NT_STATUS_UNSUCCESSFUL;
593 goto done;
594 }
595
596 if ( (count = ads_count_replies(ctx->ads, res)) == 0 ) {
597 DEBUG(10, ("No IDs found\n"));
598 }
599
600 entry = res;
601 for (i = 0; (i < count) && entry; i++) {
602 struct dom_sid sid;
603 enum id_type type;
604 struct id_map *map;
605 uint32_t id;
606 uint32_t atype;
607
608 if (i == 0) { /* first entry */
609 entry = ads_first_entry(ctx->ads, entry);
610 } else { /* following ones */
611 entry = ads_next_entry(ctx->ads, entry);
612 }
613
614 if ( !entry ) {
615 DEBUG(2, ("ERROR: Unable to fetch ldap entries from results\n"));
616 break;
617 }
618
619 /* first check if the SID is present */
620 if (!ads_pull_sid(ctx->ads, entry, "objectSid", &sid)) {
621 DEBUG(2, ("Could not retrieve SID from entry\n"));
622 continue;
623 }
624
625 map = find_map_by_sid(&ids[bidx], &sid);
626 if (!map) {
627 DEBUG(2, ("WARNING: couldn't match result with requested SID\n"));
628 continue;
629 }
630
631 /* get type */
632 if (!ads_pull_uint32(ctx->ads, entry, "sAMAccountType", &atype)) {
633 DEBUG(1, ("could not get SAM account type\n"));
634 continue;
635 }
636
637 switch (atype & 0xF0000000) {
638 case ATYPE_SECURITY_GLOBAL_GROUP:
639 case ATYPE_SECURITY_LOCAL_GROUP:
640 type = ID_TYPE_GID;
641 break;
642 case ATYPE_NORMAL_ACCOUNT:
643 case ATYPE_WORKSTATION_TRUST:
644 case ATYPE_INTERDOMAIN_TRUST:
645 type = ID_TYPE_UID;
646 break;
647 default:
648 DEBUG(1, ("unrecognized SAM account type %08x\n", atype));
649 continue;
650 }
651
652 if (!ads_pull_uint32(ctx->ads, entry, (type==ID_TYPE_UID) ?
653 ctx->ad_schema->posix_uidnumber_attr :
654 ctx->ad_schema->posix_gidnumber_attr,
655 &id))
656 {
657 DEBUG(1, ("Could not get unix ID\n"));
658 continue;
659 }
660 if (!idmap_unix_id_is_in_range(id, dom)) {
661 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
662 id, dom->low_id, dom->high_id));
663 continue;
664 }
665
666 /* mapped */
667 map->xid.type = type;
668 map->xid.id = id;
669 map->status = ID_MAPPED;
670
671 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
672 (unsigned long)map->xid.id,
673 map->xid.type));
674 }
675
676 if (res) {
677 ads_msgfree(ctx->ads, res);
678 }
679
680 if (ids[idx]) { /* still some values to map */
681 goto again;
682 }
683
684 ret = NT_STATUS_OK;
685
686 /* mark all unknown/expired ones as unmapped */
687 for (i = 0; ids[i]; i++) {
688 if (ids[i]->status != ID_MAPPED)
689 ids[i]->status = ID_UNMAPPED;
690 }
691
692 done:
693 talloc_free(memctx);
694 return ret;
695 }
696
697 /*
698 * nss_info_{sfu,sfu20,rfc2307}
699 */
700
701 /************************************************************************
702 Initialize the {sfu,sfu20,rfc2307} state
703 ***********************************************************************/
704
705 static const char *wb_posix_map_unknown_string = "WB_POSIX_MAP_UNKNOWN";
706 static const char *wb_posix_map_template_string = "WB_POSIX_MAP_TEMPLATE";
707 static const char *wb_posix_map_sfu_string = "WB_POSIX_MAP_SFU";
708 static const char *wb_posix_map_sfu20_string = "WB_POSIX_MAP_SFU20";
709 static const char *wb_posix_map_rfc2307_string = "WB_POSIX_MAP_RFC2307";
710 static const char *wb_posix_map_unixinfo_string = "WB_POSIX_MAP_UNIXINFO";
711
712 static const char *ad_map_type_string(enum wb_posix_mapping map_type)
713 {
714 switch (map_type) {
715 case WB_POSIX_MAP_TEMPLATE:
716 return wb_posix_map_template_string;
717 case WB_POSIX_MAP_SFU:
718 return wb_posix_map_sfu_string;
719 case WB_POSIX_MAP_SFU20:
720 return wb_posix_map_sfu20_string;
721 case WB_POSIX_MAP_RFC2307:
722 return wb_posix_map_rfc2307_string;
723 case WB_POSIX_MAP_UNIXINFO:
724 return wb_posix_map_unixinfo_string;
725 default:
726 return wb_posix_map_unknown_string;
727 }
728 }
729
730 static NTSTATUS nss_ad_generic_init(struct nss_domain_entry *e,
731 enum wb_posix_mapping new_ad_map_type)
732 {
733 struct idmap_domain *dom;
734 struct idmap_ad_context *ctx;
735
736 if (e->state != NULL) {
737 dom = talloc_get_type(e->state, struct idmap_domain);
738 } else {
739 dom = talloc_zero(e, struct idmap_domain);
740 if (dom == NULL) {
741 DEBUG(0, ("Out of memory!\n"));
742 return NT_STATUS_NO_MEMORY;
743 }
744 e->state = dom;
745 }
746
747 if (e->domain != NULL) {
748 dom->name = talloc_strdup(dom, e->domain);
749 if (dom->name == NULL) {
750 DEBUG(0, ("Out of memory!\n"));
751 return NT_STATUS_NO_MEMORY;
752 }
753 }
754
755 if (dom->private_data != NULL) {
756 ctx = talloc_get_type(dom->private_data,
757 struct idmap_ad_context);
758 } else {
759 ctx = talloc_zero(dom, struct idmap_ad_context);
760 if (ctx == NULL) {
761 DEBUG(0, ("Out of memory!\n"));
762 return NT_STATUS_NO_MEMORY;
763 }
764 ctx->ad_map_type = WB_POSIX_MAP_RFC2307;
765 dom->private_data = ctx;
766 }
767
768 if ((ctx->ad_map_type != WB_POSIX_MAP_UNKNOWN) &&
769 (ctx->ad_map_type != new_ad_map_type))
770 {
771 DEBUG(2, ("nss_ad_generic_init: "
772 "Warning: overriding previously set posix map type "
773 "%s for domain %s with map type %s.\n",
774 ad_map_type_string(ctx->ad_map_type),
775 dom->name,
776 ad_map_type_string(new_ad_map_type)));
777 }
778
779 ctx->ad_map_type = new_ad_map_type;
780
781 return NT_STATUS_OK;
782 }
783
784 static NTSTATUS nss_sfu_init( struct nss_domain_entry *e )
785 {
786 return nss_ad_generic_init(e, WB_POSIX_MAP_SFU);
787 }
788
789 static NTSTATUS nss_sfu20_init( struct nss_domain_entry *e )
790 {
791 return nss_ad_generic_init(e, WB_POSIX_MAP_SFU20);
792 }
793
794 static NTSTATUS nss_rfc2307_init( struct nss_domain_entry *e )
795 {
796 return nss_ad_generic_init(e, WB_POSIX_MAP_RFC2307);
797 }
798
799
800 /************************************************************************
801 ***********************************************************************/
802
803 static NTSTATUS nss_ad_get_info( struct nss_domain_entry *e,
804 const struct dom_sid *sid,
805 TALLOC_CTX *mem_ctx,
806 const char **homedir,
807 const char **shell,
808 const char **gecos,
809 uint32 *gid )
810 {
811 const char *attrs[] = {NULL, /* attr_homedir */
812 NULL, /* attr_shell */
813 NULL, /* attr_gecos */
814 NULL, /* attr_gidnumber */
815 NULL };
816 char *filter = NULL;
817 LDAPMessage *msg_internal = NULL;
818 ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
819 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
820 char *sidstr = NULL;
821 struct idmap_domain *dom;
822 struct idmap_ad_context *ctx;
823
824 DEBUG(10, ("nss_ad_get_info called for sid [%s] in domain '%s'\n",
825 sid_string_dbg(sid), e->domain?e->domain:"NULL"));
826
827 /* Only do query if we are online */
828 if (idmap_is_offline()) {
829 return NT_STATUS_FILE_IS_OFFLINE;
830 }
831
832 dom = talloc_get_type(e->state, struct idmap_domain);
833 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
834
835 ads_status = ad_idmap_cached_connection(dom);
836 if (!ADS_ERR_OK(ads_status)) {
837 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
838 }
839
840 if (!ctx->ad_schema) {
841 DEBUG(10, ("nss_ad_get_info: no ad_schema configured!\n"));
842 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
843 }
844
845 if (!sid || !homedir || !shell || !gecos) {
846 return NT_STATUS_INVALID_PARAMETER;
847 }
848
849 /* Have to do our own query */
850
851 DEBUG(10, ("nss_ad_get_info: no ads connection given, doing our "
852 "own query\n"));
853
854 attrs[0] = ctx->ad_schema->posix_homedir_attr;
855 attrs[1] = ctx->ad_schema->posix_shell_attr;
856 attrs[2] = ctx->ad_schema->posix_gecos_attr;
857 attrs[3] = ctx->ad_schema->posix_gidnumber_attr;
858
859 sidstr = ldap_encode_ndr_dom_sid(mem_ctx, sid);
860 filter = talloc_asprintf(mem_ctx, "(objectSid=%s)", sidstr);
861 TALLOC_FREE(sidstr);
862
863 if (!filter) {
864 nt_status = NT_STATUS_NO_MEMORY;
865 goto done;
866 }
867
868 ads_status = ads_search_retry(ctx->ads, &msg_internal, filter, attrs);
869 if (!ADS_ERR_OK(ads_status)) {
870 nt_status = ads_ntstatus(ads_status);
871 goto done;
872 }
873
874 *homedir = ads_pull_string(ctx->ads, mem_ctx, msg_internal, ctx->ad_schema->posix_homedir_attr);
875 *shell = ads_pull_string(ctx->ads, mem_ctx, msg_internal, ctx->ad_schema->posix_shell_attr);
876 *gecos = ads_pull_string(ctx->ads, mem_ctx, msg_internal, ctx->ad_schema->posix_gecos_attr);
877
878 if (gid) {
879 if (!ads_pull_uint32(ctx->ads, msg_internal, ctx->ad_schema->posix_gidnumber_attr, gid))
880 *gid = (uint32)-1;
881 }
882
883 nt_status = NT_STATUS_OK;
884
885 done:
886 if (msg_internal) {
887 ads_msgfree(ctx->ads, msg_internal);
888 }
889
890 return nt_status;
891 }
892
893 /**********************************************************************
894 *********************************************************************/
895
896 static NTSTATUS nss_ad_map_to_alias(TALLOC_CTX *mem_ctx,
897 struct nss_domain_entry *e,
898 const char *name,
899 char **alias)
900 {
901 const char *attrs[] = {NULL, /* attr_uid */
902 NULL };
903 char *filter = NULL;
904 LDAPMessage *msg = NULL;
905 ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
906 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
907 struct idmap_domain *dom;
908 struct idmap_ad_context *ctx = NULL;
909
910 /* Check incoming parameters */
911
912 if ( !e || !e->domain || !name || !*alias) {
913 nt_status = NT_STATUS_INVALID_PARAMETER;
914 goto done;
915 }
916
917 /* Only do query if we are online */
918
919 if (idmap_is_offline()) {
920 nt_status = NT_STATUS_FILE_IS_OFFLINE;
921 goto done;
922 }
923
924 dom = talloc_get_type(e->state, struct idmap_domain);
925 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
926
927 ads_status = ad_idmap_cached_connection(dom);
928 if (!ADS_ERR_OK(ads_status)) {
929 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
930 }
931
932 if (!ctx->ad_schema) {
933 nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
934 goto done;
935 }
936
937 attrs[0] = ctx->ad_schema->posix_uid_attr;
938
939 filter = talloc_asprintf(mem_ctx,
940 "(sAMAccountName=%s)",
941 name);
942 if (!filter) {
943 nt_status = NT_STATUS_NO_MEMORY;
944 goto done;
945 }
946
947 ads_status = ads_search_retry(ctx->ads, &msg, filter, attrs);
948 if (!ADS_ERR_OK(ads_status)) {
949 nt_status = ads_ntstatus(ads_status);
950 goto done;
951 }
952
953 *alias = ads_pull_string(ctx->ads, mem_ctx, msg, ctx->ad_schema->posix_uid_attr);
954
955 if (!*alias) {
956 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
957 }
958
959 nt_status = NT_STATUS_OK;
960
961 done:
962 if (filter) {
963 talloc_destroy(filter);
964 }
965 if (msg) {
966 ads_msgfree(ctx->ads, msg);
967 }
968
969 return nt_status;
970 }
971
972 /**********************************************************************
973 *********************************************************************/
974
975 static NTSTATUS nss_ad_map_from_alias( TALLOC_CTX *mem_ctx,
976 struct nss_domain_entry *e,
977 const char *alias,
978 char **name )
979 {
980 const char *attrs[] = {"sAMAccountName",
981 NULL };
982 char *filter = NULL;
983 LDAPMessage *msg = NULL;
984 ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
985 NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
986 char *username;
987 struct idmap_domain *dom;
988 struct idmap_ad_context *ctx = NULL;
989
990 /* Check incoming parameters */
991
992 if ( !alias || !name) {
993 nt_status = NT_STATUS_INVALID_PARAMETER;
994 goto done;
995 }
996
997 /* Only do query if we are online */
998
999 if (idmap_is_offline()) {
1000 nt_status = NT_STATUS_FILE_IS_OFFLINE;
1001 goto done;
1002 }
1003
1004 dom = talloc_get_type(e->state, struct idmap_domain);
1005 ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
1006
1007 ads_status = ad_idmap_cached_connection(dom);
1008 if (!ADS_ERR_OK(ads_status)) {
1009 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1010 }
1011
1012 if (!ctx->ad_schema) {
1013 nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
1014 goto done;
1015 }
1016
1017 filter = talloc_asprintf(mem_ctx,
1018 "(%s=%s)",
1019 ctx->ad_schema->posix_uid_attr,
1020 alias);
1021 if (!filter) {
1022 nt_status = NT_STATUS_NO_MEMORY;
1023 goto done;
1024 }
1025
1026 ads_status = ads_search_retry(ctx->ads, &msg, filter, attrs);
1027 if (!ADS_ERR_OK(ads_status)) {
1028 nt_status = ads_ntstatus(ads_status);
1029 goto done;
1030 }
1031
1032 username = ads_pull_string(ctx->ads, mem_ctx, msg,
1033 "sAMAccountName");
1034 if (!username) {
1035 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1036 }
1037
1038 *name = talloc_asprintf(mem_ctx, "%s\\%s",
1039 lp_workgroup(),
1040 username);
1041 if (!*name) {
1042 nt_status = NT_STATUS_NO_MEMORY;
1043 goto done;
1044 }
1045
1046 nt_status = NT_STATUS_OK;
1047
1048 done:
1049 if (filter) {
1050 talloc_destroy(filter);
1051 }
1052 if (msg) {
1053 ads_msgfree(ctx->ads, msg);
1054 }
1055
1056 return nt_status;
1057 }
1058
1059 /************************************************************************
1060 Function dispatch tables for the idmap and nss plugins
1061 ***********************************************************************/
1062
1063 static struct idmap_methods ad_methods = {
1064 .init = idmap_ad_initialize,
1065 .unixids_to_sids = idmap_ad_unixids_to_sids,
1066 .sids_to_unixids = idmap_ad_sids_to_unixids,
1067 };
1068
1069 /* The SFU and RFC2307 NSS plugins share everything but the init
1070 function which sets the intended schema model to use */
1071
1072 static struct nss_info_methods nss_rfc2307_methods = {
1073 .init = nss_rfc2307_init,
1074 .get_nss_info = nss_ad_get_info,
1075 .map_to_alias = nss_ad_map_to_alias,
1076 .map_from_alias = nss_ad_map_from_alias,
1077 };
1078
1079 static struct nss_info_methods nss_sfu_methods = {
1080 .init = nss_sfu_init,
1081 .get_nss_info = nss_ad_get_info,
1082 .map_to_alias = nss_ad_map_to_alias,
1083 .map_from_alias = nss_ad_map_from_alias,
1084 };
1085
1086 static struct nss_info_methods nss_sfu20_methods = {
1087 .init = nss_sfu20_init,
1088 .get_nss_info = nss_ad_get_info,
1089 .map_to_alias = nss_ad_map_to_alias,
1090 .map_from_alias = nss_ad_map_from_alias,
1091 };
1092
1093
1094
1095 /************************************************************************
1096 Initialize the plugins
1097 ***********************************************************************/
1098
1099 NTSTATUS idmap_ad_init(void)
1100 {
1101 static NTSTATUS status_idmap_ad = NT_STATUS_UNSUCCESSFUL;
1102 static NTSTATUS status_nss_rfc2307 = NT_STATUS_UNSUCCESSFUL;
1103 static NTSTATUS status_nss_sfu = NT_STATUS_UNSUCCESSFUL;
1104 static NTSTATUS status_nss_sfu20 = NT_STATUS_UNSUCCESSFUL;
1105
1106 /* Always register the AD method first in order to get the
1107 idmap_domain interface called */
1108
1109 if ( !NT_STATUS_IS_OK(status_idmap_ad) ) {
1110 status_idmap_ad = smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION,
1111 "ad", &ad_methods);
1112 if ( !NT_STATUS_IS_OK(status_idmap_ad) )
1113 return status_idmap_ad;
1114 }
1115
1116 if ( !NT_STATUS_IS_OK( status_nss_rfc2307 ) ) {
1117 status_nss_rfc2307 = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1118 "rfc2307", &nss_rfc2307_methods );
1119 if ( !NT_STATUS_IS_OK(status_nss_rfc2307) )
1120 return status_nss_rfc2307;
1121 }
1122
1123 if ( !NT_STATUS_IS_OK( status_nss_sfu ) ) {
1124 status_nss_sfu = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1125 "sfu", &nss_sfu_methods );
1126 if ( !NT_STATUS_IS_OK(status_nss_sfu) )
1127 return status_nss_sfu;
1128 }
1129
1130 if ( !NT_STATUS_IS_OK( status_nss_sfu20 ) ) {
1131 status_nss_sfu20 = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1132 "sfu20", &nss_sfu20_methods );
1133 if ( !NT_STATUS_IS_OK(status_nss_sfu20) )
1134 return status_nss_sfu20;
1135 }
1136
1137 return NT_STATUS_OK;
1138 }
1139
reg import