6b81575024632c4378f747180804c7dd8b2803dc
[amitay/samba.git] / 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                                 struct security_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 struct security_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 struct security_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 }