source4/dsdb/samdb/cracknames.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the drsuapi pipe
   5    DsCrackNames()
   6
   7    Copyright (C) Stefan Metzmacher 2004
   8    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "librpc/gen_ndr/drsuapi.h"
  26 #include "lib/events/events.h"
  27 #include "rpc_server/common/common.h"
  28 #include "lib/ldb/include/ldb.h"
  29 #include "lib/ldb/include/ldb_errors.h"
  30 #include "system/kerberos.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 static WERROR DsCrackNameOneFilter(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
  41                                    struct smb_krb5_context *smb_krb5_context,
  42                                    uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
  43                                    enum drsuapi_DsNameFormat format_desired,
  44                                    struct ldb_dn *name_dn, const char *name,
  45                                    const char *domain_filter, const char *result_filter,
  46                                    struct drsuapi_DsNameInfo1 *info1);
  47 static WERROR DsCrackNameOneSyntactical(TALLOC_CTX *mem_ctx,
  48                                         enum drsuapi_DsNameFormat format_offered,
  49                                         enum drsuapi_DsNameFormat format_desired,
  50                                         struct ldb_dn *name_dn, const char *name,
  51                                         struct drsuapi_DsNameInfo1 *info1);
  52
  53 static WERROR dns_domain_from_principal(TALLOC_CTX *mem_ctx, struct smb_krb5_context *smb_krb5_context,
  54                                         const char *name,
  55                                         struct drsuapi_DsNameInfo1 *info1)
  56 {
  57         krb5_error_code ret;
  58         krb5_principal principal;
  59         /* perhaps it's a principal with a realm, so return the right 'domain only' response */
  60         const char *realm;
  61         ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
  62                                     KRB5_PRINCIPAL_PARSE_REQUIRE_REALM, &principal);
  63         if (ret) {
  64                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
  65                 return WERR_OK;
  66         }
  67
  68         /* This isn't an allocation assignemnt, so it is free'ed with the krb5_free_principal */
  69         realm = krb5_principal_get_realm(smb_krb5_context->krb5_context, principal);
  70
  71         info1->dns_domain_name  = talloc_strdup(mem_ctx, realm);
  72         krb5_free_principal(smb_krb5_context->krb5_context, principal);
  73
  74         W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
  75
  76         info1->status = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
  77         return WERR_OK;
  78 }
  79
  80 static enum drsuapi_DsNameStatus LDB_lookup_spn_alias(krb5_context context, struct ldb_context *ldb_ctx,
  81                                                       TALLOC_CTX *mem_ctx,
  82                                                       const char *alias_from,
  83                                                       char **alias_to)
  84 {
  85         unsigned int i;
  86         int ret;
  87         struct ldb_result *res;
  88         struct ldb_message_element *spnmappings;
  89         TALLOC_CTX *tmp_ctx;
  90         struct ldb_dn *service_dn;
  91         char *service_dn_str;
  92
  93         const char *directory_attrs[] = {
  94                 "sPNMappings",
  95                 NULL
  96         };
  97
  98         tmp_ctx = talloc_new(mem_ctx);
  99         if (!tmp_ctx) {
 100                 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 101         }
 102
 103         service_dn = ldb_dn_new(tmp_ctx, ldb_ctx, "CN=Directory Service,CN=Windows NT,CN=Services");
 104         if ( ! ldb_dn_add_base(service_dn, ldb_get_config_basedn(ldb_ctx))) {
 105                 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 106         }
 107         service_dn_str = ldb_dn_alloc_linearized(tmp_ctx, service_dn);
 108         if ( ! service_dn_str) {
 109                 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 110         }
 111
 112         ret = ldb_search(ldb_ctx, tmp_ctx, &res, service_dn, LDB_SCOPE_BASE,
 113                          directory_attrs, "(objectClass=nTDSService)");
 114
 115         if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 116                 DEBUG(1, ("ldb_search: dn: %s not found: %s", service_dn_str, ldb_errstring(ldb_ctx)));
 117                 return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 118         } else if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 119                 DEBUG(1, ("ldb_search: dn: %s not found", service_dn_str));
 120                 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 121         } else if (res->count != 1) {
 122                 talloc_free(res);
 123                 DEBUG(1, ("ldb_search: dn: %s not found", service_dn_str));
 124                 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 125         }
 126
 127         spnmappings = ldb_msg_find_element(res->msgs[0], "sPNMappings");
 128         if (!spnmappings || spnmappings->num_values == 0) {
 129                 DEBUG(1, ("ldb_search: dn: %s no sPNMappings attribute", service_dn_str));
 130                 talloc_free(tmp_ctx);
 131                 return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 132         }
 133
 134         for (i = 0; i < spnmappings->num_values; i++) {
 135                 char *mapping, *p, *str;
 136                 mapping = talloc_strdup(tmp_ctx,
 137                                         (const char *)spnmappings->values[i].data);
 138                 if (!mapping) {
 139                         DEBUG(1, ("LDB_lookup_spn_alias: ldb_search: dn: %s did not have an sPNMapping\n", service_dn_str));
 140                         talloc_free(tmp_ctx);
 141                         return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 142                 }
 143
 144                 /* C string manipulation sucks */
 145
 146                 p = strchr(mapping, '=');
 147                 if (!p) {
 148                         DEBUG(1, ("ldb_search: dn: %s sPNMapping malformed: %s\n",
 149                                   service_dn_str, mapping));
 150                         talloc_free(tmp_ctx);
 151                         return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 152                 }
 153                 p[0] = '\0';
 154                 p++;
 155                 do {
 156                         str = p;
 157                         p = strchr(p, ',');
 158                         if (p) {
 159                                 p[0] = '\0';
 160                                 p++;
 161                         }
 162                         if (strcasecmp(str, alias_from) == 0) {
 163                                 *alias_to = mapping;
 164                                 talloc_steal(mem_ctx, mapping);
 165                                 talloc_free(tmp_ctx);
 166                                 return DRSUAPI_DS_NAME_STATUS_OK;
 167                         }
 168                 } while (p);
 169         }
 170         DEBUG(4, ("LDB_lookup_spn_alias: no alias for service %s applicable\n", alias_from));
 171         talloc_free(tmp_ctx);
 172         return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 173 }
 174
 175 /* When cracking a ServicePrincipalName, many services may be served
 176  * by the host/ servicePrincipalName.  The incoming query is for cifs/
 177  * but we translate it here, and search on host/.  This is done after
 178  * the cifs/ entry has been searched for, making this a fallback */
 179
 180 static WERROR DsCrackNameSPNAlias(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
 181                                   struct smb_krb5_context *smb_krb5_context,
 182                                   uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
 183                                   enum drsuapi_DsNameFormat format_desired,
 184                                   const char *name, struct drsuapi_DsNameInfo1 *info1)
 185 {
 186         WERROR wret;
 187         krb5_error_code ret;
 188         krb5_principal principal;
 189         const char *service, *dns_name;
 190         char *new_service;
 191         char *new_princ;
 192         enum drsuapi_DsNameStatus namestatus;
 193
 194         /* parse principal */
 195         ret = krb5_parse_name_flags(smb_krb5_context->krb5_context,
 196                                     name, KRB5_PRINCIPAL_PARSE_NO_REALM, &principal);
 197         if (ret) {
 198                 DEBUG(2, ("Could not parse principal: %s: %s",
 199                           name, smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 200                                                            ret, mem_ctx)));
 201                 return WERR_NOMEM;
 202         }
 203
 204         /* grab cifs/, http/ etc */
 205
 206         /* This is checked for in callers, but be safe */
 207         if (principal->name.name_string.len < 2) {
 208                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 209                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 210                 return WERR_OK;
 211         }
 212         service = principal->name.name_string.val[0];
 213         dns_name = principal->name.name_string.val[1];
 214
 215         /* MAP it */
 216         namestatus = LDB_lookup_spn_alias(smb_krb5_context->krb5_context,
 217                                           sam_ctx, mem_ctx,
 218                                           service, &new_service);
 219
 220         if (namestatus == DRSUAPI_DS_NAME_STATUS_NOT_FOUND) {
 221                 wret = WERR_OK;
 222                 info1->status           = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
 223                 info1->dns_domain_name  = talloc_strdup(mem_ctx, dns_name);
 224                 if (!info1->dns_domain_name) {
 225                         wret = WERR_NOMEM;
 226                 }
 227                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 228                 return wret;
 229         } else if (namestatus != DRSUAPI_DS_NAME_STATUS_OK) {
 230                 info1->status = namestatus;
 231                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 232                 return WERR_OK;
 233         }
 234
 235         /* ooh, very nasty playing around in the Principal... */
 236         free(principal->name.name_string.val[0]);
 237         principal->name.name_string.val[0] = strdup(new_service);
 238         if (!principal->name.name_string.val[0]) {
 239                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 240                 return WERR_NOMEM;
 241         }
 242
 243         /* reform principal */
 244         ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context, principal,
 245                                       KRB5_PRINCIPAL_UNPARSE_NO_REALM, &new_princ);
 246
 247         if (ret) {
 248                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 249                 return WERR_NOMEM;
 250         }
 251
 252         wret = DsCrackNameOneName(sam_ctx, mem_ctx, format_flags, format_offered, format_desired,
 253                                   new_princ, info1);
 254         free(new_princ);
 255         if (W_ERROR_IS_OK(wret) && (info1->status == DRSUAPI_DS_NAME_STATUS_NOT_FOUND)) {
 256                 info1->status           = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
 257                 info1->dns_domain_name  = talloc_strdup(mem_ctx, dns_name);
 258                 if (!info1->dns_domain_name) {
 259                         wret = WERR_NOMEM;
 260                 }
 261         }
 262         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 263         return wret;
 264 }
 265
 266 /* Subcase of CrackNames, for the userPrincipalName */
 267
 268 static WERROR DsCrackNameUPN(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
 269                              struct smb_krb5_context *smb_krb5_context,
 270                              uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
 271                              enum drsuapi_DsNameFormat format_desired,
 272                              const char *name, struct drsuapi_DsNameInfo1 *info1)
 273 {
 274         int ldb_ret;
 275         WERROR status;
 276         const char *domain_filter = NULL;
 277         const char *result_filter = NULL;
 278         krb5_error_code ret;
 279         krb5_principal principal;
 280         const char *realm;
 281         char *unparsed_name_short;
 282         const char *domain_attrs[] = { NULL };
 283         struct ldb_result *domain_res = NULL;
 284
 285         /* Prevent recursion */
 286         if (!name) {
 287                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 288                 return WERR_OK;
 289         }
 290
 291         ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
 292                                     KRB5_PRINCIPAL_PARSE_REQUIRE_REALM, &principal);
 293         if (ret) {
 294                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 295                 return WERR_OK;
 296         }
 297
 298         realm = krb5_principal_get_realm(smb_krb5_context->krb5_context,
 299                                          principal);
 300
 301         ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
 302                                      samdb_partitions_dn(sam_ctx, mem_ctx),
 303                                      LDB_SCOPE_ONELEVEL,
 304                                      domain_attrs,
 305                                      "(&(&(|(&(dnsRoot=%s)(nETBIOSName=*))(nETBIOSName=%s))(objectclass=crossRef))(ncName=*))",
 306                                      ldb_binary_encode_string(mem_ctx, realm),
 307                                      ldb_binary_encode_string(mem_ctx, realm));
 308
 309         if (ldb_ret != LDB_SUCCESS) {
 310                 DEBUG(2, ("DsCrackNameUPN domain ref search failed: %s", ldb_errstring(sam_ctx)));
 311                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 312                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 313                 return WERR_OK;
 314         }
 315
 316         switch (domain_res->count) {
 317         case 1:
 318                 break;
 319         case 0:
 320                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 321                 return dns_domain_from_principal(mem_ctx, smb_krb5_context,
 322                                                  name, info1);
 323         default:
 324                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
 325                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 326                 return WERR_OK;
 327         }
 328
 329         ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context, principal,
 330                                       KRB5_PRINCIPAL_UNPARSE_NO_REALM, &unparsed_name_short);
 331         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 332
 333         if (ret) {
 334                 free(unparsed_name_short);
 335                 return WERR_NOMEM;
 336         }
 337
 338         /* This may need to be extended for more userPrincipalName variations */
 339         result_filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(samAccountName=%s))",
 340                                         ldb_binary_encode_string(mem_ctx, unparsed_name_short));
 341
 342         domain_filter = talloc_asprintf(mem_ctx, "(distinguishedName=%s)", ldb_dn_get_linearized(domain_res->msgs[0]->dn));
 343
 344         if (!result_filter || !domain_filter) {
 345                 free(unparsed_name_short);
 346                 return WERR_NOMEM;
 347         }
 348         status = DsCrackNameOneFilter(sam_ctx, mem_ctx,
 349                                       smb_krb5_context,
 350                                       format_flags, format_offered, format_desired,
 351                                       NULL, unparsed_name_short, domain_filter, result_filter,
 352                                       info1);
 353         free(unparsed_name_short);
 354
 355         return status;
 356 }
 357
 358 /* Crack a single 'name', from format_offered into format_desired, returning the result in info1 */
 359
 360 WERROR DsCrackNameOneName(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
 361                           uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
 362                           enum drsuapi_DsNameFormat format_desired,
 363                           const char *name, struct drsuapi_DsNameInfo1 *info1)
 364 {
 365         krb5_error_code ret;
 366         const char *domain_filter = NULL;
 367         const char *result_filter = NULL;
 368         struct ldb_dn *name_dn = NULL;
 369
 370         struct smb_krb5_context *smb_krb5_context = NULL;
 371
 372         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 373         info1->dns_domain_name = NULL;
 374         info1->result_name = NULL;
 375
 376         if (!name) {
 377                 return WERR_INVALID_PARAM;
 378         }
 379
 380         /* TODO: - fill the correct names in all cases!
 381          *       - handle format_flags
 382          */
 383
 384         /* here we need to set the domain_filter and/or the result_filter */
 385         switch (format_offered) {
 386         case DRSUAPI_DS_NAME_FORMAT_UNKNOWN:
 387         {
 388                 unsigned int i;
 389                 enum drsuapi_DsNameFormat formats[] = {
 390                         DRSUAPI_DS_NAME_FORMAT_FQDN_1779, DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
 391                         DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT, DRSUAPI_DS_NAME_FORMAT_CANONICAL,
 392                         DRSUAPI_DS_NAME_FORMAT_GUID, DRSUAPI_DS_NAME_FORMAT_DISPLAY,
 393                         DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
 394                         DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY,
 395                         DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX
 396                 };
 397                 WERROR werr;
 398                 for (i=0; i < ARRAY_SIZE(formats); i++) {
 399                         werr = DsCrackNameOneName(sam_ctx, mem_ctx, format_flags, formats[i], format_desired, name, info1);
 400                         if (!W_ERROR_IS_OK(werr)) {
 401                                 return werr;
 402                         }
 403                         if (info1->status != DRSUAPI_DS_NAME_STATUS_NOT_FOUND) {
 404                                 return werr;
 405                         }
 406                 }
 407                 return werr;
 408         }
 409
 410         case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
 411         case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
 412         {
 413                 char *str, *s, *account;
 414
 415                 if (strlen(name) == 0) {
 416                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 417                         return WERR_OK;
 418                 }
 419
 420                 str = talloc_strdup(mem_ctx, name);
 421                 W_ERROR_HAVE_NO_MEMORY(str);
 422
 423                 if (format_offered == DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX) {
 424                         /* Look backwards for the \n, and replace it with / */
 425                         s = strrchr(str, '\n');
 426                         if (!s) {
 427                                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 428                                 return WERR_OK;
 429                         }
 430                         s[0] = '/';
 431                 }
 432
 433                 s = strchr(str, '/');
 434                 if (!s) {
 435                         /* there must be at least one / */
 436                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 437                         return WERR_OK;
 438                 }
 439
 440                 s[0] = '\0';
 441                 s++;
 442
 443                 domain_filter = talloc_asprintf(mem_ctx, "(&(objectClass=crossRef)(ncName=%s))",
 444                                                 ldb_dn_get_linearized(samdb_dns_domain_to_dn(sam_ctx, mem_ctx, str)));
 445                 W_ERROR_HAVE_NO_MEMORY(domain_filter);
 446
 447                 /* There may not be anything after the domain component (search for the domain itself) */
 448                 if (s[0]) {
 449
 450                         account = strrchr(s, '/');
 451                         if (!account) {
 452                                 account = s;
 453                         } else {
 454                                 account++;
 455                         }
 456                         account = ldb_binary_encode_string(mem_ctx, account);
 457                         W_ERROR_HAVE_NO_MEMORY(account);
 458                         result_filter = talloc_asprintf(mem_ctx, "(name=%s)",
 459                                                         account);
 460                         W_ERROR_HAVE_NO_MEMORY(result_filter);
 461                 }
 462                 break;
 463         }
 464         case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: {
 465                 char *p;
 466                 char *domain;
 467                 struct ldb_dn *dn_domain;
 468                 const char *account = NULL;
 469
 470                 domain = talloc_strdup(mem_ctx, name);
 471                 W_ERROR_HAVE_NO_MEMORY(domain);
 472
 473                 p = strchr(domain, '\\');
 474                 if (!p) {
 475                         /* invalid input format */
 476                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 477                         return WERR_OK;
 478                 }
 479                 p[0] = '\0';
 480
 481                 if (p[1]) {
 482                         account = &p[1];
 483                 }
 484
 485                 /* it could be in DNS domain form */
 486                 dn_domain = samdb_dns_domain_to_dn(sam_ctx, mem_ctx, domain);
 487                 W_ERROR_HAVE_NO_MEMORY(dn_domain);
 488
 489                 domain_filter = talloc_asprintf(mem_ctx,
 490                                                 "(&(&(|(nETBIOSName=%s)(nCName=%s))(objectclass=crossRef))(ncName=*))",
 491                                                 ldb_binary_encode_string(mem_ctx, domain),
 492                                                 ldb_dn_get_linearized(dn_domain));
 493                 W_ERROR_HAVE_NO_MEMORY(domain_filter);
 494                 if (account) {
 495                         result_filter = talloc_asprintf(mem_ctx, "(sAMAccountName=%s)",
 496                                                         ldb_binary_encode_string(mem_ctx, account));
 497                         W_ERROR_HAVE_NO_MEMORY(result_filter);
 498                 }
 499
 500                 talloc_free(domain);
 501                 break;
 502         }
 503
 504                 /* A LDAP DN as a string */
 505         case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: {
 506                 domain_filter = NULL;
 507                 name_dn = ldb_dn_new(mem_ctx, sam_ctx, name);
 508                 if (! ldb_dn_validate(name_dn)) {
 509                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 510                         return WERR_OK;
 511                 }
 512                 break;
 513         }
 514
 515                 /* A GUID as a string */
 516         case DRSUAPI_DS_NAME_FORMAT_GUID: {
 517                 struct GUID guid;
 518                 char *ldap_guid;
 519                 NTSTATUS nt_status;
 520                 domain_filter = NULL;
 521
 522                 nt_status = GUID_from_string(name, &guid);
 523                 if (!NT_STATUS_IS_OK(nt_status)) {
 524                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 525                         return WERR_OK;
 526                 }
 527
 528                 ldap_guid = ldap_encode_ndr_GUID(mem_ctx, &guid);
 529                 if (!ldap_guid) {
 530                         return WERR_NOMEM;
 531                 }
 532                 result_filter = talloc_asprintf(mem_ctx, "(objectGUID=%s)",
 533                                                 ldap_guid);
 534                 W_ERROR_HAVE_NO_MEMORY(result_filter);
 535                 break;
 536         }
 537         case DRSUAPI_DS_NAME_FORMAT_DISPLAY: {
 538                 domain_filter = NULL;
 539
 540                 result_filter = talloc_asprintf(mem_ctx, "(|(displayName=%s)(samAccountName=%s))",
 541                                                 ldb_binary_encode_string(mem_ctx, name),
 542                                                 ldb_binary_encode_string(mem_ctx, name));
 543                 W_ERROR_HAVE_NO_MEMORY(result_filter);
 544                 break;
 545         }
 546
 547                 /* A S-1234-5678 style string */
 548         case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: {
 549                 struct dom_sid *sid = dom_sid_parse_talloc(mem_ctx, name);
 550                 char *ldap_sid;
 551
 552                 domain_filter = NULL;
 553                 if (!sid) {
 554                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 555                         return WERR_OK;
 556                 }
 557                 ldap_sid = ldap_encode_ndr_dom_sid(mem_ctx,
 558                                                    sid);
 559                 if (!ldap_sid) {
 560                         return WERR_NOMEM;
 561                 }
 562                 result_filter = talloc_asprintf(mem_ctx, "(objectSid=%s)",
 563                                                 ldap_sid);
 564                 W_ERROR_HAVE_NO_MEMORY(result_filter);
 565                 break;
 566         }
 567         case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: {
 568                 krb5_principal principal;
 569                 char *unparsed_name;
 570
 571                 ret = smb_krb5_init_context(mem_ctx,
 572                                             ldb_get_event_context(sam_ctx),
 573                                             (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
 574                                             &smb_krb5_context);
 575
 576                 if (ret) {
 577                         return WERR_NOMEM;
 578                 }
 579
 580                 /* Ensure we reject compleate junk first */
 581                 ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
 582                 if (ret) {
 583                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 584                         return WERR_OK;
 585                 }
 586
 587                 domain_filter = NULL;
 588
 589                 /* By getting the unparsed name here, we ensure the escaping is correct (and trust the client less) */
 590                 ret = krb5_unparse_name(smb_krb5_context->krb5_context, principal, &unparsed_name);
 591                 if (ret) {
 592                         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 593                         return WERR_NOMEM;
 594                 }
 595
 596                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 597
 598                 /* The ldb_binary_encode_string() here avoid LDAP filter injection attacks */
 599                 result_filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(userPrincipalName=%s))",
 600                                                 ldb_binary_encode_string(mem_ctx, unparsed_name));
 601
 602                 free(unparsed_name);
 603                 W_ERROR_HAVE_NO_MEMORY(result_filter);
 604                 break;
 605         }
 606         case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: {
 607                 krb5_principal principal;
 608                 char *unparsed_name_short;
 609                 char *service;
 610
 611                 ret = smb_krb5_init_context(mem_ctx,
 612                                             ldb_get_event_context(sam_ctx),
 613                                             (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
 614                                             &smb_krb5_context);
 615
 616                 if (ret) {
 617                         return WERR_NOMEM;
 618                 }
 619
 620                 ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
 621                 if (ret == 0 && principal->name.name_string.len < 2) {
 622                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 623                         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 624                         return WERR_OK;
 625                 } else if (ret == 0) {
 626                         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 627                 }
 628                 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context, name,
 629                                             KRB5_PRINCIPAL_PARSE_NO_REALM, &principal);
 630                 if (ret) {
 631                         return dns_domain_from_principal(mem_ctx, smb_krb5_context,
 632                                                          name, info1);
 633                 }
 634
 635                 domain_filter = NULL;
 636
 637                 ret = krb5_unparse_name_flags(smb_krb5_context->krb5_context, principal,
 638                                               KRB5_PRINCIPAL_UNPARSE_NO_REALM, &unparsed_name_short);
 639                 if (ret) {
 640                         krb5_free_principal(smb_krb5_context->krb5_context, principal);
 641                         return WERR_NOMEM;
 642                 }
 643
 644                 service = principal->name.name_string.val[0];
 645                 if ((principal->name.name_string.len == 2) && (strcasecmp(service, "host") == 0)) {
 646                         /* the 'cn' attribute is just the leading part of the name */
 647                         char *computer_name;
 648                         computer_name = talloc_strndup(mem_ctx, principal->name.name_string.val[1],
 649                                                       strcspn(principal->name.name_string.val[1], "."));
 650                         if (computer_name == NULL) {
 651                                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 652                                 return WERR_NOMEM;
 653                         }
 654
 655                         result_filter = talloc_asprintf(mem_ctx, "(|(&(servicePrincipalName=%s)(objectClass=user))(&(cn=%s)(objectClass=computer)))",
 656                                                         ldb_binary_encode_string(mem_ctx, unparsed_name_short),
 657                                                         ldb_binary_encode_string(mem_ctx, computer_name));
 658                 } else {
 659                         result_filter = talloc_asprintf(mem_ctx, "(&(servicePrincipalName=%s)(objectClass=user))",
 660                                                         ldb_binary_encode_string(mem_ctx, unparsed_name_short));
 661                 }
 662                 krb5_free_principal(smb_krb5_context->krb5_context, principal);
 663                 free(unparsed_name_short);
 664                 W_ERROR_HAVE_NO_MEMORY(result_filter);
 665
 666                 break;
 667         }
 668         default: {
 669                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 670                 return WERR_OK;
 671         }
 672         }
 673
 674         if (format_flags & DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY) {
 675                 return DsCrackNameOneSyntactical(mem_ctx, format_offered, format_desired,
 676                                                  name_dn, name, info1);
 677         }
 678
 679         return DsCrackNameOneFilter(sam_ctx, mem_ctx,
 680                                     smb_krb5_context,
 681                                     format_flags, format_offered, format_desired,
 682                                     name_dn, name,
 683                                     domain_filter, result_filter,
 684                                     info1);
 685 }
 686
 687 /* Subcase of CrackNames.  It is possible to translate a LDAP-style DN
 688  * (FQDN_1779) into a canoical name without actually searching the
 689  * database */
 690
 691 static WERROR DsCrackNameOneSyntactical(TALLOC_CTX *mem_ctx,
 692                                         enum drsuapi_DsNameFormat format_offered,
 693                                         enum drsuapi_DsNameFormat format_desired,
 694                                         struct ldb_dn *name_dn, const char *name,
 695                                         struct drsuapi_DsNameInfo1 *info1)
 696 {
 697         char *cracked;
 698         if (format_offered != DRSUAPI_DS_NAME_FORMAT_FQDN_1779) {
 699                 info1->status = DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING;
 700                 return WERR_OK;
 701         }
 702
 703         switch (format_desired) {
 704         case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
 705                 cracked = ldb_dn_canonical_string(mem_ctx, name_dn);
 706                 break;
 707         case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
 708                 cracked = ldb_dn_canonical_ex_string(mem_ctx, name_dn);
 709                 break;
 710         default:
 711                 info1->status = DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING;
 712                 return WERR_OK;
 713         }
 714         info1->status = DRSUAPI_DS_NAME_STATUS_OK;
 715         info1->result_name      = cracked;
 716         if (!cracked) {
 717                 return WERR_NOMEM;
 718         }
 719
 720         return WERR_OK;
 721 }
 722
 723 /* Given a filter for the domain, and one for the result, perform the
 724  * ldb search. The format offered and desired flags change the
 725  * behaviours, including what attributes to return.
 726  *
 727  * The smb_krb5_context is required because we use the krb5 libs for principal parsing
 728  */
 729
 730 static WERROR DsCrackNameOneFilter(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
 731                                    struct smb_krb5_context *smb_krb5_context,
 732                                    uint32_t format_flags, enum drsuapi_DsNameFormat format_offered,
 733                                    enum drsuapi_DsNameFormat format_desired,
 734                                    struct ldb_dn *name_dn, const char *name,
 735                                    const char *domain_filter, const char *result_filter,
 736                                    struct drsuapi_DsNameInfo1 *info1)
 737 {
 738         int ldb_ret;
 739         struct ldb_result *domain_res = NULL;
 740         const char * const *domain_attrs;
 741         const char * const *result_attrs;
 742         struct ldb_message **result_res = NULL;
 743         struct ldb_message *result = NULL;
 744         int i;
 745         char *p;
 746         struct ldb_dn *partitions_basedn = samdb_partitions_dn(sam_ctx, mem_ctx);
 747
 748         const char * const _domain_attrs_1779[] = { "ncName", "dnsRoot", NULL};
 749         const char * const _result_attrs_null[] = { NULL };
 750
 751         const char * const _domain_attrs_canonical[] = { "ncName", "dnsRoot", NULL};
 752         const char * const _result_attrs_canonical[] = { "canonicalName", NULL };
 753
 754         const char * const _domain_attrs_nt4[] = { "ncName", "dnsRoot", "nETBIOSName", NULL};
 755         const char * const _result_attrs_nt4[] = { "sAMAccountName", "objectSid", "objectClass", NULL};
 756
 757         const char * const _domain_attrs_guid[] = { "ncName", "dnsRoot", NULL};
 758         const char * const _result_attrs_guid[] = { "objectGUID", NULL};
 759
 760         const char * const _domain_attrs_display[] = { "ncName", "dnsRoot", NULL};
 761         const char * const _result_attrs_display[] = { "displayName", "samAccountName", NULL};
 762
 763         const char * const _domain_attrs_none[] = { "ncName", "dnsRoot" , NULL};
 764         const char * const _result_attrs_none[] = { NULL};
 765
 766         /* here we need to set the attrs lists for domain and result lookups */
 767         switch (format_desired) {
 768         case DRSUAPI_DS_NAME_FORMAT_FQDN_1779:
 769         case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
 770                 domain_attrs = _domain_attrs_1779;
 771                 result_attrs = _result_attrs_null;
 772                 break;
 773         case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
 774                 domain_attrs = _domain_attrs_canonical;
 775                 result_attrs = _result_attrs_canonical;
 776                 break;
 777         case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT:
 778                 domain_attrs = _domain_attrs_nt4;
 779                 result_attrs = _result_attrs_nt4;
 780                 break;
 781         case DRSUAPI_DS_NAME_FORMAT_GUID:
 782                 domain_attrs = _domain_attrs_guid;
 783                 result_attrs = _result_attrs_guid;
 784                 break;
 785         case DRSUAPI_DS_NAME_FORMAT_DISPLAY:
 786                 domain_attrs = _domain_attrs_display;
 787                 result_attrs = _result_attrs_display;
 788                 break;
 789         default:
 790                 domain_attrs = _domain_attrs_none;
 791                 result_attrs = _result_attrs_none;
 792                 break;
 793         }
 794
 795         if (domain_filter) {
 796                 /* if we have a domain_filter look it up and set the result_basedn and the dns_domain_name */
 797                 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
 798                                              partitions_basedn,
 799                                              LDB_SCOPE_ONELEVEL,
 800                                              domain_attrs,
 801                                              "%s", domain_filter);
 802
 803                 if (ldb_ret != LDB_SUCCESS) {
 804                         DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s", ldb_errstring(sam_ctx)));
 805                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 806                         return WERR_OK;
 807                 }
 808
 809                 switch (domain_res->count) {
 810                 case 1:
 811                         break;
 812                 case 0:
 813                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 814                         return WERR_OK;
 815                 default:
 816                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
 817                         return WERR_OK;
 818                 }
 819
 820                 info1->dns_domain_name  = ldb_msg_find_attr_as_string(domain_res->msgs[0], "dnsRoot", NULL);
 821                 W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
 822                 info1->status           = DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY;
 823         } else {
 824                 info1->dns_domain_name  = NULL;
 825                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 826         }
 827
 828         if (result_filter) {
 829                 int ret;
 830                 struct ldb_result *res;
 831                 uint32_t dsdb_flags = 0;
 832                 struct ldb_dn *search_dn;
 833
 834                 if (domain_res) {
 835                         dsdb_flags = 0;
 836                         search_dn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
 837                 } else {
 838                         dsdb_flags = DSDB_SEARCH_SEARCH_ALL_PARTITIONS;
 839                         search_dn = ldb_get_root_basedn(sam_ctx);
 840                 }
 841
 842                 /* search with the 'phantom root' flag */
 843                 ret = dsdb_search(sam_ctx, mem_ctx, &res,
 844                                   search_dn,
 845                                   LDB_SCOPE_SUBTREE,
 846                                   result_attrs,
 847                                   DSDB_SEARCH_SEARCH_ALL_PARTITIONS,
 848                                   "%s", result_filter);
 849                 if (ret != LDB_SUCCESS) {
 850                         DEBUG(2, ("DsCrackNameOneFilter phantom root search failed: %s",
 851                                   ldb_errstring(sam_ctx)));
 852                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 853                         return WERR_OK;
 854                 }
 855
 856                 ldb_ret = res->count;
 857                 result_res = res->msgs;
 858         } else if (format_offered == DRSUAPI_DS_NAME_FORMAT_FQDN_1779) {
 859                 ldb_ret = gendb_search_dn(sam_ctx, mem_ctx, name_dn, &result_res,
 860                                           result_attrs);
 861         } else if (domain_res) {
 862                 name_dn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
 863                 ldb_ret = gendb_search_dn(sam_ctx, mem_ctx, name_dn, &result_res,
 864                                           result_attrs);
 865         } else {
 866                 /* Can't happen */
 867                 DEBUG(0, ("LOGIC ERROR: DsCrackNameOneFilter domain ref search not available: This can't happen..."));
 868                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 869                 return WERR_OK;
 870         }
 871
 872         switch (ldb_ret) {
 873         case 1:
 874                 result = result_res[0];
 875                 break;
 876         case 0:
 877                 switch (format_offered) {
 878                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL:
 879                         return DsCrackNameSPNAlias(sam_ctx, mem_ctx,
 880                                                    smb_krb5_context,
 881                                                    format_flags, format_offered, format_desired,
 882                                                    name, info1);
 883
 884                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL:
 885                         return DsCrackNameUPN(sam_ctx, mem_ctx, smb_krb5_context,
 886                                               format_flags, format_offered, format_desired,
 887                                               name, info1);
 888                 default:
 889                         break;
 890                 }
 891                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 892                 return WERR_OK;
 893         case -1:
 894                 DEBUG(2, ("DsCrackNameOneFilter result search failed: %s", ldb_errstring(sam_ctx)));
 895                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 896                 return WERR_OK;
 897         default:
 898                 switch (format_offered) {
 899                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
 900                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
 901                 {
 902                         const char *canonical_name = NULL; /* Not required, but we get warnings... */
 903                         /* We may need to manually filter further */
 904                         for (i = 0; i < ldb_ret; i++) {
 905                                 switch (format_offered) {
 906                                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
 907                                         canonical_name = ldb_dn_canonical_string(mem_ctx, result_res[i]->dn);
 908                                         break;
 909                                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
 910                                         canonical_name = ldb_dn_canonical_ex_string(mem_ctx, result_res[i]->dn);
 911                                         break;
 912                                 default:
 913                                         break;
 914                                 }
 915                                 if (strcasecmp_m(canonical_name, name) == 0) {
 916                                         result = result_res[i];
 917                                         break;
 918                                 }
 919                         }
 920                         if (!result) {
 921                                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 922                                 return WERR_OK;
 923                         }
 924                 }
 925                 default:
 926                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
 927                         return WERR_OK;
 928                 }
 929         }
 930
 931         info1->dns_domain_name = ldb_dn_canonical_string(mem_ctx, result->dn);
 932         W_ERROR_HAVE_NO_MEMORY(info1->dns_domain_name);
 933         p = strchr(info1->dns_domain_name, '/');
 934         if (p) {
 935                 p[0] = '\0';
 936         }
 937
 938         /* here we can use result and domain_res[0] */
 939         switch (format_desired) {
 940         case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: {
 941                 info1->result_name      = ldb_dn_alloc_linearized(mem_ctx, result->dn);
 942                 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
 943
 944                 info1->status           = DRSUAPI_DS_NAME_STATUS_OK;
 945                 return WERR_OK;
 946         }
 947         case DRSUAPI_DS_NAME_FORMAT_CANONICAL: {
 948                 info1->result_name      = ldb_msg_find_attr_as_string(result, "canonicalName", NULL);
 949                 info1->status           = DRSUAPI_DS_NAME_STATUS_OK;
 950                 return WERR_OK;
 951         }
 952         case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: {
 953                 /* Not in the virtual ldb attribute */
 954                 return DsCrackNameOneSyntactical(mem_ctx,
 955                                                  DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
 956                                                  DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX,
 957                                                  result->dn, name, info1);
 958         }
 959         case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: {
 960
 961                 const struct dom_sid *sid = samdb_result_dom_sid(mem_ctx, result, "objectSid");
 962                 const char *_acc = "", *_dom = "";
 963
 964                 if (samdb_find_attribute(sam_ctx, result, "objectClass", "domain")) {
 965
 966                         ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
 967                                                      partitions_basedn,
 968                                                      LDB_SCOPE_ONELEVEL,
 969                                                      domain_attrs,
 970                                                      "(ncName=%s)", ldb_dn_get_linearized(result->dn));
 971
 972                         if (ldb_ret != LDB_SUCCESS) {
 973                                 DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s", ldb_errstring(sam_ctx)));
 974                                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
 975                                 return WERR_OK;
 976                         }
 977
 978                         switch (domain_res->count) {
 979                         case 1:
 980                                 break;
 981                         case 0:
 982                                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
 983                                 return WERR_OK;
 984                         default:
 985                                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
 986                                 return WERR_OK;
 987                         }
 988                         _dom = ldb_msg_find_attr_as_string(domain_res->msgs[0], "nETBIOSName", NULL);
 989                         W_ERROR_HAVE_NO_MEMORY(_dom);
 990                 } else {
 991                         _acc = ldb_msg_find_attr_as_string(result, "sAMAccountName", NULL);
 992                         if (!_acc) {
 993                                 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
 994                                 return WERR_OK;
 995                         }
 996                         if (dom_sid_in_domain(dom_sid_parse_talloc(mem_ctx, SID_BUILTIN), sid)) {
 997                                 _dom = "BUILTIN";
 998                         } else {
 999                                 const char *attrs[] = { NULL };
1000                                 struct ldb_result *domain_res2;
1001                                 struct dom_sid *dom_sid = dom_sid_dup(mem_ctx, sid);
1002                                 if (!dom_sid) {
1003                                         return WERR_OK;
1004                                 }
1005                                 dom_sid->num_auths--;
1006                                 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
1007                                                              NULL,
1008                                                              LDB_SCOPE_BASE,
1009                                                              attrs,
1010                                                              "(&(objectSid=%s)(objectClass=domain))",
1011                                                              ldap_encode_ndr_dom_sid(mem_ctx, dom_sid));
1012
1013                                 if (ldb_ret != LDB_SUCCESS) {
1014                                         DEBUG(2, ("DsCrackNameOneFilter domain search failed: %s", ldb_errstring(sam_ctx)));
1015                                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1016                                         return WERR_OK;
1017                                 }
1018
1019                                 switch (domain_res->count) {
1020                                 case 1:
1021                                         break;
1022                                 case 0:
1023                                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1024                                         return WERR_OK;
1025                                 default:
1026                                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1027                                         return WERR_OK;
1028                                 }
1029
1030                                 ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res2,
1031                                                              partitions_basedn,
1032                                                              LDB_SCOPE_ONELEVEL,
1033                                                              domain_attrs,
1034                                                              "(ncName=%s)", ldb_dn_get_linearized(domain_res->msgs[0]->dn));
1035
1036                                 if (ldb_ret != LDB_SUCCESS) {
1037                                         DEBUG(2, ("DsCrackNameOneFilter domain ref search failed: %s", ldb_errstring(sam_ctx)));
1038                                         info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1039                                         return WERR_OK;
1040                                 }
1041
1042                                 switch (domain_res2->count) {
1043                                 case 1:
1044                                         break;
1045                                 case 0:
1046                                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1047                                         return WERR_OK;
1048                                 default:
1049                                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1050                                         return WERR_OK;
1051                                 }
1052                                 _dom = ldb_msg_find_attr_as_string(domain_res2->msgs[0], "nETBIOSName", NULL);
1053                                 W_ERROR_HAVE_NO_MEMORY(_dom);
1054                         }
1055                 }
1056
1057                 info1->result_name      = talloc_asprintf(mem_ctx, "%s\\%s", _dom, _acc);
1058                 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1059
1060                 info1->status           = DRSUAPI_DS_NAME_STATUS_OK;
1061                 return WERR_OK;
1062         }
1063         case DRSUAPI_DS_NAME_FORMAT_GUID: {
1064                 struct GUID guid;
1065
1066                 guid = samdb_result_guid(result, "objectGUID");
1067
1068                 info1->result_name      = GUID_string2(mem_ctx, &guid);
1069                 W_ERROR_HAVE_NO_MEMORY(info1->result_name);
1070
1071                 info1->status           = DRSUAPI_DS_NAME_STATUS_OK;
1072                 return WERR_OK;
1073         }
1074         case DRSUAPI_DS_NAME_FORMAT_DISPLAY: {
1075                 info1->result_name      = ldb_msg_find_attr_as_string(result, "displayName", NULL);
1076                 if (!info1->result_name) {
1077                         info1->result_name      = ldb_msg_find_attr_as_string(result, "sAMAccountName", NULL);
1078                 }
1079                 if (!info1->result_name) {
1080                         info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
1081                 } else {
1082                         info1->status = DRSUAPI_DS_NAME_STATUS_OK;
1083                 }
1084                 return WERR_OK;
1085         }
1086         case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: {
1087                 info1->status = DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE;
1088                 return WERR_OK;
1089         }
1090         case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN:
1091         case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: {
1092                 info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
1093                 return WERR_OK;
1094         }
1095         default:
1096                 info1->status = DRSUAPI_DS_NAME_STATUS_NO_MAPPING;
1097                 return WERR_OK;
1098         }
1099 }
1100
1101 /* Given a user Principal Name (such as foo@bar.com),
1102  * return the user and domain DNs.  This is used in the KDC to then
1103  * return the Keys and evaluate policy */
1104
1105 NTSTATUS crack_user_principal_name(struct ldb_context *sam_ctx,
1106                                    TALLOC_CTX *mem_ctx,
1107                                    const char *user_principal_name,
1108                                    struct ldb_dn **user_dn,
1109                                    struct ldb_dn **domain_dn)
1110 {
1111         WERROR werr;
1112         struct drsuapi_DsNameInfo1 info1;
1113         werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1114                                   DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
1115                                   DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1116                                   user_principal_name,
1117                                   &info1);
1118         if (!W_ERROR_IS_OK(werr)) {
1119                 return werror_to_ntstatus(werr);
1120         }
1121         switch (info1.status) {
1122         case DRSUAPI_DS_NAME_STATUS_OK:
1123                 break;
1124         case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1125         case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1126         case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1127                 return NT_STATUS_NO_SUCH_USER;
1128         case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1129         default:
1130                 return NT_STATUS_UNSUCCESSFUL;
1131         }
1132
1133         *user_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1134
1135         if (domain_dn) {
1136                 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1137                                           DRSUAPI_DS_NAME_FORMAT_CANONICAL,
1138                                           DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1139                                           talloc_asprintf(mem_ctx, "%s/",
1140                                                           info1.dns_domain_name),
1141                                           &info1);
1142                 if (!W_ERROR_IS_OK(werr)) {
1143                         return werror_to_ntstatus(werr);
1144                 }
1145                 switch (info1.status) {
1146                 case DRSUAPI_DS_NAME_STATUS_OK:
1147                         break;
1148                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1149                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1150                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1151                         return NT_STATUS_NO_SUCH_USER;
1152                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1153                 default:
1154                         return NT_STATUS_UNSUCCESSFUL;
1155                 }
1156
1157                 *domain_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1158         }
1159
1160         return NT_STATUS_OK;
1161 }
1162
1163 /* Given a Service Principal Name (such as host/foo.bar.com@BAR.COM),
1164  * return the user and domain DNs.  This is used in the KDC to then
1165  * return the Keys and evaluate policy */
1166
1167 NTSTATUS crack_service_principal_name(struct ldb_context *sam_ctx,
1168                                       TALLOC_CTX *mem_ctx,
1169                                       const char *service_principal_name,
1170                                       struct ldb_dn **user_dn,
1171                                       struct ldb_dn **domain_dn)
1172 {
1173         WERROR werr;
1174         struct drsuapi_DsNameInfo1 info1;
1175         werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1176                                   DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
1177                                   DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1178                                   service_principal_name,
1179                                   &info1);
1180         if (!W_ERROR_IS_OK(werr)) {
1181                 return werror_to_ntstatus(werr);
1182         }
1183         switch (info1.status) {
1184         case DRSUAPI_DS_NAME_STATUS_OK:
1185                 break;
1186         case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1187         case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1188         case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1189                 return NT_STATUS_NO_SUCH_USER;
1190         case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1191         default:
1192                 return NT_STATUS_UNSUCCESSFUL;
1193         }
1194
1195         *user_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1196
1197         if (domain_dn) {
1198                 werr = DsCrackNameOneName(sam_ctx, mem_ctx, 0,
1199                                           DRSUAPI_DS_NAME_FORMAT_CANONICAL,
1200                                           DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
1201                                           talloc_asprintf(mem_ctx, "%s/",
1202                                                           info1.dns_domain_name),
1203                                           &info1);
1204                 if (!W_ERROR_IS_OK(werr)) {
1205                         return werror_to_ntstatus(werr);
1206                 }
1207                 switch (info1.status) {
1208                 case DRSUAPI_DS_NAME_STATUS_OK:
1209                         break;
1210                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1211                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1212                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1213                         return NT_STATUS_NO_SUCH_USER;
1214                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1215                 default:
1216                         return NT_STATUS_UNSUCCESSFUL;
1217                 }
1218
1219                 *domain_dn = ldb_dn_new(mem_ctx, sam_ctx, info1.result_name);
1220         }
1221
1222         return NT_STATUS_OK;
1223 }
1224
1225 NTSTATUS crack_name_to_nt4_name(TALLOC_CTX *mem_ctx,
1226                                 struct tevent_context *ev_ctx,
1227                                 struct loadparm_context *lp_ctx,
1228                                 enum drsuapi_DsNameFormat format_offered,
1229                                 const char *name,
1230                                 const char **nt4_domain, const char **nt4_account)
1231 {
1232         WERROR werr;
1233         struct drsuapi_DsNameInfo1 info1;
1234         struct ldb_context *ldb;
1235         char *p;
1236
1237         /* Handle anonymous bind */
1238         if (!name || !*name) {
1239                 *nt4_domain = "";
1240                 *nt4_account = "";
1241                 return NT_STATUS_OK;
1242         }
1243
1244         ldb = samdb_connect(mem_ctx, ev_ctx, lp_ctx, system_session(lp_ctx), 0);
1245         if (ldb == NULL) {
1246                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1247         }
1248
1249         werr = DsCrackNameOneName(ldb, mem_ctx, 0,
1250                                   format_offered,
1251                                   DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT,
1252                                   name,
1253                                   &info1);
1254         if (!W_ERROR_IS_OK(werr)) {
1255                 return werror_to_ntstatus(werr);
1256         }
1257         switch (info1.status) {
1258         case DRSUAPI_DS_NAME_STATUS_OK:
1259                 break;
1260         case DRSUAPI_DS_NAME_STATUS_NOT_FOUND:
1261         case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY:
1262         case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE:
1263                 return NT_STATUS_NO_SUCH_USER;
1264         case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR:
1265         default:
1266                 return NT_STATUS_UNSUCCESSFUL;
1267         }
1268
1269         *nt4_domain = talloc_strdup(mem_ctx, info1.result_name);
1270         if (*nt4_domain == NULL) {
1271                 return NT_STATUS_NO_MEMORY;
1272         }
1273
1274         p = strchr(*nt4_domain, '\\');
1275         if (!p) {
1276                 return NT_STATUS_INVALID_PARAMETER;
1277         }
1278         p[0] = '\0';
1279
1280         *nt4_account = talloc_strdup(mem_ctx, &p[1]);
1281         if (*nt4_account == NULL) {
1282                 return NT_STATUS_NO_MEMORY;
1283         }
1284
1285         return NT_STATUS_OK;
1286 }
1287
1288 NTSTATUS crack_auto_name_to_nt4_name(TALLOC_CTX *mem_ctx,
1289                                      struct tevent_context *ev_ctx,
1290                                      struct loadparm_context *lp_ctx,
1291                                      const char *name,
1292                                      const char **nt4_domain,
1293                                      const char **nt4_account)
1294 {
1295         enum drsuapi_DsNameFormat format_offered = DRSUAPI_DS_NAME_FORMAT_UNKNOWN;
1296
1297         /* Handle anonymous bind */
1298         if (!name || !*name) {
1299                 *nt4_domain = "";
1300                 *nt4_account = "";
1301                 return NT_STATUS_OK;
1302         }
1303
1304         if (strchr_m(name, '=')) {
1305                 format_offered = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
1306         } else if (strchr_m(name, '@')) {
1307                 format_offered = DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL;
1308         } else if (strchr_m(name, '\\')) {
1309                 format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
1310         } else if (strchr_m(name, '/')) {
1311                 format_offered = DRSUAPI_DS_NAME_FORMAT_CANONICAL;
1312         } else {
1313                 return NT_STATUS_NO_SUCH_USER;
1314         }
1315
1316         return crack_name_to_nt4_name(mem_ctx, ev_ctx, lp_ctx, format_offered, name, nt4_domain, nt4_account);
1317 }
1318
1319
1320 WERROR dcesrv_drsuapi_ListRoles(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
1321                                 const struct drsuapi_DsNameRequest1 *req1,
1322                                 struct drsuapi_DsNameCtr1 **ctr1)
1323 {
1324         struct drsuapi_DsNameInfo1 *names;
1325         uint32_t i;
1326         uint32_t count = 5;/*number of fsmo role owners we are going to return*/
1327
1328         *ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
1329         W_ERROR_HAVE_NO_MEMORY(*ctr1);
1330         names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
1331         W_ERROR_HAVE_NO_MEMORY(names);
1332
1333         for (i = 0; i < count; i++) {
1334                 WERROR werr;
1335                 struct ldb_dn *role_owner_dn, *fsmo_role_dn, *server_dn;
1336                 werr = dsdb_get_fsmo_role_info(mem_ctx, sam_ctx, i,
1337                                                &fsmo_role_dn, &role_owner_dn);
1338                 if(!W_ERROR_IS_OK(werr)) {
1339                         return werr;
1340                 }
1341                 server_dn = ldb_dn_copy(mem_ctx, role_owner_dn);
1342                 ldb_dn_remove_child_components(server_dn, 1);
1343                 names[i].status = DRSUAPI_DS_NAME_STATUS_OK;
1344                 names[i].dns_domain_name = samdb_dn_to_dnshostname(sam_ctx, mem_ctx,
1345                                                                    server_dn);
1346                 if(!names[i].dns_domain_name) {
1347                         DEBUG(4, ("list_roles: Failed to find dNSHostName for server %s",
1348                                   ldb_dn_get_linearized(server_dn)));
1349                 }
1350                 names[i].result_name = talloc_strdup(mem_ctx, ldb_dn_get_linearized(role_owner_dn));
1351         }
1352
1353         (*ctr1)->count = count;
1354         (*ctr1)->array = names;
1355
1356         return WERR_OK;
1357 }
1358
1359 WERROR dcesrv_drsuapi_CrackNamesByNameFormat(struct ldb_context *sam_ctx, TALLOC_CTX *mem_ctx,
1360                                              const struct drsuapi_DsNameRequest1 *req1,
1361                                              struct drsuapi_DsNameCtr1 **ctr1)
1362 {
1363         struct drsuapi_DsNameInfo1 *names;
1364         uint32_t i, count;
1365         WERROR status;
1366
1367         *ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
1368         W_ERROR_HAVE_NO_MEMORY(*ctr1);
1369
1370         count = req1->count;
1371         names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
1372         W_ERROR_HAVE_NO_MEMORY(names);
1373
1374         for (i=0; i < count; i++) {
1375                 status = DsCrackNameOneName(sam_ctx, mem_ctx,
1376                                             req1->format_flags,
1377                                             req1->format_offered,
1378                                             req1->format_desired,
1379                                             req1->names[i].str,
1380                                             &names[i]);
1381                 if (!W_ERROR_IS_OK(status)) {
1382                         return status;
1383                 }
1384         }
1385
1386         (*ctr1)->count = count;
1387         (*ctr1)->array = names;
1388
1389         return WERR_OK;
1390 }