winsup/utils/mkgroup.c

   1 /* mkgroup.c:
   2
   3    Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   4    2007, 2008, 2009, 2010 Red Hat, Inc.
   5
   6    This file is part of Cygwin.
   7
   8    This software is a copyrighted work licensed under the terms of the
   9    Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
  10    details. */
  11
  12 #define _WIN32_WINNT 0x0600
  13 #include <ctype.h>
  14 #include <stdlib.h>
  15 #include <wchar.h>
  16 #include <wctype.h>
  17 #include <locale.h>
  18 #include <stdio.h>
  19 #include <unistd.h>
  20 #include <getopt.h>
  21 #include <io.h>
  22 #include <sys/fcntl.h>
  23 #include <sys/cygwin.h>
  24 #include <windows.h>
  25 #include <lm.h>
  26 #include <wininet.h>
  27 #include <iptypes.h>
  28 #include <ntsecapi.h>
  29 #include <dsgetdc.h>
  30 #include <ntdef.h>
  31 #include "loadlib.h"
  32
  33 #define print_win_error(x) _print_win_error(x, __LINE__)
  34
  35 #define MAX_SID_LEN 40
  36
  37 static const char version[] = "$Revision$";
  38
  39 extern char *__progname __declspec(dllimport);
  40
  41 SID_IDENTIFIER_AUTHORITY sid_world_auth = {SECURITY_WORLD_SID_AUTHORITY};
  42 SID_IDENTIFIER_AUTHORITY sid_nt_auth = {SECURITY_NT_AUTHORITY};
  43
  44 NET_API_STATUS WINAPI (*dsgetdcname)(LPWSTR,LPWSTR,GUID*,LPWSTR,ULONG,PDOMAIN_CONTROLLER_INFOW*);
  45
  46 #ifndef min
  47 #define min(a,b) (((a)<(b))?(a):(b))
  48 #endif
  49
  50 typedef struct
  51 {
  52   char *str;
  53   DWORD id_offset;
  54   BOOL domain;
  55   BOOL with_dom;
  56 } domlist_t;
  57
  58 static void
  59 _print_win_error (DWORD code, int line)
  60 {
  61   char buf[4096];
  62
  63   if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
  64       | FORMAT_MESSAGE_IGNORE_INSERTS,
  65       NULL,
  66       code,
  67       MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
  68       (LPTSTR) buf, sizeof (buf), NULL))
  69     fprintf (stderr, "mkgroup (%d): [%lu] %s", line, code, buf);
  70   else
  71     fprintf (stderr, "mkgroup (%d): error %lu", line, code);
  72 }
  73
  74 static void
  75 load_dsgetdcname ()
  76 {
  77   HANDLE h = LoadLibrary ("netapi32.dll");
  78   if (h)
  79     dsgetdcname = (void *) GetProcAddress (h, "DsGetDcNameW");
  80 }
  81
  82 static PWCHAR
  83 get_dcname (char *domain)
  84 {
  85   static WCHAR server[INTERNET_MAX_HOST_NAME_LENGTH + 1];
  86   DWORD rc;
  87   PWCHAR servername;
  88   WCHAR domain_name[MAX_DOMAIN_NAME_LEN + 1];
  89   PDOMAIN_CONTROLLER_INFOW pdci = NULL;
  90
  91   if (dsgetdcname)
  92     {
  93       if (domain)
  94         {
  95           mbstowcs (domain_name, domain, strlen (domain) + 1);
  96           rc = dsgetdcname (NULL, domain_name, NULL, NULL, 0, &pdci);
  97         }
  98       else
  99         rc = dsgetdcname (NULL, NULL, NULL, NULL, 0, &pdci);
 100       if (rc != ERROR_SUCCESS)
 101         {
 102           print_win_error (rc);
 103           return (PWCHAR) -1;
 104         }
 105       wcscpy (server, pdci->DomainControllerName);
 106       NetApiBufferFree (pdci);
 107     }
 108   else
 109     {
 110       rc = NetGetDCName (NULL, NULL, (void *) &servername);
 111       if (rc == ERROR_SUCCESS && domain)
 112         {
 113           LPWSTR server = servername;
 114           mbstowcs (domain_name, domain, strlen (domain) + 1);
 115           rc = NetGetDCName (server, domain_name, (void *) &servername);
 116           NetApiBufferFree (server);
 117         }
 118       if (rc != ERROR_SUCCESS)
 119         {
 120           print_win_error(rc);
 121           return (PWCHAR) -1;
 122         }
 123       wcscpy (server, servername);
 124       NetApiBufferFree ((PVOID) servername);
 125     }
 126   return server;
 127 }
 128
 129 static char *
 130 put_sid (PSID psid)
 131 {
 132   static char s[512];
 133   char t[32];
 134   DWORD i;
 135
 136   strcpy (s, "S-1-");
 137   sprintf(t, "%u", GetSidIdentifierAuthority (psid)->Value[5]);
 138   strcat (s, t);
 139   for (i = 0; i < *GetSidSubAuthorityCount (psid); ++i)
 140     {
 141       sprintf(t, "-%lu", *GetSidSubAuthority (psid, i));
 142       strcat (s, t);
 143     }
 144   return s;
 145 }
 146
 147 typedef struct {
 148   BYTE  Revision;
 149   BYTE  SubAuthorityCount;
 150   SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
 151   DWORD SubAuthority[8];
 152 } DBGSID, *PDBGSID;
 153
 154 #define MAX_BUILTIN_SIDS 100    /* Should be enough for the forseable future. */
 155 DBGSID builtin_sid_list[MAX_BUILTIN_SIDS];
 156 DWORD builtin_sid_cnt;
 157
 158 typedef struct {
 159   PSID psid;
 160   int buffer[10];
 161 } sidbuf;
 162
 163 static sidbuf curr_pgrp;
 164 static BOOL got_curr_pgrp = FALSE;
 165
 166 static void
 167 fetch_current_pgrp_sid ()
 168 {
 169   DWORD len;
 170   HANDLE ptok;
 171
 172   if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &ptok)
 173       || !GetTokenInformation (ptok, TokenPrimaryGroup, &curr_pgrp,
 174                                sizeof curr_pgrp, &len)
 175       || !CloseHandle (ptok))
 176     {
 177       print_win_error (GetLastError ());
 178       return;
 179     }
 180 }
 181
 182 static void
 183 current_group (const char *sep, DWORD id_offset)
 184 {
 185   WCHAR grp[GNLEN + 1];
 186   WCHAR dom[MAX_DOMAIN_NAME_LEN + 1];
 187   DWORD glen = GNLEN + 1;
 188   DWORD dlen = MAX_DOMAIN_NAME_LEN + 1;
 189   int gid;
 190   SID_NAME_USE acc_type;
 191
 192   if (!curr_pgrp.psid
 193       || !LookupAccountSidW (NULL, curr_pgrp.psid, grp, &glen, dom, &dlen,
 194                              &acc_type))
 195     {
 196       print_win_error (GetLastError ());
 197       return;
 198     }
 199   gid = *GetSidSubAuthority (curr_pgrp.psid,
 200                              *GetSidSubAuthorityCount(curr_pgrp.psid) - 1);
 201   printf ("%ls%s%ls:%s:%lu:\n",
 202           sep ? dom : L"",
 203           sep ?: "",
 204           grp,
 205           put_sid (curr_pgrp.psid),
 206           id_offset + gid);
 207 }
 208
 209 static void
 210 enum_unix_groups (domlist_t *dom_or_machine, const char *sep, DWORD id_offset,
 211                   char *unix_grp_list)
 212 {
 213   WCHAR machine[INTERNET_MAX_HOST_NAME_LENGTH + 1];
 214   PWCHAR servername = NULL;
 215   char *d_or_m = dom_or_machine ? dom_or_machine->str : NULL;
 216   BOOL with_dom = dom_or_machine ? dom_or_machine->with_dom : FALSE;
 217   SID_IDENTIFIER_AUTHORITY auth = { { 0, 0, 0, 0, 0, 22 } };
 218   char *gstr, *grp_list;
 219   WCHAR grp[GNLEN + sizeof ("Unix Group\\") + 1];
 220   WCHAR dom[MAX_DOMAIN_NAME_LEN + 1];
 221   DWORD glen, dlen, sidlen;
 222   PSID psid;
 223   char psid_buffer[MAX_SID_LEN];
 224   SID_NAME_USE acc_type;
 225
 226   if (!d_or_m)
 227     return;
 228
 229   int ret = mbstowcs (machine, d_or_m, INTERNET_MAX_HOST_NAME_LENGTH + 1);
 230   if (ret < 1 || ret >= INTERNET_MAX_HOST_NAME_LENGTH + 1)
 231     {
 232       fprintf (stderr, "%s: Invalid machine name '%s'.  Skipping...\n",
 233                __progname, d_or_m);
 234       return;
 235     }
 236   servername = machine;
 237
 238   if (!AllocateAndInitializeSid (&auth, 2, 2, 0, 0, 0, 0, 0, 0, 0, &psid))
 239     return;
 240
 241   if (!(grp_list = strdup (unix_grp_list)))
 242     {
 243       FreeSid (psid);
 244       return;
 245     }
 246
 247   for (gstr = strtok (grp_list, ","); gstr; gstr = strtok (NULL, ","))
 248     {
 249       if (!isdigit ((unsigned char) gstr[0]) && gstr[0] != '-')
 250         {
 251           PWCHAR p = wcpcpy (grp, L"Unix Group\\");
 252           ret = mbstowcs (p, gstr, GNLEN + 1);
 253           if (ret < 1 || ret >= GNLEN + 1)
 254             fprintf (stderr, "%s: Invalid group name '%s'.  Skipping...\n",
 255                      __progname, gstr);
 256           else if (LookupAccountNameW (servername, grp,
 257                                        psid = (PSID) psid_buffer,
 258                                        (sidlen = MAX_SID_LEN, &sidlen),
 259                                        dom,
 260                                        (dlen = MAX_DOMAIN_NAME_LEN + 1, &dlen),
 261                                        &acc_type))
 262             printf ("%s%s%ls:%s:%lu:\n",
 263                     with_dom ? "Unix Group" : "",
 264                     with_dom ? sep : "",
 265                     p,
 266                     put_sid (psid),
 267                     id_offset +
 268                     *GetSidSubAuthority (psid,
 269                                          *GetSidSubAuthorityCount(psid) - 1));
 270         }
 271       else
 272         {
 273           DWORD start, stop;
 274           char *p = gstr;
 275           if (*p == '-')
 276             start = 0;
 277           else
 278             start = strtol (p, &p, 10);
 279           if (!*p)
 280             stop = start;
 281           else if (*p++ != '-' || !isdigit ((unsigned char) *p)
 282                    || (stop = strtol (p, &p, 10)) < start || *p)
 283             {
 284               fprintf (stderr, "%s: Malformed unix group list entry '%s'.  "
 285                                "Skipping...\n", __progname, gstr);
 286               continue;
 287             }
 288           for (; start <= stop; ++ start)
 289             {
 290               *GetSidSubAuthority (psid, *GetSidSubAuthorityCount(psid) - 1)
 291               = start;
 292               if (LookupAccountSidW (servername, psid,
 293                                      grp, (glen = GNLEN + 1, &glen),
 294                                      dom,
 295                                      (dlen = MAX_DOMAIN_NAME_LEN + 1, &dlen),
 296                                      &acc_type)
 297                   && !iswdigit (grp[0]))
 298                 printf ("%s%s%ls:%s:%lu:\n",
 299                         with_dom ? "Unix Group" : "",
 300                         with_dom ? sep : "",
 301                         grp,
 302                         put_sid (psid),
 303                         id_offset + start);
 304             }
 305         }
 306     }
 307
 308   free (grp_list);
 309   FreeSid (psid);
 310 }
 311
 312 static int
 313 enum_local_groups (BOOL domain, domlist_t *dom_or_machine, const char *sep,
 314                    DWORD id_offset, char *disp_groupname, int print_builtin,
 315                    int print_current)
 316 {
 317   WCHAR machine[INTERNET_MAX_HOST_NAME_LENGTH + 1];
 318   PWCHAR servername = NULL;
 319   char *d_or_m = dom_or_machine ? dom_or_machine->str : NULL;
 320   BOOL with_dom = dom_or_machine ? dom_or_machine->with_dom : FALSE;
 321   LOCALGROUP_INFO_0 *buffer;
 322   DWORD entriesread = 0;
 323   DWORD totalentries = 0;
 324   DWORD resume_handle = 0;
 325   WCHAR gname[GNLEN + 1];
 326   DWORD rc;
 327
 328   if (domain)
 329     {
 330       servername = get_dcname (d_or_m);
 331       if (servername == (PWCHAR) -1)
 332         return 1;
 333     }
 334   else if (d_or_m)
 335     {
 336       int ret = mbstowcs (machine, d_or_m, INTERNET_MAX_HOST_NAME_LENGTH + 1);
 337       if (ret < 1 || ret >= INTERNET_MAX_HOST_NAME_LENGTH + 1)
 338         {
 339           fprintf (stderr, "%s: Invalid machine name '%s'.  Skipping...\n",
 340                    __progname, d_or_m);
 341           return 1;
 342         }
 343       servername = machine;
 344     }
 345
 346   do
 347     {
 348       DWORD i;
 349
 350       if (disp_groupname)
 351         {
 352           mbstowcs (gname, disp_groupname, GNLEN + 1);
 353           rc = NetLocalGroupGetInfo (servername, gname, 0, (void *) &buffer);
 354           if (rc == ERROR_SUCCESS)
 355             entriesread = 1;
 356           /* Allow further searching for the group and avoid annoying
 357              error messages just because the group is not a local group or
 358              the group hasn't been found. */
 359           else if (rc == ERROR_NO_SUCH_ALIAS || rc == NERR_GroupNotFound)
 360             return 0;
 361         }
 362       else
 363         rc = NetLocalGroupEnum (servername, 0, (void *) &buffer,
 364                                 MAX_PREFERRED_LENGTH, &entriesread,
 365                                 &totalentries, &resume_handle);
 366       switch (rc)
 367         {
 368         case ERROR_ACCESS_DENIED:
 369           print_win_error (rc);
 370           return 1;
 371
 372         case ERROR_MORE_DATA:
 373         case ERROR_SUCCESS:
 374           break;
 375
 376         default:
 377           print_win_error (rc);
 378           return 1;
 379         }
 380
 381       for (i = 0; i < entriesread; i++)
 382         {
 383           WCHAR domain_name[MAX_DOMAIN_NAME_LEN + 1];
 384           DWORD domname_len = MAX_DOMAIN_NAME_LEN + 1;
 385           char psid_buffer[MAX_SID_LEN];
 386           PSID psid = (PSID) psid_buffer;
 387           DWORD sid_length = MAX_SID_LEN;
 388           DWORD gid;
 389           SID_NAME_USE acc_type;
 390           PDBGSID pdsid;
 391           BOOL is_builtin = FALSE;
 392
 393           if (!LookupAccountNameW (servername, buffer[i].lgrpi0_name, psid,
 394                                    &sid_length, domain_name, &domname_len,
 395                                    &acc_type))
 396             {
 397               print_win_error (GetLastError ());
 398               fprintf (stderr, " (%ls)\n", buffer[i].lgrpi0_name);
 399               continue;
 400             }
 401           else if (acc_type == SidTypeDomain)
 402             {
 403               WCHAR domname[MAX_DOMAIN_NAME_LEN + GNLEN + 2];
 404
 405               wcscpy (domname, domain_name);
 406               wcscat (domname, L"\\");
 407               wcscat (domname, buffer[i].lgrpi0_name);
 408               sid_length = MAX_SID_LEN;
 409               domname_len = MAX_DOMAIN_NAME_LEN + 1;
 410               if (!LookupAccountNameW (servername, domname,
 411                                        psid, &sid_length,
 412                                        domain_name, &domname_len,
 413                                        &acc_type))
 414                 {
 415                   print_win_error (GetLastError ());
 416                   fprintf(stderr, " (%ls)\n", domname);
 417                   continue;
 418                 }
 419             }
 420
 421           /* Store all local SIDs with prefix "S-1-5-32-" and check if it
 422              has been printed already.  This allows to get all builtin
 423              groups exactly once and not once per domain. */
 424           pdsid = (PDBGSID) psid;
 425           if (pdsid->IdentifierAuthority.Value[5] == sid_nt_auth.Value[5]
 426               && pdsid->SubAuthority[0] == SECURITY_BUILTIN_DOMAIN_RID)
 427             {
 428               int b;
 429
 430               if (!print_builtin)
 431                 goto skip_group;
 432               is_builtin = TRUE;
 433               if (builtin_sid_cnt)
 434                 for (b = 0; b < builtin_sid_cnt; b++)
 435                   if (EqualSid (&builtin_sid_list[b], psid))
 436                     goto skip_group;
 437               if (builtin_sid_cnt < MAX_BUILTIN_SIDS)
 438                 CopySid (sizeof (DBGSID), &builtin_sid_list[builtin_sid_cnt++],
 439                          psid);
 440             }
 441           if (!print_current)
 442             /* fall through */;
 443           else if (EqualSid (curr_pgrp.psid, psid))
 444             got_curr_pgrp = TRUE;
 445
 446           gid = *GetSidSubAuthority (psid, *GetSidSubAuthorityCount(psid) - 1);
 447           printf ("%ls%s%ls:%s:%ld:\n",
 448                   with_dom && !is_builtin ? domain_name : L"",
 449                   with_dom && !is_builtin ? sep : "",
 450                   buffer[i].lgrpi0_name,
 451                   put_sid (psid),
 452                   gid + (is_builtin ? 0 : id_offset));
 453 skip_group:
 454           ;
 455         }
 456
 457       NetApiBufferFree (buffer);
 458
 459     }
 460   while (rc == ERROR_MORE_DATA);
 461
 462   /* Return 1 if the single group we're looking for has been found here to
 463      avoid calling enum_groups for the same group, thus avoiding a spurious
 464      error message "group name could not be found" in enum_groups. */
 465   return disp_groupname && entriesread ? 1 : 0;
 466 }
 467
 468 static void
 469 enum_groups (BOOL domain, domlist_t *dom_or_machine, const char *sep,
 470              DWORD id_offset, char *disp_groupname, int print_current)
 471 {
 472   WCHAR machine[INTERNET_MAX_HOST_NAME_LENGTH + 1];
 473   PWCHAR servername = NULL;
 474   char *d_or_m = dom_or_machine ? dom_or_machine->str : NULL;
 475   BOOL with_dom = dom_or_machine ? dom_or_machine->with_dom : FALSE;
 476   GROUP_INFO_2 *buffer;
 477   DWORD entriesread = 0;
 478   DWORD totalentries = 0;
 479   DWORD resume_handle = 0;
 480   WCHAR gname[GNLEN + 1];
 481   DWORD rc;
 482
 483   if (domain)
 484     {
 485       servername = get_dcname (d_or_m);
 486       if (servername == (PWCHAR) -1)
 487         return;
 488     }
 489   else if (d_or_m)
 490     {
 491       int ret = mbstowcs (machine, d_or_m, INTERNET_MAX_HOST_NAME_LENGTH + 1);
 492       if (ret < 1 || ret >= INTERNET_MAX_HOST_NAME_LENGTH + 1)
 493         {
 494           fprintf (stderr, "%s: Invalid machine name '%s'.  Skipping...\n",
 495                    __progname, d_or_m);
 496           return;
 497         }
 498       servername = machine;
 499     }
 500
 501   do
 502     {
 503       DWORD i;
 504
 505       if (disp_groupname != NULL)
 506         {
 507           mbstowcs (gname, disp_groupname, GNLEN + 1);
 508           rc = NetGroupGetInfo (servername, (LPWSTR) & gname, 2,
 509                                 (void *) &buffer);
 510           entriesread=1;
 511           /* Avoid annoying error messages just because the group hasn't been
 512              found. */
 513           if (rc == NERR_GroupNotFound)
 514             return;
 515         }
 516       else
 517         rc = NetGroupEnum (servername, 2, (void *) & buffer,
 518                            MAX_PREFERRED_LENGTH, &entriesread, &totalentries,
 519                            &resume_handle);
 520       switch (rc)
 521         {
 522         case ERROR_ACCESS_DENIED:
 523           print_win_error (rc);
 524           return;
 525
 526         case ERROR_MORE_DATA:
 527         case ERROR_SUCCESS:
 528           break;
 529
 530         default:
 531           print_win_error (rc);
 532           return;
 533         }
 534
 535       for (i = 0; i < entriesread; i++)
 536         {
 537           WCHAR domain_name[MAX_DOMAIN_NAME_LEN + 1];
 538           DWORD domname_len = MAX_DOMAIN_NAME_LEN + 1;
 539           char psid_buffer[MAX_SID_LEN];
 540           PSID psid = (PSID) psid_buffer;
 541           DWORD sid_length = MAX_SID_LEN;
 542           SID_NAME_USE acc_type;
 543
 544           int gid = buffer[i].grpi2_group_id;
 545           if (!LookupAccountNameW (servername, buffer[i].grpi2_name,
 546                                    psid, &sid_length,
 547                                    domain_name, &domname_len,
 548                                    &acc_type))
 549             {
 550               print_win_error (GetLastError ());
 551               fprintf(stderr, " (%ls)\n", buffer[i].grpi2_name);
 552               continue;
 553             }
 554           else if (acc_type == SidTypeDomain)
 555             {
 556               WCHAR domname[MAX_DOMAIN_NAME_LEN + GNLEN + 2];
 557
 558               wcscpy (domname, domain || !servername
 559                                ? domain_name : servername);
 560               wcscat (domname, L"\\");
 561               wcscat (domname, buffer[i].grpi2_name);
 562               sid_length = MAX_SID_LEN;
 563               domname_len = MAX_DOMAIN_NAME_LEN + 1;
 564               if (!LookupAccountNameW (servername, domname,
 565                                        psid, &sid_length,
 566                                        domain_name, &domname_len,
 567                                        &acc_type))
 568                 {
 569                   print_win_error (GetLastError ());
 570                   fprintf(stderr, " (%ls)\n", domname);
 571                   continue;
 572                 }
 573             }
 574           if (!print_current)
 575             /* fall through */;
 576           else if (EqualSid (curr_pgrp.psid, psid))
 577             got_curr_pgrp = TRUE;
 578
 579           printf ("%ls%s%ls:%s:%lu:\n",
 580                   with_dom ? domain_name : L"",
 581                   with_dom ? sep : "",
 582                   buffer[i].grpi2_name,
 583                   put_sid (psid),
 584                   id_offset + gid);
 585         }
 586
 587       NetApiBufferFree (buffer);
 588
 589     }
 590   while (rc == ERROR_MORE_DATA);
 591 }
 592
 593 static void
 594 print_special (PSID_IDENTIFIER_AUTHORITY auth, BYTE cnt,
 595                DWORD sub1, DWORD sub2, DWORD sub3, DWORD sub4,
 596                DWORD sub5, DWORD sub6, DWORD sub7, DWORD sub8)
 597 {
 598   WCHAR grp[GNLEN + 1], dom[MAX_DOMAIN_NAME_LEN + 1];
 599   DWORD glen, dlen, rid;
 600   PSID psid;
 601   SID_NAME_USE acc_type;
 602
 603   if (AllocateAndInitializeSid (auth, cnt, sub1, sub2, sub3, sub4,
 604                                 sub5, sub6, sub7, sub8, &psid))
 605     {
 606       if (LookupAccountSidW (NULL, psid,
 607                             grp, (glen = GNLEN + 1, &glen),
 608                             dom, (dlen = MAX_DOMAIN_NAME_LEN + 1, &dlen),
 609                             &acc_type))
 610         {
 611           if (sub8)
 612             rid = sub8;
 613           else if (sub7)
 614             rid = sub7;
 615           else if (sub6)
 616             rid = sub6;
 617           else if (sub5)
 618             rid = sub5;
 619           else if (sub4)
 620             rid = sub4;
 621           else if (sub3)
 622             rid = sub3;
 623           else if (sub2)
 624             rid = sub2;
 625           else
 626             rid = sub1;
 627           printf ("%ls:%s:%lu:\n", grp, put_sid (psid), rid);
 628         }
 629       FreeSid (psid);
 630     }
 631 }
 632
 633 static int
 634 usage (FILE * stream)
 635 {
 636   fprintf (stream,
 637 "Usage: mkgroup [OPTION]...\n"
 638 "Print /etc/group file to stdout\n"
 639 "\n"
 640 "Options:\n"
 641 "   -l,--local [machine[,offset]]\n"
 642 "                           print local groups with gid offset offset\n"
 643 "                           (from local machine if no machine specified)\n"
 644 "   -L,--Local [machine[,offset]]\n"
 645 "                           ditto, but generate groupname with machine prefix\n"
 646 "   -d,--domain [domain[,offset]]\n"
 647 "                           print domain groups with gid offset offset\n"
 648 "                           (from current domain if no domain specified)\n"
 649 "   -D,--Domain [domain[,offset]]\n"
 650 "                           ditto, but generate groupname with machine prefix\n"
 651 "   -c,--current            print current group\n"
 652 "   -C,--Current            ditto, but generate groupname with machine or\n"
 653 "                           domain prefix\n"
 654 "   -S,--separator char     for -L, -D, -C use character char as domain\\group\n"
 655 "                           separator in groupname instead of the default '\\'\n"
 656 "   -o,--id-offset offset   change the default offset (10000) added to gids\n"
 657 "                           in domain or foreign server accounts.\n"
 658 "   -g,--group groupname    only return information for the specified group\n"
 659 "                           one of -l, -L, -d, -D must be specified, too\n"
 660 "   -b,--no-builtin         don't print BUILTIN groups\n"
 661 "   -U,--unix grouplist     additionally print UNIX groups when using -l or -L\n"
 662 "                           on a UNIX Samba server\n"
 663 "                           grouplist is a comma-separated list of groupnames\n"
 664 "                           or gid ranges (root,-25,50-100).\n"
 665 "                           (enumerating large ranges can take a long time!)\n"
 666 "   -s,--no-sids            (ignored)\n"
 667 "   -u,--users              (ignored)\n"
 668 "   -h,--help               print this message\n"
 669 "   -v,--version            print version information and exit\n"
 670 "\n"
 671 "Default is to print local groups on stand-alone machines, plus domain\n"
 672 "groups on domain controllers and domain member machines.\n");
 673   return 1;
 674 }
 675
 676 struct option longopts[] = {
 677   {"no-builtin", no_argument, NULL, 'b'},
 678   {"current", no_argument, NULL, 'c'},
 679   {"Current", no_argument, NULL, 'C'},
 680   {"domain", optional_argument, NULL, 'd'},
 681   {"Domain", optional_argument, NULL, 'D'},
 682   {"group", required_argument, NULL, 'g'},
 683   {"help", no_argument, NULL, 'h'},
 684   {"local", optional_argument, NULL, 'l'},
 685   {"Local", optional_argument, NULL, 'L'},
 686   {"id-offset", required_argument, NULL, 'o'},
 687   {"no-sids", no_argument, NULL, 's'},
 688   {"separator", required_argument, NULL, 'S'},
 689   {"users", no_argument, NULL, 'u'},
 690   {"unix", required_argument, NULL, 'U'},
 691   {"version", no_argument, NULL, 'v'},
 692   {0, no_argument, NULL, 0}
 693 };
 694
 695 static char opts[] = "bcCd::D::g:hl::L::o:sS:uU:v";
 696
 697 static void
 698 print_version ()
 699 {
 700   const char *v = strchr (version, ':');
 701   int len;
 702   if (!v)
 703     {
 704       v = "?";
 705       len = 1;
 706     }
 707   else
 708     {
 709       v += 2;
 710       len = strchr (v, ' ') - v;
 711     }
 712   printf ("\
 713 mkgroup (cygwin) %.*s\n\
 714 group File Generator\n\
 715 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Red Hat, Inc.\n\
 716 Compiled on %s\n\
 717 ", len, v, __DATE__);
 718 }
 719
 720 static PPOLICY_PRIMARY_DOMAIN_INFO p_dom;
 721
 722 static BOOL
 723 fetch_primary_domain ()
 724 {
 725   NTSTATUS status;
 726   LSA_OBJECT_ATTRIBUTES oa = { 0, 0, 0, 0, 0, 0 };
 727   LSA_HANDLE lsa;
 728
 729   if (!p_dom)
 730     {
 731       status = LsaOpenPolicy (NULL, &oa, POLICY_EXECUTE, &lsa);
 732       if (!NT_SUCCESS (status))
 733         return FALSE;
 734       status = LsaQueryInformationPolicy (lsa, PolicyPrimaryDomainInformation,
 735                                           (PVOID *) ((void *) &p_dom));
 736       LsaClose (lsa);
 737       if (!NT_SUCCESS (status))
 738         return FALSE;
 739     }
 740   return !!p_dom->Sid;
 741 }
 742
 743 int
 744 main (int argc, char **argv)
 745 {
 746   int print_domlist = 0;
 747   domlist_t domlist[32];
 748   char *opt, *p, *ep;
 749   int print_current = 0;
 750   int print_system = 0;
 751   int print_builtin = 1;
 752   char *print_unix = NULL;
 753   const char *sep_char = "\\";
 754   DWORD id_offset = 10000, off;
 755   int c, i;
 756   char *disp_groupname = NULL;
 757   BOOL in_domain;
 758   int optional_args = 0;
 759
 760   if (!isatty (1))
 761     setmode (1, O_BINARY);
 762
 763   /* Use locale from environment.  If not set or set to "C", use UTF-8. */
 764   setlocale (LC_CTYPE, "");
 765   if (!strcmp (setlocale (LC_CTYPE, NULL), "C"))
 766     setlocale (LC_CTYPE, "en_US.UTF-8");
 767   load_dsgetdcname ();
 768   in_domain = fetch_primary_domain ();
 769   fetch_current_pgrp_sid ();
 770
 771   if (argc == 1)
 772     {
 773       print_special (&sid_nt_auth, 1, SECURITY_LOCAL_SYSTEM_RID,
 774                      0, 0, 0, 0, 0, 0, 0);
 775       if (in_domain)
 776         {
 777           if (!enum_local_groups (TRUE, NULL, sep_char, id_offset,
 778                                   disp_groupname, print_builtin, 0))
 779             enum_groups (TRUE, NULL, sep_char, id_offset, disp_groupname, 0);
 780         }
 781       else if (!enum_local_groups (FALSE, NULL, sep_char, 0, disp_groupname,
 782                                    print_builtin, 0))
 783         enum_groups (FALSE, NULL, sep_char, 0, disp_groupname, 0);
 784       return 0;
 785     }
 786
 787   unsetenv ("POSIXLY_CORRECT"); /* To get optional arg processing right. */
 788   while ((c = getopt_long (argc, argv, opts, longopts, NULL)) != EOF)
 789     switch (c)
 790       {
 791       case 'd':
 792       case 'D':
 793       case 'l':
 794       case 'L':
 795         if (print_domlist >= 32)
 796           {
 797             fprintf (stderr, "%s: Can not enumerate from more than 32 "
 798                              "domains and machines.\n", __progname);
 799             return 1;
 800           }
 801         domlist[print_domlist].domain = (c == 'd' || c == 'D');
 802         opt = optarg ?:
 803               argv[optind] && argv[optind][0] != '-' ? argv[optind] : NULL;
 804         if (argv[optind] && opt == argv[optind])
 805           ++optional_args;
 806         for (i = 0; i < print_domlist; ++i)
 807           if (domlist[i].domain == domlist[print_domlist].domain
 808               && ((!domlist[i].str && !opt)
 809                   || (domlist[i].str && opt
 810                       && (off = strlen (domlist[i].str))
 811                       && !strncmp (domlist[i].str, opt, off)
 812                       && (!opt[off] || opt[off] == ','))))
 813             {
 814               fprintf (stderr, "%s: Duplicate %s '%s'.  Skipping...\n",
 815                        __progname, domlist[i].domain ? "domain" : "machine",
 816                        domlist[i].str);
 817               goto skip;
 818             }
 819         if (!(domlist[print_domlist].str = opt))
 820           print_system = 1;
 821         domlist[print_domlist].id_offset = ULONG_MAX;
 822         if (opt && (p = strchr (opt, ',')))
 823           {
 824             if (p == opt
 825                 || !isdigit ((unsigned char) p[1])
 826                 || (domlist[print_domlist].id_offset = strtol (p + 1, &ep, 10)
 827                     , *ep))
 828               {
 829                 fprintf (stderr, "%s: Malformed machine,offset string '%s'.  "
 830                          "Skipping...\n", __progname, opt);
 831                 break;
 832               }
 833             *p = '\0';
 834           }
 835         domlist[print_domlist++].with_dom = (c == 'D' || c == 'L');
 836 skip:
 837         break;
 838       case 'S':
 839         sep_char = optarg;
 840         if (strlen (sep_char) > 1)
 841           {
 842             fprintf (stderr, "%s: Only one character allowed as domain\\user "
 843                              "separator character.\n", __progname);
 844             return 1;
 845           }
 846         if (*sep_char == ':')
 847           {
 848             fprintf (stderr, "%s: Colon not allowed as domain\\user separator "
 849                              "character.\n", __progname);
 850             return 1;
 851           }
 852         break;
 853       case 'U':
 854         print_unix = optarg;
 855         break;
 856       case 'c':
 857         sep_char = NULL;
 858         /*FALLTHRU*/
 859       case 'C':
 860         print_current = 1;
 861         break;
 862       case 'o':
 863         id_offset = strtol (optarg, NULL, 10);
 864         break;
 865       case 'b':
 866         print_builtin = 0;
 867         break;
 868       case 's':
 869         break;
 870       case 'u':
 871         break;
 872       case 'g':
 873         disp_groupname = optarg;
 874         break;
 875       case 'h':
 876         usage (stdout);
 877         return 0;
 878       case 'v':
 879         print_version ();
 880         return 0;
 881       default:
 882         fprintf (stderr, "Try '%s --help' for more information.\n", argv[0]);
 883         return 1;
 884       }
 885
 886   optind += optional_args;
 887   if (argv[optind])
 888     {
 889       fprintf (stderr,
 890                "mkgroup: non-option command line argument `%s' is not allowed.\n"
 891                "Try `mkgroup --help' for more information.\n", argv[optind]);
 892       exit (1);
 893     }
 894
 895   /* Get 'system' group */
 896   if (!disp_groupname && print_system && print_builtin && print_domlist)
 897     print_special (&sid_nt_auth, 1, SECURITY_LOCAL_SYSTEM_RID,
 898                    0, 0, 0, 0, 0, 0, 0);
 899
 900   off = id_offset;
 901   for (i = 0; i < print_domlist; ++i)
 902     {
 903       DWORD my_off = (domlist[i].domain || domlist[i].str)
 904                      ? domlist[i].id_offset != ULONG_MAX
 905                        ? domlist[i].id_offset : off : 0;
 906       if (!enum_local_groups (domlist[i].domain, domlist + i, sep_char,
 907                               my_off, disp_groupname, print_builtin, print_current))
 908         {
 909           if (!domlist[i].domain && domlist[i].str && print_unix)
 910             enum_unix_groups (domlist + i, sep_char, my_off, print_unix);
 911           enum_groups (domlist[i].domain, domlist + i, sep_char, my_off,
 912                        disp_groupname, print_current);
 913           if (my_off)
 914             off += id_offset;
 915         }
 916     }
 917
 918   if (print_current && !got_curr_pgrp)
 919     current_group (sep_char, off);
 920
 921   return 0;
 922 }