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