source4/lib/policy/gp_ldap.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Group Policy Object Support
   4  *  Copyright (C) Jelmer Vernooij 2008
   5  *  Copyright (C) Wilco Baan Hofman 2008-2010
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20 #include "includes.h"
  21 #include "param/param.h"
  22 #include "lib/ldb/include/ldb.h"
  23 #include "lib/ldb-samba/ldb_wrap.h"
  24 #include "auth/credentials/credentials.h"
  25 #include "../librpc/gen_ndr/nbt.h"
  26 #include "libcli/libcli.h"
  27 #include "libnet/libnet.h"
  28 #include "../librpc/gen_ndr/ndr_security.h"
  29 #include "../libcli/security/security.h"
  30 #include "libcli/ldap/ldap_ndr.h"
  31 #include "../lib/talloc/talloc.h"
  32 #include "lib/policy/policy.h"
  33
  34 struct gpo_stringmap {
  35         const char *str;
  36         uint32_t flags;
  37 };
  38 static const struct gpo_stringmap gplink_options [] = {
  39         { "GPLINK_OPT_DISABLE", GPLINK_OPT_DISABLE },
  40         { "GPLINK_OPT_ENFORCE", GPLINK_OPT_ENFORCE },
  41         { NULL, 0 }
  42 };
  43 static const struct gpo_stringmap gpo_flags [] = {
  44         { "GPO_FLAG_USER_DISABLE", GPO_FLAG_USER_DISABLE },
  45         { "GPO_FLAG_MACHINE_DISABLE", GPO_FLAG_MACHINE_DISABLE },
  46         { NULL, 0 }
  47 };
  48 static const struct gpo_stringmap gpo_inheritance [] = {
  49         { "GPO_INHERIT", GPO_INHERIT },
  50         { "GPO_BLOCK_INHERITANCE", GPO_BLOCK_INHERITANCE },
  51         { NULL, 0 }
  52 };
  53
  54
  55 static NTSTATUS parse_gpo(TALLOC_CTX *mem_ctx, struct ldb_message *msg, struct gp_object **ret)
  56 {
  57         struct gp_object *gpo = talloc(mem_ctx, struct gp_object);
  58         enum ndr_err_code ndr_err;
  59         const DATA_BLOB *data;
  60
  61         NT_STATUS_HAVE_NO_MEMORY(gpo);
  62
  63         gpo->dn = talloc_strdup(mem_ctx, ldb_dn_get_linearized(msg->dn));
  64         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->dn, gpo);
  65
  66         DEBUG(9, ("Parsing GPO LDAP data for %s\n", gpo->dn));
  67
  68         gpo->display_name = talloc_strdup(gpo, ldb_msg_find_attr_as_string(msg, "displayName", ""));
  69         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->display_name, gpo);
  70
  71         gpo->name = talloc_strdup(gpo, ldb_msg_find_attr_as_string(msg, "name", ""));
  72         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->name, gpo);
  73
  74         gpo->flags = ldb_msg_find_attr_as_uint(msg, "flags", 0);
  75         gpo->version = ldb_msg_find_attr_as_uint(msg, "versionNumber", 0);
  76
  77         gpo->file_sys_path = talloc_strdup(gpo, ldb_msg_find_attr_as_string(msg, "gPCFileSysPath", ""));
  78         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->file_sys_path, gpo);
  79
  80         /* Pull the security descriptor through the NDR library */
  81         data = ldb_msg_find_ldb_val(msg, "nTSecurityDescriptor");
  82         gpo->security_descriptor = talloc(gpo, struct security_descriptor);
  83         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->security_descriptor, gpo);
  84
  85         ndr_err = ndr_pull_struct_blob(data,
  86                         mem_ctx,
  87                         gpo->security_descriptor,
  88                         (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
  89         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  90                 return ndr_map_error2ntstatus(ndr_err);
  91         }
  92
  93         *ret = gpo;
  94         return NT_STATUS_OK;
  95 }
  96
  97 NTSTATUS gp_get_gpo_flags(TALLOC_CTX *mem_ctx, uint32_t flags, const char ***ret)
  98 {
  99         unsigned int i, count=0;
 100         const char **flag_strs = talloc_array(mem_ctx, const char *, 1);
 101
 102         NT_STATUS_HAVE_NO_MEMORY(flag_strs);
 103
 104         flag_strs[0] = NULL;
 105
 106         for (i = 0; gpo_flags[i].str != NULL; i++) {
 107                 if (flags & gpo_flags[i].flags) {
 108                         flag_strs = talloc_realloc(mem_ctx, flag_strs, const char *, count+2);
 109                         NT_STATUS_HAVE_NO_MEMORY(flag_strs);
 110                         flag_strs[count] = gpo_flags[i].str;
 111                         flag_strs[count+1] = NULL;
 112                         count++;
 113                 }
 114         }
 115         *ret = flag_strs;
 116         return NT_STATUS_OK;
 117 }
 118
 119 NTSTATUS gp_get_gplink_options(TALLOC_CTX *mem_ctx, uint32_t options, const char ***ret)
 120 {
 121         unsigned int i, count=0;
 122         const char **flag_strs = talloc_array(mem_ctx, const char *, 1);
 123
 124         NT_STATUS_HAVE_NO_MEMORY(flag_strs);
 125         flag_strs[0] = NULL;
 126
 127         for (i = 0; gplink_options[i].str != NULL; i++) {
 128                 if (options & gplink_options[i].flags) {
 129                         flag_strs = talloc_realloc(mem_ctx, flag_strs, const char *, count+2);
 130                         NT_STATUS_HAVE_NO_MEMORY(flag_strs);
 131                         flag_strs[count] = gplink_options[i].str;
 132                         flag_strs[count+1] = NULL;
 133                         count++;
 134                 }
 135         }
 136         *ret = flag_strs;
 137         return NT_STATUS_OK;
 138 }
 139
 140 NTSTATUS gp_init(TALLOC_CTX *mem_ctx,
 141                 struct loadparm_context *lp_ctx,
 142                 struct cli_credentials *credentials,
 143                 struct tevent_context *ev_ctx,
 144                 struct gp_context **gp_ctx)
 145 {
 146
 147         struct libnet_LookupDCs *io;
 148         char *url;
 149         struct libnet_context *net_ctx;
 150         struct ldb_context *ldb_ctx;
 151         NTSTATUS rv;
 152
 153         /* Initialise the libnet context */
 154         net_ctx = libnet_context_init(ev_ctx, lp_ctx);
 155         net_ctx->cred = credentials;
 156
 157         /* Prepare libnet lookup structure for looking a DC (PDC is correct). */
 158         io = talloc_zero(mem_ctx, struct libnet_LookupDCs);
 159         NT_STATUS_HAVE_NO_MEMORY(io);
 160         io->in.name_type = NBT_NAME_PDC;
 161         io->in.domain_name = lpcfg_workgroup(lp_ctx);
 162
 163         /* Find Active DC's */
 164         rv = libnet_LookupDCs(net_ctx, mem_ctx, io);
 165         if (!NT_STATUS_IS_OK(rv)) {
 166                 DEBUG(0, ("Failed to lookup DCs in domain\n"));
 167                 return rv;
 168         }
 169
 170         /* Connect to ldap://DC_NAME with all relevant contexts*/
 171         url = talloc_asprintf(mem_ctx, "ldap://%s", io->out.dcs[0].name);
 172         NT_STATUS_HAVE_NO_MEMORY(url);
 173         ldb_ctx = ldb_wrap_connect(mem_ctx, net_ctx->event_ctx, lp_ctx,
 174                         url, NULL, net_ctx->cred, 0);
 175         if (ldb_ctx == NULL) {
 176                 DEBUG(0, ("Can't connect to DC's LDAP with url %s\n", url));
 177                 return NT_STATUS_UNSUCCESSFUL;
 178         }
 179
 180
 181         *gp_ctx = talloc_zero(mem_ctx, struct gp_context);
 182         NT_STATUS_HAVE_NO_MEMORY(gp_ctx);
 183
 184         (*gp_ctx)->lp_ctx = lp_ctx;
 185         (*gp_ctx)->credentials = credentials;
 186         (*gp_ctx)->ev_ctx = ev_ctx;
 187         (*gp_ctx)->ldb_ctx = ldb_ctx;
 188         (*gp_ctx)->active_dc = io->out.dcs[0];
 189
 190         /* We don't need to keep the libnet context */
 191         talloc_free(net_ctx);
 192         return NT_STATUS_OK;
 193 }
 194
 195 NTSTATUS gp_list_all_gpos(struct gp_context *gp_ctx, struct gp_object ***ret)
 196 {
 197         struct ldb_result *result;
 198         int rv;
 199         NTSTATUS status;
 200         TALLOC_CTX *mem_ctx;
 201         struct ldb_dn *dn;
 202         struct gp_object **gpo;
 203         unsigned int i; /* same as in struct ldb_result */
 204         const char **attrs;
 205
 206         /* Create a forked memory context, as a base for everything here */
 207         mem_ctx = talloc_new(gp_ctx);
 208         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 209
 210         /* Create full ldb dn of the policies base object */
 211         dn = ldb_get_default_basedn(gp_ctx->ldb_ctx);
 212         rv = ldb_dn_add_child(dn, ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, "CN=Policies,CN=System"));
 213         if (!rv) {
 214                 DEBUG(0, ("Can't append subtree to DN\n"));
 215                 talloc_free(mem_ctx);
 216                 return NT_STATUS_UNSUCCESSFUL;
 217         }
 218
 219         DEBUG(10, ("Searching for policies in DN: %s\n", ldb_dn_get_linearized(dn)));
 220
 221         attrs = talloc_array(mem_ctx, const char *, 7);
 222         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(attrs, mem_ctx);
 223
 224         attrs[0] = "nTSecurityDescriptor";
 225         attrs[1] = "versionNumber";
 226         attrs[2] = "flags";
 227         attrs[3] = "name";
 228         attrs[4] = "displayName";
 229         attrs[5] = "gPCFileSysPath";
 230         attrs[6] = NULL;
 231
 232         rv = ldb_search(gp_ctx->ldb_ctx, mem_ctx, &result, dn, LDB_SCOPE_ONELEVEL, attrs, "(objectClass=groupPolicyContainer)");
 233         if (rv != LDB_SUCCESS) {
 234                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 235                 talloc_free(mem_ctx);
 236                 return NT_STATUS_UNSUCCESSFUL;
 237         }
 238
 239         gpo = talloc_array(gp_ctx, struct gp_object *, result->count+1);
 240         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo, mem_ctx);
 241
 242         gpo[result->count] = NULL;
 243
 244         for (i = 0; i < result->count; i++) {
 245                 status = parse_gpo(gp_ctx, result->msgs[i], &gpo[i]);
 246                 if (!NT_STATUS_IS_OK(status)) {
 247                         DEBUG(0, ("Failed to parse GPO.\n"));
 248                         talloc_free(mem_ctx);
 249                         return status;
 250                 }
 251         }
 252
 253         talloc_free(mem_ctx);
 254
 255         *ret = gpo;
 256         return NT_STATUS_OK;
 257 }
 258
 259 NTSTATUS gp_get_gpo_info(struct gp_context *gp_ctx, const char *dn_str, struct gp_object **ret)
 260 {
 261         struct ldb_result *result;
 262         struct ldb_dn *dn;
 263         struct gp_object *gpo;
 264         int rv;
 265         NTSTATUS status;
 266         TALLOC_CTX *mem_ctx;
 267         const char **attrs;
 268
 269         /* Create a forked memory context, as a base for everything here */
 270         mem_ctx = talloc_new(gp_ctx);
 271         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 272
 273         /* Create an ldb dn struct for the dn string */
 274         dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 275
 276         attrs = talloc_array(mem_ctx, const char *, 7);
 277         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(attrs, mem_ctx);
 278
 279         attrs[0] = "nTSecurityDescriptor";
 280         attrs[1] = "versionNumber";
 281         attrs[2] = "flags";
 282         attrs[3] = "name";
 283         attrs[4] = "displayName";
 284         attrs[5] = "gPCFileSysPath";
 285         attrs[6] = NULL;
 286
 287         rv = ldb_search(gp_ctx->ldb_ctx,
 288                         mem_ctx,
 289                         &result,
 290                         dn,
 291                         LDB_SCOPE_BASE,
 292                         attrs,
 293                         "objectClass=groupPolicyContainer");
 294         if (rv != LDB_SUCCESS) {
 295                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 296                 talloc_free(mem_ctx);
 297                 return NT_STATUS_UNSUCCESSFUL;
 298         }
 299
 300         /* We expect exactly one record */
 301         if (result->count != 1) {
 302                 DEBUG(0, ("Could not find GPC with dn %s\n", dn_str));
 303                 talloc_free(mem_ctx);
 304                 return NT_STATUS_NOT_FOUND;
 305         }
 306
 307         status = parse_gpo(gp_ctx, result->msgs[0], &gpo);
 308         if (!NT_STATUS_IS_OK(status)) {
 309                 DEBUG(0, ("Failed to parse GPO.\n"));
 310                 talloc_free(mem_ctx);
 311                 return status;
 312         }
 313
 314         talloc_free(mem_ctx);
 315
 316         *ret = gpo;
 317         return NT_STATUS_OK;
 318 }
 319
 320 static NTSTATUS parse_gplink (TALLOC_CTX *mem_ctx, const char *gplink_str, struct gp_link ***ret)
 321 {
 322         int start, idx=0;
 323         int pos;
 324         struct gp_link **gplinks;
 325         char *buf, *end;
 326         const char *gplink_start = "[LDAP://";
 327
 328         gplinks = talloc_array(mem_ctx, struct gp_link *, 1);
 329         NT_STATUS_HAVE_NO_MEMORY(gplinks);
 330
 331         gplinks[0] = NULL;
 332
 333         /* Assuming every gPLink starts with "[LDAP://" */
 334         start = strlen(gplink_start);
 335
 336         for (pos = start; pos < strlen(gplink_str); pos++) {
 337                 if (gplink_str[pos] == ';') {
 338                         gplinks = talloc_realloc(mem_ctx, gplinks, struct gp_link *, idx+2);
 339                         NT_STATUS_HAVE_NO_MEMORY(gplinks);
 340                         gplinks[idx] = talloc(mem_ctx, struct gp_link);
 341                         NT_STATUS_HAVE_NO_MEMORY(gplinks[idx]);
 342                         gplinks[idx]->dn = talloc_strndup(mem_ctx,
 343                                                           gplink_str + start,
 344                                                           pos - start);
 345                         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplinks[idx]->dn, gplinks);
 346
 347                         for (start = pos + 1; gplink_str[pos] != ']'; pos++);
 348
 349                         buf = talloc_strndup(gplinks, gplink_str + start, pos - start);
 350                         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(buf, gplinks);
 351                         gplinks[idx]->options = (uint32_t) strtoll(buf, &end, 0);
 352                         talloc_free(buf);
 353
 354                         /* Set the last entry in the array to be NULL */
 355                         gplinks[idx + 1] = NULL;
 356
 357                         /* Increment the array index, the string position past
 358                            the next "[LDAP://", and set the start reference */
 359                         idx++;
 360                         pos += strlen(gplink_start)+1;
 361                         start = pos;
 362                 }
 363         }
 364
 365         *ret = gplinks;
 366         return NT_STATUS_OK;
 367 }
 368
 369
 370 NTSTATUS gp_get_gplinks(struct gp_context *gp_ctx, const char *dn_str, struct gp_link ***ret)
 371 {
 372         TALLOC_CTX *mem_ctx;
 373         struct ldb_dn *dn;
 374         struct ldb_result *result;
 375         struct gp_link **gplinks;
 376         char *gplink_str;
 377         int rv;
 378         unsigned int i, j;
 379         NTSTATUS status;
 380
 381         /* Create a forked memory context, as a base for everything here */
 382         mem_ctx = talloc_new(gp_ctx);
 383         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 384
 385         dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 386
 387         rv = ldb_search(gp_ctx->ldb_ctx, mem_ctx, &result, dn, LDB_SCOPE_BASE, NULL, "(objectclass=*)");
 388         if (rv != LDB_SUCCESS) {
 389                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 390                 talloc_free(mem_ctx);
 391                 return NT_STATUS_UNSUCCESSFUL;
 392         }
 393
 394         for (i = 0; i < result->count; i++) {
 395                 for (j = 0; j < result->msgs[i]->num_elements; j++) {
 396                         struct ldb_message_element *element = &result->msgs[i]->elements[j];
 397
 398                         if (strcmp(element->name, "gPLink") == 0) {
 399                                 SMB_ASSERT(element->num_values > 0);
 400                                 gplink_str = talloc_strdup(mem_ctx, (char *) element->values[0].data);
 401                                 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplink_str, mem_ctx);
 402                                 goto found;
 403                         }
 404                 }
 405         }
 406         gplink_str = talloc_strdup(mem_ctx, "");
 407         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplink_str, mem_ctx);
 408
 409         found:
 410
 411         status = parse_gplink(gp_ctx, gplink_str, &gplinks);
 412         if (!NT_STATUS_IS_OK(status)) {
 413                 DEBUG(0, ("Failed to parse gPLink\n"));
 414                 return status;
 415         }
 416
 417         talloc_free(mem_ctx);
 418
 419         *ret = gplinks;
 420         return NT_STATUS_OK;
 421 }
 422
 423 NTSTATUS gp_list_gpos(struct gp_context *gp_ctx, struct security_token *token, const char ***ret)
 424 {
 425         TALLOC_CTX *mem_ctx;
 426         const char **gpos;
 427         struct ldb_result *result;
 428         char *sid;
 429         struct ldb_dn *dn;
 430         struct ldb_message_element *element;
 431         bool inherit;
 432         const char *attrs[] = { "objectClass", NULL };
 433         int rv;
 434         NTSTATUS status;
 435         unsigned int count = 0;
 436         unsigned int i;
 437         enum {
 438                 ACCOUNT_TYPE_USER = 0,
 439                 ACCOUNT_TYPE_MACHINE = 1
 440         } account_type;
 441
 442         /* Create a forked memory context, as a base for everything here */
 443         mem_ctx = talloc_new(gp_ctx);
 444         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 445
 446         sid = ldap_encode_ndr_dom_sid(mem_ctx,
 447                                       &token->sids[PRIMARY_USER_SID_INDEX]);
 448         NT_STATUS_HAVE_NO_MEMORY(sid);
 449
 450         /* Find the user DN and objectclass via the sid from the security token */
 451         rv = ldb_search(gp_ctx->ldb_ctx,
 452                         mem_ctx,
 453                         &result,
 454                         ldb_get_default_basedn(gp_ctx->ldb_ctx),
 455                         LDB_SCOPE_SUBTREE,
 456                         attrs,
 457                         "(&(objectclass=user)(objectSid=%s))", sid);
 458         if (rv != LDB_SUCCESS) {
 459                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv),
 460                                 ldb_errstring(gp_ctx->ldb_ctx)));
 461                 talloc_free(mem_ctx);
 462                 return NT_STATUS_UNSUCCESSFUL;
 463         }
 464         if (result->count != 1) {
 465                 DEBUG(0, ("Could not find user with sid %s.\n", sid));
 466                 talloc_free(mem_ctx);
 467                 return NT_STATUS_UNSUCCESSFUL;
 468         }
 469         DEBUG(10,("Found DN for this user: %s\n", ldb_dn_get_linearized(result->msgs[0]->dn)));
 470
 471         element = ldb_msg_find_element(result->msgs[0], "objectClass");
 472
 473         /* We need to know if this account is a user or machine. */
 474         account_type = ACCOUNT_TYPE_USER;
 475         for (i = 0; i < element->num_values; i++) {
 476                 if (strcmp((char *)element->values[i].data, "computer") == 0) {
 477                         account_type = ACCOUNT_TYPE_MACHINE;
 478                         DEBUG(10, ("This user is a machine\n"));
 479                 }
 480         }
 481
 482         gpos = talloc_array(gp_ctx, const char *, 1);
 483         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpos, mem_ctx);
 484         gpos[0] = NULL;
 485
 486         /* Walk through the containers until we hit the root */
 487         inherit = 1;
 488         dn = ldb_dn_get_parent(mem_ctx, result->msgs[0]->dn);
 489         while (ldb_dn_compare_base(ldb_get_default_basedn(gp_ctx->ldb_ctx), dn) == 0) {
 490                 const char *gpo_attrs[] = { "gPLink", "gPOptions", NULL };
 491                 struct gp_link **gplinks;
 492                 enum gpo_inheritance gpoptions;
 493
 494                 DEBUG(10, ("Getting gPLinks for DN: %s\n", ldb_dn_get_linearized(dn)));
 495
 496                 /* Get the gPLink and gPOptions attributes from the container */
 497                 rv = ldb_search(gp_ctx->ldb_ctx,
 498                                 mem_ctx,
 499                                 &result,
 500                                 dn,
 501                                 LDB_SCOPE_BASE,
 502                                 gpo_attrs,
 503                                 "objectclass=*");
 504                 if (rv != LDB_SUCCESS) {
 505                         DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv),
 506                                         ldb_errstring(gp_ctx->ldb_ctx)));
 507                         talloc_free(mem_ctx);
 508                         return NT_STATUS_UNSUCCESSFUL;
 509                 }
 510
 511                 /* Parse the gPLink attribute, put it into a nice struct array */
 512                 status = parse_gplink(mem_ctx, ldb_msg_find_attr_as_string(result->msgs[0], "gPLink", ""), &gplinks);
 513                 if (!NT_STATUS_IS_OK(status)) {
 514                         DEBUG(0, ("Failed to parse gPLink\n"));
 515                         talloc_free(mem_ctx);
 516                         return status;
 517                 }
 518
 519                 /* Check all group policy links on this container */
 520                 for (i = 0; gplinks[i] != NULL; i++) {
 521                         struct gp_object *gpo;
 522                         uint32_t access_granted;
 523
 524                         /* If inheritance was blocked at a higher level and this
 525                          * gplink is not enforced, it should not be applied */
 526                         if (!inherit && !(gplinks[i]->options & GPLINK_OPT_ENFORCE))
 527                                 continue;
 528
 529                         /* Don't apply disabled links */
 530                         if (gplinks[i]->options & GPLINK_OPT_DISABLE)
 531                                 continue;
 532
 533                         /* Get GPO information */
 534                         status = gp_get_gpo_info(gp_ctx, gplinks[i]->dn, &gpo);
 535                         if (!NT_STATUS_IS_OK(status)) {
 536                                 DEBUG(0, ("Failed to get gpo information for %s\n", gplinks[i]->dn));
 537                                 talloc_free(mem_ctx);
 538                                 return status;
 539                         }
 540
 541                         /* If the account does not have read access, this GPO does not apply
 542                          * to this account */
 543                         status = sec_access_check(gpo->security_descriptor,
 544                                         token,
 545                                         (SEC_STD_READ_CONTROL | SEC_ADS_LIST | SEC_ADS_READ_PROP),
 546                                         &access_granted);
 547                         if (!NT_STATUS_IS_OK(status)) {
 548                                 continue;
 549                         }
 550
 551                         /* If the account is a user and the GPO has user disabled flag, or
 552                          * a machine and the GPO has machine disabled flag, this GPO does
 553                          * not apply to this account */
 554                         if ((account_type == ACCOUNT_TYPE_USER &&
 555                                         (gpo->flags & GPO_FLAG_USER_DISABLE)) ||
 556                                         (account_type == ACCOUNT_TYPE_MACHINE &&
 557                                         (gpo->flags & GPO_FLAG_MACHINE_DISABLE))) {
 558                                 continue;
 559                         }
 560
 561                         /* Add the GPO to the list */
 562                         gpos = talloc_realloc(gp_ctx, gpos, const char *, count+2);
 563                         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpos, mem_ctx);
 564                         gpos[count] = talloc_strdup(gp_ctx, gplinks[i]->dn);
 565                         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpos[count], mem_ctx);
 566                         gpos[count+1] = NULL;
 567                         count++;
 568
 569                         /* Clean up */
 570                         talloc_free(gpo);
 571                 }
 572
 573                 /* If inheritance is blocked, then we should only add enforced gPLinks
 574                  * higher up */
 575                 gpoptions = ldb_msg_find_attr_as_uint(result->msgs[0], "gPOptions", 0);
 576                 if (gpoptions == GPO_BLOCK_INHERITANCE) {
 577                         inherit = 0;
 578                 }
 579                 dn = ldb_dn_get_parent(mem_ctx, dn);
 580         }
 581
 582         talloc_free(mem_ctx);
 583
 584         *ret = gpos;
 585         return NT_STATUS_OK;
 586 }
 587
 588 NTSTATUS gp_set_gplink(struct gp_context *gp_ctx, const char *dn_str, struct gp_link *gplink)
 589 {
 590         TALLOC_CTX *mem_ctx;
 591         struct ldb_result *result;
 592         struct ldb_dn *dn;
 593         struct ldb_message *msg;
 594         const char *attrs[] = { "gPLink", NULL };
 595         const char *gplink_str;
 596         int rv;
 597         char *start;
 598
 599         /* Create a forked memory context, as a base for everything here */
 600         mem_ctx = talloc_new(gp_ctx);
 601         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 602
 603         dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 604
 605         rv = ldb_search(gp_ctx->ldb_ctx, mem_ctx, &result, dn, LDB_SCOPE_BASE, attrs, "(objectclass=*)");
 606         if (rv != LDB_SUCCESS) {
 607                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 608                 talloc_free(mem_ctx);
 609                 return NT_STATUS_UNSUCCESSFUL;
 610         }
 611
 612         if (result->count != 1) {
 613                 talloc_free(mem_ctx);
 614                 return NT_STATUS_NOT_FOUND;
 615         }
 616
 617         gplink_str = ldb_msg_find_attr_as_string(result->msgs[0], "gPLink", "");
 618
 619         /* If this GPO link already exists, alter the options, else add it */
 620         if ((start = strcasestr(gplink_str, gplink->dn)) != NULL) {
 621                 start += strlen(gplink->dn);
 622                 *start = '\0';
 623                 start++;
 624                 while (*start != ']' && *start != '\0') {
 625                         start++;
 626                 }
 627                 gplink_str = talloc_asprintf(mem_ctx, "%s;%d%s", gplink_str, gplink->options, start);
 628                 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplink_str, mem_ctx);
 629
 630         } else {
 631                 /* Prepend the new GPO link to the string. This list is backwards in priority. */
 632                 gplink_str = talloc_asprintf(mem_ctx, "[LDAP://%s;%d]%s", gplink->dn, gplink->options, gplink_str);
 633                 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplink_str, mem_ctx);
 634         }
 635
 636
 637
 638         msg = ldb_msg_new(mem_ctx);
 639         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 640
 641         msg->dn = dn;
 642
 643         rv = ldb_msg_add_string(msg, "gPLink", gplink_str);
 644         if (rv != 0) {
 645                 DEBUG(0, ("LDB message add string failed: %s\n", ldb_strerror(rv)));
 646                 talloc_free(mem_ctx);
 647                 return NT_STATUS_UNSUCCESSFUL;
 648         }
 649         msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
 650
 651         rv = ldb_modify(gp_ctx->ldb_ctx, msg);
 652         if (rv != 0) {
 653                 DEBUG(0, ("LDB modify failed: %s\n", ldb_strerror(rv)));
 654                 talloc_free(mem_ctx);
 655                 return NT_STATUS_UNSUCCESSFUL;
 656         }
 657
 658         talloc_free(mem_ctx);
 659         return NT_STATUS_OK;
 660 }
 661
 662 NTSTATUS gp_del_gplink(struct gp_context *gp_ctx, const char *dn_str, const char *gplink_dn)
 663 {
 664         TALLOC_CTX *mem_ctx;
 665         struct ldb_result *result;
 666         struct ldb_dn *dn;
 667         struct ldb_message *msg;
 668         const char *attrs[] = { "gPLink", NULL };
 669         const char *gplink_str, *search_string;
 670         int rv;
 671         char *p;
 672
 673         /* Create a forked memory context, as a base for everything here */
 674         mem_ctx = talloc_new(gp_ctx);
 675         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 676
 677         dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 678
 679         rv = ldb_search(gp_ctx->ldb_ctx, mem_ctx, &result, dn, LDB_SCOPE_BASE, attrs, "(objectclass=*)");
 680         if (rv != LDB_SUCCESS) {
 681                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 682                 talloc_free(mem_ctx);
 683                 return NT_STATUS_UNSUCCESSFUL;
 684         }
 685
 686         if (result->count != 1) {
 687                 talloc_free(mem_ctx);
 688                 return NT_STATUS_NOT_FOUND;
 689         }
 690
 691         gplink_str = ldb_msg_find_attr_as_string(result->msgs[0], "gPLink", "");
 692
 693         /* If this GPO link already exists, alter the options, else add it */
 694         search_string = talloc_asprintf(mem_ctx, "[LDAP://%s]", gplink_dn);
 695         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(search_string, mem_ctx);
 696
 697         p = strcasestr(gplink_str, search_string);
 698         if (p == NULL) {
 699                 talloc_free(mem_ctx);
 700                 return NT_STATUS_NOT_FOUND;
 701         }
 702
 703         *p = '\0';
 704         p++;
 705         while (*p != ']' && *p != '\0') {
 706                 p++;
 707         }
 708         p++;
 709         gplink_str = talloc_asprintf(mem_ctx, "%s%s", gplink_str, p);
 710         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gplink_str, mem_ctx);
 711
 712
 713         msg = ldb_msg_new(mem_ctx);
 714         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 715
 716         msg->dn = dn;
 717
 718         if (strcmp(gplink_str, "") == 0) {
 719                 rv = ldb_msg_add_empty(msg, "gPLink", LDB_FLAG_MOD_DELETE, NULL);
 720                 if (rv != 0) {
 721                         DEBUG(0, ("LDB message add empty element failed: %s\n", ldb_strerror(rv)));
 722                         talloc_free(mem_ctx);
 723                         return NT_STATUS_UNSUCCESSFUL;
 724                 }
 725         } else {
 726                 rv = ldb_msg_add_string(msg, "gPLink", gplink_str);
 727                 if (rv != 0) {
 728                         DEBUG(0, ("LDB message add string failed: %s\n", ldb_strerror(rv)));
 729                         talloc_free(mem_ctx);
 730                         return NT_STATUS_UNSUCCESSFUL;
 731                 }
 732                 msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
 733         }
 734         rv = ldb_modify(gp_ctx->ldb_ctx, msg);
 735         if (rv != 0) {
 736                 DEBUG(0, ("LDB modify failed: %s\n", ldb_strerror(rv)));
 737                 talloc_free(mem_ctx);
 738                 return NT_STATUS_UNSUCCESSFUL;
 739         }
 740
 741         talloc_free(mem_ctx);
 742         return NT_STATUS_OK;
 743 }
 744
 745 NTSTATUS gp_get_inheritance(struct gp_context *gp_ctx, const char *dn_str, enum gpo_inheritance *inheritance)
 746 {
 747         TALLOC_CTX *mem_ctx;
 748         struct ldb_result *result;
 749         struct ldb_dn *dn;
 750         const char *attrs[] = { "gPOptions", NULL };
 751         int rv;
 752
 753         /* Create a forked memory context, as a base for everything here */
 754         mem_ctx = talloc_new(gp_ctx);
 755         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 756
 757         dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 758
 759         rv = ldb_search(gp_ctx->ldb_ctx, mem_ctx, &result, dn, LDB_SCOPE_BASE, attrs, "(objectclass=*)");
 760         if (rv != LDB_SUCCESS) {
 761                 DEBUG(0, ("LDB search failed: %s\n%s\n", ldb_strerror(rv), ldb_errstring(gp_ctx->ldb_ctx)));
 762                 talloc_free(mem_ctx);
 763                 return NT_STATUS_UNSUCCESSFUL;
 764         }
 765
 766         if (result->count != 1) {
 767                 talloc_free(mem_ctx);
 768                 return NT_STATUS_NOT_FOUND;
 769         }
 770
 771         *inheritance = ldb_msg_find_attr_as_uint(result->msgs[0], "gPOptions", 0);
 772
 773         talloc_free(mem_ctx);
 774         return NT_STATUS_OK;
 775 }
 776
 777 NTSTATUS gp_set_inheritance(struct gp_context *gp_ctx, const char *dn_str, enum gpo_inheritance inheritance)
 778 {
 779         char *inheritance_string;
 780         struct ldb_message *msg;
 781         int rv;
 782
 783         msg = ldb_msg_new(gp_ctx);
 784         NT_STATUS_HAVE_NO_MEMORY(msg);
 785
 786         msg->dn = ldb_dn_new(msg, gp_ctx->ldb_ctx, dn_str);
 787
 788         inheritance_string = talloc_asprintf(msg, "%d", inheritance);
 789         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(inheritance_string, msg);
 790
 791         rv = ldb_msg_add_string(msg, "gPOptions", inheritance_string);
 792         if (rv != 0) {
 793                 DEBUG(0, ("LDB message add string failed: %s\n", ldb_strerror(rv)));
 794                 talloc_free(msg);
 795                 return NT_STATUS_UNSUCCESSFUL;
 796         }
 797         msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
 798
 799         rv = ldb_modify(gp_ctx->ldb_ctx, msg);
 800         if (rv != 0) {
 801                 DEBUG(0, ("LDB modify failed: %s\n", ldb_strerror(rv)));
 802                 talloc_free(msg);
 803                 return NT_STATUS_UNSUCCESSFUL;
 804         }
 805
 806         talloc_free(msg);
 807         return NT_STATUS_OK;
 808 }
 809
 810 NTSTATUS gp_create_ldap_gpo(struct gp_context *gp_ctx, struct gp_object *gpo)
 811 {
 812         struct ldb_message *msg;
 813         TALLOC_CTX *mem_ctx;
 814         int rv;
 815         char *dn_str, *flags_str, *version_str;
 816         struct ldb_dn *child_dn, *gpo_dn;
 817
 818         mem_ctx = talloc_new(gp_ctx);
 819         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 820
 821         /* CN={GUID} */
 822         msg = ldb_msg_new(mem_ctx);
 823         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 824
 825         msg->dn = ldb_get_default_basedn(gp_ctx->ldb_ctx);
 826         dn_str = talloc_asprintf(mem_ctx, "CN=%s,CN=Policies,CN=System", gpo->name);
 827         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(dn_str, mem_ctx);
 828
 829         child_dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 830         rv = ldb_dn_add_child(msg->dn, child_dn);
 831         if (!rv) goto ldb_msg_add_error;
 832
 833         flags_str = talloc_asprintf(mem_ctx, "%d", gpo->flags);
 834         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(flags_str, mem_ctx);
 835
 836         version_str = talloc_asprintf(mem_ctx, "%d", gpo->version);
 837         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(version_str, mem_ctx);
 838
 839         rv = ldb_msg_add_string(msg, "objectClass", "top");
 840         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 841         rv = ldb_msg_add_string(msg, "objectClass", "container");
 842         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 843         rv = ldb_msg_add_string(msg, "objectClass", "groupPolicyContainer");
 844         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 845         rv = ldb_msg_add_string(msg, "displayName", gpo->display_name);
 846         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 847         rv = ldb_msg_add_string(msg, "name", gpo->name);
 848         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 849         rv = ldb_msg_add_string(msg, "CN", gpo->name);
 850         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 851         rv = ldb_msg_add_string(msg, "gPCFileSysPath", gpo->file_sys_path);
 852         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 853         rv = ldb_msg_add_string(msg, "flags", flags_str);
 854         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 855         rv = ldb_msg_add_string(msg, "versionNumber", version_str);
 856         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 857         rv = ldb_msg_add_string(msg, "showInAdvancedViewOnly", "TRUE");
 858         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 859         rv = ldb_msg_add_string(msg, "gpCFunctionalityVersion", "2");
 860         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 861
 862         rv = ldb_add(gp_ctx->ldb_ctx, msg);
 863         if (rv != LDB_SUCCESS) {
 864                 DEBUG(0, ("LDB add error: %s\n", ldb_errstring(gp_ctx->ldb_ctx)));
 865                 talloc_free(mem_ctx);
 866                 return NT_STATUS_UNSUCCESSFUL;
 867         }
 868
 869         gpo_dn = msg->dn;
 870
 871         /* CN=User */
 872         msg = ldb_msg_new(mem_ctx);
 873         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 874
 875         msg->dn = ldb_dn_copy(mem_ctx, gpo_dn);
 876         child_dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, "CN=User");
 877         rv = ldb_dn_add_child(msg->dn, child_dn);
 878         if (!rv) goto ldb_msg_add_error;
 879
 880         rv = ldb_msg_add_string(msg, "objectClass", "top");
 881         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 882         rv = ldb_msg_add_string(msg, "objectClass", "container");
 883         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 884         rv = ldb_msg_add_string(msg, "showInAdvancedViewOnly", "TRUE");
 885         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 886         rv = ldb_msg_add_string(msg, "CN", "User");
 887         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 888         rv = ldb_msg_add_string(msg, "name", "User");
 889         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 890
 891         rv = ldb_add(gp_ctx->ldb_ctx, msg);
 892         if (rv != LDB_SUCCESS) {
 893                 DEBUG(0, ("LDB add error: %s\n", ldb_errstring(gp_ctx->ldb_ctx)));
 894                 talloc_free(mem_ctx);
 895                 return NT_STATUS_UNSUCCESSFUL;
 896         }
 897
 898         /* CN=Machine */
 899         msg = ldb_msg_new(mem_ctx);
 900         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 901
 902         msg->dn = ldb_dn_copy(mem_ctx, gpo_dn);
 903         child_dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, "CN=Machine");
 904         rv = ldb_dn_add_child(msg->dn, child_dn);
 905         if (!rv) goto ldb_msg_add_error;
 906
 907         rv = ldb_msg_add_string(msg, "objectClass", "top");
 908         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 909         rv = ldb_msg_add_string(msg, "objectClass", "container");
 910         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 911         rv = ldb_msg_add_string(msg, "showInAdvancedViewOnly", "TRUE");
 912         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 913         rv = ldb_msg_add_string(msg, "CN", "Machine");
 914         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 915         rv = ldb_msg_add_string(msg, "name", "Machine");
 916         if (rv != LDB_SUCCESS) goto ldb_msg_add_error;
 917
 918         rv = ldb_add(gp_ctx->ldb_ctx, msg);
 919         if (rv != LDB_SUCCESS) {
 920                 DEBUG(0, ("LDB add error: %s\n", ldb_errstring(gp_ctx->ldb_ctx)));
 921                 talloc_free(mem_ctx);
 922                 return NT_STATUS_UNSUCCESSFUL;
 923         }
 924
 925         gpo->dn = talloc_strdup(gpo, ldb_dn_get_linearized(gpo_dn));
 926         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->dn, mem_ctx);
 927
 928         talloc_free(mem_ctx);
 929         return NT_STATUS_OK;
 930
 931         ldb_msg_add_error:
 932         DEBUG(0, ("LDB Error adding element to ldb message\n"));
 933         talloc_free(mem_ctx);
 934         return NT_STATUS_UNSUCCESSFUL;
 935 }
 936
 937 NTSTATUS gp_set_ads_acl (struct gp_context *gp_ctx, const char *dn_str, const struct security_descriptor *sd)
 938 {
 939         TALLOC_CTX *mem_ctx;
 940         DATA_BLOB data;
 941         enum ndr_err_code ndr_err;
 942         struct ldb_message *msg;
 943         int rv;
 944
 945         /* Create a forked memory context to clean up easily */
 946         mem_ctx = talloc_new(gp_ctx);
 947         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
 948
 949         /* Push the security descriptor through the NDR library */
 950         ndr_err = ndr_push_struct_blob(&data,
 951                         mem_ctx,
 952                         sd,
 953                         (ndr_push_flags_fn_t)ndr_push_security_descriptor);
 954         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 955                 return ndr_map_error2ntstatus(ndr_err);
 956         }
 957
 958
 959         /* Create a LDB message */
 960         msg = ldb_msg_new(mem_ctx);
 961         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 962
 963         msg->dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, dn_str);
 964
 965         rv = ldb_msg_add_value(msg, "nTSecurityDescriptor", &data, NULL);
 966         if (rv != 0) {
 967                 DEBUG(0, ("LDB message add element failed for adding nTSecurityDescriptor: %s\n", ldb_strerror(rv)));
 968                 talloc_free(mem_ctx);
 969                 return NT_STATUS_UNSUCCESSFUL;
 970         }
 971         msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
 972
 973         rv = ldb_modify(gp_ctx->ldb_ctx, msg);
 974         if (rv != 0) {
 975                 DEBUG(0, ("LDB modify failed: %s\n", ldb_strerror(rv)));
 976                 talloc_free(mem_ctx);
 977                 return NT_STATUS_UNSUCCESSFUL;
 978         }
 979
 980         talloc_free(mem_ctx);
 981         return NT_STATUS_OK;
 982 }
 983
 984 /* This function sets flags, version and displayName on a GPO */
 985 NTSTATUS gp_set_ldap_gpo(struct gp_context *gp_ctx, struct gp_object *gpo)
 986 {
 987         int rv;
 988         TALLOC_CTX *mem_ctx;
 989         struct ldb_message *msg;
 990         char *version_str, *flags_str;
 991
 992         mem_ctx = talloc_new(gp_ctx);
 993
 994         msg = ldb_msg_new(mem_ctx);
 995         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
 996
 997         msg->dn = ldb_dn_new(mem_ctx, gp_ctx->ldb_ctx, gpo->dn);
 998
 999         version_str = talloc_asprintf(mem_ctx, "%d", gpo->version);
1000         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
1001
1002         flags_str = talloc_asprintf(mem_ctx, "%d", gpo->flags);
1003         NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg, mem_ctx);
1004
1005         rv = ldb_msg_add_string(msg, "flags", flags_str);
1006         if (rv != 0) {
1007                 DEBUG(0, ("LDB message add string failed for flags: %s\n", ldb_strerror(rv)));
1008                 talloc_free(mem_ctx);
1009                 return NT_STATUS_UNSUCCESSFUL;
1010         }
1011         msg->elements[0].flags = LDB_FLAG_MOD_REPLACE;
1012
1013         rv = ldb_msg_add_string(msg, "version", version_str);
1014         if (rv != 0) {
1015                 DEBUG(0, ("LDB message add string failed for version: %s\n", ldb_strerror(rv)));
1016                 talloc_free(mem_ctx);
1017                 return NT_STATUS_UNSUCCESSFUL;
1018         }
1019         msg->elements[1].flags = LDB_FLAG_MOD_REPLACE;
1020
1021         rv = ldb_msg_add_string(msg, "displayName", gpo->display_name);
1022         if (rv != 0) {
1023                 DEBUG(0, ("LDB message add string failed for displayName: %s\n", ldb_strerror(rv)));
1024                 talloc_free(mem_ctx);
1025                 return NT_STATUS_UNSUCCESSFUL;
1026         }
1027         msg->elements[2].flags = LDB_FLAG_MOD_REPLACE;
1028
1029         rv = ldb_modify(gp_ctx->ldb_ctx, msg);
1030         if (rv != 0) {
1031                 DEBUG(0, ("LDB modify failed: %s\n", ldb_strerror(rv)));
1032                 talloc_free(mem_ctx);
1033                 return NT_STATUS_UNSUCCESSFUL;
1034         }
1035
1036         talloc_free(mem_ctx);
1037         return NT_STATUS_OK;
1038 }