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