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