libgpo/gpext/gpext.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Group Policy Support
   4  *  Copyright (C) Guenther Deschner 2007-2008
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21 #include "../libgpo/gpo.h"
  22 #include "../libgpo/gpext/gpext.h"
  23 #include "librpc/gen_ndr/ndr_misc.h"
  24 #include "lib/util/dlinklist.h"
  25 #include "../libcli/registry/util_reg.h"
  26 #if _SAMBA_BUILD_ == 3
  27 #include "libgpo/gpo_proto.h"
  28 #include "registry.h"
  29 #include "registry/reg_api.h"
  30 #endif
  31
  32 static struct gp_extension *extensions = NULL;
  33
  34 /****************************************************************
  35 ****************************************************************/
  36
  37 struct gp_extension *get_gp_extension_list(void)
  38 {
  39         return extensions;
  40 }
  41
  42 /****************************************************************
  43 ****************************************************************/
  44
  45 /* see http://support.microsoft.com/kb/216358/en-us/ for more info */
  46
  47 struct gp_extension_reg_table gpext_reg_vals[] = {
  48         { "DllName", REG_EXPAND_SZ },
  49         { "ProcessGroupPolicy", REG_SZ },
  50         { "NoMachinePolicy", REG_DWORD },
  51         { "NoUserPolicy", REG_DWORD },
  52         { "NoSlowLink", REG_DWORD },
  53         { "NoBackgroundPolicy", REG_DWORD },
  54         { "NoGPOListChanges", REG_DWORD },
  55         { "PerUserLocalSettings", REG_DWORD },
  56         { "RequiresSuccessfulRegistry", REG_DWORD },
  57         { "EnableAsynchronousProcessing", REG_DWORD },
  58         { "ExtensionDebugLevel", REG_DWORD },
  59         /* new */
  60         { "GenerateGroupPolicy", REG_SZ }, /* not supported on w2k */
  61         { "NotifyLinkTransition", REG_DWORD },
  62         { "ProcessGroupPolicyEx", REG_SZ }, /* not supported on w2k */
  63         { "ExtensionEventSource", REG_MULTI_SZ }, /* not supported on w2k */
  64         { "GenerateGroupPolicy", REG_SZ },
  65         { "MaxNoGPOListChangesInterval", REG_DWORD },
  66         { NULL, REG_NONE }
  67 };
  68
  69 /****************************************************************
  70 ****************************************************************/
  71
  72 static struct gp_extension *get_extension_by_name(struct gp_extension *be,
  73                                                   const char *name)
  74 {
  75         struct gp_extension *b;
  76
  77         for (b = be; b; b = b->next) {
  78                 if (strequal(b->name, name)) {
  79                         return b;
  80                 }
  81         }
  82
  83         return NULL;
  84 }
  85
  86 /****************************************************************
  87 ****************************************************************/
  88
  89 static struct gp_extension_methods *get_methods_by_name(struct gp_extension *be,
  90                                                         const char *name)
  91 {
  92         struct gp_extension *b;
  93
  94         for (b = be; b; b = b->next) {
  95                 if (strequal(b->name, name)) {
  96                         return b->methods;
  97                 }
  98         }
  99
 100         return NULL;
 101 }
 102
 103 /****************************************************************
 104 ****************************************************************/
 105
 106 NTSTATUS unregister_gp_extension(const char *name)
 107 {
 108         struct gp_extension *ext;
 109
 110         ext = get_extension_by_name(extensions, name);
 111         if (!ext) {
 112                 return NT_STATUS_OK;
 113         }
 114
 115         DLIST_REMOVE(extensions, ext);
 116         talloc_free(ext);
 117
 118         DEBUG(2,("Successfully removed GP extension '%s'\n", name));
 119
 120         return NT_STATUS_OK;
 121 }
 122
 123 /****************************************************************
 124 ****************************************************************/
 125
 126 NTSTATUS register_gp_extension(TALLOC_CTX *gpext_ctx,
 127                                int version,
 128                                const char *name,
 129                                const char *guid,
 130                                struct gp_extension_methods *methods)
 131 {
 132         struct gp_extension_methods *test;
 133         struct gp_extension *entry;
 134         NTSTATUS status;
 135
 136         if (!gpext_ctx) {
 137                 return NT_STATUS_INTERNAL_DB_ERROR;
 138         }
 139
 140         if ((version != SMB_GPEXT_INTERFACE_VERSION)) {
 141                 DEBUG(0,("Failed to register gp extension.\n"
 142                          "The module was compiled against "
 143                          "SMB_GPEXT_INTERFACE_VERSION %d,\n"
 144                          "current SMB_GPEXT_INTERFACE_VERSION is %d.\n"
 145                          "Please recompile against the current "
 146                          "version of samba!\n",
 147                          version, SMB_GPEXT_INTERFACE_VERSION));
 148                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 149         }
 150
 151         if (!guid || !name || !name[0] || !methods) {
 152                 DEBUG(0,("Called with NULL pointer or empty name!\n"));
 153                 return NT_STATUS_INVALID_PARAMETER;
 154         }
 155
 156         test = get_methods_by_name(extensions, name);
 157         if (test) {
 158                 DEBUG(0,("GP extension module %s already registered!\n",
 159                         name));
 160                 return NT_STATUS_OBJECT_NAME_COLLISION;
 161         }
 162
 163         entry = talloc_zero(gpext_ctx, struct gp_extension);
 164         NT_STATUS_HAVE_NO_MEMORY(entry);
 165
 166         entry->name = talloc_strdup(gpext_ctx, name);
 167         NT_STATUS_HAVE_NO_MEMORY(entry->name);
 168
 169         entry->guid = talloc_zero(gpext_ctx, struct GUID);
 170         NT_STATUS_HAVE_NO_MEMORY(entry->guid);
 171         status = GUID_from_string(guid, entry->guid);
 172         NT_STATUS_NOT_OK_RETURN(status);
 173
 174         entry->methods = methods;
 175         DLIST_ADD(extensions, entry);
 176
 177         DEBUG(2,("Successfully added GP extension '%s' %s\n",
 178                 name, GUID_string2(gpext_ctx, entry->guid)));
 179
 180         return NT_STATUS_OK;
 181 }
 182
 183 /****************************************************************
 184 ****************************************************************/
 185
 186 static NTSTATUS gp_extension_init_module(TALLOC_CTX *mem_ctx,
 187                                          const char *name,
 188                                          struct gp_extension **gpext)
 189 {
 190         NTSTATUS status;
 191         struct gp_extension *ext = NULL;
 192
 193         ext = talloc_zero(mem_ctx, struct gp_extension);
 194         NT_STATUS_HAVE_NO_MEMORY(gpext);
 195
 196         ext->methods = get_methods_by_name(extensions, name);
 197         if (!ext->methods) {
 198
 199                 status = smb_probe_module(SAMBA_SUBSYSTEM_GPEXT,
 200                                           name);
 201                 if (!NT_STATUS_IS_OK(status)) {
 202                         return status;
 203                 }
 204
 205                 ext->methods = get_methods_by_name(extensions, name);
 206                 if (!ext->methods) {
 207                         return NT_STATUS_DLL_INIT_FAILED;
 208                 }
 209         }
 210
 211         *gpext = ext;
 212
 213         return NT_STATUS_OK;
 214 }
 215
 216 /****************************************************************
 217 ****************************************************************/
 218
 219 static bool add_gp_extension_reg_entry_to_array(TALLOC_CTX *mem_ctx,
 220                                                 struct gp_extension_reg_entry *entry,
 221                                                 struct gp_extension_reg_entry **entries,
 222                                                 size_t *num)
 223 {
 224         *entries = talloc_realloc(mem_ctx, *entries,
 225                                         struct gp_extension_reg_entry,
 226                                         (*num)+1);
 227         if (*entries == NULL) {
 228                 *num = 0;
 229                 return false;
 230         }
 231
 232         (*entries)[*num].value = entry->value;
 233         (*entries)[*num].data = entry->data;
 234
 235         *num += 1;
 236         return true;
 237 }
 238
 239 /****************************************************************
 240 ****************************************************************/
 241
 242 static bool add_gp_extension_reg_info_entry_to_array(TALLOC_CTX *mem_ctx,
 243                                                      struct gp_extension_reg_info_entry *entry,
 244                                                      struct gp_extension_reg_info_entry **entries,
 245                                                      size_t *num)
 246 {
 247         *entries = talloc_realloc(mem_ctx, *entries,
 248                                         struct gp_extension_reg_info_entry,
 249                                         (*num)+1);
 250         if (*entries == NULL) {
 251                 *num = 0;
 252                 return false;
 253         }
 254
 255         (*entries)[*num].guid = entry->guid;
 256         (*entries)[*num].num_entries = entry->num_entries;
 257         (*entries)[*num].entries = entry->entries;
 258
 259         *num += 1;
 260         return true;
 261 }
 262
 263 /****************************************************************
 264 ****************************************************************/
 265
 266 static NTSTATUS gp_ext_info_add_reg(TALLOC_CTX *mem_ctx,
 267                                     struct gp_extension_reg_info_entry *entry,
 268                                     const char *value,
 269                                     enum winreg_Type type,
 270                                     const char *data_s)
 271 {
 272         struct gp_extension_reg_entry *reg_entry = NULL;
 273         struct registry_value *data = NULL;
 274
 275         reg_entry = talloc_zero(mem_ctx, struct gp_extension_reg_entry);
 276         NT_STATUS_HAVE_NO_MEMORY(reg_entry);
 277
 278         data = talloc_zero(mem_ctx, struct registry_value);
 279         NT_STATUS_HAVE_NO_MEMORY(data);
 280
 281         data->type = type;
 282
 283         switch (type) {
 284                 case REG_SZ:
 285                 case REG_EXPAND_SZ:
 286                         if (!push_reg_sz(mem_ctx, &data->data, data_s)) {
 287                                 return NT_STATUS_NO_MEMORY;
 288                         }
 289                         break;
 290                 case REG_DWORD: {
 291                         uint32_t v = atoi(data_s);
 292                         data->data = data_blob_talloc(mem_ctx, NULL, 4);
 293                         SIVAL(data->data.data, 0, v);
 294                         break;
 295                 }
 296                 default:
 297                         return NT_STATUS_NOT_SUPPORTED;
 298         }
 299
 300         reg_entry->value = value;
 301         reg_entry->data = data;
 302
 303         if (!add_gp_extension_reg_entry_to_array(mem_ctx, reg_entry,
 304                                                  &entry->entries,
 305                                                  &entry->num_entries)) {
 306                 return NT_STATUS_NO_MEMORY;
 307         }
 308
 309         return NT_STATUS_OK;
 310 }
 311
 312 /****************************************************************
 313 ****************************************************************/
 314
 315 static NTSTATUS gp_ext_info_add_reg_table(TALLOC_CTX *mem_ctx,
 316                                           const char *module,
 317                                           struct gp_extension_reg_info_entry *entry,
 318                                           struct gp_extension_reg_table *table)
 319 {
 320         NTSTATUS status;
 321         const char *module_name = NULL;
 322         int i;
 323
 324         module_name = talloc_asprintf(mem_ctx, "%s.%s", module, shlib_ext());
 325         NT_STATUS_HAVE_NO_MEMORY(module_name);
 326
 327         status = gp_ext_info_add_reg(mem_ctx, entry,
 328                                      "DllName", REG_EXPAND_SZ, module_name);
 329         NT_STATUS_NOT_OK_RETURN(status);
 330
 331         for (i=0; table[i].val; i++) {
 332                 status = gp_ext_info_add_reg(mem_ctx, entry,
 333                                              table[i].val,
 334                                              table[i].type,
 335                                              table[i].data);
 336                 NT_STATUS_NOT_OK_RETURN(status);
 337         }
 338
 339         return status;
 340 }
 341
 342 /****************************************************************
 343 ****************************************************************/
 344
 345 NTSTATUS gp_ext_info_add_entry(TALLOC_CTX *mem_ctx,
 346                                const char *module,
 347                                const char *ext_guid,
 348                                struct gp_extension_reg_table *table,
 349                                struct gp_extension_reg_info *info)
 350 {
 351         NTSTATUS status;
 352         struct gp_extension_reg_info_entry *entry = NULL;
 353
 354         entry = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info_entry);
 355         NT_STATUS_HAVE_NO_MEMORY(entry);
 356
 357         status = GUID_from_string(ext_guid, &entry->guid);
 358         NT_STATUS_NOT_OK_RETURN(status);
 359
 360         status = gp_ext_info_add_reg_table(mem_ctx, module, entry, table);
 361         NT_STATUS_NOT_OK_RETURN(status);
 362
 363         if (!add_gp_extension_reg_info_entry_to_array(mem_ctx, entry,
 364                                                       &info->entries,
 365                                                       &info->num_entries)) {
 366                 return NT_STATUS_NO_MEMORY;
 367         }
 368
 369         return NT_STATUS_OK;
 370 }
 371
 372 /****************************************************************
 373 ****************************************************************/
 374
 375 static bool gp_extension_reg_info_verify_entry(struct gp_extension_reg_entry *entry)
 376 {
 377         int i;
 378
 379         for (i=0; gpext_reg_vals[i].val; i++) {
 380
 381                 if ((strequal(entry->value, gpext_reg_vals[i].val)) &&
 382                     (entry->data->type == gpext_reg_vals[i].type)) {
 383                         return true;
 384                 }
 385         }
 386
 387         return false;
 388 }
 389
 390 /****************************************************************
 391 ****************************************************************/
 392
 393 static bool gp_extension_reg_info_verify(struct gp_extension_reg_info_entry *entry)
 394 {
 395         int i;
 396
 397         for (i=0; i < entry->num_entries; i++) {
 398                 if (!gp_extension_reg_info_verify_entry(&entry->entries[i])) {
 399                         return false;
 400                 }
 401         }
 402
 403         return true;
 404 }
 405
 406 /****************************************************************
 407 ****************************************************************/
 408
 409 static WERROR gp_extension_store_reg_vals(TALLOC_CTX *mem_ctx,
 410                                           struct registry_key *key,
 411                                           struct gp_extension_reg_info_entry *entry)
 412 {
 413         WERROR werr = WERR_OK;
 414         size_t i;
 415
 416         for (i=0; i < entry->num_entries; i++) {
 417
 418                 werr = reg_setvalue(key,
 419                                     entry->entries[i].value,
 420                                     entry->entries[i].data);
 421                 W_ERROR_NOT_OK_RETURN(werr);
 422         }
 423
 424         return werr;
 425 }
 426
 427 /****************************************************************
 428 ****************************************************************/
 429
 430 static WERROR gp_extension_store_reg_entry(TALLOC_CTX *mem_ctx,
 431                                            struct gp_registry_context *reg_ctx,
 432                                            struct gp_extension_reg_info_entry *entry)
 433 {
 434         WERROR werr;
 435         struct registry_key *key = NULL;
 436         const char *subkeyname = NULL;
 437
 438         if (!gp_extension_reg_info_verify(entry)) {
 439                 return WERR_INVALID_PARAM;
 440         }
 441
 442         subkeyname = GUID_string2(mem_ctx, &entry->guid);
 443         W_ERROR_HAVE_NO_MEMORY(subkeyname);
 444
 445         strupper_m(CONST_DISCARD(char *,subkeyname));
 446
 447         werr = gp_store_reg_subkey(mem_ctx,
 448                                    subkeyname,
 449                                    reg_ctx->curr_key,
 450                                    &key);
 451         W_ERROR_NOT_OK_RETURN(werr);
 452
 453         werr = gp_extension_store_reg_vals(mem_ctx,
 454                                            key,
 455                                            entry);
 456         W_ERROR_NOT_OK_RETURN(werr);
 457
 458         return werr;
 459 }
 460
 461 /****************************************************************
 462 ****************************************************************/
 463
 464 static WERROR gp_extension_store_reg(TALLOC_CTX *mem_ctx,
 465                                      struct gp_registry_context *reg_ctx,
 466                                      struct gp_extension_reg_info *info)
 467 {
 468         WERROR werr = WERR_OK;
 469         int i;
 470
 471         if (!info) {
 472                 return WERR_OK;
 473         }
 474
 475         for (i=0; i < info->num_entries; i++) {
 476                 werr = gp_extension_store_reg_entry(mem_ctx,
 477                                                     reg_ctx,
 478                                                     &info->entries[i]);
 479                 W_ERROR_NOT_OK_RETURN(werr);
 480         }
 481
 482         return werr;
 483 }
 484
 485 /****************************************************************
 486 ****************************************************************/
 487
 488 static NTSTATUS gp_glob_ext_list(TALLOC_CTX *mem_ctx,
 489                                  const char ***ext_list,
 490                                  size_t *ext_list_len)
 491 {
 492         SMB_STRUCT_DIR *dir = NULL;
 493         SMB_STRUCT_DIRENT *dirent = NULL;
 494
 495         dir = sys_opendir(modules_path(SAMBA_SUBSYSTEM_GPEXT));
 496         if (!dir) {
 497                 return map_nt_error_from_unix(errno);
 498         }
 499
 500         while ((dirent = sys_readdir(dir))) {
 501
 502                 fstring name; /* forgive me... */
 503                 char *p;
 504
 505                 if ((strequal(dirent->d_name, ".")) ||
 506                     (strequal(dirent->d_name, ".."))) {
 507                         continue;
 508                 }
 509
 510                 p = strrchr(dirent->d_name, '.');
 511                 if (!p) {
 512                         sys_closedir(dir);
 513                         return NT_STATUS_NO_MEMORY;
 514                 }
 515
 516                 if (!strcsequal(p+1, shlib_ext())) {
 517                         DEBUG(10,("gp_glob_ext_list: not a *.so file: %s\n",
 518                                 dirent->d_name));
 519                         continue;
 520                 }
 521
 522                 fstrcpy(name, dirent->d_name);
 523                 name[PTR_DIFF(p, dirent->d_name)] = 0;
 524
 525                 if (!add_string_to_array(mem_ctx, name, ext_list,
 526                                          (int *)ext_list_len)) {
 527                         sys_closedir(dir);
 528                         return NT_STATUS_NO_MEMORY;
 529                 }
 530         }
 531
 532         sys_closedir(dir);
 533
 534         return NT_STATUS_OK;
 535 }
 536
 537 /****************************************************************
 538 ****************************************************************/
 539
 540 NTSTATUS shutdown_gp_extensions(void)
 541 {
 542         struct gp_extension *ext = NULL;
 543
 544         for (ext = extensions; ext; ext = ext->next) {
 545                 if (ext->methods && ext->methods->shutdown) {
 546                         ext->methods->shutdown();
 547                 }
 548         }
 549
 550         return NT_STATUS_OK;
 551 }
 552
 553 /****************************************************************
 554 ****************************************************************/
 555
 556 NTSTATUS init_gp_extensions(TALLOC_CTX *mem_ctx)
 557 {
 558         NTSTATUS status;
 559         WERROR werr;
 560         int i = 0;
 561         const char **ext_array = NULL;
 562         size_t ext_array_len = 0;
 563         struct gp_extension *gpext = NULL;
 564         struct gp_registry_context *reg_ctx = NULL;
 565
 566         if (get_gp_extension_list()) {
 567                 return NT_STATUS_OK;
 568         }
 569
 570         status = gp_glob_ext_list(mem_ctx, &ext_array, &ext_array_len);
 571         NT_STATUS_NOT_OK_RETURN(status);
 572
 573         for (i=0; i<ext_array_len; i++) {
 574
 575                 struct gp_extension_reg_info *info = NULL;
 576
 577                 status = gp_extension_init_module(mem_ctx, ext_array[i],
 578                                                   &gpext);
 579                 if (!NT_STATUS_IS_OK(status)) {
 580                         goto out;
 581                 }
 582
 583                 if (gpext->methods->get_reg_config) {
 584
 585                         status = gpext->methods->initialize(mem_ctx);
 586                         if (!NT_STATUS_IS_OK(status)) {
 587                                 gpext->methods->shutdown();
 588                                 goto out;
 589                         }
 590
 591                         status = gpext->methods->get_reg_config(mem_ctx,
 592                                                                 &info);
 593                         if (!NT_STATUS_IS_OK(status)) {
 594                                 gpext->methods->shutdown();
 595                                 goto out;
 596                         }
 597
 598                         if (!reg_ctx) {
 599                                 struct security_token *token;
 600
 601                                 token = registry_create_system_token(mem_ctx);
 602                                 NT_STATUS_HAVE_NO_MEMORY(token);
 603
 604                                 werr = gp_init_reg_ctx(mem_ctx,
 605                                                        KEY_WINLOGON_GPEXT_PATH,
 606                                                        REG_KEY_WRITE,
 607                                                        token,
 608                                                        &reg_ctx);
 609                                 if (!W_ERROR_IS_OK(werr)) {
 610                                         status = werror_to_ntstatus(werr);
 611                                         gpext->methods->shutdown();
 612                                         goto out;
 613                                 }
 614                         }
 615
 616                         werr = gp_extension_store_reg(mem_ctx, reg_ctx, info);
 617                         if (!W_ERROR_IS_OK(werr)) {
 618                                 DEBUG(1,("gp_extension_store_reg failed: %s\n",
 619                                         win_errstr(werr)));
 620                                 TALLOC_FREE(info);
 621                                 gpext->methods->shutdown();
 622                                 status = werror_to_ntstatus(werr);
 623                                 goto out;
 624                         }
 625                         TALLOC_FREE(info);
 626                 }
 627
 628         }
 629
 630  out:
 631         TALLOC_FREE(reg_ctx);
 632
 633         return status;
 634 }
 635
 636 /****************************************************************
 637 ****************************************************************/
 638
 639 NTSTATUS free_gp_extensions(void)
 640 {
 641         struct gp_extension *ext, *ext_next = NULL;
 642
 643         for (ext = extensions; ext; ext = ext_next) {
 644                 ext_next = ext->next;
 645                 DLIST_REMOVE(extensions, ext);
 646                 TALLOC_FREE(ext);
 647         }
 648
 649         extensions = NULL;
 650
 651         return NT_STATUS_OK;
 652 }
 653
 654 /****************************************************************
 655 ****************************************************************/
 656
 657 void debug_gpext_header(int lvl,
 658                         const char *name,
 659                         uint32_t flags,
 660                         struct GROUP_POLICY_OBJECT *gpo,
 661                         const char *extension_guid,
 662                         const char *snapin_guid)
 663 {
 664         char *flags_str = NULL;
 665
 666         DEBUG(lvl,("%s\n", name));
 667         DEBUGADD(lvl,("\tgpo:           %s (%s)\n", gpo->name,
 668                 gpo->display_name));
 669         DEBUGADD(lvl,("\tcse extension: %s (%s)\n", extension_guid,
 670                 cse_gpo_guid_string_to_name(extension_guid)));
 671         DEBUGADD(lvl,("\tgplink:        %s\n", gpo->link));
 672         DEBUGADD(lvl,("\tsnapin:        %s (%s)\n", snapin_guid,
 673                 cse_snapin_gpo_guid_string_to_name(snapin_guid)));
 674
 675         flags_str = gpo_flag_str(NULL, flags);
 676         DEBUGADD(lvl,("\tflags:         0x%08x %s\n", flags, flags_str));
 677         TALLOC_FREE(flags_str);
 678 }
 679
 680 NTSTATUS process_gpo_list_with_extension(ADS_STRUCT *ads,
 681                            TALLOC_CTX *mem_ctx,
 682                            uint32_t flags,
 683                            const struct security_token *token,
 684                            struct GROUP_POLICY_OBJECT *gpo_list,
 685                            const char *extension_guid,
 686                            const char *snapin_guid)
 687 {
 688         return NT_STATUS_OK;
 689 }
 690
 691 /****************************************************************
 692 ****************************************************************/
 693
 694 NTSTATUS gpext_process_extension(ADS_STRUCT *ads,
 695                                  TALLOC_CTX *mem_ctx,
 696                                  uint32_t flags,
 697                                  const struct security_token *token,
 698                                  struct registry_key *root_key,
 699                                  struct GROUP_POLICY_OBJECT *gpo,
 700                                  const char *extension_guid,
 701                                  const char *snapin_guid)
 702 {
 703         NTSTATUS status;
 704         struct gp_extension *ext = NULL;
 705         struct GUID guid;
 706         bool cse_found = false;
 707
 708         status = init_gp_extensions(mem_ctx);
 709         if (!NT_STATUS_IS_OK(status)) {
 710                 DEBUG(1,("init_gp_extensions failed: %s\n",
 711                         nt_errstr(status)));
 712                 return status;
 713         }
 714
 715         status = GUID_from_string(extension_guid, &guid);
 716         if (!NT_STATUS_IS_OK(status)) {
 717                 return status;
 718         }
 719
 720         for (ext = extensions; ext; ext = ext->next) {
 721
 722                 if (GUID_equal(ext->guid, &guid)) {
 723                         cse_found = true;
 724                         break;
 725                 }
 726         }
 727
 728         if (!cse_found) {
 729                 goto no_ext;
 730         }
 731
 732         status = ext->methods->initialize(mem_ctx);
 733         NT_STATUS_NOT_OK_RETURN(status);
 734
 735         status = ext->methods->process_group_policy(ads,
 736                                                     mem_ctx,
 737                                                     flags,
 738                                                     root_key,
 739                                                     token,
 740                                                     gpo,
 741                                                     extension_guid,
 742                                                     snapin_guid);
 743         if (!NT_STATUS_IS_OK(status)) {
 744                 ext->methods->shutdown();
 745         }
 746
 747         return status;
 748
 749  no_ext:
 750         if (flags & GPO_INFO_FLAG_VERBOSE) {
 751                 DEBUG(0,("process_extension: no extension available for:\n"));
 752                 DEBUGADD(0,("%s (%s) (snapin: %s)\n",
 753                         extension_guid,
 754                         cse_gpo_guid_string_to_name(extension_guid),
 755                         snapin_guid));
 756         }
 757
 758         return NT_STATUS_OK;
 759 }