?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Fix Coverity ID 2470: STRAY_SEMICOLON
[Samba.git] / nsswitch / wbinfo.c
blobbb03750fa8ba4dafca11f37c7175e08db40d7a1e
1 /*
2 Unix SMB/CIFS implementation.
3
4 Winbind status program.
5
6 Copyright (C) Tim Potter 2000-2003
7 Copyright (C) Andrew Bartlett 2002-2007
8 Copyright (C) Volker Lendecke 2009
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "popt_common.h"
26 #include "winbind_client.h"
27 #include "libwbclient/wbclient.h"
28 #include "lib/popt/popt.h"
29 #include "../libcli/auth/libcli_auth.h"
30 #if (_SAMBA_BUILD_) >= 4
31 #include "lib/cmdline/popt_common.h"
32 #endif
33
34 #ifdef DBGC_CLASS
35 #undef DBGC_CLASS
36 #define DBGC_CLASS DBGC_WINBIND
37 #endif
38
39 static struct wbcInterfaceDetails *init_interface_details(void)
40 {
41 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
42 static struct wbcInterfaceDetails *details;
43
44 if (details) {
45 return details;
46 }
47
48 wbc_status = wbcInterfaceDetails(&details);
49 if (!WBC_ERROR_IS_OK(wbc_status)) {
50 d_fprintf(stderr, "could not obtain winbind interface "
51 "details: %s\n", wbcErrorString(wbc_status));
52 }
53
54 return details;
55 }
56
57 static char winbind_separator(void)
58 {
59 struct wbcInterfaceDetails *details;
60 static bool got_sep;
61 static char sep;
62
63 if (got_sep)
64 return sep;
65
66 details = init_interface_details();
67
68 if (!details) {
69 d_fprintf(stderr, "could not obtain winbind separator!\n");
70 return 0;
71 }
72
73 sep = details->winbind_separator;
74 got_sep = true;
75
76 if (!sep) {
77 d_fprintf(stderr, "winbind separator was NULL!\n");
78 return 0;
79 }
80
81 return sep;
82 }
83
84 static const char *get_winbind_domain(void)
85 {
86 static struct wbcInterfaceDetails *details;
87
88 details = init_interface_details();
89
90 if (!details) {
91 d_fprintf(stderr, "could not obtain winbind domain name!\n");
92 return 0;
93 }
94
95 return details->netbios_domain;
96 }
97
98 static const char *get_winbind_netbios_name(void)
99 {
100 static struct wbcInterfaceDetails *details;
101
102 details = init_interface_details();
103
104 if (!details) {
105 d_fprintf(stderr, "could not obtain winbind netbios name!\n");
106 return 0;
107 }
108
109 return details->netbios_name;
110 }
111
112 /* Copy of parse_domain_user from winbindd_util.c. Parse a string of the
113 form DOMAIN/user into a domain and a user */
114
115 static bool parse_wbinfo_domain_user(const char *domuser, fstring domain,
116 fstring user)
117 {
118
119 char *p = strchr(domuser,winbind_separator());
120
121 if (!p) {
122 /* Maybe it was a UPN? */
123 if ((p = strchr(domuser, '@')) != NULL) {
124 fstrcpy(domain, "");
125 fstrcpy(user, domuser);
126 return true;
127 }
128
129 fstrcpy(user, domuser);
130 fstrcpy(domain, get_winbind_domain());
131 return true;
132 }
133
134 fstrcpy(user, p+1);
135 fstrcpy(domain, domuser);
136 domain[PTR_DIFF(p, domuser)] = 0;
137 strupper_m(domain);
138
139 return true;
140 }
141
142 /* Parse string of "uid,sid" or "gid,sid" into separate int and string values.
143 * Return true if input was valid, false otherwise. */
144 static bool parse_mapping_arg(char *arg, int *id, char **sid)
145 {
146 char *tmp, *endptr;
147
148 if (!arg || !*arg)
149 return false;
150
151 tmp = strtok(arg, ",");
152 *sid = strtok(NULL, ",");
153
154 if (!tmp || !*tmp || !*sid || !**sid)
155 return false;
156
157 /* Because atoi() can return 0 on invalid input, which would be a valid
158 * UID/GID we must use strtoul() and do error checking */
159 *id = strtoul(tmp, &endptr, 10);
160
161 if (endptr[0] != '\0')
162 return false;
163
164 return true;
165 }
166
167 /* pull pwent info for a given user */
168
169 static bool wbinfo_get_userinfo(char *user)
170 {
171 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
172 struct passwd *pwd = NULL;
173
174 wbc_status = wbcGetpwnam(user, &pwd);
175 if (!WBC_ERROR_IS_OK(wbc_status)) {
176 d_fprintf(stderr, "failed to call wbcGetpwnam: %s\n",
177 wbcErrorString(wbc_status));
178 return false;
179 }
180
181 d_printf("%s:%s:%u:%u:%s:%s:%s\n",
182 pwd->pw_name,
183 pwd->pw_passwd,
184 (unsigned int)pwd->pw_uid,
185 (unsigned int)pwd->pw_gid,
186 pwd->pw_gecos,
187 pwd->pw_dir,
188 pwd->pw_shell);
189
190 wbcFreeMemory(pwd);
191
192 return true;
193 }
194
195 /* pull pwent info for a given uid */
196 static bool wbinfo_get_uidinfo(int uid)
197 {
198 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
199 struct passwd *pwd = NULL;
200
201 wbc_status = wbcGetpwuid(uid, &pwd);
202 if (!WBC_ERROR_IS_OK(wbc_status)) {
203 d_fprintf(stderr, "failed to call wbcGetpwuid: %s\n",
204 wbcErrorString(wbc_status));
205 return false;
206 }
207
208 d_printf("%s:%s:%u:%u:%s:%s:%s\n",
209 pwd->pw_name,
210 pwd->pw_passwd,
211 (unsigned int)pwd->pw_uid,
212 (unsigned int)pwd->pw_gid,
213 pwd->pw_gecos,
214 pwd->pw_dir,
215 pwd->pw_shell);
216
217 wbcFreeMemory(pwd);
218
219 return true;
220 }
221
222 static bool wbinfo_get_user_sidinfo(const char *sid_str)
223 {
224 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
225 struct passwd *pwd = NULL;
226 struct wbcDomainSid sid;
227
228 wbc_status = wbcStringToSid(sid_str, &sid);
229 wbc_status = wbcGetpwsid(&sid, &pwd);
230 if (!WBC_ERROR_IS_OK(wbc_status)) {
231 d_fprintf(stderr, "failed to call wbcGetpwsid: %s\n",
232 wbcErrorString(wbc_status));
233 return false;
234 }
235
236 d_printf("%s:%s:%u:%u:%s:%s:%s\n",
237 pwd->pw_name,
238 pwd->pw_passwd,
239 (unsigned int)pwd->pw_uid,
240 (unsigned int)pwd->pw_gid,
241 pwd->pw_gecos,
242 pwd->pw_dir,
243 pwd->pw_shell);
244
245 return true;
246 }
247
248
249 /* pull grent for a given group */
250 static bool wbinfo_get_groupinfo(const char *group)
251 {
252 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
253 struct group *grp;
254 char **mem;
255
256 wbc_status = wbcGetgrnam(group, &grp);
257 if (!WBC_ERROR_IS_OK(wbc_status)) {
258 d_fprintf(stderr, "failed to call wbcGetgrnam: %s\n",
259 wbcErrorString(wbc_status));
260 return false;
261 }
262
263 d_printf("%s:%s:%u:",
264 grp->gr_name,
265 grp->gr_passwd,
266 (unsigned int)grp->gr_gid);
267
268 mem = grp->gr_mem;
269 while (*mem != NULL) {
270 d_printf("%s%s", *mem, *(mem+1) != NULL ? "," : "");
271 mem += 1;
272 }
273 d_printf("\n");
274
275 wbcFreeMemory(grp);
276
277 return true;
278 }
279
280 /* pull grent for a given gid */
281 static bool wbinfo_get_gidinfo(int gid)
282 {
283 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
284 struct group *grp;
285 char **mem;
286
287 wbc_status = wbcGetgrgid(gid, &grp);
288 if (!WBC_ERROR_IS_OK(wbc_status)) {
289 d_fprintf(stderr, "failed to call wbcGetgrgid: %s\n",
290 wbcErrorString(wbc_status));
291 return false;
292 }
293
294 d_printf("%s:%s:%u:",
295 grp->gr_name,
296 grp->gr_passwd,
297 (unsigned int)grp->gr_gid);
298
299 mem = grp->gr_mem;
300 while (*mem != NULL) {
301 d_printf("%s%s", *mem, *(mem+1) != NULL ? "," : "");
302 mem += 1;
303 }
304 d_printf("\n");
305
306 wbcFreeMemory(grp);
307
308 return true;
309 }
310
311 /* List groups a user is a member of */
312
313 static bool wbinfo_get_usergroups(const char *user)
314 {
315 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
316 uint32_t num_groups;
317 uint32_t i;
318 gid_t *groups = NULL;
319
320 /* Send request */
321
322 wbc_status = wbcGetGroups(user, &num_groups, &groups);
323 if (!WBC_ERROR_IS_OK(wbc_status)) {
324 d_fprintf(stderr, "failed to call wbcGetGroups: %s\n",
325 wbcErrorString(wbc_status));
326 return false;
327 }
328
329 for (i = 0; i < num_groups; i++) {
330 d_printf("%d\n", (int)groups[i]);
331 }
332
333 wbcFreeMemory(groups);
334
335 return true;
336 }
337
338
339 /* List group SIDs a user SID is a member of */
340 static bool wbinfo_get_usersids(const char *user_sid_str)
341 {
342 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
343 uint32_t num_sids;
344 uint32_t i;
345 struct wbcDomainSid user_sid, *sids = NULL;
346
347 /* Send request */
348
349 wbc_status = wbcStringToSid(user_sid_str, &user_sid);
350 if (!WBC_ERROR_IS_OK(wbc_status)) {
351 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
352 wbcErrorString(wbc_status));
353 return false;
354 }
355
356 wbc_status = wbcLookupUserSids(&user_sid, false, &num_sids, &sids);
357 if (!WBC_ERROR_IS_OK(wbc_status)) {
358 d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
359 wbcErrorString(wbc_status));
360 return false;
361 }
362
363 for (i = 0; i < num_sids; i++) {
364 char str[WBC_SID_STRING_BUFLEN];
365 wbcSidToStringBuf(&sids[i], str, sizeof(str));
366 d_printf("%s\n", str);
367 }
368
369 wbcFreeMemory(sids);
370
371 return true;
372 }
373
374 static bool wbinfo_get_userdomgroups(const char *user_sid_str)
375 {
376 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
377 uint32_t num_sids;
378 uint32_t i;
379 struct wbcDomainSid user_sid, *sids = NULL;
380
381 /* Send request */
382
383 wbc_status = wbcStringToSid(user_sid_str, &user_sid);
384 if (!WBC_ERROR_IS_OK(wbc_status)) {
385 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
386 wbcErrorString(wbc_status));
387 return false;
388 }
389
390 wbc_status = wbcLookupUserSids(&user_sid, true, &num_sids, &sids);
391 if (!WBC_ERROR_IS_OK(wbc_status)) {
392 d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
393 wbcErrorString(wbc_status));
394 return false;
395 }
396
397 for (i = 0; i < num_sids; i++) {
398 char str[WBC_SID_STRING_BUFLEN];
399 wbcSidToStringBuf(&sids[i], str, sizeof(str));
400 d_printf("%s\n", str);
401 }
402
403 wbcFreeMemory(sids);
404
405 return true;
406 }
407
408 static bool wbinfo_get_sidaliases(const char *domain,
409 const char *user_sid_str)
410 {
411 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
412 struct wbcDomainInfo *dinfo = NULL;
413 uint32_t i;
414 struct wbcDomainSid user_sid;
415 uint32_t *alias_rids = NULL;
416 uint32_t num_alias_rids;
417 char domain_sid_str[WBC_SID_STRING_BUFLEN];
418
419 /* Send request */
420 if ((domain == NULL) || (strequal(domain, ".")) ||
421 (domain[0] == '\0')) {
422 domain = get_winbind_domain();
423 }
424
425 /* Send request */
426
427 wbc_status = wbcDomainInfo(domain, &dinfo);
428 if (!WBC_ERROR_IS_OK(wbc_status)) {
429 d_fprintf(stderr, "wbcDomainInfo(%s) failed: %s\n", domain,
430 wbcErrorString(wbc_status));
431 goto done;
432 }
433 wbc_status = wbcStringToSid(user_sid_str, &user_sid);
434 if (!WBC_ERROR_IS_OK(wbc_status)) {
435 goto done;
436 }
437
438 wbc_status = wbcGetSidAliases(&dinfo->sid, &user_sid, 1,
439 &alias_rids, &num_alias_rids);
440 if (!WBC_ERROR_IS_OK(wbc_status)) {
441 goto done;
442 }
443
444 wbcSidToStringBuf(&dinfo->sid, domain_sid_str, sizeof(domain_sid_str));
445
446 for (i = 0; i < num_alias_rids; i++) {
447 d_printf("%s-%d\n", domain_sid_str, alias_rids[i]);
448 }
449
450 wbcFreeMemory(alias_rids);
451
452 done:
453 wbcFreeMemory(dinfo);
454 return (WBC_ERR_SUCCESS == wbc_status);
455 }
456
457
458 /* Convert NetBIOS name to IP */
459
460 static bool wbinfo_wins_byname(const char *name)
461 {
462 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
463 char *ip = NULL;
464
465 wbc_status = wbcResolveWinsByName(name, &ip);
466 if (!WBC_ERROR_IS_OK(wbc_status)) {
467 d_fprintf(stderr, "failed to call wbcResolveWinsByName: %s\n",
468 wbcErrorString(wbc_status));
469 return false;
470 }
471
472 /* Display response */
473
474 d_printf("%s\n", ip);
475
476 wbcFreeMemory(ip);
477
478 return true;
479 }
480
481 /* Convert IP to NetBIOS name */
482
483 static bool wbinfo_wins_byip(const char *ip)
484 {
485 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
486 char *name = NULL;
487
488 wbc_status = wbcResolveWinsByIP(ip, &name);
489 if (!WBC_ERROR_IS_OK(wbc_status)) {
490 d_fprintf(stderr, "failed to call wbcResolveWinsByIP: %s\n",
491 wbcErrorString(wbc_status));
492 return false;
493 }
494
495 /* Display response */
496
497 d_printf("%s\n", name);
498
499 wbcFreeMemory(name);
500
501 return true;
502 }
503
504 /* List all/trusted domains */
505
506 static bool wbinfo_list_domains(bool list_all_domains, bool verbose)
507 {
508 struct wbcDomainInfo *domain_list = NULL;
509 size_t num_domains;
510 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
511 bool print_all = !list_all_domains && verbose;
512 int i;
513
514 wbc_status = wbcListTrusts(&domain_list, &num_domains);
515 if (!WBC_ERROR_IS_OK(wbc_status)) {
516 d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
517 wbcErrorString(wbc_status));
518 return false;
519 }
520
521 if (print_all) {
522 d_printf("%-16s%-24s%-12s%-12s%-5s%-5s\n",
523 "Domain Name", "DNS Domain", "Trust Type",
524 "Transitive", "In", "Out");
525 }
526
527 for (i=0; i<num_domains; i++) {
528 if (print_all) {
529 d_printf("%-16s", domain_list[i].short_name);
530 } else {
531 d_printf("%s", domain_list[i].short_name);
532 d_printf("\n");
533 continue;
534 }
535
536 d_printf("%-24s", domain_list[i].dns_name);
537
538 switch(domain_list[i].trust_type) {
539 case WBC_DOMINFO_TRUSTTYPE_NONE:
540 d_printf("None ");
541 break;
542 case WBC_DOMINFO_TRUSTTYPE_FOREST:
543 d_printf("Forest ");
544 break;
545 case WBC_DOMINFO_TRUSTTYPE_EXTERNAL:
546 d_printf("External ");
547 break;
548 case WBC_DOMINFO_TRUSTTYPE_IN_FOREST:
549 d_printf("In-Forest ");
550 break;
551 }
552
553 if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_TRANSITIVE) {
554 d_printf("Yes ");
555 } else {
556 d_printf("No ");
557 }
558
559 if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_INCOMING) {
560 d_printf("Yes ");
561 } else {
562 d_printf("No ");
563 }
564
565 if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_OUTGOING) {
566 d_printf("Yes ");
567 } else {
568 d_printf("No ");
569 }
570
571 d_printf("\n");
572 }
573
574 wbcFreeMemory(domain_list);
575
576 return true;
577 }
578
579 /* List own domain */
580
581 static bool wbinfo_list_own_domain(void)
582 {
583 d_printf("%s\n", get_winbind_domain());
584
585 return true;
586 }
587
588 /* show sequence numbers */
589 static bool wbinfo_show_sequence(const char *domain)
590 {
591 d_printf("This command has been deprecated. Please use the "
592 "--online-status option instead.\n");
593 return false;
594 }
595
596 /* show sequence numbers */
597 static bool wbinfo_show_onlinestatus(const char *domain)
598 {
599 struct wbcDomainInfo *domain_list = NULL;
600 size_t num_domains;
601 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
602 int i;
603
604 wbc_status = wbcListTrusts(&domain_list, &num_domains);
605 if (!WBC_ERROR_IS_OK(wbc_status)) {
606 d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
607 wbcErrorString(wbc_status));
608 return false;
609 }
610
611 for (i=0; i<num_domains; i++) {
612 bool is_offline;
613
614 if (domain) {
615 if (!strequal(domain_list[i].short_name, domain)) {
616 continue;
617 }
618 }
619
620 is_offline = (domain_list[i].domain_flags &
621 WBC_DOMINFO_DOMAIN_OFFLINE);
622
623 d_printf("%s : %s\n",
624 domain_list[i].short_name,
625 is_offline ? "offline" : "online" );
626 }
627
628 wbcFreeMemory(domain_list);
629
630 return true;
631 }
632
633
634 /* Show domain info */
635
636 static bool wbinfo_domain_info(const char *domain)
637 {
638 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
639 struct wbcDomainInfo *dinfo = NULL;
640 char sid_str[WBC_SID_STRING_BUFLEN];
641
642 if ((domain == NULL) || (strequal(domain, ".")) || (domain[0] == '\0')){
643 domain = get_winbind_domain();
644 }
645
646 /* Send request */
647
648 wbc_status = wbcDomainInfo(domain, &dinfo);
649 if (!WBC_ERROR_IS_OK(wbc_status)) {
650 d_fprintf(stderr, "failed to call wbcDomainInfo: %s\n",
651 wbcErrorString(wbc_status));
652 return false;
653 }
654
655 wbcSidToStringBuf(&dinfo->sid, sid_str, sizeof(sid_str));
656
657 /* Display response */
658
659 d_printf("Name : %s\n", dinfo->short_name);
660 d_printf("Alt_Name : %s\n", dinfo->dns_name);
661
662 d_printf("SID : %s\n", sid_str);
663
664 d_printf("Active Directory : %s\n",
665 (dinfo->domain_flags & WBC_DOMINFO_DOMAIN_AD) ? "Yes" : "No");
666 d_printf("Native : %s\n",
667 (dinfo->domain_flags & WBC_DOMINFO_DOMAIN_NATIVE) ?
668 "Yes" : "No");
669
670 d_printf("Primary : %s\n",
671 (dinfo->domain_flags & WBC_DOMINFO_DOMAIN_PRIMARY) ?
672 "Yes" : "No");
673
674 wbcFreeMemory(dinfo);
675
676 return true;
677 }
678
679 /* Get a foreign DC's name */
680 static bool wbinfo_getdcname(const char *domain_name)
681 {
682 struct winbindd_request request;
683 struct winbindd_response response;
684
685 ZERO_STRUCT(request);
686 ZERO_STRUCT(response);
687
688 fstrcpy(request.domain_name, domain_name);
689
690 /* Send request */
691
692 if (winbindd_request_response(WINBINDD_GETDCNAME, &request,
693 &response) != NSS_STATUS_SUCCESS) {
694 d_fprintf(stderr, "Could not get dc name for %s\n",domain_name);
695 return false;
696 }
697
698 /* Display response */
699
700 d_printf("%s\n", response.data.dc_name);
701
702 return true;
703 }
704
705 /* Find a DC */
706 static bool wbinfo_dsgetdcname(const char *domain_name, uint32_t flags)
707 {
708 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
709 struct wbcDomainControllerInfoEx *dc_info;
710 char *str = NULL;
711
712 wbc_status = wbcLookupDomainControllerEx(domain_name, NULL, NULL,
713 flags | DS_DIRECTORY_SERVICE_REQUIRED,
714 &dc_info);
715 if (!WBC_ERROR_IS_OK(wbc_status)) {
716 printf("Could not find dc for %s\n", domain_name);
717 return false;
718 }
719
720 wbcGuidToString(dc_info->domain_guid, &str);
721
722 d_printf("%s\n", dc_info->dc_unc);
723 d_printf("%s\n", dc_info->dc_address);
724 d_printf("%d\n", dc_info->dc_address_type);
725 d_printf("%s\n", str);
726 d_printf("%s\n", dc_info->domain_name);
727 d_printf("%s\n", dc_info->forest_name);
728 d_printf("0x%08x\n", dc_info->dc_flags);
729 d_printf("%s\n", dc_info->dc_site_name);
730 d_printf("%s\n", dc_info->client_site_name);
731
732 return true;
733 }
734
735 /* Check trust account password */
736
737 static bool wbinfo_check_secret(const char *domain)
738 {
739 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
740 struct wbcAuthErrorInfo *error = NULL;
741 const char *domain_name;
742
743 if (domain) {
744 domain_name = domain;
745 } else {
746 domain_name = get_winbind_domain();
747 }
748
749 wbc_status = wbcCheckTrustCredentials(domain_name, &error);
750
751 d_printf("checking the trust secret for domain %s via RPC calls %s\n",
752 domain_name,
753 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
754
755 if (wbc_status == WBC_ERR_AUTH_ERROR) {
756 d_fprintf(stderr, "error code was %s (0x%x)\n",
757 error->nt_string, error->nt_status);
758 wbcFreeMemory(error);
759 }
760 if (!WBC_ERROR_IS_OK(wbc_status)) {
761 d_fprintf(stderr, "failed to call wbcCheckTrustCredentials: "
762 "%s\n", wbcErrorString(wbc_status));
763 return false;
764 }
765
766 return true;
767 }
768
769 /* Find the currently connected DCs */
770
771 static bool wbinfo_dc_info(const char *domain_name)
772 {
773 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
774 size_t i, num_dcs;
775 const char **dc_names, **dc_ips;
776
777 wbc_status = wbcDcInfo(domain_name, &num_dcs,
778 &dc_names, &dc_ips);
779 if (!WBC_ERROR_IS_OK(wbc_status)) {
780 printf("Could not find dc info %s\n",
781 domain_name ? domain_name : "our domain");
782 return false;
783 }
784
785 for (i=0; i<num_dcs; i++) {
786 printf("%s (%s)\n", dc_names[i], dc_ips[i]);
787 }
788 wbcFreeMemory(dc_names);
789 wbcFreeMemory(dc_ips);
790
791 return true;
792 }
793
794 /* Change trust account password */
795
796 static bool wbinfo_change_secret(const char *domain)
797 {
798 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
799 struct wbcAuthErrorInfo *error = NULL;
800 const char *domain_name;
801
802 if (domain) {
803 domain_name = domain;
804 } else {
805 domain_name = get_winbind_domain();
806 }
807
808 wbc_status = wbcChangeTrustCredentials(domain_name, &error);
809
810 d_printf("changing the trust secret for domain %s via RPC calls %s\n",
811 domain_name,
812 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
813
814 if (wbc_status == WBC_ERR_AUTH_ERROR) {
815 d_fprintf(stderr, "error code was %s (0x%x)\n",
816 error->nt_string, error->nt_status);
817 wbcFreeMemory(error);
818 }
819 if (!WBC_ERROR_IS_OK(wbc_status)) {
820 d_fprintf(stderr, "failed to call wbcChangeTrustCredentials: "
821 "%s\n", wbcErrorString(wbc_status));
822 return false;
823 }
824
825 return true;
826 }
827
828 /* Check DC connection */
829
830 static bool wbinfo_ping_dc(void)
831 {
832 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
833 struct wbcAuthErrorInfo *error = NULL;
834
835 wbc_status = wbcPingDc(NULL, &error);
836
837 d_printf("checking the NETLOGON dc connection %s\n",
838 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
839
840 if (wbc_status == WBC_ERR_AUTH_ERROR) {
841 d_fprintf(stderr, "error code was %s (0x%x)\n",
842 error->nt_string, error->nt_status);
843 wbcFreeMemory(error);
844 }
845 if (!WBC_ERROR_IS_OK(wbc_status)) {
846 d_fprintf(stderr, "failed to call wbcPingDc: %s\n",
847 wbcErrorString(wbc_status));
848 return false;
849 }
850
851 return true;
852 }
853
854 /* Convert uid to sid */
855
856 static bool wbinfo_uid_to_sid(uid_t uid)
857 {
858 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
859 struct wbcDomainSid sid;
860 char sid_str[WBC_SID_STRING_BUFLEN];
861
862 /* Send request */
863
864 wbc_status = wbcUidToSid(uid, &sid);
865 if (!WBC_ERROR_IS_OK(wbc_status)) {
866 d_fprintf(stderr, "failed to call wbcUidToSid: %s\n",
867 wbcErrorString(wbc_status));
868 return false;
869 }
870
871 wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
872
873 /* Display response */
874
875 d_printf("%s\n", sid_str);
876
877 return true;
878 }
879
880 /* Convert gid to sid */
881
882 static bool wbinfo_gid_to_sid(gid_t gid)
883 {
884 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
885 struct wbcDomainSid sid;
886 char sid_str[WBC_SID_STRING_BUFLEN];
887
888 /* Send request */
889
890 wbc_status = wbcGidToSid(gid, &sid);
891 if (!WBC_ERROR_IS_OK(wbc_status)) {
892 d_fprintf(stderr, "failed to call wbcGidToSid: %s\n",
893 wbcErrorString(wbc_status));
894 return false;
895 }
896
897 wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
898
899 /* Display response */
900
901 d_printf("%s\n", sid_str);
902
903 return true;
904 }
905
906 /* Convert sid to uid */
907
908 static bool wbinfo_sid_to_uid(const char *sid_str)
909 {
910 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
911 struct wbcDomainSid sid;
912 uid_t uid;
913
914 /* Send request */
915
916 wbc_status = wbcStringToSid(sid_str, &sid);
917 if (!WBC_ERROR_IS_OK(wbc_status)) {
918 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
919 wbcErrorString(wbc_status));
920 return false;
921 }
922
923 wbc_status = wbcSidToUid(&sid, &uid);
924 if (!WBC_ERROR_IS_OK(wbc_status)) {
925 d_fprintf(stderr, "failed to call wbcSidToUid: %s\n",
926 wbcErrorString(wbc_status));
927 return false;
928 }
929
930 /* Display response */
931
932 d_printf("%d\n", (int)uid);
933
934 return true;
935 }
936
937 static bool wbinfo_sid_to_gid(const char *sid_str)
938 {
939 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
940 struct wbcDomainSid sid;
941 gid_t gid;
942
943 /* Send request */
944
945 wbc_status = wbcStringToSid(sid_str, &sid);
946 if (!WBC_ERROR_IS_OK(wbc_status)) {
947 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
948 wbcErrorString(wbc_status));
949 return false;
950 }
951
952 wbc_status = wbcSidToGid(&sid, &gid);
953 if (!WBC_ERROR_IS_OK(wbc_status)) {
954 d_fprintf(stderr, "failed to call wbcSidToGid: %s\n",
955 wbcErrorString(wbc_status));
956 return false;
957 }
958
959 /* Display response */
960
961 d_printf("%d\n", (int)gid);
962
963 return true;
964 }
965
966 static bool wbinfo_allocate_uid(void)
967 {
968 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
969 uid_t uid;
970
971 /* Send request */
972
973 wbc_status = wbcAllocateUid(&uid);
974 if (!WBC_ERROR_IS_OK(wbc_status)) {
975 d_fprintf(stderr, "failed to call wbcAllocateUid: %s\n",
976 wbcErrorString(wbc_status));
977 return false;
978 }
979
980 /* Display response */
981
982 d_printf("New uid: %u\n", (unsigned int)uid);
983
984 return true;
985 }
986
987 static bool wbinfo_allocate_gid(void)
988 {
989 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
990 gid_t gid;
991
992 /* Send request */
993
994 wbc_status = wbcAllocateGid(&gid);
995 if (!WBC_ERROR_IS_OK(wbc_status)) {
996 d_fprintf(stderr, "failed to call wbcAllocateGid: %s\n",
997 wbcErrorString(wbc_status));
998 return false;
999 }
1000
1001 /* Display response */
1002
1003 d_printf("New gid: %u\n", (unsigned int)gid);
1004
1005 return true;
1006 }
1007
1008 static bool wbinfo_set_uid_mapping(uid_t uid, const char *sid_str)
1009 {
1010 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1011 struct wbcDomainSid sid;
1012
1013 /* Send request */
1014
1015 wbc_status = wbcStringToSid(sid_str, &sid);
1016 if (!WBC_ERROR_IS_OK(wbc_status)) {
1017 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1018 wbcErrorString(wbc_status));
1019 return false;
1020 }
1021
1022 wbc_status = wbcSetUidMapping(uid, &sid);
1023 if (!WBC_ERROR_IS_OK(wbc_status)) {
1024 d_fprintf(stderr, "failed to call wbcSetUidMapping: %s\n",
1025 wbcErrorString(wbc_status));
1026 return false;
1027 }
1028
1029 /* Display response */
1030
1031 d_printf("uid %u now mapped to sid %s\n",
1032 (unsigned int)uid, sid_str);
1033
1034 return true;
1035 }
1036
1037 static bool wbinfo_set_gid_mapping(gid_t gid, const char *sid_str)
1038 {
1039 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1040 struct wbcDomainSid sid;
1041
1042 /* Send request */
1043
1044 wbc_status = wbcStringToSid(sid_str, &sid);
1045 if (!WBC_ERROR_IS_OK(wbc_status)) {
1046 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1047 wbcErrorString(wbc_status));
1048 return false;
1049 }
1050
1051 wbc_status = wbcSetGidMapping(gid, &sid);
1052 if (!WBC_ERROR_IS_OK(wbc_status)) {
1053 d_fprintf(stderr, "failed to call wbcSetGidMapping: %s\n",
1054 wbcErrorString(wbc_status));
1055 return false;
1056 }
1057
1058 /* Display response */
1059
1060 d_printf("gid %u now mapped to sid %s\n",
1061 (unsigned int)gid, sid_str);
1062
1063 return true;
1064 }
1065
1066 static bool wbinfo_remove_uid_mapping(uid_t uid, const char *sid_str)
1067 {
1068 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1069 struct wbcDomainSid sid;
1070
1071 /* Send request */
1072
1073 wbc_status = wbcStringToSid(sid_str, &sid);
1074 if (!WBC_ERROR_IS_OK(wbc_status)) {
1075 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1076 wbcErrorString(wbc_status));
1077 return false;
1078 }
1079
1080 wbc_status = wbcRemoveUidMapping(uid, &sid);
1081 if (!WBC_ERROR_IS_OK(wbc_status)) {
1082 d_fprintf(stderr, "failed to call wbcRemoveUidMapping: %s\n",
1083 wbcErrorString(wbc_status));
1084 return false;
1085 }
1086
1087 /* Display response */
1088
1089 d_printf("Removed uid %u to sid %s mapping\n",
1090 (unsigned int)uid, sid_str);
1091
1092 return true;
1093 }
1094
1095 static bool wbinfo_remove_gid_mapping(gid_t gid, const char *sid_str)
1096 {
1097 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1098 struct wbcDomainSid sid;
1099
1100 /* Send request */
1101
1102 wbc_status = wbcStringToSid(sid_str, &sid);
1103 if (!WBC_ERROR_IS_OK(wbc_status)) {
1104 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1105 wbcErrorString(wbc_status));
1106 return false;
1107 }
1108
1109 wbc_status = wbcRemoveGidMapping(gid, &sid);
1110 if (!WBC_ERROR_IS_OK(wbc_status)) {
1111 d_fprintf(stderr, "failed to call wbcRemoveGidMapping: %s\n",
1112 wbcErrorString(wbc_status));
1113 return false;
1114 }
1115
1116 /* Display response */
1117
1118 d_printf("Removed gid %u to sid %s mapping\n",
1119 (unsigned int)gid, sid_str);
1120
1121 return true;
1122 }
1123
1124 /* Convert sid to string */
1125
1126 static bool wbinfo_lookupsid(const char *sid_str)
1127 {
1128 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1129 struct wbcDomainSid sid;
1130 char *domain;
1131 char *name;
1132 enum wbcSidType type;
1133
1134 /* Send off request */
1135
1136 wbc_status = wbcStringToSid(sid_str, &sid);
1137 if (!WBC_ERROR_IS_OK(wbc_status)) {
1138 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1139 wbcErrorString(wbc_status));
1140 return false;
1141 }
1142
1143 wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
1144 if (!WBC_ERROR_IS_OK(wbc_status)) {
1145 d_fprintf(stderr, "failed to call wbcLookupSid: %s\n",
1146 wbcErrorString(wbc_status));
1147 return false;
1148 }
1149
1150 /* Display response */
1151
1152 d_printf("%s%c%s %d\n",
1153 domain, winbind_separator(), name, type);
1154
1155 return true;
1156 }
1157
1158 /* Convert sid to fullname */
1159
1160 static bool wbinfo_lookupsid_fullname(const char *sid_str)
1161 {
1162 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1163 struct wbcDomainSid sid;
1164 char *domain;
1165 char *name;
1166 enum wbcSidType type;
1167
1168 /* Send off request */
1169
1170 wbc_status = wbcStringToSid(sid_str, &sid);
1171 if (!WBC_ERROR_IS_OK(wbc_status)) {
1172 d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
1173 wbcErrorString(wbc_status));
1174 return false;
1175 }
1176
1177 wbc_status = wbcGetDisplayName(&sid, &domain, &name, &type);
1178 if (!WBC_ERROR_IS_OK(wbc_status)) {
1179 d_fprintf(stderr, "failed to call wbcGetDisplayName: %s\n",
1180 wbcErrorString(wbc_status));
1181 return false;
1182 }
1183
1184 /* Display response */
1185
1186 d_printf("%s%c%s %d\n",
1187 domain, winbind_separator(), name, type);
1188
1189 return true;
1190 }
1191
1192 /* Lookup a list of RIDs */
1193
1194 static bool wbinfo_lookuprids(const char *domain, const char *arg)
1195 {
1196 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1197 struct wbcDomainInfo *dinfo = NULL;
1198 char *domain_name = NULL;
1199 const char **names = NULL;
1200 enum wbcSidType *types = NULL;
1201 size_t i;
1202 int num_rids;
1203 uint32_t *rids = NULL;
1204 const char *p;
1205 char *ridstr;
1206 TALLOC_CTX *mem_ctx = NULL;
1207 bool ret = false;
1208
1209 if ((domain == NULL) || (strequal(domain, ".")) || (domain[0] == '\0')){
1210 domain = get_winbind_domain();
1211 }
1212
1213 /* Send request */
1214
1215 wbc_status = wbcDomainInfo(domain, &dinfo);
1216 if (!WBC_ERROR_IS_OK(wbc_status)) {
1217 d_printf("wbcDomainInfo(%s) failed: %s\n", domain,
1218 wbcErrorString(wbc_status));
1219 goto done;
1220 }
1221
1222 mem_ctx = talloc_new(NULL);
1223 if (mem_ctx == NULL) {
1224 d_printf("talloc_new failed\n");
1225 goto done;
1226 }
1227
1228 num_rids = 0;
1229 rids = NULL;
1230 p = arg;
1231
1232 while (next_token_talloc(mem_ctx, &p, &ridstr, " ,\n")) {
1233 uint32_t rid = strtoul(ridstr, NULL, 10);
1234 rids = talloc_realloc(mem_ctx, rids, uint32_t, num_rids + 1);
1235 if (rids == NULL) {
1236 d_printf("talloc_realloc failed\n");
1237 }
1238 rids[num_rids] = rid;
1239 num_rids += 1;
1240 }
1241
1242 if (rids == NULL) {
1243 d_printf("no rids\n");
1244 goto done;
1245 }
1246
1247 wbc_status = wbcLookupRids(&dinfo->sid, num_rids, rids,
1248 (const char **)&domain_name, &names, &types);
1249 if (!WBC_ERROR_IS_OK(wbc_status)) {
1250 d_printf("winbind_lookup_rids failed: %s\n",
1251 wbcErrorString(wbc_status));
1252 goto done;
1253 }
1254
1255 d_printf("Domain: %s\n", domain_name);
1256
1257 for (i=0; i<num_rids; i++) {
1258 d_printf("%8d: %s (%s)\n", rids[i], names[i],
1259 wbcSidTypeString(types[i]));
1260 }
1261
1262 ret = true;
1263 done:
1264 wbcFreeMemory(dinfo);
1265 wbcFreeMemory(domain_name);
1266 wbcFreeMemory(names);
1267 wbcFreeMemory(types);
1268 TALLOC_FREE(mem_ctx);
1269 return ret;
1270 }
1271
1272 /* Convert string to sid */
1273
1274 static bool wbinfo_lookupname(const char *full_name)
1275 {
1276 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1277 struct wbcDomainSid sid;
1278 char sid_str[WBC_SID_STRING_BUFLEN];
1279 enum wbcSidType type;
1280 fstring domain_name;
1281 fstring account_name;
1282
1283 /* Send off request */
1284
1285 parse_wbinfo_domain_user(full_name, domain_name,
1286 account_name);
1287
1288 wbc_status = wbcLookupName(domain_name, account_name,
1289 &sid, &type);
1290 if (!WBC_ERROR_IS_OK(wbc_status)) {
1291 d_fprintf(stderr, "failed to call wbcLookupName: %s\n",
1292 wbcErrorString(wbc_status));
1293 return false;
1294 }
1295
1296 wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
1297
1298 /* Display response */
1299
1300 d_printf("%s %s (%d)\n", sid_str, wbcSidTypeString(type), type);
1301
1302 return true;
1303 }
1304
1305 static char *wbinfo_prompt_pass(TALLOC_CTX *mem_ctx,
1306 const char *prefix,
1307 const char *username)
1308 {
1309 char *prompt;
1310 const char *ret = NULL;
1311
1312 prompt = talloc_asprintf(mem_ctx, "Enter %s's ", username);
1313 if (!prompt) {
1314 return NULL;
1315 }
1316 if (prefix) {
1317 prompt = talloc_asprintf_append(prompt, "%s ", prefix);
1318 if (!prompt) {
1319 return NULL;
1320 }
1321 }
1322 prompt = talloc_asprintf_append(prompt, "password: ");
1323 if (!prompt) {
1324 return NULL;
1325 }
1326
1327 ret = getpass(prompt);
1328 TALLOC_FREE(prompt);
1329
1330 return talloc_strdup(mem_ctx, ret);
1331 }
1332
1333 /* Authenticate a user with a plaintext password */
1334
1335 static bool wbinfo_auth_krb5(char *username, const char *cctype, uint32_t flags)
1336 {
1337 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1338 char *s = NULL;
1339 char *p = NULL;
1340 char *password = NULL;
1341 char *name = NULL;
1342 char *local_cctype = NULL;
1343 uid_t uid;
1344 struct wbcLogonUserParams params;
1345 struct wbcLogonUserInfo *info;
1346 struct wbcAuthErrorInfo *error;
1347 struct wbcUserPasswordPolicyInfo *policy;
1348 TALLOC_CTX *frame = talloc_tos();
1349
1350 if ((s = talloc_strdup(frame, username)) == NULL) {
1351 return false;
1352 }
1353
1354 if ((p = strchr(s, '%')) != NULL) {
1355 *p = 0;
1356 p++;
1357 password = talloc_strdup(frame, p);
1358 } else {
1359 password = wbinfo_prompt_pass(frame, NULL, username);
1360 }
1361
1362 local_cctype = talloc_strdup(frame, cctype);
1363
1364 name = s;
1365
1366 uid = geteuid();
1367
1368 params.username = name;
1369 params.password = password;
1370 params.num_blobs = 0;
1371 params.blobs = NULL;
1372
1373 wbc_status = wbcAddNamedBlob(&params.num_blobs,
1374 &params.blobs,
1375 "flags",
1376 0,
1377 (uint8_t *)&flags,
1378 sizeof(flags));
1379 if (!WBC_ERROR_IS_OK(wbc_status)) {
1380 d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
1381 wbcErrorString(wbc_status));
1382 goto done;
1383 }
1384
1385 wbc_status = wbcAddNamedBlob(&params.num_blobs,
1386 &params.blobs,
1387 "user_uid",
1388 0,
1389 (uint8_t *)&uid,
1390 sizeof(uid));
1391 if (!WBC_ERROR_IS_OK(wbc_status)) {
1392 d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
1393 wbcErrorString(wbc_status));
1394 goto done;
1395 }
1396
1397 wbc_status = wbcAddNamedBlob(&params.num_blobs,
1398 &params.blobs,
1399 "krb5_cc_type",
1400 0,
1401 (uint8_t *)local_cctype,
1402 strlen(cctype)+1);
1403 if (!WBC_ERROR_IS_OK(wbc_status)) {
1404 d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
1405 wbcErrorString(wbc_status));
1406 goto done;
1407 }
1408
1409 wbc_status = wbcLogonUser(&params, &info, &error, &policy);
1410
1411 d_printf("plaintext kerberos password authentication for [%s] %s "
1412 "(requesting cctype: %s)\n",
1413 username, WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed",
1414 cctype);
1415
1416 if (error) {
1417 d_fprintf(stderr,
1418 "error code was %s (0x%x)\nerror message was: %s\n",
1419 error->nt_string,
1420 error->nt_status,
1421 error->display_string);
1422 }
1423
1424 if (WBC_ERROR_IS_OK(wbc_status)) {
1425 if (flags & WBFLAG_PAM_INFO3_TEXT) {
1426 if (info && info->info && info->info->user_flags &
1427 NETLOGON_CACHED_ACCOUNT) {
1428 d_printf("user_flgs: "
1429 "NETLOGON_CACHED_ACCOUNT\n");
1430 }
1431 }
1432
1433 if (info) {
1434 int i;
1435 for (i=0; i < info->num_blobs; i++) {
1436 if (strequal(info->blobs[i].name,
1437 "krb5ccname")) {
1438 d_printf("credentials were put "
1439 "in: %s\n",
1440 (const char *)
1441 info->blobs[i].blob.data);
1442 break;
1443 }
1444 }
1445 } else {
1446 d_printf("no credentials cached\n");
1447 }
1448 }
1449 done:
1450
1451 wbcFreeMemory(params.blobs);
1452
1453 return WBC_ERROR_IS_OK(wbc_status);
1454 }
1455
1456 /* Authenticate a user with a plaintext password */
1457
1458 static bool wbinfo_auth(char *username)
1459 {
1460 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1461 char *s = NULL;
1462 char *p = NULL;
1463 char *password = NULL;
1464 char *name = NULL;
1465 TALLOC_CTX *frame = talloc_tos();
1466
1467 if ((s = talloc_strdup(frame, username)) == NULL) {
1468 return false;
1469 }
1470
1471 if ((p = strchr(s, '%')) != NULL) {
1472 *p = 0;
1473 p++;
1474 password = talloc_strdup(frame, p);
1475 } else {
1476 password = wbinfo_prompt_pass(frame, NULL, username);
1477 }
1478
1479 name = s;
1480
1481 wbc_status = wbcAuthenticateUser(name, password);
1482
1483 d_printf("plaintext password authentication %s\n",
1484 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1485
1486 #if 0
1487 if (response.data.auth.nt_status)
1488 d_fprintf(stderr,
1489 "error code was %s (0x%x)\nerror message was: %s\n",
1490 response.data.auth.nt_status_string,
1491 response.data.auth.nt_status,
1492 response.data.auth.error_string);
1493 #endif
1494
1495 return WBC_ERROR_IS_OK(wbc_status);
1496 }
1497
1498 /* Authenticate a user with a challenge/response */
1499
1500 static bool wbinfo_auth_crap(char *username, bool use_ntlmv2, bool use_lanman)
1501 {
1502 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1503 struct wbcAuthUserParams params;
1504 struct wbcAuthUserInfo *info = NULL;
1505 struct wbcAuthErrorInfo *err = NULL;
1506 DATA_BLOB lm = data_blob_null;
1507 DATA_BLOB nt = data_blob_null;
1508 fstring name_user;
1509 fstring name_domain;
1510 char *pass;
1511 char *p;
1512 TALLOC_CTX *frame = talloc_tos();
1513
1514 p = strchr(username, '%');
1515
1516 if (p) {
1517 *p = 0;
1518 pass = talloc_strdup(frame, p + 1);
1519 } else {
1520 pass = wbinfo_prompt_pass(frame, NULL, username);
1521 }
1522
1523 parse_wbinfo_domain_user(username, name_domain, name_user);
1524
1525 params.account_name = name_user;
1526 params.domain_name = name_domain;
1527 params.workstation_name = NULL;
1528
1529 params.flags = 0;
1530 params.parameter_control= WBC_MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT |
1531 WBC_MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT;
1532
1533 params.level = WBC_AUTH_USER_LEVEL_RESPONSE;
1534
1535 generate_random_buffer(params.password.response.challenge, 8);
1536
1537 if (use_ntlmv2) {
1538 DATA_BLOB server_chal;
1539 DATA_BLOB names_blob;
1540
1541 server_chal = data_blob(params.password.response.challenge, 8);
1542
1543 /* Pretend this is a login to 'us', for blob purposes */
1544 names_blob = NTLMv2_generate_names_blob(NULL,
1545 get_winbind_netbios_name(),
1546 get_winbind_domain());
1547
1548 if (!SMBNTLMv2encrypt(NULL, name_user, name_domain, pass,
1549 &server_chal,
1550 &names_blob,
1551 &lm, &nt, NULL, NULL)) {
1552 data_blob_free(&names_blob);
1553 data_blob_free(&server_chal);
1554 TALLOC_FREE(pass);
1555 return false;
1556 }
1557 data_blob_free(&names_blob);
1558 data_blob_free(&server_chal);
1559
1560 } else {
1561 if (use_lanman) {
1562 bool ok;
1563 lm = data_blob(NULL, 24);
1564 ok = SMBencrypt(pass,
1565 params.password.response.challenge,
1566 lm.data);
1567 if (!ok) {
1568 data_blob_free(&lm);
1569 }
1570 }
1571 nt = data_blob(NULL, 24);
1572 SMBNTencrypt(pass, params.password.response.challenge,
1573 nt.data);
1574 }
1575
1576 params.password.response.nt_length = nt.length;
1577 params.password.response.nt_data = nt.data;
1578 params.password.response.lm_length = lm.length;
1579 params.password.response.lm_data = lm.data;
1580
1581 wbc_status = wbcAuthenticateUserEx(&params, &info, &err);
1582
1583 /* Display response */
1584
1585 d_printf("challenge/response password authentication %s\n",
1586 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1587
1588 if (wbc_status == WBC_ERR_AUTH_ERROR) {
1589 d_fprintf(stderr,
1590 "error code was %s (0x%x)\nerror message was: %s\n",
1591 err->nt_string,
1592 err->nt_status,
1593 err->display_string);
1594 wbcFreeMemory(err);
1595 } else if (WBC_ERROR_IS_OK(wbc_status)) {
1596 wbcFreeMemory(info);
1597 }
1598
1599 data_blob_free(&nt);
1600 data_blob_free(&lm);
1601
1602 return WBC_ERROR_IS_OK(wbc_status);
1603 }
1604
1605 /* Authenticate a user with a plaintext password */
1606
1607 static bool wbinfo_pam_logon(char *username)
1608 {
1609 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1610 struct wbcLogonUserParams params;
1611 struct wbcAuthErrorInfo *error;
1612 char *s = NULL;
1613 char *p = NULL;
1614 TALLOC_CTX *frame = talloc_tos();
1615 uint32_t flags;
1616 uint32_t uid;
1617
1618 ZERO_STRUCT(params);
1619
1620 if ((s = talloc_strdup(frame, username)) == NULL) {
1621 return false;
1622 }
1623
1624 if ((p = strchr(s, '%')) != NULL) {
1625 *p = 0;
1626 p++;
1627 params.password = talloc_strdup(frame, p);
1628 } else {
1629 params.password = wbinfo_prompt_pass(frame, NULL, username);
1630 }
1631 params.username = s;
1632
1633 flags = WBFLAG_PAM_CACHED_LOGIN;
1634
1635 wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
1636 "flags", 0,
1637 (uint8_t *)&flags, sizeof(flags));
1638 if (!WBC_ERROR_IS_OK(wbc_status)) {
1639 d_printf("wbcAddNamedBlob failed: %s\n",
1640 wbcErrorString(wbc_status));
1641 return false;
1642 }
1643
1644 uid = getuid();
1645
1646 wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
1647 "user_uid", 0,
1648 (uint8_t *)&uid, sizeof(uid));
1649 if (!WBC_ERROR_IS_OK(wbc_status)) {
1650 d_printf("wbcAddNamedBlob failed: %s\n",
1651 wbcErrorString(wbc_status));
1652 return false;
1653 }
1654
1655 wbc_status = wbcLogonUser(&params, NULL, &error, NULL);
1656
1657 wbcFreeMemory(params.blobs);
1658
1659 d_printf("plaintext password authentication %s\n",
1660 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1661
1662 if (!WBC_ERROR_IS_OK(wbc_status)) {
1663 d_fprintf(stderr,
1664 "error code was %s (0x%x)\nerror message was: %s\n",
1665 error->nt_string,
1666 (int)error->nt_status,
1667 error->display_string);
1668 wbcFreeMemory(error);
1669 return false;
1670 }
1671 return true;
1672 }
1673
1674 /* Save creds with winbind */
1675
1676 static bool wbinfo_ccache_save(char *username)
1677 {
1678 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1679 char *s = NULL;
1680 char *p = NULL;
1681 char *password = NULL;
1682 char *name = NULL;
1683 TALLOC_CTX *frame = talloc_stackframe();
1684
1685 s = talloc_strdup(frame, username);
1686 if (s == NULL) {
1687 return false;
1688 }
1689
1690 p = strchr(s, '%');
1691 if (p != NULL) {
1692 *p = 0;
1693 p++;
1694 password = talloc_strdup(frame, p);
1695 } else {
1696 password = wbinfo_prompt_pass(frame, NULL, username);
1697 }
1698
1699 name = s;
1700
1701 wbc_status = wbcCredentialSave(name, password);
1702
1703 d_printf("saving creds %s\n",
1704 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1705
1706 TALLOC_FREE(frame);
1707
1708 return WBC_ERROR_IS_OK(wbc_status);
1709 }
1710
1711 #ifdef WITH_FAKE_KASERVER
1712 /* Authenticate a user with a plaintext password and set a token */
1713
1714 static bool wbinfo_klog(char *username)
1715 {
1716 struct winbindd_request request;
1717 struct winbindd_response response;
1718 NSS_STATUS result;
1719 char *p;
1720
1721 /* Send off request */
1722
1723 ZERO_STRUCT(request);
1724 ZERO_STRUCT(response);
1725
1726 p = strchr(username, '%');
1727
1728 if (p) {
1729 *p = 0;
1730 fstrcpy(request.data.auth.user, username);
1731 fstrcpy(request.data.auth.pass, p + 1);
1732 *p = '%';
1733 } else {
1734 fstrcpy(request.data.auth.user, username);
1735 fstrcpy(request.data.auth.pass, getpass("Password: "));
1736 }
1737
1738 request.flags |= WBFLAG_PAM_AFS_TOKEN;
1739
1740 result = winbindd_request_response(WINBINDD_PAM_AUTH, &request,
1741 &response);
1742
1743 /* Display response */
1744
1745 d_printf("plaintext password authentication %s\n",
1746 (result == NSS_STATUS_SUCCESS) ? "succeeded" : "failed");
1747
1748 if (response.data.auth.nt_status)
1749 d_fprintf(stderr,
1750 "error code was %s (0x%x)\nerror message was: %s\n",
1751 response.data.auth.nt_status_string,
1752 response.data.auth.nt_status,
1753 response.data.auth.error_string);
1754
1755 if (result != NSS_STATUS_SUCCESS)
1756 return false;
1757
1758 if (response.extra_data.data == NULL) {
1759 d_fprintf(stderr, "Did not get token data\n");
1760 return false;
1761 }
1762
1763 if (!afs_settoken_str((char *)response.extra_data.data)) {
1764 d_fprintf(stderr, "Could not set token\n");
1765 return false;
1766 }
1767
1768 d_printf("Successfully created AFS token\n");
1769 return true;
1770 }
1771 #else
1772 static bool wbinfo_klog(char *username)
1773 {
1774 d_fprintf(stderr, "No AFS support compiled in.\n");
1775 return false;
1776 }
1777 #endif
1778
1779 /* Print domain users */
1780
1781 static bool print_domain_users(const char *domain)
1782 {
1783 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1784 uint32_t i;
1785 uint32_t num_users = 0;
1786 const char **users = NULL;
1787
1788 /* Send request to winbind daemon */
1789
1790 /* '.' is the special sign for our own domain */
1791 if (domain && strcmp(domain, ".") == 0) {
1792 domain = get_winbind_domain();
1793 }
1794
1795 wbc_status = wbcListUsers(domain, &num_users, &users);
1796 if (!WBC_ERROR_IS_OK(wbc_status)) {
1797 return false;
1798 }
1799
1800 for (i=0; i < num_users; i++) {
1801 d_printf("%s\n", users[i]);
1802 }
1803
1804 wbcFreeMemory(users);
1805
1806 return true;
1807 }
1808
1809 /* Print domain groups */
1810
1811 static bool print_domain_groups(const char *domain)
1812 {
1813 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
1814 uint32_t i;
1815 uint32_t num_groups = 0;
1816 const char **groups = NULL;
1817
1818 /* Send request to winbind daemon */
1819
1820 /* '.' is the special sign for our own domain */
1821 if (domain && strcmp(domain, ".") == 0) {
1822 domain = get_winbind_domain();
1823 }
1824
1825 wbc_status = wbcListGroups(domain, &num_groups, &groups);
1826 if (!WBC_ERROR_IS_OK(wbc_status)) {
1827 d_fprintf(stderr, "failed to call wbcListGroups: %s\n",
1828 wbcErrorString(wbc_status));
1829 return false;
1830 }
1831
1832 for (i=0; i < num_groups; i++) {
1833 d_printf("%s\n", groups[i]);
1834 }
1835
1836 wbcFreeMemory(groups);
1837
1838 return true;
1839 }
1840
1841 /* Set the authorised user for winbindd access in secrets.tdb */
1842
1843 static bool wbinfo_set_auth_user(char *username)
1844 {
1845 d_fprintf(stderr, "This functionality was moved to the 'net' utility.\n"
1846 "See 'net help setauthuser' for details.\n");
1847 return false;
1848 }
1849
1850 static void wbinfo_get_auth_user(void)
1851 {
1852 d_fprintf(stderr, "This functionality was moved to the 'net' utility.\n"
1853 "See 'net help getauthuser' for details.\n");
1854 }
1855
1856 static bool wbinfo_ping(void)
1857 {
1858 wbcErr wbc_status;
1859
1860 wbc_status = wbcPing();
1861
1862 /* Display response */
1863
1864 d_printf("Ping to winbindd %s\n",
1865 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1866
1867 return WBC_ERROR_IS_OK(wbc_status);
1868 }
1869
1870 static bool wbinfo_change_user_password(const char *username)
1871 {
1872 wbcErr wbc_status;
1873 char *old_password = NULL;
1874 char *new_password = NULL;
1875 TALLOC_CTX *frame = talloc_tos();
1876
1877 old_password = wbinfo_prompt_pass(frame, "old", username);
1878 new_password = wbinfo_prompt_pass(frame, "new", username);
1879
1880 wbc_status = wbcChangeUserPassword(username, old_password,new_password);
1881
1882 /* Display response */
1883
1884 d_printf("Password change for user %s %s\n", username,
1885 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
1886
1887 return WBC_ERROR_IS_OK(wbc_status);
1888 }
1889
1890 /* Main program */
1891
1892 enum {
1893 OPT_SET_AUTH_USER = 1000,
1894 OPT_GET_AUTH_USER,
1895 OPT_DOMAIN_NAME,
1896 OPT_SEQUENCE,
1897 OPT_GETDCNAME,
1898 OPT_DSGETDCNAME,
1899 OPT_DC_INFO,
1900 OPT_USERDOMGROUPS,
1901 OPT_SIDALIASES,
1902 OPT_USERSIDS,
1903 OPT_ALLOCATE_UID,
1904 OPT_ALLOCATE_GID,
1905 OPT_SET_UID_MAPPING,
1906 OPT_SET_GID_MAPPING,
1907 OPT_REMOVE_UID_MAPPING,
1908 OPT_REMOVE_GID_MAPPING,
1909 OPT_SEPARATOR,
1910 OPT_LIST_ALL_DOMAINS,
1911 OPT_LIST_OWN_DOMAIN,
1912 OPT_UID_INFO,
1913 OPT_USER_SIDINFO,
1914 OPT_GROUP_INFO,
1915 OPT_GID_INFO,
1916 OPT_VERBOSE,
1917 OPT_ONLINESTATUS,
1918 OPT_CHANGE_USER_PASSWORD,
1919 OPT_CCACHE_SAVE,
1920 OPT_SID_TO_FULLNAME,
1921 OPT_NTLMV2,
1922 OPT_PAM_LOGON,
1923 OPT_LOGOFF,
1924 OPT_LOGOFF_USER,
1925 OPT_LOGOFF_UID,
1926 OPT_LANMAN
1927 };
1928
1929 int main(int argc, char **argv, char **envp)
1930 {
1931 int opt;
1932 TALLOC_CTX *frame = talloc_stackframe();
1933 poptContext pc;
1934 static char *string_arg;
1935 char *string_subarg = NULL;
1936 static char *opt_domain_name;
1937 static int int_arg;
1938 int int_subarg = -1;
1939 int result = 1;
1940 bool verbose = false;
1941 bool use_ntlmv2 = false;
1942 bool use_lanman = false;
1943 char *logoff_user = getenv("USER");
1944 int logoff_uid = geteuid();
1945
1946 struct poptOption long_options[] = {
1947 POPT_AUTOHELP
1948
1949 /* longName, shortName, argInfo, argPtr, value, descrip,
1950 argDesc */
1951
1952 { "domain-users", 'u', POPT_ARG_NONE, 0, 'u', "Lists all domain users", "domain"},
1953 { "domain-groups", 'g', POPT_ARG_NONE, 0, 'g', "Lists all domain groups", "domain" },
1954 { "WINS-by-name", 'N', POPT_ARG_STRING, &string_arg, 'N', "Converts NetBIOS name to IP", "NETBIOS-NAME" },
1955 { "WINS-by-ip", 'I', POPT_ARG_STRING, &string_arg, 'I', "Converts IP address to NetBIOS name", "IP" },
1956 { "name-to-sid", 'n', POPT_ARG_STRING, &string_arg, 'n', "Converts name to sid", "NAME" },
1957 { "sid-to-name", 's', POPT_ARG_STRING, &string_arg, 's', "Converts sid to name", "SID" },
1958 { "sid-to-fullname", 0, POPT_ARG_STRING, &string_arg,
1959 OPT_SID_TO_FULLNAME, "Converts sid to fullname", "SID" },
1960 { "lookup-rids", 'R', POPT_ARG_STRING, &string_arg, 'R', "Converts RIDs to names", "RIDs" },
1961 { "uid-to-sid", 'U', POPT_ARG_INT, &int_arg, 'U', "Converts uid to sid" , "UID" },
1962 { "gid-to-sid", 'G', POPT_ARG_INT, &int_arg, 'G', "Converts gid to sid", "GID" },
1963 { "sid-to-uid", 'S', POPT_ARG_STRING, &string_arg, 'S', "Converts sid to uid", "SID" },
1964 { "sid-to-gid", 'Y', POPT_ARG_STRING, &string_arg, 'Y', "Converts sid to gid", "SID" },
1965 { "allocate-uid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_UID,
1966 "Get a new UID out of idmap" },
1967 { "allocate-gid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_GID,
1968 "Get a new GID out of idmap" },
1969 { "set-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_UID_MAPPING, "Create or modify uid to sid mapping in idmap", "UID,SID" },
1970 { "set-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_GID_MAPPING, "Create or modify gid to sid mapping in idmap", "GID,SID" },
1971 { "remove-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_UID_MAPPING, "Remove uid to sid mapping in idmap", "UID,SID" },
1972 { "remove-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_GID_MAPPING, "Remove gid to sid mapping in idmap", "GID,SID" },
1973 { "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
1974 { "change-secret", 'c', POPT_ARG_NONE, 0, 'c', "Change shared secret" },
1975 { "ping-dc", 'P', POPT_ARG_NONE, 0, 'P',
1976 "Check the NETLOGON connection" },
1977 { "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
1978 { "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
1979 { "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
1980 { "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Deprecated command, see --online-status" },
1981 { "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
1982 { "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
1983 { "user-info", 'i', POPT_ARG_STRING, &string_arg, 'i', "Get user info", "USER" },
1984 { "uid-info", 0, POPT_ARG_INT, &int_arg, OPT_UID_INFO, "Get user info from uid", "UID" },
1985 { "group-info", 0, POPT_ARG_STRING, &string_arg, OPT_GROUP_INFO, "Get group info", "GROUP" },
1986 { "user-sidinfo", 0, POPT_ARG_STRING, &string_arg, OPT_USER_SIDINFO, "Get user info from sid", "SID" },
1987 { "gid-info", 0, POPT_ARG_INT, &int_arg, OPT_GID_INFO, "Get group info from gid", "GID" },
1988 { "user-groups", 'r', POPT_ARG_STRING, &string_arg, 'r', "Get user groups", "USER" },
1989 { "user-domgroups", 0, POPT_ARG_STRING, &string_arg,
1990 OPT_USERDOMGROUPS, "Get user domain groups", "SID" },
1991 { "sid-aliases", 0, POPT_ARG_STRING, &string_arg, OPT_SIDALIASES, "Get sid aliases", "SID" },
1992 { "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
1993 { "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
1994 { "pam-logon", 0, POPT_ARG_STRING, &string_arg, OPT_PAM_LOGON,
1995 "do a pam logon equivalent", "user%password" },
1996 { "logoff", 0, POPT_ARG_NONE, NULL, OPT_LOGOFF,
1997 "log off user", "uid" },
1998 { "logoff-user", 0, POPT_ARG_STRING, &logoff_user,
1999 OPT_LOGOFF_USER, "username to log off" },
2000 { "logoff-uid", 0, POPT_ARG_INT, &logoff_uid,
2001 OPT_LOGOFF_UID, "uid to log off" },
2002 { "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
2003 { "ccache-save", 0, POPT_ARG_STRING, &string_arg,
2004 OPT_CCACHE_SAVE, "Store user and password for ccache "
2005 "operation", "user%password" },
2006 { "getdcname", 0, POPT_ARG_STRING, &string_arg, OPT_GETDCNAME,
2007 "Get a DC name for a foreign domain", "domainname" },
2008 { "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
2009 { "dc-info", 0, POPT_ARG_STRING, &string_arg, OPT_DC_INFO,
2010 "Find the currently known DCs", "domainname" },
2011 { "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
2012 { "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
2013 { "domain", 0, POPT_ARG_STRING, &opt_domain_name, OPT_DOMAIN_NAME, "Define to the domain to restrict operation", "domain" },
2014 #ifdef WITH_FAKE_KASERVER
2015 { "klog", 'k', POPT_ARG_STRING, &string_arg, 'k', "set an AFS token from winbind", "user%password" },
2016 #endif
2017 #ifdef HAVE_KRB5
2018 { "krb5auth", 'K', POPT_ARG_STRING, &string_arg, 'K', "authenticate user using Kerberos", "user%password" },
2019 /* destroys wbinfo --help output */
2020 /* "user%password,DOM\\user%password,user@EXAMPLE.COM,EXAMPLE.COM\\user%password" }, */
2021 #endif
2022 { "separator", 0, POPT_ARG_NONE, 0, OPT_SEPARATOR, "Get the active winbind separator", NULL },
2023 { "verbose", 0, POPT_ARG_NONE, 0, OPT_VERBOSE, "Print additional information per command", NULL },
2024 { "change-user-password", 0, POPT_ARG_STRING, &string_arg, OPT_CHANGE_USER_PASSWORD, "Change the password for a user", NULL },
2025 { "ntlmv2", 0, POPT_ARG_NONE, 0, OPT_NTLMV2, "Use NTLMv2 cryptography for user authentication", NULL},
2026 { "lanman", 0, POPT_ARG_NONE, 0, OPT_LANMAN, "Use lanman cryptography for user authentication", NULL},
2027 POPT_COMMON_VERSION
2028 POPT_TABLEEND
2029 };
2030
2031 /* Samba client initialisation */
2032 load_case_tables();
2033
2034
2035 /* Parse options */
2036
2037 pc = poptGetContext("wbinfo", argc, (const char **)argv,
2038 long_options, 0);
2039
2040 /* Parse command line options */
2041
2042 if (argc == 1) {
2043 poptPrintHelp(pc, stderr, 0);
2044 return 1;
2045 }
2046
2047 while((opt = poptGetNextOpt(pc)) != -1) {
2048 /* get the generic configuration parameters like --domain */
2049 switch (opt) {
2050 case OPT_VERBOSE:
2051 verbose = true;
2052 break;
2053 case OPT_NTLMV2:
2054 use_ntlmv2 = true;
2055 break;
2056 case OPT_LANMAN:
2057 use_lanman = true;
2058 break;
2059 }
2060 }
2061
2062 poptFreeContext(pc);
2063
2064 pc = poptGetContext(NULL, argc, (const char **)argv, long_options,
2065 POPT_CONTEXT_KEEP_FIRST);
2066
2067 while((opt = poptGetNextOpt(pc)) != -1) {
2068 switch (opt) {
2069 case 'u':
2070 if (!print_domain_users(opt_domain_name)) {
2071 d_fprintf(stderr,
2072 "Error looking up domain users\n");
2073 goto done;
2074 }
2075 break;
2076 case 'g':
2077 if (!print_domain_groups(opt_domain_name)) {
2078 d_fprintf(stderr,
2079 "Error looking up domain groups\n");
2080 goto done;
2081 }
2082 break;
2083 case 's':
2084 if (!wbinfo_lookupsid(string_arg)) {
2085 d_fprintf(stderr,
2086 "Could not lookup sid %s\n",
2087 string_arg);
2088 goto done;
2089 }
2090 break;
2091 case OPT_SID_TO_FULLNAME:
2092 if (!wbinfo_lookupsid_fullname(string_arg)) {
2093 d_fprintf(stderr, "Could not lookup sid %s\n",
2094 string_arg);
2095 goto done;
2096 }
2097 break;
2098 case 'R':
2099 if (!wbinfo_lookuprids(opt_domain_name, string_arg)) {
2100 d_fprintf(stderr, "Could not lookup RIDs %s\n",
2101 string_arg);
2102 goto done;
2103 }
2104 break;
2105 case 'n':
2106 if (!wbinfo_lookupname(string_arg)) {
2107 d_fprintf(stderr, "Could not lookup name %s\n",
2108 string_arg);
2109 goto done;
2110 }
2111 break;
2112 case 'N':
2113 if (!wbinfo_wins_byname(string_arg)) {
2114 d_fprintf(stderr,
2115 "Could not lookup WINS by name %s\n",
2116 string_arg);
2117 goto done;
2118 }
2119 break;
2120 case 'I':
2121 if (!wbinfo_wins_byip(string_arg)) {
2122 d_fprintf(stderr,
2123 "Could not lookup WINS by IP %s\n",
2124 string_arg);
2125 goto done;
2126 }
2127 break;
2128 case 'U':
2129 if (!wbinfo_uid_to_sid(int_arg)) {
2130 d_fprintf(stderr,
2131 "Could not convert uid %d to sid\n",
2132 int_arg);
2133 goto done;
2134 }
2135 break;
2136 case 'G':
2137 if (!wbinfo_gid_to_sid(int_arg)) {
2138 d_fprintf(stderr,
2139 "Could not convert gid %d to sid\n",
2140 int_arg);
2141 goto done;
2142 }
2143 break;
2144 case 'S':
2145 if (!wbinfo_sid_to_uid(string_arg)) {
2146 d_fprintf(stderr,
2147 "Could not convert sid %s to uid\n",
2148 string_arg);
2149 goto done;
2150 }
2151 break;
2152 case 'Y':
2153 if (!wbinfo_sid_to_gid(string_arg)) {
2154 d_fprintf(stderr,
2155 "Could not convert sid %s to gid\n",
2156 string_arg);
2157 goto done;
2158 }
2159 break;
2160 case OPT_ALLOCATE_UID:
2161 if (!wbinfo_allocate_uid()) {
2162 d_fprintf(stderr, "Could not allocate a uid\n");
2163 goto done;
2164 }
2165 break;
2166 case OPT_ALLOCATE_GID:
2167 if (!wbinfo_allocate_gid()) {
2168 d_fprintf(stderr, "Could not allocate a gid\n");
2169 goto done;
2170 }
2171 break;
2172 case OPT_SET_UID_MAPPING:
2173 if (!parse_mapping_arg(string_arg, &int_subarg,
2174 &string_subarg) ||
2175 !wbinfo_set_uid_mapping(int_subarg, string_subarg))
2176 {
2177 d_fprintf(stderr, "Could not create or modify "
2178 "uid to sid mapping\n");
2179 goto done;
2180 }
2181 break;
2182 case OPT_SET_GID_MAPPING:
2183 if (!parse_mapping_arg(string_arg, &int_subarg,
2184 &string_subarg) ||
2185 !wbinfo_set_gid_mapping(int_subarg, string_subarg))
2186 {
2187 d_fprintf(stderr, "Could not create or modify "
2188 "gid to sid mapping\n");
2189 goto done;
2190 }
2191 break;
2192 case OPT_REMOVE_UID_MAPPING:
2193 if (!parse_mapping_arg(string_arg, &int_subarg,
2194 &string_subarg) ||
2195 !wbinfo_remove_uid_mapping(int_subarg,
2196 string_subarg))
2197 {
2198 d_fprintf(stderr, "Could not remove uid to sid "
2199 "mapping\n");
2200 goto done;
2201 }
2202 break;
2203 case OPT_REMOVE_GID_MAPPING:
2204 if (!parse_mapping_arg(string_arg, &int_subarg,
2205 &string_subarg) ||
2206 !wbinfo_remove_gid_mapping(int_subarg,
2207 string_subarg))
2208 {
2209 d_fprintf(stderr, "Could not remove gid to sid "
2210 "mapping\n");
2211 goto done;
2212 }
2213 break;
2214 case 't':
2215 if (!wbinfo_check_secret(opt_domain_name)) {
2216 d_fprintf(stderr, "Could not check secret\n");
2217 goto done;
2218 }
2219 break;
2220 case 'c':
2221 if (!wbinfo_change_secret(opt_domain_name)) {
2222 d_fprintf(stderr, "Could not change secret\n");
2223 goto done;
2224 }
2225 break;
2226 case 'P':
2227 if (!wbinfo_ping_dc()) {
2228 d_fprintf(stderr, "Could not ping our DC\n");
2229 goto done;
2230 }
2231 break;
2232 case 'm':
2233 if (!wbinfo_list_domains(false, verbose)) {
2234 d_fprintf(stderr,
2235 "Could not list trusted domains\n");
2236 goto done;
2237 }
2238 break;
2239 case OPT_SEQUENCE:
2240 if (!wbinfo_show_sequence(opt_domain_name)) {
2241 d_fprintf(stderr,
2242 "Could not show sequence numbers\n");
2243 goto done;
2244 }
2245 break;
2246 case OPT_ONLINESTATUS:
2247 if (!wbinfo_show_onlinestatus(opt_domain_name)) {
2248 d_fprintf(stderr,
2249 "Could not show online-status\n");
2250 goto done;
2251 }
2252 break;
2253 case 'D':
2254 if (!wbinfo_domain_info(string_arg)) {
2255 d_fprintf(stderr,
2256 "Could not get domain info\n");
2257 goto done;
2258 }
2259 break;
2260 case 'i':
2261 if (!wbinfo_get_userinfo(string_arg)) {
2262 d_fprintf(stderr,
2263 "Could not get info for user %s\n",
2264 string_arg);
2265 goto done;
2266 }
2267 break;
2268 case OPT_USER_SIDINFO:
2269 if ( !wbinfo_get_user_sidinfo(string_arg)) {
2270 d_fprintf(stderr,
2271 "Could not get info for user "
2272 "sid %s\n", string_arg);
2273 goto done;
2274 }
2275 break;
2276 case OPT_UID_INFO:
2277 if ( !wbinfo_get_uidinfo(int_arg)) {
2278 d_fprintf(stderr, "Could not get info for uid "
2279 "%d\n", int_arg);
2280 goto done;
2281 }
2282 break;
2283 case OPT_GROUP_INFO:
2284 if ( !wbinfo_get_groupinfo(string_arg)) {
2285 d_fprintf(stderr, "Could not get info for "
2286 "group %s\n", string_arg);
2287 goto done;
2288 }
2289 break;
2290 case OPT_GID_INFO:
2291 if ( !wbinfo_get_gidinfo(int_arg)) {
2292 d_fprintf(stderr, "Could not get info for gid "
2293 "%d\n", int_arg);
2294 goto done;
2295 }
2296 break;
2297 case 'r':
2298 if (!wbinfo_get_usergroups(string_arg)) {
2299 d_fprintf(stderr,
2300 "Could not get groups for user %s\n",
2301 string_arg);
2302 goto done;
2303 }
2304 break;
2305 case OPT_USERSIDS:
2306 if (!wbinfo_get_usersids(string_arg)) {
2307 d_fprintf(stderr, "Could not get group SIDs "
2308 "for user SID %s\n",
2309 string_arg);
2310 goto done;
2311 }
2312 break;
2313 case OPT_USERDOMGROUPS:
2314 if (!wbinfo_get_userdomgroups(string_arg)) {
2315 d_fprintf(stderr, "Could not get user's domain "
2316 "groups for user SID %s\n",
2317 string_arg);
2318 goto done;
2319 }
2320 break;
2321 case OPT_SIDALIASES:
2322 if (!wbinfo_get_sidaliases(opt_domain_name,
2323 string_arg)) {
2324 d_fprintf(stderr, "Could not get sid aliases "
2325 "for user SID %s\n", string_arg);
2326 goto done;
2327 }
2328 break;
2329 case 'a': {
2330 bool got_error = false;
2331
2332 if (!wbinfo_auth(string_arg)) {
2333 d_fprintf(stderr,
2334 "Could not authenticate user "
2335 "%s with plaintext "
2336 "password\n", string_arg);
2337 got_error = true;
2338 }
2339
2340 if (!wbinfo_auth_crap(string_arg, use_ntlmv2,
2341 use_lanman)) {
2342 d_fprintf(stderr,
2343 "Could not authenticate user "
2344 "%s with challenge/response\n",
2345 string_arg);
2346 got_error = true;
2347 }
2348
2349 if (got_error)
2350 goto done;
2351 break;
2352 }
2353 case OPT_PAM_LOGON:
2354 if (!wbinfo_pam_logon(string_arg)) {
2355 d_fprintf(stderr, "pam_logon failed for %s\n",
2356 string_arg);
2357 goto done;
2358 }
2359 break;
2360 case OPT_LOGOFF:
2361 {
2362 wbcErr wbc_status;
2363
2364 wbc_status = wbcLogoffUser(logoff_user, logoff_uid,
2365 "");
2366 d_printf("Logoff %s (%d): %s\n", logoff_user,
2367 logoff_uid, wbcErrorString(wbc_status));
2368 break;
2369 }
2370 case 'K': {
2371 uint32_t flags = WBFLAG_PAM_KRB5 |
2372 WBFLAG_PAM_CACHED_LOGIN |
2373 WBFLAG_PAM_FALLBACK_AFTER_KRB5 |
2374 WBFLAG_PAM_INFO3_TEXT |
2375 WBFLAG_PAM_CONTACT_TRUSTDOM;
2376
2377 if (!wbinfo_auth_krb5(string_arg, "FILE",
2378 flags)) {
2379 d_fprintf(stderr,
2380 "Could not authenticate user "
2381 "[%s] with Kerberos "
2382 "(ccache: %s)\n", string_arg,
2383 "FILE");
2384 goto done;
2385 }
2386 break;
2387 }
2388 case 'k':
2389 if (!wbinfo_klog(string_arg)) {
2390 d_fprintf(stderr, "Could not klog user\n");
2391 goto done;
2392 }
2393 break;
2394 case 'p':
2395 if (!wbinfo_ping()) {
2396 d_fprintf(stderr, "could not ping winbindd!\n");
2397 goto done;
2398 }
2399 break;
2400 case OPT_SET_AUTH_USER:
2401 if (!wbinfo_set_auth_user(string_arg)) {
2402 goto done;
2403 }
2404 break;
2405 case OPT_GET_AUTH_USER:
2406 wbinfo_get_auth_user();
2407 goto done;
2408 break;
2409 case OPT_CCACHE_SAVE:
2410 if (!wbinfo_ccache_save(string_arg)) {
2411 goto done;
2412 }
2413 break;
2414 case OPT_GETDCNAME:
2415 if (!wbinfo_getdcname(string_arg)) {
2416 goto done;
2417 }
2418 break;
2419 case OPT_DSGETDCNAME:
2420 if (!wbinfo_dsgetdcname(string_arg, 0)) {
2421 goto done;
2422 }
2423 break;
2424 case OPT_DC_INFO:
2425 if (!wbinfo_dc_info(string_arg)) {
2426 goto done;
2427 }
2428 break;
2429 case OPT_SEPARATOR: {
2430 const char sep = winbind_separator();
2431 if ( !sep ) {
2432 goto done;
2433 }
2434 d_printf("%c\n", sep);
2435 break;
2436 }
2437 case OPT_LIST_ALL_DOMAINS:
2438 if (!wbinfo_list_domains(true, verbose)) {
2439 goto done;
2440 }
2441 break;
2442 case OPT_LIST_OWN_DOMAIN:
2443 if (!wbinfo_list_own_domain()) {
2444 goto done;
2445 }
2446 break;
2447 case OPT_CHANGE_USER_PASSWORD:
2448 if (!wbinfo_change_user_password(string_arg)) {
2449 d_fprintf(stderr,
2450 "Could not change user password "
2451 "for user %s\n", string_arg);
2452 goto done;
2453 }
2454 break;
2455
2456 /* generic configuration options */
2457 case OPT_DOMAIN_NAME:
2458 case OPT_VERBOSE:
2459 case OPT_NTLMV2:
2460 case OPT_LANMAN:
2461 case OPT_LOGOFF_USER:
2462 case OPT_LOGOFF_UID:
2463 break;
2464 default:
2465 d_fprintf(stderr, "Invalid option\n");
2466 poptPrintHelp(pc, stderr, 0);
2467 goto done;
2468 }
2469 }
2470
2471 result = 0;
2472
2473 /* Exit code */
2474
2475 done:
2476 talloc_free(frame);
2477
2478 poptFreeContext(pc);
2479 return result;
2480 }
Samba GIT mirror