?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: move smbldap_util to pdb_ldap_util.
[Samba/id10ts.git] / source3 / utils / net_sam.c
blobff8f8c0977b37c1a8f1b08c4b9b6894f0e5ff1b8
1 /*
2 * Unix SMB/CIFS implementation.
3 * Local SAM access routines
4 * Copyright (C) Volker Lendecke 2006
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
21 #include "includes.h"
22 #include "system/passwd.h"
23 #include "utils/net.h"
24 #include "../librpc/gen_ndr/samr.h"
25 #include "smbldap.h"
26 #include "../libcli/security/security.h"
27 #include "lib/winbind_util.h"
28 #include "passdb.h"
29 #include "passdb/pdb_ldap_util.h"
30 #include "lib/privileges.h"
31
32 /*
33 * Set a user's data
34 */
35
36 static int net_sam_userset(struct net_context *c, int argc, const char **argv,
37 const char *field,
38 bool (*fn)(struct samu *, const char *,
39 enum pdb_value_state))
40 {
41 struct samu *sam_acct = NULL;
42 struct dom_sid sid;
43 enum lsa_SidType type;
44 const char *dom, *name;
45 NTSTATUS status;
46
47 if (argc != 2 || c->display_usage) {
48 d_fprintf(stderr, "%s\n", _("Usage:"));
49 d_fprintf(stderr, _("net sam set %s <user> <value>\n"),
50 field);
51 return -1;
52 }
53
54 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
55 &dom, &name, &sid, &type)) {
56 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
57 return -1;
58 }
59
60 if (type != SID_NAME_USER) {
61 d_fprintf(stderr, _("%s is a %s, not a user\n"), argv[0],
62 sid_type_lookup(type));
63 return -1;
64 }
65
66 if ( !(sam_acct = samu_new( NULL )) ) {
67 d_fprintf(stderr, _("Internal error\n"));
68 return -1;
69 }
70
71 if (!pdb_getsampwsid(sam_acct, &sid)) {
72 d_fprintf(stderr, _("Loading user %s failed\n"), argv[0]);
73 return -1;
74 }
75
76 if (!fn(sam_acct, argv[1], PDB_CHANGED)) {
77 d_fprintf(stderr, _("Internal error\n"));
78 return -1;
79 }
80
81 status = pdb_update_sam_account(sam_acct);
82 if (!NT_STATUS_IS_OK(status)) {
83 d_fprintf(stderr, _("Updating sam account %s failed with %s\n"),
84 argv[0], nt_errstr(status));
85 return -1;
86 }
87
88 TALLOC_FREE(sam_acct);
89
90 d_printf(_("Updated %s for %s\\%s to %s\n"), field, dom, name, argv[1]);
91 return 0;
92 }
93
94 static int net_sam_set_fullname(struct net_context *c, int argc,
95 const char **argv)
96 {
97 return net_sam_userset(c, argc, argv, "fullname",
98 pdb_set_fullname);
99 }
100
101 static int net_sam_set_logonscript(struct net_context *c, int argc,
102 const char **argv)
103 {
104 return net_sam_userset(c, argc, argv, "logonscript",
105 pdb_set_logon_script);
106 }
107
108 static int net_sam_set_profilepath(struct net_context *c, int argc,
109 const char **argv)
110 {
111 return net_sam_userset(c, argc, argv, "profilepath",
112 pdb_set_profile_path);
113 }
114
115 static int net_sam_set_homedrive(struct net_context *c, int argc,
116 const char **argv)
117 {
118 return net_sam_userset(c, argc, argv, "homedrive",
119 pdb_set_dir_drive);
120 }
121
122 static int net_sam_set_homedir(struct net_context *c, int argc,
123 const char **argv)
124 {
125 return net_sam_userset(c, argc, argv, "homedir",
126 pdb_set_homedir);
127 }
128
129 static int net_sam_set_workstations(struct net_context *c, int argc,
130 const char **argv)
131 {
132 return net_sam_userset(c, argc, argv, "workstations",
133 pdb_set_workstations);
134 }
135
136 /*
137 * Set account flags
138 */
139
140 static int net_sam_set_userflag(struct net_context *c, int argc,
141 const char **argv, const char *field,
142 uint16 flag)
143 {
144 struct samu *sam_acct = NULL;
145 struct dom_sid sid;
146 enum lsa_SidType type;
147 const char *dom, *name;
148 NTSTATUS status;
149 uint32_t acct_flags;
150
151 if ((argc != 2) || c->display_usage ||
152 (!strequal(argv[1], "yes") &&
153 !strequal(argv[1], "no"))) {
154 d_fprintf(stderr, "%s\n", _("Usage:"));
155 d_fprintf(stderr, _("net sam set %s <user> [yes|no]\n"),
156 field);
157 return -1;
158 }
159
160 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
161 &dom, &name, &sid, &type)) {
162 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
163 return -1;
164 }
165
166 if (type != SID_NAME_USER) {
167 d_fprintf(stderr, _("%s is a %s, not a user\n"), argv[0],
168 sid_type_lookup(type));
169 return -1;
170 }
171
172 if ( !(sam_acct = samu_new( NULL )) ) {
173 d_fprintf(stderr, _("Internal error\n"));
174 return -1;
175 }
176
177 if (!pdb_getsampwsid(sam_acct, &sid)) {
178 d_fprintf(stderr, _("Loading user %s failed\n"), argv[0]);
179 return -1;
180 }
181
182 acct_flags = pdb_get_acct_ctrl(sam_acct);
183
184 if (strequal(argv[1], "yes")) {
185 acct_flags |= flag;
186 } else {
187 acct_flags &= ~flag;
188 }
189
190 pdb_set_acct_ctrl(sam_acct, acct_flags, PDB_CHANGED);
191
192 status = pdb_update_sam_account(sam_acct);
193 if (!NT_STATUS_IS_OK(status)) {
194 d_fprintf(stderr, _("Updating sam account %s failed with %s\n"),
195 argv[0], nt_errstr(status));
196 return -1;
197 }
198
199 TALLOC_FREE(sam_acct);
200
201 d_fprintf(stderr, _("Updated flag %s for %s\\%s to %s\n"), field, dom,
202 name, argv[1]);
203 return 0;
204 }
205
206 static int net_sam_set_disabled(struct net_context *c, int argc,
207 const char **argv)
208 {
209 return net_sam_set_userflag(c, argc, argv, "disabled", ACB_DISABLED);
210 }
211
212 static int net_sam_set_pwnotreq(struct net_context *c, int argc,
213 const char **argv)
214 {
215 return net_sam_set_userflag(c, argc, argv, "pwnotreq", ACB_PWNOTREQ);
216 }
217
218 static int net_sam_set_autolock(struct net_context *c, int argc,
219 const char **argv)
220 {
221 return net_sam_set_userflag(c, argc, argv, "autolock", ACB_AUTOLOCK);
222 }
223
224 static int net_sam_set_pwnoexp(struct net_context *c, int argc,
225 const char **argv)
226 {
227 return net_sam_set_userflag(c, argc, argv, "pwnoexp", ACB_PWNOEXP);
228 }
229
230 /*
231 * Set pass last change time, based on force pass change now
232 */
233
234 static int net_sam_set_pwdmustchangenow(struct net_context *c, int argc,
235 const char **argv)
236 {
237 struct samu *sam_acct = NULL;
238 struct dom_sid sid;
239 enum lsa_SidType type;
240 const char *dom, *name;
241 NTSTATUS status;
242
243 if ((argc != 2) || c->display_usage ||
244 (!strequal(argv[1], "yes") &&
245 !strequal(argv[1], "no"))) {
246 d_fprintf(stderr, "%s\n%s",
247 _("Usage:"),
248 _("net sam set pwdmustchangenow <user> [yes|no]\n"));
249 return -1;
250 }
251
252 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
253 &dom, &name, &sid, &type)) {
254 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
255 return -1;
256 }
257
258 if (type != SID_NAME_USER) {
259 d_fprintf(stderr, _("%s is a %s, not a user\n"), argv[0],
260 sid_type_lookup(type));
261 return -1;
262 }
263
264 if ( !(sam_acct = samu_new( NULL )) ) {
265 d_fprintf(stderr, _("Internal error\n"));
266 return -1;
267 }
268
269 if (!pdb_getsampwsid(sam_acct, &sid)) {
270 d_fprintf(stderr, _("Loading user %s failed\n"), argv[0]);
271 return -1;
272 }
273
274 if (strequal(argv[1], "yes")) {
275 pdb_set_pass_last_set_time(sam_acct, 0, PDB_CHANGED);
276 } else {
277 pdb_set_pass_last_set_time(sam_acct, time(NULL), PDB_CHANGED);
278 }
279
280 status = pdb_update_sam_account(sam_acct);
281 if (!NT_STATUS_IS_OK(status)) {
282 d_fprintf(stderr, _("Updating sam account %s failed with %s\n"),
283 argv[0], nt_errstr(status));
284 return -1;
285 }
286
287 TALLOC_FREE(sam_acct);
288
289 d_fprintf(stderr, _("Updated 'user must change password at next logon' "
290 "for %s\\%s to %s\n"), dom,
291 name, argv[1]);
292 return 0;
293 }
294
295
296 /*
297 * Set a user's or a group's comment
298 */
299
300 static int net_sam_set_comment(struct net_context *c, int argc,
301 const char **argv)
302 {
303 GROUP_MAP *map;
304 struct dom_sid sid;
305 enum lsa_SidType type;
306 const char *dom, *name;
307 NTSTATUS status;
308
309 if (argc != 2 || c->display_usage) {
310 d_fprintf(stderr, "%s\n%s",
311 _("Usage:"),
312 _("net sam set comment <name> <comment>\n"));
313 return -1;
314 }
315
316 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
317 &dom, &name, &sid, &type)) {
318 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
319 return -1;
320 }
321
322 if (type == SID_NAME_USER) {
323 return net_sam_userset(c, argc, argv, "comment",
324 pdb_set_acct_desc);
325 }
326
327 if ((type != SID_NAME_DOM_GRP) && (type != SID_NAME_ALIAS) &&
328 (type != SID_NAME_WKN_GRP)) {
329 d_fprintf(stderr, _("%s is a %s, not a group\n"), argv[0],
330 sid_type_lookup(type));
331 return -1;
332 }
333
334 map = talloc_zero(talloc_tos(), GROUP_MAP);
335 if (!map) {
336 d_fprintf(stderr, _("Out of memory!\n"));
337 return -1;
338 }
339
340 if (!pdb_getgrsid(map, sid)) {
341 d_fprintf(stderr, _("Could not load group %s\n"), argv[0]);
342 return -1;
343 }
344
345 map->comment = talloc_strdup(map, argv[1]);
346 if (!map->comment) {
347 d_fprintf(stderr, _("Out of memory!\n"));
348 return -1;
349 }
350
351 status = pdb_update_group_mapping_entry(map);
352
353 if (!NT_STATUS_IS_OK(status)) {
354 d_fprintf(stderr, _("Updating group mapping entry failed with "
355 "%s\n"), nt_errstr(status));
356 return -1;
357 }
358
359 d_printf("Updated comment of group %s\\%s to %s\n", dom, name,
360 argv[1]);
361
362 TALLOC_FREE(map);
363 return 0;
364 }
365
366 static int net_sam_set(struct net_context *c, int argc, const char **argv)
367 {
368 struct functable func[] = {
369 {
370 "homedir",
371 net_sam_set_homedir,
372 NET_TRANSPORT_LOCAL,
373 N_("Change a user's home directory"),
374 N_("net sam set homedir\n"
375 " Change a user's home directory")
376 },
377 {
378 "profilepath",
379 net_sam_set_profilepath,
380 NET_TRANSPORT_LOCAL,
381 N_("Change a user's profile path"),
382 N_("net sam set profilepath\n"
383 " Change a user's profile path")
384 },
385 {
386 "comment",
387 net_sam_set_comment,
388 NET_TRANSPORT_LOCAL,
389 N_("Change a users or groups description"),
390 N_("net sam set comment\n"
391 " Change a users or groups description")
392 },
393 {
394 "fullname",
395 net_sam_set_fullname,
396 NET_TRANSPORT_LOCAL,
397 N_("Change a user's full name"),
398 N_("net sam set fullname\n"
399 " Change a user's full name")
400 },
401 {
402 "logonscript",
403 net_sam_set_logonscript,
404 NET_TRANSPORT_LOCAL,
405 N_("Change a user's logon script"),
406 N_("net sam set logonscript\n"
407 " Change a user's logon script")
408 },
409 {
410 "homedrive",
411 net_sam_set_homedrive,
412 NET_TRANSPORT_LOCAL,
413 N_("Change a user's home drive"),
414 N_("net sam set homedrive\n"
415 " Change a user's home drive")
416 },
417 {
418 "workstations",
419 net_sam_set_workstations,
420 NET_TRANSPORT_LOCAL,
421 N_("Change a user's allowed workstations"),
422 N_("net sam set workstations\n"
423 " Change a user's allowed workstations")
424 },
425 {
426 "disabled",
427 net_sam_set_disabled,
428 NET_TRANSPORT_LOCAL,
429 N_("Disable/Enable a user"),
430 N_("net sam set disable\n"
431 " Disable/Enable a user")
432 },
433 {
434 "pwnotreq",
435 net_sam_set_pwnotreq,
436 NET_TRANSPORT_LOCAL,
437 N_("Disable/Enable the password not required flag"),
438 N_("net sam set pwnotreq\n"
439 " Disable/Enable the password not required flag")
440 },
441 {
442 "autolock",
443 net_sam_set_autolock,
444 NET_TRANSPORT_LOCAL,
445 N_("Disable/Enable a user's lockout flag"),
446 N_("net sam set autolock\n"
447 " Disable/Enable a user's lockout flag")
448 },
449 {
450 "pwnoexp",
451 net_sam_set_pwnoexp,
452 NET_TRANSPORT_LOCAL,
453 N_("Disable/Enable whether a user's pw does not "
454 "expire"),
455 N_("net sam set pwnoexp\n"
456 " Disable/Enable whether a user's pw does not "
457 "expire")
458 },
459 {
460 "pwdmustchangenow",
461 net_sam_set_pwdmustchangenow,
462 NET_TRANSPORT_LOCAL,
463 N_("Force users password must change at next logon"),
464 N_("net sam set pwdmustchangenow\n"
465 " Force users password must change at next logon")
466 },
467 {NULL, NULL, 0, NULL, NULL}
468 };
469
470 return net_run_function(c, argc, argv, "net sam set", func);
471 }
472
473 /*
474 * Manage account policies
475 */
476
477 static int net_sam_policy_set(struct net_context *c, int argc, const char **argv)
478 {
479 const char *account_policy = NULL;
480 uint32 value = 0;
481 uint32 old_value = 0;
482 enum pdb_policy_type field;
483 char *endptr;
484
485 if (argc != 2 || c->display_usage) {
486 d_fprintf(stderr, "%s\n%s",
487 _("Usage:"),
488 _("net sam policy set \"<account policy>\" <value>\n"));
489 return -1;
490 }
491
492 account_policy = argv[0];
493 field = account_policy_name_to_typenum(account_policy);
494
495 if (strequal(argv[1], "forever") || strequal(argv[1], "never")
496 || strequal(argv[1], "off")) {
497 value = -1;
498 }
499 else {
500 value = strtoul(argv[1], &endptr, 10);
501
502 if ((endptr == argv[1]) || (endptr[0] != '\0')) {
503 d_printf(_("Unable to set policy \"%s\"! Invalid value "
504 "\"%s\".\n"),
505 account_policy, argv[1]);
506 return -1;
507 }
508 }
509
510 if (field == 0) {
511 const char **names;
512 int i, count;
513
514 account_policy_names_list(talloc_tos(), &names, &count);
515 d_fprintf(stderr, _("No account policy \"%s\"!\n\n"), argv[0]);
516 d_fprintf(stderr, _("Valid account policies are:\n"));
517
518 for (i=0; i<count; i++) {
519 d_fprintf(stderr, "%s\n", names[i]);
520 }
521
522 TALLOC_FREE(names);
523
524 return -1;
525 }
526
527 if (!pdb_get_account_policy(field, &old_value)) {
528 d_fprintf(stderr, _("Valid account policy, but unable to fetch "
529 "value!\n"));
530 } else {
531 d_printf(_("Account policy \"%s\" value was: %d\n"),
532 account_policy, old_value);
533 }
534
535 if (!pdb_set_account_policy(field, value)) {
536 d_fprintf(stderr, _("Valid account policy, but unable to "
537 "set value!\n"));
538 return -1;
539 } else {
540 d_printf(_("Account policy \"%s\" value is now: %d\n"),
541 account_policy, value);
542 }
543
544 return 0;
545 }
546
547 static int net_sam_policy_show(struct net_context *c, int argc, const char **argv)
548 {
549 const char *account_policy = NULL;
550 uint32 old_value;
551 enum pdb_policy_type field;
552
553 if (argc != 1 || c->display_usage) {
554 d_fprintf(stderr, "%s\n%s",
555 _("Usage:"),
556 _("net sam policy show \"<account policy>\"\n"));
557 return -1;
558 }
559
560 account_policy = argv[0];
561 field = account_policy_name_to_typenum(account_policy);
562
563 if (field == 0) {
564 const char **names;
565 int count;
566 int i;
567 account_policy_names_list(talloc_tos(), &names, &count);
568 d_fprintf(stderr, _("No account policy by that name!\n"));
569 if (count != 0) {
570 d_fprintf(stderr, _("Valid account policies "
571 "are:\n"));
572 for (i=0; i<count; i++) {
573 d_fprintf(stderr, "%s\n", names[i]);
574 }
575 }
576 TALLOC_FREE(names);
577 return -1;
578 }
579
580 if (!pdb_get_account_policy(field, &old_value)) {
581 fprintf(stderr, _("Valid account policy, but unable to "
582 "fetch value!\n"));
583 return -1;
584 }
585
586 printf(_("Account policy \"%s\" description: %s\n"),
587 account_policy, account_policy_get_desc(field));
588 printf(_("Account policy \"%s\" value is: %d\n"), account_policy,
589 old_value);
590 return 0;
591 }
592
593 static int net_sam_policy_list(struct net_context *c, int argc, const char **argv)
594 {
595 const char **names;
596 int count;
597 int i;
598
599 if (c->display_usage) {
600 d_printf( "%s\n"
601 "net sam policy list\n"
602 " %s\n",
603 _("Usage:"),
604 _("List account policies"));
605 return 0;
606 }
607
608 account_policy_names_list(talloc_tos(), &names, &count);
609 if (count != 0) {
610 d_fprintf(stderr, _("Valid account policies "
611 "are:\n"));
612 for (i = 0; i < count ; i++) {
613 d_fprintf(stderr, "%s\n", names[i]);
614 }
615 }
616 TALLOC_FREE(names);
617 return -1;
618 }
619
620 static int net_sam_policy(struct net_context *c, int argc, const char **argv)
621 {
622 struct functable func[] = {
623 {
624 "list",
625 net_sam_policy_list,
626 NET_TRANSPORT_LOCAL,
627 N_("List account policies"),
628 N_("net sam policy list\n"
629 " List account policies")
630 },
631 {
632 "show",
633 net_sam_policy_show,
634 NET_TRANSPORT_LOCAL,
635 N_("Show account policies"),
636 N_("net sam policy show\n"
637 " Show account policies")
638 },
639 {
640 "set",
641 net_sam_policy_set,
642 NET_TRANSPORT_LOCAL,
643 N_("Change account policies"),
644 N_("net sam policy set\n"
645 " Change account policies")
646 },
647 {NULL, NULL, 0, NULL, NULL}
648 };
649
650 return net_run_function(c, argc, argv, "net sam policy", func);
651 }
652
653 static int net_sam_rights_list(struct net_context *c, int argc,
654 const char **argv)
655 {
656 enum sec_privilege privilege;
657
658 if (argc > 1 || c->display_usage) {
659 d_fprintf(stderr, "%s\n%s",
660 _("Usage:"),
661 _("net sam rights list [privilege name]\n"));
662 return -1;
663 }
664
665 if (argc == 0) {
666 int i;
667 int num = num_privileges_in_short_list();
668
669 for (i=0; i<num; i++) {
670 d_printf("%s\n", sec_privilege_name_from_index(i));
671 }
672 return 0;
673 }
674
675 privilege = sec_privilege_id(argv[0]);
676
677 if (privilege != SEC_PRIV_INVALID) {
678 struct dom_sid *sids;
679 int i, num_sids;
680 NTSTATUS status;
681
682 status = privilege_enum_sids(privilege, talloc_tos(),
683 &sids, &num_sids);
684 if (!NT_STATUS_IS_OK(status)) {
685 d_fprintf(stderr, _("Could not list rights: %s\n"),
686 nt_errstr(status));
687 return -1;
688 }
689
690 for (i=0; i<num_sids; i++) {
691 const char *dom, *name;
692 enum lsa_SidType type;
693
694 if (lookup_sid(talloc_tos(), &sids[i], &dom, &name,
695 &type)) {
696 d_printf("%s\\%s\n", dom, name);
697 }
698 else {
699 d_printf("%s\n", sid_string_tos(&sids[i]));
700 }
701 }
702 return 0;
703 }
704
705 return -1;
706 }
707
708 static int net_sam_rights_grant(struct net_context *c, int argc,
709 const char **argv)
710 {
711 struct dom_sid sid;
712 enum lsa_SidType type;
713 const char *dom, *name;
714 int i;
715
716 if (argc < 2 || c->display_usage) {
717 d_fprintf(stderr, "%s\n%s",
718 _("Usage:"),
719 _("net sam rights grant <name> <rights> ...\n"));
720 return -1;
721 }
722
723 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
724 &dom, &name, &sid, &type)) {
725 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
726 return -1;
727 }
728
729 for (i=1; i < argc; i++) {
730 enum sec_privilege privilege = sec_privilege_id(argv[i]);
731 if (privilege == SEC_PRIV_INVALID) {
732 d_fprintf(stderr, _("%s unknown\n"), argv[i]);
733 return -1;
734 }
735
736 if (!grant_privilege_by_name(&sid, argv[i])) {
737 d_fprintf(stderr, _("Could not grant privilege\n"));
738 return -1;
739 }
740
741 d_printf(_("Granted %s to %s\\%s\n"), argv[i], dom, name);
742 }
743
744 return 0;
745 }
746
747 static int net_sam_rights_revoke(struct net_context *c, int argc,
748 const char **argv)
749 {
750 struct dom_sid sid;
751 enum lsa_SidType type;
752 const char *dom, *name;
753 int i;
754
755 if (argc < 2 || c->display_usage) {
756 d_fprintf(stderr, "%s\n%s",
757 _("Usage:"),
758 _("net sam rights revoke <name> <rights>\n"));
759 return -1;
760 }
761
762 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
763 &dom, &name, &sid, &type)) {
764 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
765 return -1;
766 }
767
768 for (i=1; i < argc; i++) {
769 enum sec_privilege privilege = sec_privilege_id(argv[i]);
770 if (privilege == SEC_PRIV_INVALID) {
771 d_fprintf(stderr, _("%s unknown\n"), argv[i]);
772 return -1;
773 }
774
775 if (!revoke_privilege_by_name(&sid, argv[i])) {
776 d_fprintf(stderr, _("Could not revoke privilege\n"));
777 return -1;
778 }
779
780 d_printf(_("Revoked %s from %s\\%s\n"), argv[i], dom, name);
781 }
782
783 return 0;
784 }
785
786 static int net_sam_rights(struct net_context *c, int argc, const char **argv)
787 {
788 struct functable func[] = {
789 {
790 "list",
791 net_sam_rights_list,
792 NET_TRANSPORT_LOCAL,
793 N_("List possible user rights"),
794 N_("net sam rights list\n"
795 " List possible user rights")
796 },
797 {
798 "grant",
799 net_sam_rights_grant,
800 NET_TRANSPORT_LOCAL,
801 N_("Grant right(s)"),
802 N_("net sam rights grant\n"
803 " Grant right(s)")
804 },
805 {
806 "revoke",
807 net_sam_rights_revoke,
808 NET_TRANSPORT_LOCAL,
809 N_("Revoke right(s)"),
810 N_("net sam rights revoke\n"
811 " Revoke right(s)")
812 },
813 {NULL, NULL, 0, NULL, NULL}
814 };
815 return net_run_function(c, argc, argv, "net sam rights", func);
816 }
817
818 /*
819 * Map a unix group to a domain group
820 */
821
822 static NTSTATUS map_unix_group(const struct group *grp, GROUP_MAP *map)
823 {
824 const char *dom, *name;
825 uint32 rid;
826
827 if (pdb_getgrgid(map, grp->gr_gid)) {
828 return NT_STATUS_GROUP_EXISTS;
829 }
830
831 map->gid = grp->gr_gid;
832
833 if (lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
834 &dom, &name, NULL, NULL)) {
835
836 map->nt_name = talloc_asprintf(map, "Unix Group %s",
837 grp->gr_name);
838
839 DEBUG(5, ("%s exists as %s\\%s, retrying as \"%s\"\n",
840 grp->gr_name, dom, name, map->nt_name));
841 }
842
843 if (lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
844 NULL, NULL, NULL, NULL)) {
845 DEBUG(3, ("\"%s\" exists, can't map it\n", grp->gr_name));
846 return NT_STATUS_GROUP_EXISTS;
847 }
848
849 if (pdb_capabilities() & PDB_CAP_STORE_RIDS) {
850 if (!pdb_new_rid(&rid)) {
851 DEBUG(3, ("Could not get a new RID for %s\n",
852 grp->gr_name));
853 return NT_STATUS_ACCESS_DENIED;
854 }
855 } else {
856 rid = algorithmic_pdb_gid_to_group_rid( grp->gr_gid );
857 }
858
859 sid_compose(&map->sid, get_global_sam_sid(), rid);
860 map->sid_name_use = SID_NAME_DOM_GRP;
861 map->comment = talloc_asprintf(map, "Unix Group %s", grp->gr_name);
862
863 return pdb_add_group_mapping_entry(map);
864 }
865
866 static int net_sam_mapunixgroup(struct net_context *c, int argc, const char **argv)
867 {
868 NTSTATUS status;
869 GROUP_MAP *map;
870 struct group *grp;
871
872 if (argc != 1 || c->display_usage) {
873 d_fprintf(stderr, "%s\n%s",
874 _("Usage:"),
875 _("net sam mapunixgroup <name>\n"));
876 return -1;
877 }
878
879 grp = getgrnam(argv[0]);
880 if (grp == NULL) {
881 d_fprintf(stderr, _("Could not find group %s\n"), argv[0]);
882 return -1;
883 }
884
885 map = talloc_zero(talloc_tos(), GROUP_MAP);
886 if (!map) {
887 d_fprintf(stderr, _("Out of memory!\n"));
888 return -1;
889 }
890
891 status = map_unix_group(grp, map);
892
893 if (!NT_STATUS_IS_OK(status)) {
894 d_fprintf(stderr, _("Mapping group %s failed with %s\n"),
895 argv[0], nt_errstr(status));
896 return -1;
897 }
898
899 d_printf(_("Mapped unix group %s to SID %s\n"), argv[0],
900 sid_string_tos(&map->sid));
901
902 TALLOC_FREE(map);
903 return 0;
904 }
905
906 /*
907 * Remove a group mapping
908 */
909
910 static NTSTATUS unmap_unix_group(const struct group *grp)
911 {
912 struct dom_sid dom_sid;
913
914 if (!lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
915 NULL, NULL, NULL, NULL)) {
916 DEBUG(3, ("\"%s\" does not exist, can't unmap it\n", grp->gr_name));
917 return NT_STATUS_NO_SUCH_GROUP;
918 }
919
920 if (!pdb_gid_to_sid(grp->gr_gid, &dom_sid)) {
921 return NT_STATUS_UNSUCCESSFUL;
922 }
923
924 return pdb_delete_group_mapping_entry(dom_sid);
925 }
926
927 static int net_sam_unmapunixgroup(struct net_context *c, int argc, const char **argv)
928 {
929 NTSTATUS status;
930 struct group *grp;
931
932 if (argc != 1 || c->display_usage) {
933 d_fprintf(stderr, "%s\n%s",
934 _("Usage:"),
935 _("net sam unmapunixgroup <name>\n"));
936 return -1;
937 }
938
939 grp = getgrnam(argv[0]);
940 if (grp == NULL) {
941 d_fprintf(stderr, _("Could not find mapping for group %s.\n"),
942 argv[0]);
943 return -1;
944 }
945
946 status = unmap_unix_group(grp);
947
948 if (!NT_STATUS_IS_OK(status)) {
949 d_fprintf(stderr, _("Unmapping group %s failed with %s.\n"),
950 argv[0], nt_errstr(status));
951 return -1;
952 }
953
954 d_printf(_("Unmapped unix group %s.\n"), argv[0]);
955
956 return 0;
957 }
958
959 /*
960 * Create a domain group
961 */
962
963 static int net_sam_createdomaingroup(struct net_context *c, int argc,
964 const char **argv)
965 {
966 NTSTATUS status;
967 uint32 rid;
968
969 if (argc != 1 || c->display_usage) {
970 d_fprintf(stderr, "%s\n%s",
971 _("Usage:"),
972 _("net sam createdomaingroup <name>\n"));
973 return -1;
974 }
975
976 status = pdb_create_dom_group(talloc_tos(), argv[0], &rid);
977
978 if (!NT_STATUS_IS_OK(status)) {
979 d_fprintf(stderr, _("Creating %s failed with %s\n"),
980 argv[0], nt_errstr(status));
981 return -1;
982 }
983
984 d_printf(_("Created domain group %s with RID %d\n"), argv[0], rid);
985
986 return 0;
987 }
988
989 /*
990 * Delete a domain group
991 */
992
993 static int net_sam_deletedomaingroup(struct net_context *c, int argc,
994 const char **argv)
995 {
996 struct dom_sid sid;
997 uint32_t rid;
998 enum lsa_SidType type;
999 const char *dom, *name;
1000 NTSTATUS status;
1001
1002 if (argc != 1 || c->display_usage) {
1003 d_fprintf(stderr, "%s\n%s",
1004 _("Usage:"),
1005 _("net sam deletelocalgroup <name>\n"));
1006 return -1;
1007 }
1008
1009 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1010 &dom, &name, &sid, &type)) {
1011 d_fprintf(stderr, _("Could not find %s.\n"), argv[0]);
1012 return -1;
1013 }
1014
1015 if (type != SID_NAME_DOM_GRP) {
1016 d_fprintf(stderr, _("%s is a %s, not a domain group.\n"),
1017 argv[0], sid_type_lookup(type));
1018 return -1;
1019 }
1020
1021 sid_peek_rid(&sid, &rid);
1022
1023 status = pdb_delete_dom_group(talloc_tos(), rid);
1024
1025 if (!NT_STATUS_IS_OK(status)) {
1026 d_fprintf(stderr,_("Deleting domain group %s failed with %s\n"),
1027 argv[0], nt_errstr(status));
1028 return -1;
1029 }
1030
1031 d_printf(_("Deleted domain group %s.\n"), argv[0]);
1032
1033 return 0;
1034 }
1035
1036 /*
1037 * Create a local group
1038 */
1039
1040 static int net_sam_createlocalgroup(struct net_context *c, int argc, const char **argv)
1041 {
1042 NTSTATUS status;
1043 uint32 rid;
1044
1045 if (argc != 1 || c->display_usage) {
1046 d_fprintf(stderr, "%s\n%s",
1047 _("Usage:"),
1048 _("net sam createlocalgroup <name>\n"));
1049 return -1;
1050 }
1051
1052 if (!winbind_ping()) {
1053 d_fprintf(stderr, _("winbind seems not to run. "
1054 "createlocalgroup only works when winbind runs.\n"));
1055 return -1;
1056 }
1057
1058 status = pdb_create_alias(argv[0], &rid);
1059
1060 if (!NT_STATUS_IS_OK(status)) {
1061 d_fprintf(stderr, _("Creating %s failed with %s\n"),
1062 argv[0], nt_errstr(status));
1063 return -1;
1064 }
1065
1066 d_printf(_("Created local group %s with RID %d\n"), argv[0], rid);
1067
1068 return 0;
1069 }
1070
1071 /*
1072 * Delete a local group
1073 */
1074
1075 static int net_sam_deletelocalgroup(struct net_context *c, int argc, const char **argv)
1076 {
1077 struct dom_sid sid;
1078 enum lsa_SidType type;
1079 const char *dom, *name;
1080 NTSTATUS status;
1081
1082 if (argc != 1 || c->display_usage) {
1083 d_fprintf(stderr, "%s\n%s",
1084 _("Usage:"),
1085 _("net sam deletelocalgroup <name>\n"));
1086 return -1;
1087 }
1088
1089 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1090 &dom, &name, &sid, &type)) {
1091 d_fprintf(stderr,_("Could not find %s.\n"), argv[0]);
1092 return -1;
1093 }
1094
1095 if (type != SID_NAME_ALIAS) {
1096 d_fprintf(stderr, _("%s is a %s, not a local group.\n"),argv[0],
1097 sid_type_lookup(type));
1098 return -1;
1099 }
1100
1101 status = pdb_delete_alias(&sid);
1102
1103 if (!NT_STATUS_IS_OK(status)) {
1104 d_fprintf(stderr, _("Deleting local group %s failed with %s\n"),
1105 argv[0], nt_errstr(status));
1106 return -1;
1107 }
1108
1109 d_printf(_("Deleted local group %s.\n"), argv[0]);
1110
1111 return 0;
1112 }
1113
1114 /*
1115 * Create a builtin group
1116 */
1117
1118 static int net_sam_createbuiltingroup(struct net_context *c, int argc, const char **argv)
1119 {
1120 NTSTATUS status;
1121 uint32 rid;
1122 enum lsa_SidType type;
1123 fstring groupname;
1124 struct dom_sid sid;
1125
1126 if (argc != 1 || c->display_usage) {
1127 d_fprintf(stderr, "%s\n%s",
1128 _("Usage:"),
1129 _("net sam createbuiltingroup <name>\n"));
1130 return -1;
1131 }
1132
1133 if (!winbind_ping()) {
1134 d_fprintf(stderr, _("winbind seems not to run. "
1135 "createbuiltingroup only works when winbind "
1136 "runs.\n"));
1137 return -1;
1138 }
1139
1140 /* validate the name and get the group */
1141
1142 fstrcpy( groupname, "BUILTIN\\" );
1143 fstrcat( groupname, argv[0] );
1144
1145 if ( !lookup_name(talloc_tos(), groupname, LOOKUP_NAME_ALL, NULL,
1146 NULL, &sid, &type)) {
1147 d_fprintf(stderr, _("%s is not a BUILTIN group\n"), argv[0]);
1148 return -1;
1149 }
1150
1151 if ( !sid_peek_rid( &sid, &rid ) ) {
1152 d_fprintf(stderr, _("Failed to get RID for %s\n"), argv[0]);
1153 return -1;
1154 }
1155
1156 status = pdb_create_builtin_alias( rid );
1157
1158 if (!NT_STATUS_IS_OK(status)) {
1159 d_fprintf(stderr, _("Creating %s failed with %s\n"),
1160 argv[0], nt_errstr(status));
1161 return -1;
1162 }
1163
1164 d_printf(_("Created BUILTIN group %s with RID %d\n"), argv[0], rid);
1165
1166 return 0;
1167 }
1168
1169 /*
1170 * Add a group member
1171 */
1172
1173 static int net_sam_addmem(struct net_context *c, int argc, const char **argv)
1174 {
1175 const char *groupdomain, *groupname, *memberdomain, *membername;
1176 struct dom_sid group, member;
1177 enum lsa_SidType grouptype, membertype;
1178 NTSTATUS status;
1179
1180 if (argc != 2 || c->display_usage) {
1181 d_fprintf(stderr, "%s\n%s",
1182 _("Usage:"),
1183 _("net sam addmem <group> <member>\n"));
1184 return -1;
1185 }
1186
1187 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1188 &groupdomain, &groupname, &group, &grouptype)) {
1189 d_fprintf(stderr, _("Could not find group %s\n"), argv[0]);
1190 return -1;
1191 }
1192
1193 /* check to see if the member to be added is a name or a SID */
1194
1195 if (!lookup_name(talloc_tos(), argv[1], LOOKUP_NAME_LOCAL,
1196 &memberdomain, &membername, &member, &membertype))
1197 {
1198 /* try it as a SID */
1199
1200 if ( !string_to_sid( &member, argv[1] ) ) {
1201 d_fprintf(stderr, _("Could not find member %s\n"),
1202 argv[1]);
1203 return -1;
1204 }
1205
1206 if ( !lookup_sid(talloc_tos(), &member, &memberdomain,
1207 &membername, &membertype) )
1208 {
1209 d_fprintf(stderr, _("Could not resolve SID %s\n"),
1210 argv[1]);
1211 return -1;
1212 }
1213 }
1214
1215 if ((grouptype == SID_NAME_ALIAS) || (grouptype == SID_NAME_WKN_GRP)) {
1216 if ((membertype != SID_NAME_USER) &&
1217 (membertype != SID_NAME_DOM_GRP)) {
1218 d_fprintf(stderr, _("%s is a local group, only users "
1219 "and domain groups can be added.\n"
1220 "%s is a %s\n"), argv[0], argv[1],
1221 sid_type_lookup(membertype));
1222 return -1;
1223 }
1224 status = pdb_add_aliasmem(&group, &member);
1225
1226 if (!NT_STATUS_IS_OK(status)) {
1227 d_fprintf(stderr, _("Adding local group member failed "
1228 "with %s\n"), nt_errstr(status));
1229 return -1;
1230 }
1231 } else if (grouptype == SID_NAME_DOM_GRP) {
1232 uint32_t grouprid, memberrid;
1233
1234 sid_peek_rid(&group, &grouprid);
1235 sid_peek_rid(&member, &memberrid);
1236
1237 status = pdb_add_groupmem(talloc_tos(), grouprid, memberrid);
1238 if (!NT_STATUS_IS_OK(status)) {
1239 d_fprintf(stderr, _("Adding domain group member failed "
1240 "with %s\n"), nt_errstr(status));
1241 return -1;
1242 }
1243 } else {
1244 d_fprintf(stderr, _("Can only add members to local groups so "
1245 "far, %s is a %s\n"), argv[0],
1246 sid_type_lookup(grouptype));
1247 return -1;
1248 }
1249
1250 d_printf(_("Added %s\\%s to %s\\%s\n"), memberdomain, membername,
1251 groupdomain, groupname);
1252
1253 return 0;
1254 }
1255
1256 /*
1257 * Delete a group member
1258 */
1259
1260 static int net_sam_delmem(struct net_context *c, int argc, const char **argv)
1261 {
1262 const char *groupdomain, *groupname;
1263 const char *memberdomain = NULL;
1264 const char *membername = NULL;
1265 struct dom_sid group, member;
1266 enum lsa_SidType grouptype;
1267 NTSTATUS status;
1268
1269 if (argc != 2 || c->display_usage) {
1270 d_fprintf(stderr,"%s\n%s",
1271 _("Usage:"),
1272 _("net sam delmem <group> <member>\n"));
1273 return -1;
1274 }
1275
1276 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1277 &groupdomain, &groupname, &group, &grouptype)) {
1278 d_fprintf(stderr, _("Could not find group %s\n"), argv[0]);
1279 return -1;
1280 }
1281
1282 if (!lookup_name(talloc_tos(), argv[1], LOOKUP_NAME_LOCAL,
1283 &memberdomain, &membername, &member, NULL)) {
1284 if (!string_to_sid(&member, argv[1])) {
1285 d_fprintf(stderr, _("Could not find member %s\n"),
1286 argv[1]);
1287 return -1;
1288 }
1289 }
1290
1291 if ((grouptype == SID_NAME_ALIAS) ||
1292 (grouptype == SID_NAME_WKN_GRP)) {
1293 status = pdb_del_aliasmem(&group, &member);
1294
1295 if (!NT_STATUS_IS_OK(status)) {
1296 d_fprintf(stderr,_("Deleting local group member failed "
1297 "with %s\n"), nt_errstr(status));
1298 return -1;
1299 }
1300 } else if (grouptype == SID_NAME_DOM_GRP) {
1301 uint32_t grouprid, memberrid;
1302
1303 sid_peek_rid(&group, &grouprid);
1304 sid_peek_rid(&member, &memberrid);
1305
1306 status = pdb_del_groupmem(talloc_tos(), grouprid, memberrid);
1307 if (!NT_STATUS_IS_OK(status)) {
1308 d_fprintf(stderr, _("Deleting domain group member "
1309 "failed with %s\n"), nt_errstr(status));
1310 return -1;
1311 }
1312 } else {
1313 d_fprintf(stderr, _("Can only delete members from local groups "
1314 "so far, %s is a %s\n"), argv[0],
1315 sid_type_lookup(grouptype));
1316 return -1;
1317 }
1318
1319 if (membername != NULL) {
1320 d_printf(_("Deleted %s\\%s from %s\\%s\n"),
1321 memberdomain, membername, groupdomain, groupname);
1322 } else {
1323 d_printf(_("Deleted %s from %s\\%s\n"),
1324 sid_string_tos(&member), groupdomain, groupname);
1325 }
1326
1327 return 0;
1328 }
1329
1330 /*
1331 * List group members
1332 */
1333
1334 static int net_sam_listmem(struct net_context *c, int argc, const char **argv)
1335 {
1336 const char *groupdomain, *groupname;
1337 struct dom_sid group;
1338 struct dom_sid *members = NULL;
1339 size_t i, num_members = 0;
1340 enum lsa_SidType grouptype;
1341 NTSTATUS status;
1342
1343 if (argc != 1 || c->display_usage) {
1344 d_fprintf(stderr, "%s\n%s",
1345 _("Usage:"),
1346 _("net sam listmem <group>\n"));
1347 return -1;
1348 }
1349
1350 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1351 &groupdomain, &groupname, &group, &grouptype)) {
1352 d_fprintf(stderr, _("Could not find group %s\n"), argv[0]);
1353 return -1;
1354 }
1355
1356 if ((grouptype == SID_NAME_ALIAS) ||
1357 (grouptype == SID_NAME_WKN_GRP)) {
1358 status = pdb_enum_aliasmem(&group, talloc_tos(), &members,
1359 &num_members);
1360 if (!NT_STATUS_IS_OK(status)) {
1361 d_fprintf(stderr, _("Listing group members failed with "
1362 "%s\n"), nt_errstr(status));
1363 return -1;
1364 }
1365 } else if (grouptype == SID_NAME_DOM_GRP) {
1366 uint32_t *rids;
1367
1368 status = pdb_enum_group_members(talloc_tos(), &group,
1369 &rids, &num_members);
1370 if (!NT_STATUS_IS_OK(status)) {
1371 d_fprintf(stderr, _("Listing group members failed with "
1372 "%s\n"), nt_errstr(status));
1373 return -1;
1374 }
1375
1376 members = talloc_array(talloc_tos(), struct dom_sid,
1377 num_members);
1378 if (members == NULL) {
1379 TALLOC_FREE(rids);
1380 return -1;
1381 }
1382
1383 for (i=0; i<num_members; i++) {
1384 sid_compose(&members[i], get_global_sam_sid(),
1385 rids[i]);
1386 }
1387 TALLOC_FREE(rids);
1388 } else {
1389 d_fprintf(stderr,_("Can only list local group members so far.\n"
1390 "%s is a %s\n"), argv[0], sid_type_lookup(grouptype));
1391 return -1;
1392 }
1393
1394 d_printf(_("%s\\%s has %u members\n"), groupdomain, groupname,
1395 (unsigned int)num_members);
1396 for (i=0; i<num_members; i++) {
1397 const char *dom, *name;
1398 if (lookup_sid(talloc_tos(), &members[i], &dom, &name, NULL)) {
1399 d_printf(" %s\\%s\n", dom, name);
1400 } else {
1401 d_printf(" %s\n", sid_string_tos(&members[i]));
1402 }
1403 }
1404
1405 TALLOC_FREE(members);
1406
1407 return 0;
1408 }
1409
1410 /*
1411 * Do the listing
1412 */
1413 static int net_sam_do_list(struct net_context *c, int argc, const char **argv,
1414 struct pdb_search *search, const char *what)
1415 {
1416 bool verbose = (argc == 1);
1417
1418 if ((argc > 1) || c->display_usage ||
1419 ((argc == 1) && !strequal(argv[0], "verbose"))) {
1420 d_fprintf(stderr, "%s\n", _("Usage:"));
1421 d_fprintf(stderr, _("net sam list %s [verbose]\n"), what);
1422 return -1;
1423 }
1424
1425 if (search == NULL) {
1426 d_fprintf(stderr, _("Could not start search\n"));
1427 return -1;
1428 }
1429
1430 while (true) {
1431 struct samr_displayentry entry;
1432 if (!search->next_entry(search, &entry)) {
1433 break;
1434 }
1435 if (verbose) {
1436 d_printf("%s:%d:%s\n",
1437 entry.account_name,
1438 entry.rid,
1439 entry.description);
1440 } else {
1441 d_printf("%s\n", entry.account_name);
1442 }
1443 }
1444
1445 TALLOC_FREE(search);
1446 return 0;
1447 }
1448
1449 static int net_sam_list_users(struct net_context *c, int argc,
1450 const char **argv)
1451 {
1452 return net_sam_do_list(c, argc, argv,
1453 pdb_search_users(talloc_tos(), ACB_NORMAL),
1454 "users");
1455 }
1456
1457 static int net_sam_list_groups(struct net_context *c, int argc,
1458 const char **argv)
1459 {
1460 return net_sam_do_list(c, argc, argv, pdb_search_groups(talloc_tos()),
1461 "groups");
1462 }
1463
1464 static int net_sam_list_localgroups(struct net_context *c, int argc,
1465 const char **argv)
1466 {
1467 return net_sam_do_list(c, argc, argv,
1468 pdb_search_aliases(talloc_tos(),
1469 get_global_sam_sid()),
1470 "localgroups");
1471 }
1472
1473 static int net_sam_list_builtin(struct net_context *c, int argc,
1474 const char **argv)
1475 {
1476 return net_sam_do_list(c, argc, argv,
1477 pdb_search_aliases(talloc_tos(),
1478 &global_sid_Builtin),
1479 "builtin");
1480 }
1481
1482 static int net_sam_list_workstations(struct net_context *c, int argc,
1483 const char **argv)
1484 {
1485 return net_sam_do_list(c, argc, argv,
1486 pdb_search_users(talloc_tos(), ACB_WSTRUST),
1487 "workstations");
1488 }
1489
1490 /*
1491 * List stuff
1492 */
1493
1494 static int net_sam_list(struct net_context *c, int argc, const char **argv)
1495 {
1496 struct functable func[] = {
1497 {
1498 "users",
1499 net_sam_list_users,
1500 NET_TRANSPORT_LOCAL,
1501 N_("List SAM users"),
1502 N_("net sam list users\n"
1503 " List SAM users")
1504 },
1505 {
1506 "groups",
1507 net_sam_list_groups,
1508 NET_TRANSPORT_LOCAL,
1509 N_("List SAM groups"),
1510 N_("net sam list groups\n"
1511 " List SAM groups")
1512 },
1513 {
1514 "localgroups",
1515 net_sam_list_localgroups,
1516 NET_TRANSPORT_LOCAL,
1517 N_("List SAM local groups"),
1518 N_("net sam list localgroups\n"
1519 " List SAM local groups")
1520 },
1521 {
1522 "builtin",
1523 net_sam_list_builtin,
1524 NET_TRANSPORT_LOCAL,
1525 N_("List builtin groups"),
1526 N_("net sam list builtin\n"
1527 " List builtin groups")
1528 },
1529 {
1530 "workstations",
1531 net_sam_list_workstations,
1532 NET_TRANSPORT_LOCAL,
1533 N_("List domain member workstations"),
1534 N_("net sam list workstations\n"
1535 " List domain member workstations")
1536 },
1537 {NULL, NULL, 0, NULL, NULL}
1538 };
1539
1540 return net_run_function(c, argc, argv, "net sam list", func);
1541 }
1542
1543 /*
1544 * Show details of SAM entries
1545 */
1546
1547 static int net_sam_show(struct net_context *c, int argc, const char **argv)
1548 {
1549 struct dom_sid sid;
1550 enum lsa_SidType type;
1551 const char *dom, *name;
1552
1553 if (argc != 1 || c->display_usage) {
1554 d_fprintf(stderr, "%s\n%s",
1555 _("Usage:"),
1556 _("net sam show <name>\n"));
1557 return -1;
1558 }
1559
1560 if (!lookup_name(talloc_tos(), argv[0], LOOKUP_NAME_LOCAL,
1561 &dom, &name, &sid, &type)) {
1562 d_fprintf(stderr, _("Could not find name %s\n"), argv[0]);
1563 return -1;
1564 }
1565
1566 d_printf(_("%s\\%s is a %s with SID %s\n"), dom, name,
1567 sid_type_lookup(type), sid_string_tos(&sid));
1568
1569 return 0;
1570 }
1571
1572 #ifdef HAVE_LDAP
1573
1574 /*
1575 * Init an LDAP tree with default users and Groups
1576 * if ldapsam:editposix is enabled
1577 */
1578
1579 static int net_sam_provision(struct net_context *c, int argc, const char **argv)
1580 {
1581 TALLOC_CTX *tc;
1582 char *ldap_bk;
1583 char *ldap_uri = NULL;
1584 char *p;
1585 struct smbldap_state *ls;
1586 GROUP_MAP *gmap = NULL;
1587 struct dom_sid gsid;
1588 gid_t domusers_gid = -1;
1589 gid_t domadmins_gid = -1;
1590 struct samu *samuser;
1591 struct passwd *pwd;
1592 bool is_ipa = false;
1593
1594 if (c->display_usage) {
1595 d_printf( "%s\n"
1596 "net sam provision\n"
1597 " %s\n",
1598 _("Usage:"),
1599 _("Init an LDAP tree with default users/groups"));
1600 return 0;
1601 }
1602
1603 tc = talloc_new(NULL);
1604 if (!tc) {
1605 d_fprintf(stderr, _("Out of Memory!\n"));
1606 return -1;
1607 }
1608
1609 if ((ldap_bk = talloc_strdup(tc, lp_passdb_backend())) == NULL) {
1610 d_fprintf(stderr, _("talloc failed\n"));
1611 talloc_free(tc);
1612 return -1;
1613 }
1614 p = strchr(ldap_bk, ':');
1615 if (p) {
1616 *p = 0;
1617 ldap_uri = talloc_strdup(tc, p+1);
1618 trim_char(ldap_uri, ' ', ' ');
1619 }
1620
1621 trim_char(ldap_bk, ' ', ' ');
1622
1623 if (strcmp(ldap_bk, "IPA_ldapsam") == 0 ) {
1624 is_ipa = true;
1625 }
1626
1627 if (strcmp(ldap_bk, "ldapsam") != 0 && !is_ipa ) {
1628 d_fprintf(stderr,
1629 _("Provisioning works only with ldapsam backend\n"));
1630 goto failed;
1631 }
1632
1633 if (!lp_parm_bool(-1, "ldapsam", "trusted", false) ||
1634 !lp_parm_bool(-1, "ldapsam", "editposix", false)) {
1635
1636 d_fprintf(stderr, _("Provisioning works only if ldapsam:trusted"
1637 " and ldapsam:editposix are enabled.\n"));
1638 goto failed;
1639 }
1640
1641 if (!is_ipa && !winbind_ping()) {
1642 d_fprintf(stderr, _("winbind seems not to run. Provisioning "
1643 "LDAP only works when winbind runs.\n"));
1644 goto failed;
1645 }
1646
1647 if (!NT_STATUS_IS_OK(smbldap_init(tc, NULL, ldap_uri, &ls))) {
1648 d_fprintf(stderr, _("Unable to connect to the LDAP server.\n"));
1649 goto failed;
1650 }
1651
1652 d_printf(_("Checking for Domain Users group.\n"));
1653
1654 sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_USERS);
1655
1656 gmap = talloc_zero(tc, GROUP_MAP);
1657 if (!gmap) {
1658 d_printf(_("Out of memory!\n"));
1659 goto failed;
1660 }
1661
1662 if (!pdb_getgrsid(gmap, gsid)) {
1663 LDAPMod **mods = NULL;
1664 char *dn;
1665 char *uname;
1666 char *wname;
1667 char *gidstr;
1668 char *gtype;
1669 int rc;
1670
1671 d_printf(_("Adding the Domain Users group.\n"));
1672
1673 /* lets allocate a new groupid for this group */
1674 if (is_ipa) {
1675 domusers_gid = 999;
1676 } else {
1677 if (!winbind_allocate_gid(&domusers_gid)) {
1678 d_fprintf(stderr, _("Unable to allocate a new gid to "
1679 "create Domain Users group!\n"));
1680 goto domu_done;
1681 }
1682 }
1683
1684 uname = talloc_strdup(tc, "domusers");
1685 wname = talloc_strdup(tc, "Domain Users");
1686 dn = talloc_asprintf(tc, "cn=%s,%s", "domusers", lp_ldap_group_suffix());
1687 gidstr = talloc_asprintf(tc, "%u", (unsigned int)domusers_gid);
1688 gtype = talloc_asprintf(tc, "%d", SID_NAME_DOM_GRP);
1689
1690 if (!uname || !wname || !dn || !gidstr || !gtype) {
1691 d_fprintf(stderr, "Out of Memory!\n");
1692 goto failed;
1693 }
1694
1695 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
1696 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
1697 if (is_ipa) {
1698 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
1699 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
1700 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
1701 }
1702 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
1703 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);
1704 smbldap_set_mod(&mods, LDAP_MOD_ADD, "gidNumber", gidstr);
1705 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaSid",
1706 sid_string_talloc(tc, &gsid));
1707 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaGroupType", gtype);
1708
1709 talloc_autofree_ldapmod(tc, mods);
1710
1711 rc = smbldap_add(ls, dn, mods);
1712
1713 if (rc != LDAP_SUCCESS) {
1714 d_fprintf(stderr, _("Failed to add Domain Users group "
1715 "to ldap directory\n"));
1716 }
1717
1718 if (is_ipa) {
1719 if (!pdb_getgrsid(gmap, gsid)) {
1720 d_fprintf(stderr, _("Failed to read just "
1721 "created domain group.\n"));
1722 goto failed;
1723 } else {
1724 domusers_gid = gmap->gid;
1725 }
1726 }
1727 } else {
1728 domusers_gid = gmap->gid;
1729 d_printf(_("found!\n"));
1730 }
1731
1732 domu_done:
1733
1734 d_printf(_("Checking for Domain Admins group.\n"));
1735
1736 sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_ADMINS);
1737
1738 if (!pdb_getgrsid(gmap, gsid)) {
1739 LDAPMod **mods = NULL;
1740 char *dn;
1741 char *uname;
1742 char *wname;
1743 char *gidstr;
1744 char *gtype;
1745 int rc;
1746
1747 d_printf(_("Adding the Domain Admins group.\n"));
1748
1749 /* lets allocate a new groupid for this group */
1750 if (is_ipa) {
1751 domadmins_gid = 999;
1752 } else {
1753 if (!winbind_allocate_gid(&domadmins_gid)) {
1754 d_fprintf(stderr, _("Unable to allocate a new gid to "
1755 "create Domain Admins group!\n"));
1756 goto doma_done;
1757 }
1758 }
1759
1760 uname = talloc_strdup(tc, "domadmins");
1761 wname = talloc_strdup(tc, "Domain Admins");
1762 dn = talloc_asprintf(tc, "cn=%s,%s", "domadmins", lp_ldap_group_suffix());
1763 gidstr = talloc_asprintf(tc, "%u", (unsigned int)domadmins_gid);
1764 gtype = talloc_asprintf(tc, "%d", SID_NAME_DOM_GRP);
1765
1766 if (!uname || !wname || !dn || !gidstr || !gtype) {
1767 d_fprintf(stderr, _("Out of Memory!\n"));
1768 goto failed;
1769 }
1770
1771 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
1772 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
1773 if (is_ipa) {
1774 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
1775 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
1776 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
1777 }
1778 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
1779 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);
1780 smbldap_set_mod(&mods, LDAP_MOD_ADD, "gidNumber", gidstr);
1781 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaSid",
1782 sid_string_talloc(tc, &gsid));
1783 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaGroupType", gtype);
1784
1785 talloc_autofree_ldapmod(tc, mods);
1786
1787 rc = smbldap_add(ls, dn, mods);
1788
1789 if (rc != LDAP_SUCCESS) {
1790 d_fprintf(stderr, _("Failed to add Domain Admins group "
1791 "to ldap directory\n"));
1792 }
1793
1794 if (is_ipa) {
1795 if (!pdb_getgrsid(gmap, gsid)) {
1796 d_fprintf(stderr, _("Failed to read just "
1797 "created domain group.\n"));
1798 goto failed;
1799 } else {
1800 domadmins_gid = gmap->gid;
1801 }
1802 }
1803 } else {
1804 domadmins_gid = gmap->gid;
1805 d_printf(_("found!\n"));
1806 }
1807
1808 doma_done:
1809
1810 d_printf(_("Check for Administrator account.\n"));
1811
1812 samuser = samu_new(tc);
1813 if (!samuser) {
1814 d_fprintf(stderr, _("Out of Memory!\n"));
1815 goto failed;
1816 }
1817
1818 if (!pdb_getsampwnam(samuser, "Administrator")) {
1819 LDAPMod **mods = NULL;
1820 struct dom_sid sid;
1821 char *dn;
1822 char *name;
1823 char *uidstr;
1824 char *gidstr;
1825 char *shell;
1826 char *dir;
1827 char *princ;
1828 uid_t uid;
1829 int rc;
1830
1831 d_printf(_("Adding the Administrator user.\n"));
1832
1833 if (domadmins_gid == -1) {
1834 d_fprintf(stderr,
1835 _("Can't create Administrator user, Domain "
1836 "Admins group not available!\n"));
1837 goto done;
1838 }
1839
1840 if (is_ipa) {
1841 uid = 999;
1842 } else {
1843 if (!winbind_allocate_uid(&uid)) {
1844 d_fprintf(stderr,
1845 _("Unable to allocate a new uid to create "
1846 "the Administrator user!\n"));
1847 goto done;
1848 }
1849 }
1850
1851 name = talloc_strdup(tc, "Administrator");
1852 dn = talloc_asprintf(tc, "uid=Administrator,%s", lp_ldap_user_suffix());
1853 uidstr = talloc_asprintf(tc, "%u", (unsigned int)uid);
1854 gidstr = talloc_asprintf(tc, "%u", (unsigned int)domadmins_gid);
1855 dir = talloc_sub_specified(tc, lp_template_homedir(),
1856 "Administrator",
1857 get_global_sam_name(),
1858 uid, domadmins_gid);
1859 shell = talloc_sub_specified(tc, lp_template_shell(),
1860 "Administrator",
1861 get_global_sam_name(),
1862 uid, domadmins_gid);
1863
1864 if (!name || !dn || !uidstr || !gidstr || !dir || !shell) {
1865 d_fprintf(stderr, _("Out of Memory!\n"));
1866 goto failed;
1867 }
1868
1869 sid_compose(&sid, get_global_sam_sid(), DOMAIN_RID_ADMINISTRATOR);
1870
1871 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_ACCOUNT);
1872 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXACCOUNT);
1873 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SAMBASAMACCOUNT);
1874 if (is_ipa) {
1875 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "person");
1876 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "organizationalperson");
1877 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetorgperson");
1878 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetuser");
1879 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbprincipalaux");
1880 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbticketpolicyaux");
1881 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sn", name);
1882 princ = talloc_asprintf(tc, "%s@%s", name, lp_realm());
1883 if (!princ) {
1884 d_fprintf(stderr, _("Out of Memory!\n"));
1885 goto failed;
1886 }
1887 smbldap_set_mod(&mods, LDAP_MOD_ADD, "krbPrincipalName", princ);
1888 }
1889 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uid", name);
1890 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", name);
1891 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", name);
1892 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uidNumber", uidstr);
1893 smbldap_set_mod(&mods, LDAP_MOD_ADD, "gidNumber", gidstr);
1894 smbldap_set_mod(&mods, LDAP_MOD_ADD, "homeDirectory", dir);
1895 smbldap_set_mod(&mods, LDAP_MOD_ADD, "loginShell", shell);
1896 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaSID",
1897 sid_string_talloc(tc, &sid));
1898 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaAcctFlags",
1899 pdb_encode_acct_ctrl(ACB_NORMAL|ACB_DISABLED,
1900 NEW_PW_FORMAT_SPACE_PADDED_LEN));
1901
1902 talloc_autofree_ldapmod(tc, mods);
1903
1904 rc = smbldap_add(ls, dn, mods);
1905
1906 if (rc != LDAP_SUCCESS) {
1907 d_fprintf(stderr, _("Failed to add Administrator user "
1908 "to ldap directory\n"));
1909 }
1910
1911 if (is_ipa) {
1912 if (!pdb_getsampwnam(samuser, "Administrator")) {
1913 d_fprintf(stderr, _("Failed to read just "
1914 "created user.\n"));
1915 goto failed;
1916 }
1917 }
1918 } else {
1919 d_printf(_("found!\n"));
1920 }
1921
1922 d_printf(_("Checking for Guest user.\n"));
1923
1924 samuser = samu_new(tc);
1925 if (!samuser) {
1926 d_fprintf(stderr, _("Out of Memory!\n"));
1927 goto failed;
1928 }
1929
1930 if (!pdb_getsampwnam(samuser, lp_guestaccount())) {
1931 LDAPMod **mods = NULL;
1932 struct dom_sid sid;
1933 char *dn;
1934 char *uidstr;
1935 char *gidstr;
1936 int rc;
1937
1938 d_printf(_("Adding the Guest user.\n"));
1939
1940 sid_compose(&sid, get_global_sam_sid(), DOMAIN_RID_GUEST);
1941
1942 pwd = Get_Pwnam_alloc(tc, lp_guestaccount());
1943
1944 if (!pwd) {
1945 if (domusers_gid == -1) {
1946 d_fprintf(stderr,
1947 _("Can't create Guest user, Domain "
1948 "Users group not available!\n"));
1949 goto done;
1950 }
1951 if ((pwd = talloc(tc, struct passwd)) == NULL) {
1952 d_fprintf(stderr, _("talloc failed\n"));
1953 goto done;
1954 }
1955 pwd->pw_name = talloc_strdup(pwd, lp_guestaccount());
1956
1957 if (is_ipa) {
1958 pwd->pw_uid = 999;
1959 } else {
1960 if (!winbind_allocate_uid(&(pwd->pw_uid))) {
1961 d_fprintf(stderr,
1962 _("Unable to allocate a new uid to "
1963 "create the Guest user!\n"));
1964 goto done;
1965 }
1966 }
1967 pwd->pw_gid = domusers_gid;
1968 pwd->pw_dir = talloc_strdup(tc, "/");
1969 pwd->pw_shell = talloc_strdup(tc, "/bin/false");
1970 if (!pwd->pw_dir || !pwd->pw_shell) {
1971 d_fprintf(stderr, _("Out of Memory!\n"));
1972 goto failed;
1973 }
1974 }
1975
1976 dn = talloc_asprintf(tc, "uid=%s,%s", pwd->pw_name, lp_ldap_user_suffix ());
1977 uidstr = talloc_asprintf(tc, "%u", (unsigned int)pwd->pw_uid);
1978 gidstr = talloc_asprintf(tc, "%u", (unsigned int)pwd->pw_gid);
1979 if (!dn || !uidstr || !gidstr) {
1980 d_fprintf(stderr, _("Out of Memory!\n"));
1981 goto failed;
1982 }
1983
1984 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_ACCOUNT);
1985 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXACCOUNT);
1986 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SAMBASAMACCOUNT);
1987 if (is_ipa) {
1988 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "person");
1989 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "organizationalperson");
1990 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetorgperson");
1991 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetuser");
1992 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbprincipalaux");
1993 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbticketpolicyaux");
1994 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sn", pwd->pw_name);
1995 }
1996 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uid", pwd->pw_name);
1997 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", pwd->pw_name);
1998 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", pwd->pw_name);
1999 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uidNumber", uidstr);
2000 smbldap_set_mod(&mods, LDAP_MOD_ADD, "gidNumber", gidstr);
2001 if ((pwd->pw_dir != NULL) && (pwd->pw_dir[0] != '\0')) {
2002 smbldap_set_mod(&mods, LDAP_MOD_ADD, "homeDirectory", pwd->pw_dir);
2003 }
2004 if ((pwd->pw_shell != NULL) && (pwd->pw_shell[0] != '\0')) {
2005 smbldap_set_mod(&mods, LDAP_MOD_ADD, "loginShell", pwd->pw_shell);
2006 }
2007 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaSID",
2008 sid_string_talloc(tc, &sid));
2009 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaAcctFlags",
2010 pdb_encode_acct_ctrl(ACB_NORMAL|ACB_DISABLED,
2011 NEW_PW_FORMAT_SPACE_PADDED_LEN));
2012
2013 talloc_autofree_ldapmod(tc, mods);
2014
2015 rc = smbldap_add(ls, dn, mods);
2016
2017 if (rc != LDAP_SUCCESS) {
2018 d_fprintf(stderr, _("Failed to add Guest user to "
2019 "ldap directory\n"));
2020 }
2021
2022 if (is_ipa) {
2023 if (!pdb_getsampwnam(samuser, lp_guestaccount())) {
2024 d_fprintf(stderr, _("Failed to read just "
2025 "created user.\n"));
2026 goto failed;
2027 }
2028 }
2029 } else {
2030 d_printf(_("found!\n"));
2031 }
2032
2033 d_printf(_("Checking Guest's group.\n"));
2034
2035 pwd = Get_Pwnam_alloc(tc, lp_guestaccount());
2036 if (!pwd) {
2037 d_fprintf(stderr,
2038 _("Failed to find just created Guest account!\n"
2039 " Is nss properly configured?!\n"));
2040 goto failed;
2041 }
2042
2043 if (pwd->pw_gid == domusers_gid) {
2044 d_printf(_("found!\n"));
2045 goto done;
2046 }
2047
2048 if (!pdb_getgrgid(gmap, pwd->pw_gid)) {
2049 LDAPMod **mods = NULL;
2050 char *dn;
2051 char *uname;
2052 char *wname;
2053 char *gidstr;
2054 char *gtype;
2055 int rc;
2056
2057 d_printf(_("Adding the Domain Guests group.\n"));
2058
2059 uname = talloc_strdup(tc, "domguests");
2060 wname = talloc_strdup(tc, "Domain Guests");
2061 dn = talloc_asprintf(tc, "cn=%s,%s", "domguests", lp_ldap_group_suffix());
2062 gidstr = talloc_asprintf(tc, "%u", (unsigned int)pwd->pw_gid);
2063 gtype = talloc_asprintf(tc, "%d", SID_NAME_DOM_GRP);
2064
2065 if (!uname || !wname || !dn || !gidstr || !gtype) {
2066 d_fprintf(stderr, _("Out of Memory!\n"));
2067 goto failed;
2068 }
2069
2070 sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_GUESTS);
2071
2072 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
2073 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
2074 if (is_ipa) {
2075 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
2076 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
2077 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
2078 }
2079 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
2080 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);
2081 smbldap_set_mod(&mods, LDAP_MOD_ADD, "gidNumber", gidstr);
2082 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaSid",
2083 sid_string_talloc(tc, &gsid));
2084 smbldap_set_mod(&mods, LDAP_MOD_ADD, "sambaGroupType", gtype);
2085
2086 talloc_autofree_ldapmod(tc, mods);
2087
2088 rc = smbldap_add(ls, dn, mods);
2089
2090 if (rc != LDAP_SUCCESS) {
2091 d_fprintf(stderr,
2092 _("Failed to add Domain Guests group to ldap "
2093 "directory\n"));
2094 }
2095 } else {
2096 d_printf(_("found!\n"));
2097 }
2098
2099
2100 done:
2101 talloc_free(tc);
2102 return 0;
2103
2104 failed:
2105 talloc_free(tc);
2106 return -1;
2107 }
2108
2109 #endif
2110
2111 /***********************************************************
2112 migrated functionality from smbgroupedit
2113 **********************************************************/
2114 int net_sam(struct net_context *c, int argc, const char **argv)
2115 {
2116 struct functable func[] = {
2117 {
2118 "createbuiltingroup",
2119 net_sam_createbuiltingroup,
2120 NET_TRANSPORT_LOCAL,
2121 N_("Create a new BUILTIN group"),
2122 N_("net sam createbuiltingroup\n"
2123 " Create a new BUILTIN group")
2124 },
2125 {
2126 "createlocalgroup",
2127 net_sam_createlocalgroup,
2128 NET_TRANSPORT_LOCAL,
2129 N_("Create a new local group"),
2130 N_("net sam createlocalgroup\n"
2131 " Create a new local group")
2132 },
2133 {
2134 "createdomaingroup",
2135 net_sam_createdomaingroup,
2136 NET_TRANSPORT_LOCAL,
2137 N_("Create a new group"),
2138 N_("net sam createdomaingroup\n"
2139 " Create a new group")
2140 },
2141 {
2142 "deletelocalgroup",
2143 net_sam_deletelocalgroup,
2144 NET_TRANSPORT_LOCAL,
2145 N_("Delete an existing local group"),
2146 N_("net sam deletelocalgroup\n"
2147 " Delete an existing local group")
2148 },
2149 {
2150 "deletedomaingroup",
2151 net_sam_deletedomaingroup,
2152 NET_TRANSPORT_LOCAL,
2153 N_("Delete a domain group"),
2154 N_("net sam deletedomaingroup\n"
2155 " Delete a group")
2156 },
2157 {
2158 "mapunixgroup",
2159 net_sam_mapunixgroup,
2160 NET_TRANSPORT_LOCAL,
2161 N_("Map a unix group to a domain group"),
2162 N_("net sam mapunixgroup\n"
2163 " Map a unix group to a domain group")
2164 },
2165 {
2166 "unmapunixgroup",
2167 net_sam_unmapunixgroup,
2168 NET_TRANSPORT_LOCAL,
2169 N_("Remove a group mapping of an unix group to a "
2170 "domain group"),
2171 N_("net sam unmapunixgroup\n"
2172 " Remove a group mapping of an unix group to a "
2173 "domain group")
2174 },
2175 {
2176 "addmem",
2177 net_sam_addmem,
2178 NET_TRANSPORT_LOCAL,
2179 N_("Add a member to a group"),
2180 N_("net sam addmem\n"
2181 " Add a member to a group")
2182 },
2183 {
2184 "delmem",
2185 net_sam_delmem,
2186 NET_TRANSPORT_LOCAL,
2187 N_("Delete a member from a group"),
2188 N_("net sam delmem\n"
2189 " Delete a member from a group")
2190 },
2191 {
2192 "listmem",
2193 net_sam_listmem,
2194 NET_TRANSPORT_LOCAL,
2195 N_("List group members"),
2196 N_("net sam listmem\n"
2197 " List group members")
2198 },
2199 {
2200 "list",
2201 net_sam_list,
2202 NET_TRANSPORT_LOCAL,
2203 N_("List users, groups and local groups"),
2204 N_("net sam list\n"
2205 " List users, groups and local groups")
2206 },
2207 {
2208 "show",
2209 net_sam_show,
2210 NET_TRANSPORT_LOCAL,
2211 N_("Show details of a SAM entry"),
2212 N_("net sam show\n"
2213 " Show details of a SAM entry")
2214 },
2215 {
2216 "set",
2217 net_sam_set,
2218 NET_TRANSPORT_LOCAL,
2219 N_("Set details of a SAM account"),
2220 N_("net sam set\n"
2221 " Set details of a SAM account")
2222 },
2223 {
2224 "policy",
2225 net_sam_policy,
2226 NET_TRANSPORT_LOCAL,
2227 N_("Set account policies"),
2228 N_("net sam policy\n"
2229 " Set account policies")
2230 },
2231 {
2232 "rights",
2233 net_sam_rights,
2234 NET_TRANSPORT_LOCAL,
2235 N_("Manipulate user privileges"),
2236 N_("net sam rights\n"
2237 " Manipulate user privileges")
2238 },
2239 #ifdef HAVE_LDAP
2240 {
2241 "provision",
2242 net_sam_provision,
2243 NET_TRANSPORT_LOCAL,
2244 N_("Provision a clean user database"),
2245 N_("net sam privison\n"
2246 " Provision a clear user database")
2247 },
2248 #endif
2249 {NULL, NULL, 0, NULL, NULL}
2250 };
2251
2252 if (getuid() != 0) {
2253 d_fprintf(stderr, _("You are not root, most things won't "
2254 "work\n"));
2255 }
2256
2257 return net_run_function(c, argc, argv, "net sam", func);
2258 }
2259
Working branch of Samba for id10ts