?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drsuapi.idl: fix source_dsa spelling
[samba4-gss.git] / source4 / dsdb / samdb / cracknames.c
blobc04d4aed572388de31d074a3da01b5f5c50015cd
1 /*
2 Unix SMB/CIFS implementation.
3
4 crachnames implementation for the drsuapi pipe
5 DsCrackNames()
6
7 Copyright (C) Stefan Metzmacher 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
9 Copyright (C) Matthieu Patou <mat@matws.net> 2012
10 Copyright (C) Catalyst .Net Ltd 2017
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 "librpc/gen_ndr/drsuapi.h"
28 #include "lib/events/events.h"
29 #include <ldb.h>
30 #include <ldb_errors.h>
31 #include "auth/kerberos/kerberos.h"
32 #include "libcli/ldap/ldap_ndr.h"
33 #include "libcli/security/security.h"
34 #include "auth/auth.h"
35 #include "../lib/util/util_ldb.h"
36 #include "dsdb/samdb/samdb.h"
37 #include "dsdb/common/util.h"
38 #include "param/param.h"
39
40 #undef strcasecmp
41
42 static WERROR DsCrackNameOneFilter(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
43 struct smb_krb5_context *smb_krb5_context,
44 uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
45 enum drsuapi_DsNameFormat format_desired,
46 struct ldb_dn *name_dn, const char *name,
47 const char *domain_filter, const char *result_filter,
48 struct drsuapi_DsNameInfo1 *info1, int scope, struct ldb_dn *search_dn);
49 static WERROR DsCrackNameOneSyntactical(TALLOC_CTX *mem_ctx,
50 enum drsuapi_DsNameFormat format_offered,
51 enum drsuapi_DsNameFormat format_desired,
52 struct ldb_dn *name_dn, const char *name,
53 struct drsuapi_DsNameInfo1 *info1);
54
55 static WERROR dns_domain_from_principal(TALLOC_CTX *mem_ctx, struct smb_krb5_context *smb_krb5_context,
56 const char *name,
57 struct drsuapi_DsNameInfo1 *info1)
58 {
59 krb5_error_code ret;
60 krb5_principal principal;
61 /* perhaps it's a principal with a realm, so return the right 'domain only' response */
62 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
63 KRB5_PRINCIPAL_PARSE_REQUIRE_REALM, &principal);
64 if (ret) {
65 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
66 return WERR_OK;
67 }
68
69 info1->dns_domain_name = smb_krb5_principal_get_realm(
70 mem_ctx, smb_krb5_context->krb5_context, principal);
71 krb5_free_principal(smb_krb5_context->krb5_context, principal);
72
73 W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
74
75 info1->status = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
76 return WERR_OK;
77 }
78
79 static enum drsuapi_DsNameStatus LDB_lookup_spn_alias(struct ldb_context *ldb_ctx,
80 TALLOC_CTX *mem_ctx,
81 const char *alias_from,
82 char **alias_to)
83 {
84 /*
85 * Some of the logic of this function is mirrored in find_spn_alias()
86 * in source4/dsdb/samdb/ldb_modules/samldb.c. If you change this to
87 * not return the first matched alias, you will need to rethink that
88 * function too.
89 */
90 unsigned int i;
91 int ret;
92 struct ldb_result *res;
93 struct ldb_message_element *spnmappings;
94 TALLOC_CTX *tmp_ctx;
95 struct ldb_dn *service_dn;
96 char *service_dn_str;
97
98 const char *directory_attrs[] = {
99 "sPNMappings",
100 NULL
101 };
102
103 tmp_ctx = talloc_new(mem_ctx);
104 if (!tmp_ctx) {
105 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
106 }
107
108 service_dn = ldb_dn_new(tmp_ctx, ldb_ctx, "CN=Directory Service,CN=Windows NT,CN=Services");
109 if ( ! ldb_dn_add_base(service_dn, ldb_get_config_basedn(ldb_ctx))) {
110 talloc_free(tmp_ctx);
111 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
112 }
113 service_dn_str = ldb_dn_alloc_linearized(tmp_ctx, service_dn);
114 if ( ! service_dn_str) {
115 talloc_free(tmp_ctx);
116 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
117 }
118
119 ret = ldb_search(ldb_ctx, tmp_ctx, &res, service_dn, LDB_SCOPE_BASE,
120 directory_attrs, "(objectClass=nTDSService)");
121
122 if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
123 DEBUG(1, ("ldb_search: dn: %s not found: %s\n", service_dn_str, ldb_errstring(ldb_ctx)));
124 talloc_free(tmp_ctx);
125 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
126 } else if (ret == LDB_ERR_NO_SUCH_OBJECT) {
127 DEBUG(1, ("ldb_search: dn: %s not found\n", service_dn_str));
128 talloc_free(tmp_ctx);
129 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
130 } else if (res->count != 1) {
131 DEBUG(1, ("ldb_search: dn: %s not found\n", service_dn_str));
132 talloc_free(tmp_ctx);
133 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
134 }
135
136 spnmappings = ldb_msg_find_element(res->msgs[0], "sPNMappings");
137 if (!spnmappings || spnmappings->num_values == 0) {
138 DEBUG(1, ("ldb_search: dn: %s no sPNMappings attribute\n", service_dn_str));
139 talloc_free(tmp_ctx);
140 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
141 }
142
143 for (i = 0; i < spnmappings->num_values; i++) {
144 char *mapping, *p, *str;
145 mapping = talloc_strdup(tmp_ctx,
146 (const char *)spnmappings->values[i].data);
147 if (!mapping) {
148 DEBUG(1, ("LDB_lookup_spn_alias: ldb_search: dn: %s did not have an sPNMapping\n", service_dn_str));
149 talloc_free(tmp_ctx);
150 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
151 }
152
153 /* C string manipulation sucks */
154
155 p = strchr(mapping, '=');
156 if (!p) {
157 DEBUG(1, ("ldb_search: dn: %s sPNMapping malformed: %s\n",
158 service_dn_str, mapping));
159 talloc_free(tmp_ctx);
160 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
161 }
162 p[0] = '\0';
163 p++;
164 do {
165 str = p;
166 p = strchr(p, ',');
167 if (p) {
168 p[0] = '\0';
169 p++;
170 }
171 if (strcasecmp(str, alias_from) == 0) {
172 *alias_to = mapping;
173 talloc_steal(mem_ctx, mapping);
174 talloc_free(tmp_ctx);
175 return DRSUAPI_DS_NAME_STATUS_OK;
176 }
177 } while (p);
178 }
179 DEBUG(4, ("LDB_lookup_spn_alias: no alias for service %s applicable\n", alias_from));
180 talloc_free(tmp_ctx);
181 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
182 }
183
184 /* When cracking a ServicePrincipalName, many services may be served
185 * by the host/ servicePrincipalName. The incoming query is for cifs/
186 * but we translate it here, and search on host/. This is done after
187 * the cifs/ entry has been searched for, making this a fallback */
188
189 static WERROR DsCrackNameSPNAlias(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
190 struct smb_krb5_context *smb_krb5_context,
191 uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
192 enum drsuapi_DsNameFormat format_desired,
193 const char *name, struct drsuapi_DsNameInfo1 *info1)
194 {
195 WERROR wret;
196 krb5_error_code ret;
197 krb5_principal principal;
198 krb5_data component;
199 const char *service, *dns_name;
200 char *new_service;
201 char *new_princ;
202 enum drsuapi_DsNameStatus namestatus;
203
204 /* parse principal */
205 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context,
206 name, KRB5_PRINCIPAL_PARSE_NO_REALM, &principal);
207 if (ret) {
208 DEBUG(2, ("Could not parse principal: %s: %s\n",
209 name, smb_get_krb5_error_message(smb_krb5_context->krb5_context,
210 ret, mem_ctx)));
211 return WERR_NOT_ENOUGH_MEMORY;
212 }
213
214 /* grab cifs/, http/ etc */
215
216 ret = smb_krb5_princ_component(smb_krb5_context->krb5_context,
217 principal, 0, &component);
218 if (ret) {
219 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
220 krb5_free_principal(smb_krb5_context->krb5_context, principal);
221 return WERR_OK;
222 }
223 service = (const char *)component.data;
224 ret = smb_krb5_princ_component(smb_krb5_context->krb5_context,
225 principal, 1, &component);
226 if (ret) {
227 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
228 krb5_free_principal(smb_krb5_context->krb5_context, principal);
229 return WERR_OK;
230 }
231 dns_name = (const char *)component.data;
232
233 /* MAP it */
234 namestatus = LDB_lookup_spn_alias(sam_ctx, mem_ctx,
235 service, &new_service);
236
237 if (namestatus == DRSUAPI_DS_NAME_STATUS_NOT_FOUND) {
238 wret = WERR_OK;
239 info1->status = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
240 info1->dns_domain_name = talloc_strdup(mem_ctx, dns_name);
241 if (!info1->dns_domain_name) {
242 wret = WERR_NOT_ENOUGH_MEMORY;
243 }
244 krb5_free_principal(smb_krb5_context->krb5_context, principal);
245 return wret;
246 } else if (namestatus != DRSUAPI_DS_NAME_STATUS_OK) {
247 info1->status = namestatus;
248 krb5_free_principal(smb_krb5_context->krb5_context, principal);
249 return WERR_OK;
250 }
251
252 /* reform principal */
253 new_princ = talloc_asprintf(mem_ctx, "%s/%s", new_service, dns_name);
254 if (!new_princ) {
255 krb5_free_principal(smb_krb5_context->krb5_context, principal);
256 return WERR_NOT_ENOUGH_MEMORY;
257 }
258
259 wret = DsCrackNameOneName(sam_ctx, mem_ctx, format_flags, format_offered, format_desired,
260 new_princ, info1);
261 talloc_free(new_princ);
262 if (W_ERROR_IS_OK(wret) && (info1->status == DRSUAPI_DS_NAME_STATUS_NOT_FOUND)) {
263 info1->status = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
264 info1->dns_domain_name = talloc_strdup(mem_ctx, dns_name);
265 if (!info1->dns_domain_name) {
266 wret = WERR_NOT_ENOUGH_MEMORY;
267 }
268 }
269 krb5_free_principal(smb_krb5_context->krb5_context, principal);
270 return wret;
271 }
272
273 /* Subcase of CrackNames, for the userPrincipalName */
274
275 static WERROR DsCrackNameUPN(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
276 struct smb_krb5_context *smb_krb5_context,
277 uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
278 enum drsuapi_DsNameFormat format_desired,
279 const char *name, struct drsuapi_DsNameInfo1 *info1)
280 {
281 int ldb_ret;
282 WERROR status;
283 const char *domain_filter = NULL;
284 const char *result_filter = NULL;
285 krb5_error_code ret;
286 krb5_principal principal;
287 char *realm;
288 char *realm_encoded = NULL;
289 char *unparsed_name_short;
290 const char *unparsed_name_short_encoded = NULL;
291 const char *domain_attrs[] = { NULL };
292 struct ldb_result *domain_res = NULL;
293
294 /* Prevent recursion */
295 if (!name) {
296 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
297 return WERR_OK;
298 }
299
300 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
301 KRB5_PRINCIPAL_PARSE_REQUIRE_REALM, &principal);
302 if (ret) {
303 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
304 return WERR_OK;
305 }
306
307 realm = smb_krb5_principal_get_realm(
308 mem_ctx, smb_krb5_context->krb5_context, principal);
309 if (realm == NULL) {
310 krb5_free_principal(smb_krb5_context->krb5_context, principal);
311 return WERR_NOT_ENOUGH_MEMORY;
312 }
313
314 realm_encoded = ldb_binary_encode_string(mem_ctx, realm);
315 if (realm_encoded == NULL) {
316 TALLOC_FREE(realm);
317 krb5_free_principal(smb_krb5_context->krb5_context, principal);
318 return WERR_NOT_ENOUGH_MEMORY;
319 }
320
321 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
322 samdb_partitions_dn(sam_ctx, mem_ctx),
323 LDB_SCOPE_ONELEVEL,
324 domain_attrs,
325 "(&(objectClass=crossRef)(|(dnsRoot=%s)(netbiosName=%s))"
326 "(systemFlags:"LDB_OID_COMPARATOR_AND":=%u))",
327 realm_encoded,
328 realm_encoded,
329 SYSTEM_FLAG_CR_NTDS_DOMAIN);
330 TALLOC_FREE(realm_encoded);
331 TALLOC_FREE(realm);
332
333 if (ldb_ret != LDB_SUCCESS) {
334 DEBUG(2, ("DsCrackNameUPN domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
335 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
336 krb5_free_principal(smb_krb5_context->krb5_context, principal);
337 return WERR_OK;
338 }
339
340 switch (domain_res->count) {
341 case 1:
342 break;
343 case 0:
344 krb5_free_principal(smb_krb5_context->krb5_context, principal);
345 return dns_domain_from_principal(mem_ctx, smb_krb5_context,
346 name, info1);
347 default:
348 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
349 krb5_free_principal(smb_krb5_context->krb5_context, principal);
350 return WERR_OK;
351 }
352
353 /*
354 * The important thing here is that a samAccountName may have
355 * a space in it, and this must not be kerberos escaped to
356 * match this filter, so we specify
357 * KRB5_PRINCIPAL_UNPARSE_DISPLAY
358 */
359 ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context, principal,
360 KRB5_PRINCIPAL_UNPARSE_NO_REALM |
361 KRB5_PRINCIPAL_UNPARSE_DISPLAY,
362 &unparsed_name_short);
363 krb5_free_principal(smb_krb5_context->krb5_context, principal);
364
365 if (ret) {
366 free(unparsed_name_short);
367 return WERR_NOT_ENOUGH_MEMORY;
368 }
369
370 unparsed_name_short_encoded = ldb_binary_encode_string(mem_ctx, unparsed_name_short);
371 if (unparsed_name_short_encoded == NULL) {
372 free(unparsed_name_short);
373 return WERR_NOT_ENOUGH_MEMORY;
374 }
375
376 /* This may need to be extended for more userPrincipalName variations */
377 result_filter = talloc_asprintf(mem_ctx, "(&(samAccountName=%s)(objectClass=user))",
378 unparsed_name_short_encoded);
379
380 domain_filter = talloc_asprintf(mem_ctx, "(distinguishedName=%s)", ldb_dn_get_linearized(domain_res->msgs[0]->dn));
381
382 if (!result_filter || !domain_filter) {
383 free(unparsed_name_short);
384 return WERR_NOT_ENOUGH_MEMORY;
385 }
386 status = DsCrackNameOneFilter(sam_ctx, mem_ctx,
387 smb_krb5_context,
388 format_flags, format_offered, format_desired,
389 NULL, unparsed_name_short, domain_filter, result_filter,
390 info1, LDB_SCOPE_SUBTREE, NULL);
391 free(unparsed_name_short);
392
393 return status;
394 }
395
396 /*
397 * This function will workout the filtering parameter in order to be able to do
398 * the adapted search when the incoming format is format_functional.
399 * This boils down to defining the search_dn (passed as pointer to ldb_dn *) and the
400 * ldap filter request.
401 * Main input parameters are:
402 * * name, which is the portion of the functional name after the
403 * first '/'.
404 * * domain_filter, which is a ldap search filter used to find the NC DN given the
405 * function name to crack.
406 */
407 static WERROR get_format_functional_filtering_param(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
408 char *name, struct drsuapi_DsNameInfo1 *info1,
409 struct ldb_dn **psearch_dn, const char *domain_filter, const char **presult_filter)
410 {
411 struct ldb_result *domain_res = NULL;
412 const char * const domain_attrs[] = {"ncName", NULL};
413 struct ldb_dn *partitions_basedn = samdb_partitions_dn(sam_ctx, mem_ctx);
414 int ldb_ret;
415 char *account, *s, *result_filter = NULL;
416 struct ldb_dn *search_dn = NULL;
417
418 *psearch_dn = NULL;
419 *presult_filter = NULL;
420
421 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
422 partitions_basedn,
423 LDB_SCOPE_ONELEVEL,
424 domain_attrs,
425 "%s", domain_filter);
426
427 if (ldb_ret != LDB_SUCCESS) {
428 DEBUG(2, ("DsCrackNameOne domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
429 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
430 return WERR_FOOBAR;
431 }
432
433 if (domain_res->count == 1) {
434 struct ldb_dn *tmp_dn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
435 const char * const name_attrs[] = {"name", NULL};
436
437 account = name;
438 s = strchr(account, '/');
439 talloc_free(domain_res);
440 while(s) {
441 s[0] = '\0';
442 s++;
443
444 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
445 tmp_dn,
446 LDB_SCOPE_ONELEVEL,
447 name_attrs,
448 "name=%s", account);
449
450 if (ldb_ret != LDB_SUCCESS) {
451 DEBUG(2, ("DsCrackNameOne domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
452 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
453 return WERR_OK;
454 }
455 talloc_free(tmp_dn);
456 switch (domain_res->count) {
457 case 1:
458 break;
459 case 0:
460 talloc_free(domain_res);
461 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
462 return WERR_OK;
463 default:
464 talloc_free(domain_res);
465 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
466 return WERR_OK;
467 }
468
469 tmp_dn = talloc_steal(mem_ctx, domain_res->msgs[0]->dn);
470 talloc_free(domain_res);
471 search_dn = tmp_dn;
472 account = s;
473 s = strchr(account, '/');
474 }
475 account = ldb_binary_encode_string(mem_ctx, account);
476 W_ERROR_HAVE_NO_MEMORY(account);
477 result_filter = talloc_asprintf(mem_ctx, "(name=%s)",
478 account);
479 W_ERROR_HAVE_NO_MEMORY(result_filter);
480 }
481 *psearch_dn = search_dn;
482 *presult_filter = result_filter;
483 return WERR_OK;
484 }
485
486 /* Crack a single 'name', from format_offered into format_desired, returning the result in info1 */
487
488 WERROR DsCrackNameOneName(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
489 uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
490 enum drsuapi_DsNameFormat format_desired,
491 const char *name, struct drsuapi_DsNameInfo1 *info1)
492 {
493 krb5_error_code ret;
494 const char *domain_filter = NULL;
495 const char *result_filter = NULL;
496 struct ldb_dn *name_dn = NULL;
497 struct ldb_dn *search_dn = NULL;
498
499 struct smb_krb5_context *smb_krb5_context = NULL;
500 int scope = LDB_SCOPE_SUBTREE;
501
502 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
503 info1->dns_domain_name = NULL;
504 info1->result_name = NULL;
505
506 if (!name) {
507 return WERR_INVALID_PARAMETER;
508 }
509
510 /* TODO: - fill the correct names in all cases!
511 * - handle format_flags
512 */
513 if (format_desired == DRSUAPI_DS_NAME_FORMAT_UNKNOWN) {
514 return WERR_OK;
515 }
516 /* here we need to set the domain_filter and/or the result_filter */
517 switch (format_offered) {
518 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN:
519 {
520 unsigned int i;
521 enum drsuapi_DsNameFormat formats[] = {
522 DRSUAPI_DS_NAME_FORMAT_FQDN_1779, DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
523 DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT, DRSUAPI_DS_NAME_FORMAT_CANONICAL,
524 DRSUAPI_DS_NAME_FORMAT_GUID, DRSUAPI_DS_NAME_FORMAT_DISPLAY,
525 DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
526 DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY,
527 DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX
528 };
529 WERROR werr;
530 for (i=0; i < ARRAY_SIZE(formats); i++) {
531 werr = DsCrackNameOneName(sam_ctx, mem_ctx, format_flags, formats[i], format_desired, name, info1);
532 if (!W_ERROR_IS_OK(werr)) {
533 return werr;
534 }
535 if (info1->status != DRSUAPI_DS_NAME_STATUS_NOT_FOUND &&
536 (formats[i] != DRSUAPI_DS_NAME_FORMAT_CANONICAL ||
537 info1->status != DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR))
538 {
539 return werr;
540 }
541 }
542 return werr;
543 }
544
545 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
546 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
547 {
548 char *str, *s, *account;
549 const char *str_encoded = NULL;
550 scope = LDB_SCOPE_ONELEVEL;
551
552 if (strlen(name) == 0) {
553 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
554 return WERR_OK;
555 }
556
557 str = talloc_strdup(mem_ctx, name);
558 W_ERROR_HAVE_NO_MEMORY(str);
559
560 if (format_offered == DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX) {
561 /* Look backwards for the \n, and replace it with / */
562 s = strrchr(str, '\n');
563 if (!s) {
564 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
565 return WERR_OK;
566 }
567 s[0] = '/';
568 }
569
570 s = strchr(str, '/');
571 if (!s) {
572 /* there must be at least one / */
573 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
574 return WERR_OK;
575 }
576
577 s[0] = '\0';
578 s++;
579
580 str_encoded = ldb_binary_encode_string(mem_ctx, str);
581 if (str_encoded == NULL) {
582 return WERR_NOT_ENOUGH_MEMORY;
583 }
584
585 domain_filter = talloc_asprintf(mem_ctx, "(&(objectClass=crossRef)(dnsRoot=%s)(systemFlags:%s:=%u))",
586 str_encoded,
587 LDB_OID_COMPARATOR_AND,
588 SYSTEM_FLAG_CR_NTDS_DOMAIN);
589 W_ERROR_HAVE_NO_MEMORY(domain_filter);
590
591 /* There may not be anything after the domain component (search for the domain itself) */
592 account = s;
593 if (account && *account) {
594 WERROR werr = get_format_functional_filtering_param(sam_ctx,
595 mem_ctx,
596 account,
597 info1,
598 &search_dn,
599 domain_filter,
600 &result_filter);
601 if (!W_ERROR_IS_OK(werr)) {
602 return werr;
603 }
604 if (info1->status != DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR)
605 return WERR_OK;
606 }
607 break;
608 }
609 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: {
610 char *p;
611 char *domain;
612 char *domain_encoded = NULL;
613 const char *account = NULL;
614
615 domain = talloc_strdup(mem_ctx, name);
616 W_ERROR_HAVE_NO_MEMORY(domain);
617
618 p = strchr(domain, '\\');
619 if (!p) {
620 /* invalid input format */
621 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
622 return WERR_OK;
623 }
624 p[0] = '\0';
625
626 if (p[1]) {
627 account = &p[1];
628 }
629
630 domain_encoded = ldb_binary_encode_string(mem_ctx, domain);
631 if (domain_encoded == NULL) {
632 return WERR_NOT_ENOUGH_MEMORY;
633 }
634
635 domain_filter = talloc_asprintf(mem_ctx,
636 "(&(objectClass=crossRef)(netbiosName=%s)(systemFlags:%s:=%u))",
637 domain_encoded,
638 LDB_OID_COMPARATOR_AND,
639 SYSTEM_FLAG_CR_NTDS_DOMAIN);
640 W_ERROR_HAVE_NO_MEMORY(domain_filter);
641 if (account) {
642 const char *account_encoded = NULL;
643
644 account_encoded = ldb_binary_encode_string(mem_ctx, account);
645 if (account_encoded == NULL) {
646 return WERR_NOT_ENOUGH_MEMORY;
647 }
648
649 result_filter = talloc_asprintf(mem_ctx, "(sAMAccountName=%s)",
650 account_encoded);
651 W_ERROR_HAVE_NO_MEMORY(result_filter);
652 }
653
654 talloc_free(domain);
655 break;
656 }
657
658 /* A LDAP DN as a string */
659 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: {
660 domain_filter = NULL;
661 name_dn = ldb_dn_new(mem_ctx, sam_ctx, name);
662 if (! ldb_dn_validate(name_dn)) {
663 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
664 return WERR_OK;
665 }
666 break;
667 }
668
669 /* A GUID as a string */
670 case DRSUAPI_DS_NAME_FORMAT_GUID: {
671 struct GUID guid;
672 char *ldap_guid;
673 NTSTATUS nt_status;
674 domain_filter = NULL;
675
676 nt_status = GUID_from_string(name, &guid);
677 if (!NT_STATUS_IS_OK(nt_status)) {
678 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
679 return WERR_OK;
680 }
681
682 ldap_guid = ldap_encode_ndr_GUID(mem_ctx, &guid);
683 if (!ldap_guid) {
684 return WERR_NOT_ENOUGH_MEMORY;
685 }
686 result_filter = talloc_asprintf(mem_ctx, "(objectGUID=%s)",
687 ldap_guid);
688 W_ERROR_HAVE_NO_MEMORY(result_filter);
689 break;
690 }
691 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: {
692 const char *name_encoded = NULL;
693
694 domain_filter = NULL;
695
696 name_encoded = ldb_binary_encode_string(mem_ctx, name);
697 if (name_encoded == NULL) {
698 return WERR_NOT_ENOUGH_MEMORY;
699 }
700
701 result_filter = talloc_asprintf(mem_ctx, "(|(displayName=%s)(samAccountName=%s))",
702 name_encoded,
703 name_encoded);
704 W_ERROR_HAVE_NO_MEMORY(result_filter);
705 break;
706 }
707
708 /* A S-1234-5678 style string */
709 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: {
710 struct dom_sid *sid = dom_sid_parse_talloc(mem_ctx, name);
711 char *ldap_sid;
712
713 domain_filter = NULL;
714 if (!sid) {
715 info1->dns_domain_name = NULL;
716 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
717 return WERR_OK;
718 }
719 ldap_sid = ldap_encode_ndr_dom_sid(mem_ctx,
720 sid);
721 if (!ldap_sid) {
722 return WERR_NOT_ENOUGH_MEMORY;
723 }
724 result_filter = talloc_asprintf(mem_ctx, "(objectSid=%s)",
725 ldap_sid);
726 W_ERROR_HAVE_NO_MEMORY(result_filter);
727 break;
728 }
729 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: {
730 krb5_principal principal;
731 char *unparsed_name;
732 const char *unparsed_name_encoded = NULL;
733
734 ret = smb_krb5_init_context(mem_ctx,
735 (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
736 &smb_krb5_context);
737
738 if (ret) {
739 return WERR_NOT_ENOUGH_MEMORY;
740 }
741
742 /* Ensure we reject complete junk first */
743 ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
744 if (ret) {
745 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
746 return WERR_OK;
747 }
748
749 domain_filter = NULL;
750
751 /*
752 * By getting the unparsed name here, we ensure the
753 * escaping is removed correctly (and trust the client
754 * less). The important thing here is that a
755 * userPrincipalName may have a space in it, and this
756 * must not be kerberos escaped to match this filter,
757 * so we specify KRB5_PRINCIPAL_UNPARSE_DISPLAY
758 */
759 ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context,
760 principal,
761 KRB5_PRINCIPAL_UNPARSE_DISPLAY,
762 &unparsed_name);
763 if (ret) {
764 krb5_free_principal(smb_krb5_context->krb5_context, principal);
765 return WERR_NOT_ENOUGH_MEMORY;
766 }
767
768 krb5_free_principal(smb_krb5_context->krb5_context, principal);
769
770 /* The ldb_binary_encode_string() here avoids LDAP filter injection attacks */
771 unparsed_name_encoded = ldb_binary_encode_string(mem_ctx, unparsed_name);
772 if (unparsed_name_encoded == NULL) {
773 return WERR_NOT_ENOUGH_MEMORY;
774 }
775
776 result_filter = talloc_asprintf(mem_ctx, "(&(userPrincipalName=%s)(objectClass=user))",
777 unparsed_name_encoded);
778
779 free(unparsed_name);
780 W_ERROR_HAVE_NO_MEMORY(result_filter);
781 break;
782 }
783 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: {
784 krb5_principal principal;
785 char *unparsed_name_short;
786 const char *unparsed_name_short_encoded = NULL;
787 bool principal_is_host = false;
788
789 ret = smb_krb5_init_context(mem_ctx,
790 (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
791 &smb_krb5_context);
792
793 if (ret) {
794 return WERR_NOT_ENOUGH_MEMORY;
795 }
796
797 ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
798 if (ret == 0 &&
799 krb5_princ_size(smb_krb5_context->krb5_context,
800 principal) < 2) {
801 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
802 krb5_free_principal(smb_krb5_context->krb5_context, principal);
803 return WERR_OK;
804 } else if (ret == 0) {
805 krb5_free_principal(smb_krb5_context->krb5_context, principal);
806 }
807 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
808 KRB5_PRINCIPAL_PARSE_NO_REALM, &principal);
809 if (ret) {
810 return dns_domain_from_principal(mem_ctx, smb_krb5_context,
811 name, info1);
812 }
813
814 domain_filter = NULL;
815
816 ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context, principal,
817 KRB5_PRINCIPAL_UNPARSE_NO_REALM, &unparsed_name_short);
818 if (ret) {
819 krb5_free_principal(smb_krb5_context->krb5_context, principal);
820 return WERR_NOT_ENOUGH_MEMORY;
821 }
822
823 unparsed_name_short_encoded = ldb_binary_encode_string(mem_ctx, unparsed_name_short);
824 if (unparsed_name_short_encoded == NULL) {
825 krb5_free_principal(smb_krb5_context->krb5_context, principal);
826 free(unparsed_name_short);
827 return WERR_NOT_ENOUGH_MEMORY;
828 }
829
830 if ((krb5_princ_size(smb_krb5_context->krb5_context, principal) == 2)) {
831 krb5_data component;
832
833 ret = smb_krb5_princ_component(smb_krb5_context->krb5_context,
834 principal, 0, &component);
835 if (ret) {
836 krb5_free_principal(smb_krb5_context->krb5_context, principal);
837 free(unparsed_name_short);
838 return WERR_INTERNAL_ERROR;
839 }
840
841 principal_is_host = strcasecmp(component.data, "host") == 0;
842 }
843
844 if (principal_is_host) {
845 /* the 'cn' attribute is just the leading part of the name */
846 krb5_data component;
847 char *computer_name;
848 const char *computer_name_encoded = NULL;
849 ret = smb_krb5_princ_component(
850 smb_krb5_context->krb5_context,
851 principal, 1, &component);
852 if (ret) {
853 krb5_free_principal(smb_krb5_context->krb5_context, principal);
854 free(unparsed_name_short);
855 return WERR_INTERNAL_ERROR;
856 }
857 computer_name = talloc_strndup(mem_ctx, (char *)component.data,
858 strcspn((char *)component.data, "."));
859 if (computer_name == NULL) {
860 krb5_free_principal(smb_krb5_context->krb5_context, principal);
861 free(unparsed_name_short);
862 return WERR_NOT_ENOUGH_MEMORY;
863 }
864
865 computer_name_encoded = ldb_binary_encode_string(mem_ctx, computer_name);
866 if (computer_name_encoded == NULL) {
867 krb5_free_principal(smb_krb5_context->krb5_context, principal);
868 free(unparsed_name_short);
869 return WERR_NOT_ENOUGH_MEMORY;
870 }
871
872 result_filter = talloc_asprintf(mem_ctx, "(|(&(servicePrincipalName=%s)(objectClass=user))(&(cn=%s)(objectClass=computer)))",
873 unparsed_name_short_encoded,
874 computer_name_encoded);
875 } else {
876 result_filter = talloc_asprintf(mem_ctx, "(&(servicePrincipalName=%s)(objectClass=user))",
877 unparsed_name_short_encoded);
878 }
879 krb5_free_principal(smb_krb5_context->krb5_context, principal);
880 free(unparsed_name_short);
881 W_ERROR_HAVE_NO_MEMORY(result_filter);
882
883 break;
884 }
885 default: {
886 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
887 return WERR_OK;
888 }
889 }
890
891 if (format_flags & DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY) {
892 return DsCrackNameOneSyntactical(mem_ctx, format_offered, format_desired,
893 name_dn, name, info1);
894 }
895
896 return DsCrackNameOneFilter(sam_ctx, mem_ctx,
897 smb_krb5_context,
898 format_flags, format_offered, format_desired,
899 name_dn, name,
900 domain_filter, result_filter,
901 info1, scope, search_dn);
902 }
903
904 /* Subcase of CrackNames. It is possible to translate a LDAP-style DN
905 * (FQDN_1779) into a canonical name without actually searching the
906 * database */
907
908 static WERROR DsCrackNameOneSyntactical(TALLOC_CTX *mem_ctx,
909 enum drsuapi_DsNameFormat format_offered,
910 enum drsuapi_DsNameFormat format_desired,
911 struct ldb_dn *name_dn, const char *name,
912 struct drsuapi_DsNameInfo1 *info1)
913 {
914 char *cracked;
915 if (format_offered != DRSUAPI_DS_NAME_FORMAT_FQDN_1779) {
916 info1->status = DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING;
917 return WERR_OK;
918 }
919
920 switch (format_desired) {
921 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
922 cracked = ldb_dn_canonical_string(mem_ctx, name_dn);
923 break;
924 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
925 cracked = ldb_dn_canonical_ex_string(mem_ctx, name_dn);
926 break;
927 default:
928 info1->status = DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING;
929 return WERR_OK;
930 }
931 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
932 info1->result_name = cracked;
933 if (!cracked) {
934 return WERR_NOT_ENOUGH_MEMORY;
935 }
936
937 return WERR_OK;
938 }
939
940 /* Given a filter for the domain, and one for the result, perform the
941 * ldb search. The format offered and desired flags change the
942 * behaviours, including what attributes to return.
943 *
944 * The smb_krb5_context is required because we use the krb5 libs for principal parsing
945 */
946
947 static WERROR DsCrackNameOneFilter(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
948 struct smb_krb5_context *smb_krb5_context,
949 uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
950 enum drsuapi_DsNameFormat format_desired,
951 struct ldb_dn *name_dn, const char *name,
952 const char *domain_filter, const char *result_filter,
953 struct drsuapi_DsNameInfo1 *info1,
954 int scope, struct ldb_dn *search_dn)
955 {
956 int ldb_ret;
957 struct ldb_result *domain_res = NULL;
958 const char * const *domain_attrs;
959 const char * const *result_attrs;
960 struct ldb_message **result_res = NULL;
961 struct ldb_message *result = NULL;
962 int i;
963 char *p;
964 struct ldb_dn *partitions_basedn = samdb_partitions_dn(sam_ctx, mem_ctx);
965
966 const char * const _domain_attrs_1779[] = { "ncName", "dnsRoot", NULL};
967 const char * const _result_attrs_null[] = { NULL };
968
969 const char * const _domain_attrs_canonical[] = { "ncName", "dnsRoot", NULL};
970 const char * const _result_attrs_canonical[] = { "canonicalName", NULL };
971
972 const char * const _domain_attrs_nt4[] = { "ncName", "dnsRoot", "nETBIOSName", NULL};
973 const char * const _result_attrs_nt4[] = { "sAMAccountName", "objectSid", "objectClass", NULL};
974
975 const char * const _domain_attrs_guid[] = { "ncName", "dnsRoot", NULL};
976 const char * const _result_attrs_guid[] = { "objectGUID", NULL};
977
978 const char * const _domain_attrs_upn[] = { "ncName", "dnsRoot", NULL};
979 const char * const _result_attrs_upn[] = { "userPrincipalName", NULL};
980
981 const char * const _domain_attrs_spn[] = { "ncName", "dnsRoot", NULL};
982 const char * const _result_attrs_spn[] = { "servicePrincipalName", NULL};
983
984 const char * const _domain_attrs_display[] = { "ncName", "dnsRoot", NULL};
985 const char * const _result_attrs_display[] = { "displayName", "sAMAccountName", NULL};
986
987 const char * const _domain_attrs_sid[] = { "ncName", "dnsRoot", NULL};
988 const char * const _result_attrs_sid[] = { "objectSid", NULL};
989
990 const char * const _domain_attrs_none[] = { "ncName", "dnsRoot" , NULL};
991 const char * const _result_attrs_none[] = { NULL};
992
993 /* here we need to set the attrs lists for domain and result lookups */
994 switch (format_desired) {
995 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779:
996 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
997 domain_attrs = _domain_attrs_1779;
998 result_attrs = _result_attrs_null;
999 break;
1000 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
1001 domain_attrs = _domain_attrs_canonical;
1002 result_attrs = _result_attrs_canonical;
1003 break;
1004 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT:
1005 domain_attrs = _domain_attrs_nt4;
1006 result_attrs = _result_attrs_nt4;
1007 break;
1008 case DRSUAPI_DS_NAME_FORMAT_GUID:
1009 domain_attrs = _domain_attrs_guid;
1010 result_attrs = _result_attrs_guid;
1011 break;
1012 case DRSUAPI_DS_NAME_FORMAT_DISPLAY:
1013 domain_attrs = _domain_attrs_display;
1014 result_attrs = _result_attrs_display;
1015 break;
1016 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
1017 domain_attrs = _domain_attrs_upn;
1018 result_attrs = _result_attrs_upn;
1019 break;
1020 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:
1021 domain_attrs = _domain_attrs_spn;
1022 result_attrs = _result_attrs_spn;
1023 break;
1024 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY:
1025 domain_attrs = _domain_attrs_sid;
1026 result_attrs = _result_attrs_sid;
1027 break;
1028 default:
1029 domain_attrs = _domain_attrs_none;
1030 result_attrs = _result_attrs_none;
1031 break;
1032 }
1033
1034 if (domain_filter) {
1035 /* if we have a domain_filter look it up and set the result_basedn and the dns_domain_name */
1036 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
1037 partitions_basedn,
1038 LDB_SCOPE_ONELEVEL,
1039 domain_attrs,
1040 "%s", domain_filter);
1041
1042 if (ldb_ret != LDB_SUCCESS) {
1043 DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
1044 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1045 return WERR_OK;
1046 }
1047
1048 switch (domain_res->count) {
1049 case 1:
1050 break;
1051 case 0:
1052 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1053 return WERR_OK;
1054 default:
1055 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1056 return WERR_OK;
1057 }
1058
1059 info1->dns_domain_name = ldb_msg_find_attr_as_string(domain_res->msgs[0], "dnsRoot", NULL);
1060 W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
1061 info1->status = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
1062 } else {
1063 info1->dns_domain_name = NULL;
1064 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1065 }
1066
1067 if (result_filter) {
1068 int ret;
1069 struct ldb_result *res;
1070 uint32_t dsdb_flags = 0;
1071 struct ldb_dn *real_search_dn = NULL;
1072 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1073
1074 /*
1075 * From 4.1.4.2.11 of MS-DRSR
1076 * if DS_NAME_FLAG_GCVERIFY in flags then
1077 * rt := select all O from all
1078 * where attrValue in GetAttrVals(O, att, false)
1079 * else
1080 * rt := select all O from subtree DefaultNC()
1081 * where attrValue in GetAttrVals(O, att, false)
1082 * endif
1083 * return rt
1084 */
1085 if (format_flags & DRSUAPI_DS_NAME_FLAG_GCVERIFY ||
1086 format_offered == DRSUAPI_DS_NAME_FORMAT_GUID)
1087 {
1088 dsdb_flags = DSDB_SEARCH_SEARCH_ALL_PARTITIONS;
1089 } else if (domain_res) {
1090 if (!search_dn) {
1091 struct ldb_dn *tmp_dn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
1092 real_search_dn = tmp_dn;
1093 } else {
1094 real_search_dn = search_dn;
1095 }
1096 } else {
1097 real_search_dn = ldb_get_default_basedn(sam_ctx);
1098 }
1099 if (format_offered == DRSUAPI_DS_NAME_FORMAT_GUID){
1100 dsdb_flags |= DSDB_SEARCH_SHOW_RECYCLED;
1101 }
1102 /* search with the 'phantom root' flag */
1103 ret = dsdb_search(sam_ctx, mem_ctx, &res,
1104 real_search_dn,
1105 scope,
1106 result_attrs,
1107 dsdb_flags,
1108 "%s", result_filter);
1109 if (ret != LDB_SUCCESS) {
1110 DEBUG(2, ("DsCrackNameOneFilter search from '%s' with flags 0x%08x failed: %s\n",
1111 ldb_dn_get_linearized(real_search_dn),
1112 dsdb_flags,
1113 ldb_errstring(sam_ctx)));
1114 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1115 return WERR_OK;
1116 }
1117
1118 ldb_ret = res->count;
1119 result_res = res->msgs;
1120 } else if (format_offered == DRSUAPI_DS_NAME_FORMAT_FQDN_1779) {
1121 ldb_ret = gendb_search_dn(sam_ctx, mem_ctx, name_dn, &result_res,
1122 result_attrs);
1123 } else if (domain_res) {
1124 name_dn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
1125 ldb_ret = gendb_search_dn(sam_ctx, mem_ctx, name_dn, &result_res,
1126 result_attrs);
1127 } else {
1128 /* Can't happen */
1129 DEBUG(0, ("LOGIC ERROR: DsCrackNameOneFilter domain ref search not available: This can't happen...\n"));
1130 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1131 return WERR_OK;
1132 }
1133
1134 switch (ldb_ret) {
1135 case 1:
1136 result = result_res[0];
1137 break;
1138 case 0:
1139 switch (format_offered) {
1140 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:
1141 return DsCrackNameSPNAlias(sam_ctx, mem_ctx,
1142 smb_krb5_context,
1143 format_flags, format_offered, format_desired,
1144 name, info1);
1145
1146 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
1147 return DsCrackNameUPN(sam_ctx, mem_ctx, smb_krb5_context,
1148 format_flags, format_offered, format_desired,
1149 name, info1);
1150 default:
1151 break;
1152 }
1153 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1154 return WERR_OK;
1155 case -1:
1156 DEBUG(2, ("DsCrackNameOneFilter result search failed: %s\n", ldb_errstring(sam_ctx)));
1157 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1158 return WERR_OK;
1159 default:
1160 switch (format_offered) {
1161 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
1162 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
1163 {
1164 const char *canonical_name = NULL; /* Not required, but we get warnings... */
1165 /* We may need to manually filter further */
1166 for (i = 0; i < ldb_ret; i++) {
1167 switch (format_offered) {
1168 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
1169 canonical_name = ldb_dn_canonical_string(mem_ctx, result_res[i]->dn);
1170 break;
1171 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
1172 canonical_name = ldb_dn_canonical_ex_string(mem_ctx, result_res[i]->dn);
1173 break;
1174 default:
1175 break;
1176 }
1177 if (strcasecmp_m(canonical_name, name) == 0) {
1178 result = result_res[i];
1179 break;
1180 }
1181 }
1182 if (!result) {
1183 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1184 return WERR_OK;
1185 }
1186 }
1187 FALL_THROUGH;
1188 default:
1189 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1190 return WERR_OK;
1191 }
1192 }
1193
1194 info1->dns_domain_name = ldb_dn_canonical_string(mem_ctx, result->dn);
1195 W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
1196 p = strchr(info1->dns_domain_name, '/');
1197 if (p) {
1198 p[0] = '\0';
1199 }
1200
1201 /* here we can use result and domain_res[0] */
1202 switch (format_desired) {
1203 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: {
1204 info1->result_name = ldb_dn_alloc_linearized(mem_ctx, result->dn);
1205 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1206
1207 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1208 return WERR_OK;
1209 }
1210 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: {
1211 info1->result_name = ldb_msg_find_attr_as_string(result, "canonicalName", NULL);
1212 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1213 return WERR_OK;
1214 }
1215 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: {
1216 /* Not in the virtual ldb attribute */
1217 return DsCrackNameOneSyntactical(mem_ctx,
1218 DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1219 DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX,
1220 result->dn, name, info1);
1221 }
1222 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: {
1223
1224 const struct dom_sid *sid = samdb_result_dom_sid(mem_ctx, result, "objectSid");
1225 const char *_acc = "", *_dom = "";
1226 if (sid == NULL) {
1227 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1228 return WERR_OK;
1229 }
1230
1231 if (samdb_find_attribute(sam_ctx, result, "objectClass",
1232 "domain")) {
1233 /* This can also find a DomainDNSZones entry,
1234 * but it won't have the SID we just
1235 * checked. */
1236 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
1237 partitions_basedn,
1238 LDB_SCOPE_ONELEVEL,
1239 domain_attrs,
1240 "(ncName=%s)", ldb_dn_get_linearized(result->dn));
1241
1242 if (ldb_ret != LDB_SUCCESS) {
1243 DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
1244 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1245 return WERR_OK;
1246 }
1247
1248 switch (domain_res->count) {
1249 case 1:
1250 break;
1251 case 0:
1252 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1253 return WERR_OK;
1254 default:
1255 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1256 return WERR_OK;
1257 }
1258 _dom = ldb_msg_find_attr_as_string(domain_res->msgs[0], "nETBIOSName", NULL);
1259 W_ERROR_HAVE_NO_MEMORY(_dom);
1260 } else {
1261 _acc = ldb_msg_find_attr_as_string(result, "sAMAccountName", NULL);
1262 if (!_acc) {
1263 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1264 return WERR_OK;
1265 }
1266 if (dom_sid_in_domain(&global_sid_Builtin, sid)) {
1267 _dom = "BUILTIN";
1268 } else {
1269 const char *attrs[] = { NULL };
1270 struct ldb_result *domain_res2;
1271 struct dom_sid *dom_sid = dom_sid_dup(mem_ctx, sid);
1272 if (!dom_sid) {
1273 return WERR_OK;
1274 }
1275 dom_sid->num_auths--;
1276 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
1277 NULL,
1278 LDB_SCOPE_BASE,
1279 attrs,
1280 "(&(objectSid=%s)(objectClass=domain))",
1281 ldap_encode_ndr_dom_sid(mem_ctx, dom_sid));
1282
1283 if (ldb_ret != LDB_SUCCESS) {
1284 DEBUG(2, ("DsCrackNameOneFilter domain search failed: %s\n", ldb_errstring(sam_ctx)));
1285 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1286 return WERR_OK;
1287 }
1288
1289 switch (domain_res->count) {
1290 case 1:
1291 break;
1292 case 0:
1293 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1294 return WERR_OK;
1295 default:
1296 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1297 return WERR_OK;
1298 }
1299
1300 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res2,
1301 partitions_basedn,
1302 LDB_SCOPE_ONELEVEL,
1303 domain_attrs,
1304 "(ncName=%s)", ldb_dn_get_linearized(domain_res->msgs[0]->dn));
1305
1306 if (ldb_ret != LDB_SUCCESS) {
1307 DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s\n", ldb_errstring(sam_ctx)));
1308 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1309 return WERR_OK;
1310 }
1311
1312 switch (domain_res2->count) {
1313 case 1:
1314 break;
1315 case 0:
1316 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1317 return WERR_OK;
1318 default:
1319 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1320 return WERR_OK;
1321 }
1322 _dom = ldb_msg_find_attr_as_string(domain_res2->msgs[0], "nETBIOSName", NULL);
1323 W_ERROR_HAVE_NO_MEMORY(_dom);
1324 }
1325 }
1326
1327 info1->result_name = talloc_asprintf(mem_ctx, "%s\\%s", _dom, _acc);
1328 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1329
1330 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1331 return WERR_OK;
1332 }
1333 case DRSUAPI_DS_NAME_FORMAT_GUID: {
1334 struct GUID guid;
1335
1336 guid = samdb_result_guid(result, "objectGUID");
1337
1338 info1->result_name = GUID_string2(mem_ctx, &guid);
1339 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1340
1341 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1342 return WERR_OK;
1343 }
1344 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: {
1345 info1->result_name = ldb_msg_find_attr_as_string(result, "displayName", NULL);
1346 if (!info1->result_name) {
1347 info1->result_name = ldb_msg_find_attr_as_string(result, "sAMAccountName", NULL);
1348 }
1349 if (!info1->result_name) {
1350 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1351 } else {
1352 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1353 }
1354 return WERR_OK;
1355 }
1356 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: {
1357 struct ldb_message_element *el
1358 = ldb_msg_find_element(result,
1359 "servicePrincipalName");
1360 if (el == NULL) {
1361 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1362 return WERR_OK;
1363 } else if (el->num_values > 1) {
1364 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1365 return WERR_OK;
1366 }
1367
1368 info1->result_name = ldb_msg_find_attr_as_string(result, "servicePrincipalName", NULL);
1369 if (!info1->result_name) {
1370 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1371 } else {
1372 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1373 }
1374 return WERR_OK;
1375 }
1376 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: {
1377 info1->dns_domain_name = NULL;
1378 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1379 return WERR_OK;
1380 }
1381 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: {
1382 const struct dom_sid *sid = samdb_result_dom_sid(mem_ctx, result, "objectSid");
1383
1384 if (sid == NULL) {
1385 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1386 return WERR_OK;
1387 }
1388
1389 info1->result_name = dom_sid_string(mem_ctx, sid);
1390 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1391
1392 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1393 return WERR_OK;
1394 }
1395 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: {
1396 info1->result_name = ldb_msg_find_attr_as_string(result, "userPrincipalName", NULL);
1397 if (!info1->result_name) {
1398 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1399 } else {
1400 info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1401 }
1402 return WERR_OK;
1403 }
1404 default:
1405 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1406 return WERR_OK;
1407 }
1408 }
1409
1410 /* Given a user Principal Name (such as foo@bar.com),
1411 * return the user and domain DNs. This is used in the KDC to then
1412 * return the Keys and evaluate policy */
1413
1414 NTSTATUS crack_user_principal_name(struct ldb_context *sam_ctx,
1415 TALLOC_CTX *mem_ctx,
1416 const char *user_principal_name,
1417 struct ldb_dn **user_dn,
1418 struct ldb_dn **domain_dn)
1419 {
1420 WERROR werr;
1421 struct drsuapi_DsNameInfo1 info1;
1422 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1423 DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
1424 DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1425 user_principal_name,
1426 &info1);
1427 if (!W_ERROR_IS_OK(werr)) {
1428 return werror_to_ntstatus(werr);
1429 }
1430 switch (info1.status) {
1431 case DRSUAPI_DS_NAME_STATUS_OK:
1432 break;
1433 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1434 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1435 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1436 return NT_STATUS_NO_SUCH_USER;
1437 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1438 default:
1439 return NT_STATUS_UNSUCCESSFUL;
1440 }
1441
1442 *user_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1443
1444 if (domain_dn) {
1445 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1446 DRSUAPI_DS_NAME_FORMAT_CANONICAL,
1447 DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1448 talloc_asprintf(mem_ctx, "%s/",
1449 info1.dns_domain_name),
1450 &info1);
1451 if (!W_ERROR_IS_OK(werr)) {
1452 return werror_to_ntstatus(werr);
1453 }
1454 switch (info1.status) {
1455 case DRSUAPI_DS_NAME_STATUS_OK:
1456 break;
1457 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1458 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1459 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1460 return NT_STATUS_NO_SUCH_USER;
1461 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1462 default:
1463 return NT_STATUS_UNSUCCESSFUL;
1464 }
1465
1466 *domain_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1467 }
1468
1469 return NT_STATUS_OK;
1470 }
1471
1472 /* Given a Service Principal Name (such as host/foo.bar.com@BAR.COM),
1473 * return the user and domain DNs. This is used in the KDC to then
1474 * return the Keys and evaluate policy */
1475
1476 NTSTATUS crack_service_principal_name(struct ldb_context *sam_ctx,
1477 TALLOC_CTX *mem_ctx,
1478 const char *service_principal_name,
1479 struct ldb_dn **user_dn,
1480 struct ldb_dn **domain_dn)
1481 {
1482 WERROR werr;
1483 struct drsuapi_DsNameInfo1 info1;
1484 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1485 DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
1486 DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1487 service_principal_name,
1488 &info1);
1489 if (!W_ERROR_IS_OK(werr)) {
1490 return werror_to_ntstatus(werr);
1491 }
1492 switch (info1.status) {
1493 case DRSUAPI_DS_NAME_STATUS_OK:
1494 break;
1495 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1496 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1497 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1498 return NT_STATUS_NO_SUCH_USER;
1499 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1500 default:
1501 return NT_STATUS_UNSUCCESSFUL;
1502 }
1503
1504 *user_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1505
1506 if (domain_dn) {
1507 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1508 DRSUAPI_DS_NAME_FORMAT_CANONICAL,
1509 DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1510 talloc_asprintf(mem_ctx, "%s/",
1511 info1.dns_domain_name),
1512 &info1);
1513 if (!W_ERROR_IS_OK(werr)) {
1514 return werror_to_ntstatus(werr);
1515 }
1516 switch (info1.status) {
1517 case DRSUAPI_DS_NAME_STATUS_OK:
1518 break;
1519 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1520 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1521 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1522 return NT_STATUS_NO_SUCH_USER;
1523 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1524 default:
1525 return NT_STATUS_UNSUCCESSFUL;
1526 }
1527
1528 *domain_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1529 }
1530
1531 return NT_STATUS_OK;
1532 }
1533
1534 NTSTATUS crack_name_to_nt4_name(TALLOC_CTX *mem_ctx,
1535 struct ldb_context *ldb,
1536 enum drsuapi_DsNameFormat format_offered,
1537 const char *name,
1538 const char **nt4_domain, const char **nt4_account)
1539 {
1540 WERROR werr;
1541 struct drsuapi_DsNameInfo1 info1;
1542 char *p;
1543
1544 /* Handle anonymous bind */
1545 if (!name || !*name) {
1546 *nt4_domain = "";
1547 *nt4_account = "";
1548 return NT_STATUS_OK;
1549 }
1550
1551 werr = DsCrackNameOneName(ldb, mem_ctx, 0,
1552 format_offered,
1553 DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT,
1554 name,
1555 &info1);
1556 if (!W_ERROR_IS_OK(werr)) {
1557 return werror_to_ntstatus(werr);
1558 }
1559 switch (info1.status) {
1560 case DRSUAPI_DS_NAME_STATUS_OK:
1561 break;
1562 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1563 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1564 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1565 return NT_STATUS_NO_SUCH_USER;
1566 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1567 default:
1568 return NT_STATUS_UNSUCCESSFUL;
1569 }
1570
1571 *nt4_domain = talloc_strdup(mem_ctx, info1.result_name);
1572 if (*nt4_domain == NULL) {
1573 return NT_STATUS_NO_MEMORY;
1574 }
1575
1576 p = strchr(*nt4_domain, '\\');
1577 if (!p) {
1578 return NT_STATUS_INVALID_PARAMETER;
1579 }
1580 p[0] = '\0';
1581
1582 *nt4_account = talloc_strdup(mem_ctx, &p[1]);
1583 if (*nt4_account == NULL) {
1584 return NT_STATUS_NO_MEMORY;
1585 }
1586
1587 return NT_STATUS_OK;
1588 }
1589
1590 NTSTATUS crack_auto_name_to_nt4_name(TALLOC_CTX *mem_ctx,
1591 struct ldb_context *ldb,
1592 const char *name,
1593 const char **nt4_domain,
1594 const char **nt4_account)
1595 {
1596 enum drsuapi_DsNameFormat format_offered = DRSUAPI_DS_NAME_FORMAT_UNKNOWN;
1597
1598 /* Handle anonymous bind */
1599 if (!name || !*name) {
1600 *nt4_domain = "";
1601 *nt4_account = "";
1602 return NT_STATUS_OK;
1603 }
1604
1605 /*
1606 * Here we only consider a subset of the possible name forms listed in
1607 * [MS-ADTS] 5.1.1.1.1, and we don't retry with a different name form if
1608 * the first attempt fails.
1609 */
1610
1611 if (strchr_m(name, '=')) {
1612 format_offered = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
1613 } else if (strchr_m(name, '@')) {
1614 format_offered = DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL;
1615 } else if (strchr_m(name, '\\')) {
1616 format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
1617 } else if (strchr_m(name, '\n')) {
1618 format_offered = DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX;
1619 } else if (strchr_m(name, '/')) {
1620 format_offered = DRSUAPI_DS_NAME_FORMAT_CANONICAL;
1621 } else if ((name[0] == 'S' || name[0] == 's') && name[1] == '-') {
1622 format_offered = DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY;
1623 } else {
1624 return NT_STATUS_NO_SUCH_USER;
1625 }
1626
1627 return crack_name_to_nt4_name(mem_ctx, ldb, format_offered, name, nt4_domain, nt4_account);
1628 }
1629
1630
1631 WERROR dcesrv_drsuapi_ListRoles(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
1632 const struct drsuapi_DsNameRequest1 *req1,
1633 struct drsuapi_DsNameCtr1 **ctr1)
1634 {
1635 struct drsuapi_DsNameInfo1 *names;
1636 uint32_t i;
1637 uint32_t count = 5;/*number of fsmo role owners we are going to return*/
1638
1639 *ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
1640 W_ERROR_HAVE_NO_MEMORY(*ctr1);
1641 names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
1642 W_ERROR_HAVE_NO_MEMORY(names);
1643
1644 for (i = 0; i < count; i++) {
1645 WERROR werr;
1646 struct ldb_dn *role_owner_dn, *fsmo_role_dn, *server_dn;
1647 werr = dsdb_get_fsmo_role_info(mem_ctx, sam_ctx, i,
1648 &fsmo_role_dn, &role_owner_dn);
1649 if(!W_ERROR_IS_OK(werr)) {
1650 return werr;
1651 }
1652 server_dn = ldb_dn_copy(mem_ctx, role_owner_dn);
1653 ldb_dn_remove_child_components(server_dn, 1);
1654 names[i].status = DRSUAPI_DS_NAME_STATUS_OK;
1655 names[i].dns_domain_name = samdb_dn_to_dnshostname(sam_ctx, mem_ctx,
1656 server_dn);
1657 if(!names[i].dns_domain_name) {
1658 DEBUG(4, ("list_roles: Failed to find dNSHostName for server %s\n",
1659 ldb_dn_get_linearized(server_dn)));
1660 }
1661 names[i].result_name = talloc_strdup(mem_ctx, ldb_dn_get_linearized(role_owner_dn));
1662 }
1663
1664 (*ctr1)->count = count;
1665 (*ctr1)->array = names;
1666
1667 return WERR_OK;
1668 }
1669
1670 WERROR dcesrv_drsuapi_CrackNamesByNameFormat(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
1671 const struct drsuapi_DsNameRequest1 *req1,
1672 struct drsuapi_DsNameCtr1 **ctr1)
1673 {
1674 struct drsuapi_DsNameInfo1 *names;
1675 uint32_t i, count;
1676 WERROR status;
1677
1678 *ctr1 = talloc_zero(mem_ctx, struct drsuapi_DsNameCtr1);
1679 W_ERROR_HAVE_NO_MEMORY(*ctr1);
1680
1681 count = req1->count;
1682 names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
1683 W_ERROR_HAVE_NO_MEMORY(names);
1684
1685 for (i=0; i < count; i++) {
1686 status = DsCrackNameOneName(sam_ctx, mem_ctx,
1687 req1->format_flags,
1688 req1->format_offered,
1689 req1->format_desired,
1690 req1->names[i].str,
1691 &names[i]);
1692 if (!W_ERROR_IS_OK(status)) {
1693 return status;
1694 }
1695 }
1696
1697 (*ctr1)->count = count;
1698 (*ctr1)->array = names;
1699
1700 return WERR_OK;
1701 }
1702
1703 WERROR dcesrv_drsuapi_ListInfoServer(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
1704 const struct drsuapi_DsNameRequest1 *req1,
1705 struct drsuapi_DsNameCtr1 **_ctr1)
1706 {
1707 struct drsuapi_DsNameInfo1 *names;
1708 struct ldb_result *res;
1709 struct ldb_dn *server_dn, *dn;
1710 struct drsuapi_DsNameCtr1 *ctr1;
1711 int ret, i;
1712 const char *str;
1713 const char *attrs[] = {
1714 "dNSHostName",
1715 "serverReference",
1716 NULL
1717 };
1718
1719 *_ctr1 = NULL;
1720
1721 ctr1 = talloc_zero(mem_ctx, struct drsuapi_DsNameCtr1);
1722 W_ERROR_HAVE_NO_MEMORY(ctr1);
1723
1724 /*
1725 * No magic value here, we have to return 3 entries according to the
1726 * MS-DRSR.pdf
1727 */
1728 ctr1->count = 3;
1729 names = talloc_zero_array(ctr1, struct drsuapi_DsNameInfo1,
1730 ctr1->count);
1731 W_ERROR_HAVE_NO_MEMORY(names);
1732 ctr1->array = names;
1733
1734 for (i=0; i < ctr1->count; i++) {
1735 names[i].status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1736 }
1737 *_ctr1 = ctr1;
1738
1739 if (req1->count != 1) {
1740 DEBUG(1, ("Expected a count of 1 for the ListInfoServer crackname \n"));
1741 return WERR_OK;
1742 }
1743
1744 if (req1->names[0].str == NULL) {
1745 return WERR_OK;
1746 }
1747
1748 server_dn = ldb_dn_new(mem_ctx, sam_ctx, req1->names[0].str);
1749 W_ERROR_HAVE_NO_MEMORY(server_dn);
1750
1751 ret = ldb_search(sam_ctx, mem_ctx, &res, server_dn, LDB_SCOPE_ONELEVEL,
1752 NULL, "(objectClass=nTDSDSA)");
1753
1754 if (ret != LDB_SUCCESS) {
1755 DEBUG(1, ("Search for objectClass=nTDSDSA "
1756 "returned less than 1 objects\n"));
1757 return WERR_OK;
1758 }
1759
1760 if (res->count != 1) {
1761 DEBUG(1, ("Search for objectClass=nTDSDSA "
1762 "returned less than 1 objects\n"));
1763 return WERR_OK;
1764 }
1765
1766 if (res->msgs[0]->dn) {
1767 names[0].result_name = ldb_dn_alloc_linearized(names, res->msgs[0]->dn);
1768 W_ERROR_HAVE_NO_MEMORY(names[0].result_name);
1769 names[0].status = DRSUAPI_DS_NAME_STATUS_OK;
1770 }
1771
1772 talloc_free(res);
1773
1774 ret = ldb_search(sam_ctx, mem_ctx, &res, server_dn, LDB_SCOPE_BASE,
1775 attrs, "(objectClass=*)");
1776 if (ret != LDB_SUCCESS) {
1777 DEBUG(1, ("Search for objectClass=* on dn %s"
1778 "returned %s\n", req1->names[0].str,
1779 ldb_strerror(ret)));
1780 return WERR_OK;
1781 }
1782
1783 if (res->count != 1) {
1784 DEBUG(1, ("Search for objectClass=* on dn %s"
1785 "returned less than 1 objects\n", req1->names[0].str));
1786 return WERR_OK;
1787 }
1788
1789 str = ldb_msg_find_attr_as_string(res->msgs[0], "dNSHostName", NULL);
1790 if (str != NULL) {
1791 names[1].result_name = talloc_strdup(names, str);
1792 W_ERROR_HAVE_NO_MEMORY(names[1].result_name);
1793 names[1].status = DRSUAPI_DS_NAME_STATUS_OK;
1794 }
1795
1796 dn = ldb_msg_find_attr_as_dn(sam_ctx, mem_ctx, res->msgs[0], "serverReference");
1797 if (dn != NULL) {
1798 names[2].result_name = ldb_dn_alloc_linearized(names, dn);
1799 W_ERROR_HAVE_NO_MEMORY(names[2].result_name);
1800 names[2].status = DRSUAPI_DS_NAME_STATUS_OK;
1801 }
1802
1803 talloc_free(dn);
1804 talloc_free(res);
1805
1806 return WERR_OK;
1807 }
GSS-enabled samba4