libgpo: remove unrequired references to ads_struct.
[samba.git] / source3 / utils / net_ads_gpo.c
1 /*
2    Samba Unix/Linux SMB client library
3    net ads commands for Group Policy
4    Copyright (C) 2005-2008 Guenther Deschner (gd@samba.org)
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 "utils/net.h"
22 #include "ads.h"
23 #include "../libgpo/gpo.h"
24 #include "libgpo/gpo_proto.h"
25 #include "../libds/common/flags.h"
26
27 #ifdef HAVE_ADS
28
29 static int net_ads_gpo_refresh(struct net_context *c, int argc, const char **argv)
30 {
31         TALLOC_CTX *mem_ctx;
32         ADS_STRUCT *ads;
33         ADS_STATUS status;
34         const char *dn = NULL;
35         struct GROUP_POLICY_OBJECT *gpo_list = NULL;
36         struct GROUP_POLICY_OBJECT *read_list = NULL;
37         uint32 uac = 0;
38         uint32 flags = 0;
39         struct GROUP_POLICY_OBJECT *gpo;
40         NTSTATUS result;
41         struct security_token *token = NULL;
42
43         if (argc < 1 || c->display_usage) {
44                 d_printf("%s\n%s\n%s",
45                          _("Usage:"),
46                          _("net ads gpo refresh <username|machinename>"),
47                          _("  Lists all GPOs assigned to an account and "
48                            "downloads them\n"
49                            "    username\tUser to refresh GPOs for\n"
50                            "    machinename\tMachine to refresh GPOs for\n"));
51                 return -1;
52         }
53
54         mem_ctx = talloc_init("net_ads_gpo_refresh");
55         if (mem_ctx == NULL) {
56                 return -1;
57         }
58
59         status = ads_startup(c, false, &ads);
60         if (!ADS_ERR_OK(status)) {
61                 d_printf(_("failed to connect AD server: %s\n"), ads_errstr(status));
62                 goto out;
63         }
64
65         status = ads_find_samaccount(ads, mem_ctx, argv[0], &uac, &dn);
66         if (!ADS_ERR_OK(status)) {
67                 d_printf(_("failed to find samaccount for %s\n"), argv[0]);
68                 goto out;
69         }
70
71         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
72                 flags |= GPO_LIST_FLAG_MACHINE;
73         }
74
75         d_printf(_("\n%s: '%s' has dn: '%s'\n\n"),
76                 (uac & UF_WORKSTATION_TRUST_ACCOUNT) ? _("machine") : _("user"),
77                 argv[0], dn);
78
79         d_printf(_("* fetching token "));
80         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
81                 status = gp_get_machine_token(ads, mem_ctx, dn, &token);
82         } else {
83                 status = ads_get_sid_token(ads, mem_ctx, dn, &token);
84         }
85
86         if (!ADS_ERR_OK(status)) {
87                 d_printf(_("failed: %s\n"), ads_errstr(status));
88                 goto out;
89         }
90         d_printf(_("finished\n"));
91
92         d_printf(_("* fetching GPO List "));
93         status = ads_get_gpo_list(ads, mem_ctx, dn, flags, token, &gpo_list);
94         if (!ADS_ERR_OK(status)) {
95                 d_printf(_("failed: %s\n"),
96                          ads_errstr(status));
97                 goto out;
98         }
99         d_printf(_("finished\n"));
100
101         d_printf(_("* Refreshing Group Policy Data "));
102         if (!NT_STATUS_IS_OK(result = check_refresh_gpo_list(ads, mem_ctx,
103                                                              cache_path(GPO_CACHE_DIR),
104                                                              flags,
105                                                              gpo_list))) {
106                 d_printf(_("failed: %s\n"), nt_errstr(result));
107                 goto out;
108         }
109         d_printf(_("finished\n"));
110
111         d_printf(_("* storing GPO list to registry "));
112
113         {
114                 WERROR werr = gp_reg_state_store(mem_ctx, flags, dn,
115                                                  token, gpo_list);
116                 if (!W_ERROR_IS_OK(werr)) {
117                         d_printf(_("failed: %s\n"), win_errstr(werr));
118                         goto out;
119                 }
120         }
121
122         d_printf(_("finished\n"));
123
124         if (c->opt_verbose) {
125
126                 d_printf(_("* dumping GPO list\n"));
127
128                 for (gpo = gpo_list; gpo; gpo = gpo->next) {
129
130                         dump_gpo(ads, mem_ctx, gpo, 0);
131 #if 0
132                 char *server, *share, *nt_path, *unix_path;
133
134                 d_printf("--------------------------------------\n");
135                 d_printf("Name:\t\t\t%s\n", gpo->display_name);
136                 d_printf("LDAP GPO version:\t%d (user: %d, machine: %d)\n",
137                         gpo->version,
138                         GPO_VERSION_USER(gpo->version),
139                         GPO_VERSION_MACHINE(gpo->version));
140
141                 result = gpo_explode_filesyspath(mem_ctx, gpo->file_sys_path,
142                                                  &server, &share, &nt_path,
143                                                  &unix_path);
144                 if (!NT_STATUS_IS_OK(result)) {
145                         d_printf("got: %s\n", nt_errstr(result));
146                 }
147
148                 d_printf("GPO stored on server: %s, share: %s\n", server, share);
149                 d_printf("\tremote path:\t%s\n", nt_path);
150                 d_printf("\tlocal path:\t%s\n", unix_path);
151 #endif
152                 }
153         }
154
155         d_printf(_("* re-reading GPO list from registry "));
156
157         {
158                 WERROR werr = gp_reg_state_read(mem_ctx, flags,
159                                                 &token->sids[0],
160                                                 &read_list);
161                 if (!W_ERROR_IS_OK(werr)) {
162                         d_printf(_("failed: %s\n"), win_errstr(werr));
163                         goto out;
164                 }
165         }
166
167         d_printf(_("finished\n"));
168
169         if (c->opt_verbose) {
170
171                 d_printf(_("* dumping GPO list from registry\n"));
172
173                 for (gpo = read_list; gpo; gpo = gpo->next) {
174
175                         dump_gpo(ads, mem_ctx, gpo, 0);
176
177 #if 0
178                 char *server, *share, *nt_path, *unix_path;
179
180                 d_printf("--------------------------------------\n");
181                 d_printf("Name:\t\t\t%s\n", gpo->display_name);
182                 d_printf("LDAP GPO version:\t%d (user: %d, machine: %d)\n",
183                         gpo->version,
184                         GPO_VERSION_USER(gpo->version),
185                         GPO_VERSION_MACHINE(gpo->version));
186
187                 result = gpo_explode_filesyspath(mem_ctx, gpo->file_sys_path,
188                                                  &server, &share, &nt_path,
189                                                  &unix_path);
190                 if (!NT_STATUS_IS_OK(result)) {
191                         d_printf("got: %s\n", nt_errstr(result));
192                 }
193
194                 d_printf("GPO stored on server: %s, share: %s\n", server, share);
195                 d_printf("\tremote path:\t%s\n", nt_path);
196                 d_printf("\tlocal path:\t%s\n", unix_path);
197 #endif
198                 }
199         }
200
201  out:
202         ads_destroy(&ads);
203         talloc_destroy(mem_ctx);
204         return 0;
205 }
206
207 static int net_ads_gpo_list_all(struct net_context *c, int argc, const char **argv)
208 {
209         ADS_STRUCT *ads;
210         ADS_STATUS status;
211         LDAPMessage *res = NULL;
212         int num_reply = 0;
213         LDAPMessage *msg = NULL;
214         struct GROUP_POLICY_OBJECT gpo;
215         TALLOC_CTX *mem_ctx;
216         char *dn;
217         const char *attrs[] = {
218                 "versionNumber",
219                 "flags",
220                 "gPCFileSysPath",
221                 "displayName",
222                 "name",
223                 "gPCMachineExtensionNames",
224                 "gPCUserExtensionNames",
225                 "ntSecurityDescriptor",
226                 NULL
227         };
228
229         if (c->display_usage) {
230                 d_printf(  "%s\n"
231                            "net ads gpo listall\n"
232                            "    %s\n",
233                          _("Usage:"),
234                          _("List all GPOs on the DC"));
235                 return 0;
236         }
237
238         mem_ctx = talloc_init("net_ads_gpo_list_all");
239         if (mem_ctx == NULL) {
240                 return -1;
241         }
242
243         status = ads_startup(c, false, &ads);
244         if (!ADS_ERR_OK(status)) {
245                 goto out;
246         }
247
248         status = ads_do_search_all_sd_flags(ads, ads->config.bind_path,
249                                             LDAP_SCOPE_SUBTREE,
250                                             "(objectclass=groupPolicyContainer)",
251                                             attrs,
252                                             SECINFO_DACL,
253                                             &res);
254
255         if (!ADS_ERR_OK(status)) {
256                 d_printf(_("search failed: %s\n"), ads_errstr(status));
257                 goto out;
258         }
259
260         num_reply = ads_count_replies(ads, res);
261
262         d_printf(_("Got %d replies\n\n"), num_reply);
263
264         /* dump the results */
265         for (msg = ads_first_entry(ads, res);
266              msg;
267              msg = ads_next_entry(ads, msg)) {
268
269                 if ((dn = ads_get_dn(ads, mem_ctx, msg)) == NULL) {
270                         goto out;
271                 }
272
273                 status = ads_parse_gpo(ads, mem_ctx, msg, dn, &gpo);
274
275                 if (!ADS_ERR_OK(status)) {
276                         d_printf(_("ads_parse_gpo failed: %s\n"),
277                                 ads_errstr(status));
278                         goto out;
279                 }
280
281                 dump_gpo(ads, mem_ctx, &gpo, 0);
282         }
283
284 out:
285         ads_msgfree(ads, res);
286
287         TALLOC_FREE(mem_ctx);
288         ads_destroy(&ads);
289
290         return 0;
291 }
292
293 static int net_ads_gpo_list(struct net_context *c, int argc, const char **argv)
294 {
295         ADS_STRUCT *ads = NULL;
296         ADS_STATUS status;
297         LDAPMessage *res = NULL;
298         TALLOC_CTX *mem_ctx;
299         const char *dn = NULL;
300         uint32 uac = 0;
301         uint32 flags = 0;
302         struct GROUP_POLICY_OBJECT *gpo_list;
303         struct security_token *token = NULL;
304
305         if (argc < 1 || c->display_usage) {
306                 d_printf("%s\n%s\n%s",
307                          _("Usage:"),
308                          _("net ads gpo list <username|machinename>"),
309                          _("  Lists all GPOs for machine/user\n"
310                            "    username\tUser to list GPOs for\n"
311                            "    machinename\tMachine to list GPOs for\n"));
312                 return -1;
313         }
314
315         mem_ctx = talloc_init("net_ads_gpo_list");
316         if (mem_ctx == NULL) {
317                 goto out;
318         }
319
320         status = ads_startup(c, false, &ads);
321         if (!ADS_ERR_OK(status)) {
322                 goto out;
323         }
324
325         status = ads_find_samaccount(ads, mem_ctx, argv[0], &uac, &dn);
326         if (!ADS_ERR_OK(status)) {
327                 goto out;
328         }
329
330         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
331                 flags |= GPO_LIST_FLAG_MACHINE;
332         }
333
334         d_printf(_("%s: '%s' has dn: '%s'\n"),
335                 (uac & UF_WORKSTATION_TRUST_ACCOUNT) ? _("machine") : _("user"),
336                 argv[0], dn);
337
338         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
339                 status = gp_get_machine_token(ads, mem_ctx, dn, &token);
340         } else {
341                 status = ads_get_sid_token(ads, mem_ctx, dn, &token);
342         }
343
344         if (!ADS_ERR_OK(status)) {
345                 goto out;
346         }
347
348         status = ads_get_gpo_list(ads, mem_ctx, dn, flags, token, &gpo_list);
349         if (!ADS_ERR_OK(status)) {
350                 goto out;
351         }
352
353         dump_gpo_list(ads, mem_ctx, gpo_list, 0);
354
355 out:
356         ads_msgfree(ads, res);
357
358         talloc_destroy(mem_ctx);
359         ads_destroy(&ads);
360
361         return 0;
362 }
363
364 static int net_ads_gpo_apply(struct net_context *c, int argc, const char **argv)
365 {
366         TALLOC_CTX *mem_ctx;
367         ADS_STRUCT *ads;
368         ADS_STATUS status;
369         const char *dn = NULL;
370         struct GROUP_POLICY_OBJECT *gpo_list;
371         uint32 uac = 0;
372         uint32 flags = 0;
373         struct security_token *token = NULL;
374         const char *filter = NULL;
375
376         if (argc < 1 || c->display_usage) {
377                 d_printf("Usage:\n"
378                          "net ads gpo apply <username|machinename>\n"
379                          "  Apply GPOs for machine/user\n"
380                          "    username\tUsername to apply GPOs for\n"
381                          "    machinename\tMachine to apply GPOs for\n");
382                 return -1;
383         }
384
385         mem_ctx = talloc_init("net_ads_gpo_apply");
386         if (mem_ctx == NULL) {
387                 goto out;
388         }
389
390         if (argc >= 2) {
391                 filter = cse_gpo_name_to_guid_string(argv[1]);
392         }
393
394         status = ads_startup(c, false, &ads);
395         /* filter = cse_gpo_name_to_guid_string("Security"); */
396
397         if (!ADS_ERR_OK(status)) {
398                 d_printf("got: %s\n", ads_errstr(status));
399                 goto out;
400         }
401
402         status = ads_find_samaccount(ads, mem_ctx, argv[0], &uac, &dn);
403         if (!ADS_ERR_OK(status)) {
404                 d_printf("failed to find samaccount for %s: %s\n",
405                         argv[0], ads_errstr(status));
406                 goto out;
407         }
408
409         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
410                 flags |= GPO_LIST_FLAG_MACHINE;
411         }
412
413         if (c->opt_verbose) {
414                 flags |= GPO_INFO_FLAG_VERBOSE;
415         }
416
417         d_printf("%s: '%s' has dn: '%s'\n",
418                 (uac & UF_WORKSTATION_TRUST_ACCOUNT) ? "machine" : "user",
419                 argv[0], dn);
420
421         if (uac & UF_WORKSTATION_TRUST_ACCOUNT) {
422                 status = gp_get_machine_token(ads, mem_ctx, dn, &token);
423         } else {
424                 status = ads_get_sid_token(ads, mem_ctx, dn, &token);
425         }
426
427         if (!ADS_ERR_OK(status)) {
428                 goto out;
429         }
430
431         status = ads_get_gpo_list(ads, mem_ctx, dn, flags, token, &gpo_list);
432         if (!ADS_ERR_OK(status)) {
433                 goto out;
434         }
435
436         status = gpo_process_gpo_list(mem_ctx, token, gpo_list,
437                                       filter, flags);
438         if (!ADS_ERR_OK(status)) {
439                 d_printf("failed to process gpo list: %s\n",
440                         ads_errstr(status));
441                 goto out;
442         }
443
444 out:
445         ads_destroy(&ads);
446         talloc_destroy(mem_ctx);
447         return 0;
448 }
449
450 static int net_ads_gpo_link_get(struct net_context *c, int argc, const char **argv)
451 {
452         ADS_STRUCT *ads;
453         ADS_STATUS status;
454         TALLOC_CTX *mem_ctx;
455         struct GP_LINK gp_link;
456
457         if (argc < 1 || c->display_usage) {
458                 d_printf("%s\n%s\n%s",
459                          _("Usage:"),
460                          _("net ads gpo linkget <container>"),
461                          _("  Lists gPLink of a containter\n"
462                            "    container\tContainer to get link for\n"));
463                 return -1;
464         }
465
466         mem_ctx = talloc_init("add_gpo_link");
467         if (mem_ctx == NULL) {
468                 return -1;
469         }
470
471         status = ads_startup(c, false, &ads);
472         if (!ADS_ERR_OK(status)) {
473                 goto out;
474         }
475
476         status = ads_get_gpo_link(ads, mem_ctx, argv[0], &gp_link);
477         if (!ADS_ERR_OK(status)) {
478                 d_printf(_("get link for %s failed: %s\n"), argv[0],
479                         ads_errstr(status));
480                 goto out;
481         }
482
483         dump_gplink(ads, mem_ctx, &gp_link);
484
485 out:
486         talloc_destroy(mem_ctx);
487         ads_destroy(&ads);
488
489         return 0;
490 }
491
492 static int net_ads_gpo_link_add(struct net_context *c, int argc, const char **argv)
493 {
494         ADS_STRUCT *ads;
495         ADS_STATUS status;
496         uint32 gpo_opt = 0;
497         TALLOC_CTX *mem_ctx;
498
499         if (argc < 2 || c->display_usage) {
500                 d_printf("%s\n%s\n%s",
501                          _("Usage:"),
502                          _("net ads gpo linkadd <linkdn> <gpodn> [options]"),
503                          _("  Link a container to a GPO\n"
504                            "    linkdn\tContainer to link to a GPO\n"
505                            "    gpodn\tGPO to link container to\n"));
506                 d_printf(_("note: DNs must be provided properly escaped.\n"
507                            "See RFC 4514 for details\n"));
508                 return -1;
509         }
510
511         mem_ctx = talloc_init("add_gpo_link");
512         if (mem_ctx == NULL) {
513                 return -1;
514         }
515
516         if (argc == 3) {
517                 gpo_opt = atoi(argv[2]);
518         }
519
520         status = ads_startup(c, false, &ads);
521         if (!ADS_ERR_OK(status)) {
522                 goto out;
523         }
524
525         status = ads_add_gpo_link(ads, mem_ctx, argv[0], argv[1], gpo_opt);
526         if (!ADS_ERR_OK(status)) {
527                 d_printf(_("link add failed: %s\n"), ads_errstr(status));
528                 goto out;
529         }
530
531 out:
532         talloc_destroy(mem_ctx);
533         ads_destroy(&ads);
534
535         return 0;
536 }
537
538 #if 0 /* broken */
539
540 static int net_ads_gpo_link_delete(struct net_context *c, int argc, const char **argv)
541 {
542         ADS_STRUCT *ads;
543         ADS_STATUS status;
544         TALLOC_CTX *mem_ctx;
545
546         if (argc < 2 || c->display_usage) {
547                 d_printf("Usage:\n"
548                          "net ads gpo linkdelete <linkdn> <gpodn>\n"
549                          "  Delete a GPO link\n"
550                          "    <linkdn>\tContainer to delete GPO from\n"
551                          "    <gpodn>\tGPO to delete from container\n");
552                 return -1;
553         }
554
555         mem_ctx = talloc_init("delete_gpo_link");
556         if (mem_ctx == NULL) {
557                 return -1;
558         }
559
560         status = ads_startup(c, false, &ads);
561         if (!ADS_ERR_OK(status)) {
562                 goto out;
563         }
564
565         status = ads_delete_gpo_link(ads, mem_ctx, argv[0], argv[1]);
566         if (!ADS_ERR_OK(status)) {
567                 d_printf("delete link failed: %s\n", ads_errstr(status));
568                 goto out;
569         }
570
571 out:
572         talloc_destroy(mem_ctx);
573         ads_destroy(&ads);
574
575         return 0;
576 }
577
578 #endif
579
580 static int net_ads_gpo_get_gpo(struct net_context *c, int argc, const char **argv)
581 {
582         ADS_STRUCT *ads;
583         ADS_STATUS status;
584         TALLOC_CTX *mem_ctx;
585         struct GROUP_POLICY_OBJECT gpo;
586
587         if (argc < 1 || c->display_usage) {
588                 d_printf("%s\n%s\n%s",
589                          _("Usage:"),
590                          _("net ads gpo getgpo <gpo>"),
591                          _("  List speciefied GPO\n"
592                            "    gpo\t\tGPO to list\n"));
593                 return -1;
594         }
595
596         mem_ctx = talloc_init("ads_gpo_get_gpo");
597         if (mem_ctx == NULL) {
598                 return -1;
599         }
600
601         status = ads_startup(c, false, &ads);
602         if (!ADS_ERR_OK(status)) {
603                 goto out;
604         }
605
606         if (strnequal(argv[0], "CN={", strlen("CN={"))) {
607                 status = ads_get_gpo(ads, mem_ctx, argv[0], NULL, NULL, &gpo);
608         } else {
609                 status = ads_get_gpo(ads, mem_ctx, NULL, argv[0], NULL, &gpo);
610         }
611
612         if (!ADS_ERR_OK(status)) {
613                 d_printf(_("get gpo for [%s] failed: %s\n"), argv[0],
614                         ads_errstr(status));
615                 goto out;
616         }
617
618         dump_gpo(ads, mem_ctx, &gpo, 1);
619
620 out:
621         talloc_destroy(mem_ctx);
622         ads_destroy(&ads);
623
624         return 0;
625 }
626
627 int net_ads_gpo(struct net_context *c, int argc, const char **argv)
628 {
629         struct functable func[] = {
630                 {
631                         "apply",
632                         net_ads_gpo_apply,
633                         NET_TRANSPORT_ADS,
634                         "Apply GPO to container",
635                         "net ads gpo apply\n"
636                         "    Apply GPO to container"
637                 },
638                 {
639                         "getgpo",
640                         net_ads_gpo_get_gpo,
641                         NET_TRANSPORT_ADS,
642                         N_("List specified GPO"),
643                         N_("net ads gpo getgpo\n"
644                            "    List specified GPO")
645                 },
646                 {
647                         "linkadd",
648                         net_ads_gpo_link_add,
649                         NET_TRANSPORT_ADS,
650                         N_("Link a container to a GPO"),
651                         N_("net ads gpo linkadd\n"
652                            "    Link a container to a GPO")
653                 },
654 #if 0
655                 {
656                         "linkdelete",
657                         net_ads_gpo_link_delete,
658                         NET_TRANSPORT_ADS,
659                         "Delete GPO link from a container",
660                         "net ads gpo linkdelete\n"
661                         "    Delete GPO link from a container"
662                 },
663 #endif
664                 {
665                         "linkget",
666                         net_ads_gpo_link_get,
667                         NET_TRANSPORT_ADS,
668                         N_("Lists gPLink of containter"),
669                         N_("net ads gpo linkget\n"
670                            "    Lists gPLink of containter")
671                 },
672                 {
673                         "list",
674                         net_ads_gpo_list,
675                         NET_TRANSPORT_ADS,
676                         N_("Lists all GPOs for machine/user"),
677                         N_("net ads gpo list\n"
678                            "    Lists all GPOs for machine/user")
679                 },
680                 {
681                         "listall",
682                         net_ads_gpo_list_all,
683                         NET_TRANSPORT_ADS,
684                         N_("Lists all GPOs on a DC"),
685                         N_("net ads gpo listall\n"
686                            "    Lists all GPOs on a DC")
687                 },
688                 {
689                         "refresh",
690                         net_ads_gpo_refresh,
691                         NET_TRANSPORT_ADS,
692                         N_("Lists all GPOs assigned to an account and "
693                            "downloads them"),
694                         N_("net ads gpo refresh\n"
695                            "    Lists all GPOs assigned to an account and "
696                            "downloads them")
697                 },
698                 {NULL, NULL, 0, NULL, NULL}
699         };
700
701         return net_run_function(c, argc, argv, "net ads gpo", func);
702 }
703
704 #endif /* HAVE_ADS */