source/nsswitch/winbindd_user.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind daemon - user related functions
   5
   6    Copyright (C) Tim Potter 2000
   7    Copyright (C) Jeremy Allison 2001.
   8    Copyright (C) Gerald (Jerry) Carter 2003.
   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 2 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, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "winbindd.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_WINBIND
  30
  31 extern userdom_struct current_user_info;
  32
  33 /* Fill a pwent structure with information we have obtained */
  34
  35 static BOOL winbindd_fill_pwent(char *dom_name, char *user_name,
  36                                 DOM_SID *user_sid, DOM_SID *group_sid,
  37                                 char *full_name, struct winbindd_pw *pw)
  38 {
  39         fstring output_username;
  40         char *homedir;
  41         char *shell;
  42         fstring sid_string;
  43
  44         if (!pw || !dom_name || !user_name)
  45                 return False;
  46
  47         /* Resolve the uid number */
  48
  49         if (!NT_STATUS_IS_OK(idmap_sid_to_uid(user_sid, &(pw->pw_uid), 0))) {
  50                 DEBUG(1, ("error getting user id for sid %s\n", sid_to_string(sid_string, user_sid)));
  51                 return False;
  52         }
  53
  54         /* Resolve the gid number */
  55
  56         if (!NT_STATUS_IS_OK(idmap_sid_to_gid(group_sid, &(pw->pw_gid), 0))) {
  57                 DEBUG(1, ("error getting group id for sid %s\n", sid_to_string(sid_string, group_sid)));
  58                 return False;
  59         }
  60
  61         /* Username */
  62
  63         fill_domain_username(output_username, dom_name, user_name);
  64
  65         safe_strcpy(pw->pw_name, output_username, sizeof(pw->pw_name) - 1);
  66
  67         /* Full name (gecos) */
  68
  69         safe_strcpy(pw->pw_gecos, full_name, sizeof(pw->pw_gecos) - 1);
  70
  71         /* Home directory and shell - use template config parameters.  The
  72            defaults are /tmp for the home directory and /bin/false for
  73            shell. */
  74
  75         /* The substitution of %U and %D in the 'template homedir' is done
  76            by alloc_sub_specified() below. */
  77
  78         fstrcpy(current_user_info.domain, dom_name);
  79
  80         homedir = alloc_sub_specified(lp_template_homedir(), user_name, dom_name, pw->pw_uid, pw->pw_gid);
  81
  82         if (!homedir)
  83                 return False;
  84
  85         safe_strcpy(pw->pw_dir, homedir, sizeof(pw->pw_dir) - 1);
  86
  87         SAFE_FREE(homedir);
  88
  89         shell = alloc_sub_specified(lp_template_shell(), user_name, dom_name, pw->pw_uid, pw->pw_gid);
  90
  91         if (!shell)
  92                 return False;
  93
  94         safe_strcpy(pw->pw_shell, shell,
  95                     sizeof(pw->pw_shell) - 1);
  96
  97         /* Password - set to "x" as we can't generate anything useful here.
  98            Authentication can be done using the pam_winbind module. */
  99
 100         safe_strcpy(pw->pw_passwd, "x", sizeof(pw->pw_passwd) - 1);
 101
 102         return True;
 103 }
 104
 105 /* Return a password structure from a username.  */
 106
 107 enum winbindd_result winbindd_getpwnam(struct winbindd_cli_state *state)
 108 {
 109         WINBIND_USERINFO user_info;
 110         WINBINDD_PW *pw;
 111         DOM_SID user_sid;
 112         NTSTATUS status;
 113         fstring name_domain, name_user;
 114         enum SID_NAME_USE name_type;
 115         struct winbindd_domain *domain;
 116         TALLOC_CTX *mem_ctx;
 117
 118         /* Ensure null termination */
 119         state->request.data.username[sizeof(state->request.data.username)-1]='\0';
 120
 121         DEBUG(3, ("[%5lu]: getpwnam %s\n", (unsigned long)state->pid,
 122                   state->request.data.username));
 123
 124         /* Parse domain and username */
 125
 126         parse_domain_user(state->request.data.username,
 127                           name_domain, name_user);
 128
 129         /* if this is our local domain (or no domain), the do a local tdb search */
 130
 131         if ( !*name_domain || strequal(name_domain, get_global_sam_name()) ) {
 132                 if ( !(pw = wb_getpwnam(name_user)) ) {
 133                         DEBUG(5,("winbindd_getpwnam: lookup for %s\\%s failed\n",
 134                                 name_domain, name_user));
 135                         return WINBINDD_ERROR;
 136                 }
 137                 memcpy( &state->response.data.pw, pw, sizeof(WINBINDD_PW) );
 138                 return WINBINDD_OK;
 139         }
 140
 141         /* should we deal with users for our domain? */
 142
 143         if ((domain = find_domain_from_name(name_domain)) == NULL) {
 144                 DEBUG(5, ("no such domain: %s\n", name_domain));
 145                 return WINBINDD_ERROR;
 146         }
 147
 148         if ( domain->primary && lp_winbind_trusted_domains_only()) {
 149                 DEBUG(7,("winbindd_getpwnam: My domain -- rejecting getpwnam() for %s\\%s.\n",
 150                         name_domain, name_user));
 151                 return WINBINDD_ERROR;
 152         }
 153
 154         /* Get rid and name type from name */
 155
 156         if (!winbindd_lookup_sid_by_name(domain, domain->name, name_user, &user_sid, &name_type)) {
 157                 DEBUG(1, ("user '%s' does not exist\n", name_user));
 158                 return WINBINDD_ERROR;
 159         }
 160
 161         if (name_type != SID_NAME_USER && name_type != SID_NAME_COMPUTER) {
 162                 DEBUG(1, ("name '%s' is not a user name: %d\n", name_user,
 163                           name_type));
 164                 return WINBINDD_ERROR;
 165         }
 166
 167         /* Get some user info. */
 168
 169         if (!(mem_ctx = talloc_init("winbindd_getpwnam([%s]\\[%s])",
 170                                           name_domain, name_user))) {
 171                 DEBUG(1, ("out of memory\n"));
 172                 return WINBINDD_ERROR;
 173         }
 174
 175         status = domain->methods->query_user(domain, mem_ctx, &user_sid,
 176                                              &user_info);
 177
 178         if (!NT_STATUS_IS_OK(status)) {
 179                 DEBUG(1, ("error getting user info for user '[%s]\\[%s]'\n",
 180                           name_domain, name_user));
 181                 talloc_destroy(mem_ctx);
 182                 return WINBINDD_ERROR;
 183         }
 184
 185         /* Now take all this information and fill in a passwd structure */
 186         if (!winbindd_fill_pwent(name_domain, name_user,
 187                                  user_info.user_sid, user_info.group_sid,
 188                                  user_info.full_name,
 189                                  &state->response.data.pw)) {
 190                 talloc_destroy(mem_ctx);
 191                 return WINBINDD_ERROR;
 192         }
 193
 194         talloc_destroy(mem_ctx);
 195
 196         return WINBINDD_OK;
 197 }
 198
 199 /* Return a password structure given a uid number */
 200
 201 enum winbindd_result winbindd_getpwuid(struct winbindd_cli_state *state)
 202 {
 203         DOM_SID user_sid;
 204         struct winbindd_domain *domain;
 205         WINBINDD_PW *pw;
 206         fstring dom_name;
 207         fstring user_name;
 208         enum SID_NAME_USE name_type;
 209         WINBIND_USERINFO user_info;
 210         TALLOC_CTX *mem_ctx;
 211         NTSTATUS status;
 212         gid_t gid;
 213
 214         /* Bug out if the uid isn't in the winbind range */
 215
 216         if ((state->request.data.uid < server_state.uid_low ) ||
 217             (state->request.data.uid > server_state.uid_high))
 218                 return WINBINDD_ERROR;
 219
 220         DEBUG(3, ("[%5lu]: getpwuid %lu\n", (unsigned long)state->pid,
 221                   (unsigned long)state->request.data.uid));
 222
 223         /* always try local tdb first */
 224
 225         if ( (pw = wb_getpwuid(state->request.data.uid)) != NULL ) {
 226                 memcpy( &state->response.data.pw, pw, sizeof(WINBINDD_PW) );
 227                 return WINBINDD_OK;
 228         }
 229
 230         /* Get rid from uid */
 231
 232         if (!NT_STATUS_IS_OK(idmap_uid_to_sid(&user_sid, state->request.data.uid))) {
 233                 DEBUG(1, ("could not convert uid %lu to SID\n",
 234                           (unsigned long)state->request.data.uid));
 235                 return WINBINDD_ERROR;
 236         }
 237
 238         /* Get name and name type from rid */
 239
 240         if (!winbindd_lookup_name_by_sid(&user_sid, dom_name, user_name, &name_type)) {
 241                 fstring temp;
 242
 243                 sid_to_string(temp, &user_sid);
 244                 DEBUG(1, ("could not lookup sid %s\n", temp));
 245                 return WINBINDD_ERROR;
 246         }
 247
 248         domain = find_domain_from_sid(&user_sid);
 249
 250         if (!domain) {
 251                 DEBUG(1,("Can't find domain from sid\n"));
 252                 return WINBINDD_ERROR;
 253         }
 254
 255         /* Get some user info */
 256
 257         if (!(mem_ctx = talloc_init("winbind_getpwuid(%lu)",
 258                                     (unsigned long)state->request.data.uid))) {
 259
 260                 DEBUG(1, ("out of memory\n"));
 261                 return WINBINDD_ERROR;
 262         }
 263
 264         status = domain->methods->query_user(domain, mem_ctx, &user_sid,
 265                                              &user_info);
 266
 267         if (!NT_STATUS_IS_OK(status)) {
 268                 DEBUG(1, ("error getting user info for user '%s'\n",
 269                           user_name));
 270                 talloc_destroy(mem_ctx);
 271                 return WINBINDD_ERROR;
 272         }
 273
 274         /* Check group has a gid number */
 275
 276         if (!NT_STATUS_IS_OK(idmap_sid_to_gid(user_info.group_sid, &gid, 0))) {
 277                 DEBUG(1, ("error getting group id for user %s\n", user_name));
 278                 talloc_destroy(mem_ctx);
 279                 return WINBINDD_ERROR;
 280         }
 281
 282         /* Fill in password structure */
 283
 284         if (!winbindd_fill_pwent(domain->name, user_name, user_info.user_sid,
 285                                  user_info.group_sid,
 286                                  user_info.full_name, &state->response.data.pw)) {
 287                 talloc_destroy(mem_ctx);
 288                 return WINBINDD_ERROR;
 289         }
 290
 291         talloc_destroy(mem_ctx);
 292
 293         return WINBINDD_OK;
 294 }
 295
 296 /*
 297  * set/get/endpwent functions
 298  */
 299
 300 /* Rewind file pointer for ntdom passwd database */
 301
 302 enum winbindd_result winbindd_setpwent(struct winbindd_cli_state *state)
 303 {
 304         struct winbindd_domain *domain;
 305
 306         DEBUG(3, ("[%5lu]: setpwent\n", (unsigned long)state->pid));
 307
 308         /* Check user has enabled this */
 309
 310         if (!lp_winbind_enum_users())
 311                 return WINBINDD_ERROR;
 312
 313         /* Free old static data if it exists */
 314
 315         if (state->getpwent_state != NULL) {
 316                 free_getent_state(state->getpwent_state);
 317                 state->getpwent_state = NULL;
 318         }
 319
 320 #if 0   /* JERRY */
 321         /* add any local users we have */
 322
 323         if ( (domain_state = (struct getent_state *)malloc(sizeof(struct getent_state))) == NULL )
 324                 return WINBINDD_ERROR;
 325
 326         ZERO_STRUCTP(domain_state);
 327
 328         /* Add to list of open domains */
 329
 330         DLIST_ADD(state->getpwent_state, domain_state);
 331 #endif
 332
 333         /* Create sam pipes for each domain we know about */
 334
 335         for(domain = domain_list(); domain != NULL; domain = domain->next) {
 336                 struct getent_state *domain_state;
 337
 338
 339                 /* don't add our domaina if we are a PDC or if we
 340                    are a member of a Samba domain */
 341
 342                 if ( (IS_DC || lp_winbind_trusted_domains_only())
 343                         && strequal(domain->name, lp_workgroup()) )
 344                 {
 345                         continue;
 346                 }
 347
 348                 /* Create a state record for this domain */
 349
 350                 if ((domain_state = (struct getent_state *)
 351                      malloc(sizeof(struct getent_state))) == NULL)
 352                         return WINBINDD_ERROR;
 353
 354                 ZERO_STRUCTP(domain_state);
 355
 356                 fstrcpy(domain_state->domain_name, domain->name);
 357
 358                 /* Add to list of open domains */
 359
 360                 DLIST_ADD(state->getpwent_state, domain_state);
 361         }
 362
 363         return WINBINDD_OK;
 364 }
 365
 366 /* Close file pointer to ntdom passwd database */
 367
 368 enum winbindd_result winbindd_endpwent(struct winbindd_cli_state *state)
 369 {
 370         DEBUG(3, ("[%5lu]: endpwent\n", (unsigned long)state->pid));
 371
 372         free_getent_state(state->getpwent_state);
 373         state->getpwent_state = NULL;
 374
 375         return WINBINDD_OK;
 376 }
 377
 378 /* Get partial list of domain users for a domain.  We fill in the sam_entries,
 379    and num_sam_entries fields with domain user information.  The dispinfo_ndx
 380    field is incremented to the index of the next user to fetch.  Return True if
 381    some users were returned, False otherwise. */
 382
 383 #define MAX_FETCH_SAM_ENTRIES 100
 384
 385 static BOOL get_sam_user_entries(struct getent_state *ent)
 386 {
 387         NTSTATUS status;
 388         uint32 num_entries;
 389         WINBIND_USERINFO *info;
 390         struct getpwent_user *name_list = NULL;
 391         BOOL result = False;
 392         TALLOC_CTX *mem_ctx;
 393         struct winbindd_domain *domain;
 394         struct winbindd_methods *methods;
 395         unsigned int i;
 396
 397         if (ent->num_sam_entries)
 398                 return False;
 399
 400         if (!(mem_ctx = talloc_init("get_sam_user_entries(%s)",
 401                                     ent->domain_name)))
 402                 return False;
 403
 404         if (!(domain = find_domain_from_name(ent->domain_name))) {
 405                 DEBUG(3, ("no such domain %s in get_sam_user_entries\n",
 406                           ent->domain_name));
 407                 return False;
 408         }
 409
 410         methods = domain->methods;
 411
 412         /* Free any existing user info */
 413
 414         SAFE_FREE(ent->sam_entries);
 415         ent->num_sam_entries = 0;
 416
 417         /* Call query_user_list to get a list of usernames and user rids */
 418
 419         num_entries = 0;
 420
 421         status = methods->query_user_list(domain, mem_ctx, &num_entries,
 422                                           &info);
 423
 424         if (num_entries) {
 425                 struct getpwent_user *tnl;
 426
 427                 tnl = (struct getpwent_user *)Realloc(name_list,
 428                                                       sizeof(struct getpwent_user) *
 429                                                       (ent->num_sam_entries +
 430                                                        num_entries));
 431
 432                 if (!tnl) {
 433                         DEBUG(0,("get_sam_user_entries realloc failed.\n"));
 434                         SAFE_FREE(name_list);
 435                         goto done;
 436                 } else
 437                         name_list = tnl;
 438         }
 439
 440         for (i = 0; i < num_entries; i++) {
 441                 /* Store account name and gecos */
 442                 if (!info[i].acct_name) {
 443                         fstrcpy(name_list[ent->num_sam_entries + i].name, "");
 444                 } else {
 445                         fstrcpy(name_list[ent->num_sam_entries + i].name,
 446                                 info[i].acct_name);
 447                 }
 448                 if (!info[i].full_name) {
 449                         fstrcpy(name_list[ent->num_sam_entries + i].gecos, "");
 450                 } else {
 451                         fstrcpy(name_list[ent->num_sam_entries + i].gecos,
 452                                 info[i].full_name);
 453                 }
 454
 455                 /* User and group ids */
 456                 sid_copy(&name_list[ent->num_sam_entries+i].user_sid, info[i].user_sid);
 457                 sid_copy(&name_list[ent->num_sam_entries+i].group_sid, info[i].group_sid);
 458         }
 459
 460         ent->num_sam_entries += num_entries;
 461
 462         /* Fill in remaining fields */
 463
 464         ent->sam_entries = name_list;
 465         ent->sam_entry_index = 0;
 466         result = ent->num_sam_entries > 0;
 467
 468  done:
 469
 470         talloc_destroy(mem_ctx);
 471
 472         return result;
 473 }
 474
 475 /* Fetch next passwd entry from ntdom database */
 476
 477 #define MAX_GETPWENT_USERS 500
 478
 479 enum winbindd_result winbindd_getpwent(struct winbindd_cli_state *state)
 480 {
 481         struct getent_state *ent;
 482         struct winbindd_pw *user_list;
 483         int num_users, user_list_ndx = 0, i;
 484
 485         DEBUG(3, ("[%5lu]: getpwent\n", (unsigned long)state->pid));
 486
 487         /* Check user has enabled this */
 488
 489         if (!lp_winbind_enum_users())
 490                 return WINBINDD_ERROR;
 491
 492         /* Allocate space for returning a chunk of users */
 493
 494         num_users = MIN(MAX_GETPWENT_USERS, state->request.data.num_entries);
 495
 496         if ((state->response.extra_data =
 497              malloc(num_users * sizeof(struct winbindd_pw))) == NULL)
 498                 return WINBINDD_ERROR;
 499
 500         memset(state->response.extra_data, 0, num_users *
 501                sizeof(struct winbindd_pw));
 502
 503         user_list = (struct winbindd_pw *)state->response.extra_data;
 504
 505         if (!(ent = state->getpwent_state))
 506                 return WINBINDD_ERROR;
 507
 508         /* Start sending back users */
 509
 510         for (i = 0; i < num_users; i++) {
 511                 struct getpwent_user *name_list = NULL;
 512                 uint32 result;
 513
 514                 /* Do we need to fetch another chunk of users? */
 515
 516                 if (ent->num_sam_entries == ent->sam_entry_index) {
 517
 518                         while(ent && !get_sam_user_entries(ent)) {
 519                                 struct getent_state *next_ent;
 520
 521                                 /* Free state information for this domain */
 522
 523                                 SAFE_FREE(ent->sam_entries);
 524
 525                                 next_ent = ent->next;
 526                                 DLIST_REMOVE(state->getpwent_state, ent);
 527
 528                                 SAFE_FREE(ent);
 529                                 ent = next_ent;
 530                         }
 531
 532                         /* No more domains */
 533
 534                         if (!ent)
 535                                 break;
 536                 }
 537
 538                 name_list = ent->sam_entries;
 539
 540                 /* Lookup user info */
 541
 542                 result = winbindd_fill_pwent(
 543                         ent->domain_name,
 544                         name_list[ent->sam_entry_index].name,
 545                         &name_list[ent->sam_entry_index].user_sid,
 546                         &name_list[ent->sam_entry_index].group_sid,
 547                         name_list[ent->sam_entry_index].gecos,
 548                         &user_list[user_list_ndx]);
 549
 550                 ent->sam_entry_index++;
 551
 552                 /* Add user to return list */
 553
 554                 if (result) {
 555
 556                         user_list_ndx++;
 557                         state->response.data.num_entries++;
 558                         state->response.length +=
 559                                 sizeof(struct winbindd_pw);
 560
 561                 } else
 562                         DEBUG(1, ("could not lookup domain user %s\n",
 563                                   name_list[ent->sam_entry_index].name));
 564         }
 565
 566         /* Out of domains */
 567
 568         return (user_list_ndx > 0) ? WINBINDD_OK : WINBINDD_ERROR;
 569 }
 570
 571 /* List domain users without mapping to unix ids */
 572
 573 enum winbindd_result winbindd_list_users(struct winbindd_cli_state *state)
 574 {
 575         struct winbindd_domain *domain;
 576         WINBIND_USERINFO *info;
 577         const char *which_domain;
 578         uint32 num_entries = 0, total_entries = 0;
 579         char *ted, *extra_data = NULL;
 580         int extra_data_len = 0;
 581         TALLOC_CTX *mem_ctx;
 582         enum winbindd_result rv = WINBINDD_ERROR;
 583
 584         DEBUG(3, ("[%5lu]: list users\n", (unsigned long)state->pid));
 585
 586         if (!(mem_ctx = talloc_init("winbindd_list_users")))
 587                 return WINBINDD_ERROR;
 588
 589         /* Ensure null termination */
 590         state->request.domain_name[sizeof(state->request.domain_name)-1]='\0';
 591         which_domain = state->request.domain_name;
 592
 593         /* Enumerate over trusted domains */
 594
 595         for (domain = domain_list(); domain; domain = domain->next) {
 596                 NTSTATUS status;
 597                 struct winbindd_methods *methods;
 598                 unsigned int i;
 599
 600                 /* if we have a domain name restricting the request and this
 601                    one in the list doesn't match, then just bypass the remainder
 602                    of the loop */
 603
 604                 if ( *which_domain && !strequal(which_domain, domain->name) )
 605                         continue;
 606
 607                 methods = domain->methods;
 608
 609                 /* Query display info */
 610                 status = methods->query_user_list(domain, mem_ctx,
 611                                                   &num_entries, &info);
 612
 613                 if (num_entries == 0)
 614                         continue;
 615
 616                 /* Allocate some memory for extra data */
 617                 total_entries += num_entries;
 618
 619                 ted = Realloc(extra_data, sizeof(fstring) * total_entries);
 620
 621                 if (!ted) {
 622                         DEBUG(0,("failed to enlarge buffer!\n"));
 623                         SAFE_FREE(extra_data);
 624                         goto done;
 625                 } else
 626                         extra_data = ted;
 627
 628                 /* Pack user list into extra data fields */
 629
 630                 for (i = 0; i < num_entries; i++) {
 631                         fstring acct_name, name;
 632
 633                         if (!info[i].acct_name) {
 634                                 fstrcpy(acct_name, "");
 635                         } else {
 636                                 fstrcpy(acct_name, info[i].acct_name);
 637                         }
 638
 639                         fill_domain_username(name, domain->name, acct_name);
 640
 641                                 /* Append to extra data */
 642                         memcpy(&extra_data[extra_data_len], name,
 643                                strlen(name));
 644                         extra_data_len += strlen(name);
 645                         extra_data[extra_data_len++] = ',';
 646                 }
 647         }
 648
 649         /* Assign extra_data fields in response structure */
 650
 651         if (extra_data) {
 652                 extra_data[extra_data_len - 1] = '\0';
 653                 state->response.extra_data = extra_data;
 654                 state->response.length += extra_data_len;
 655         }
 656
 657         /* No domains responded but that's still OK so don't return an
 658            error. */
 659
 660         rv = WINBINDD_OK;
 661
 662  done:
 663
 664         talloc_destroy(mem_ctx);
 665
 666         return rv;
 667 }