nsswitch/wbinfo.c

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