This is the 'winbind default domain' patch from Alexander Bokovoy
[ira/wip.git] / source3 / nsswitch / winbindd_user.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.2
4
5    Winbind daemon - user related functions
6
7    Copyright (C) Tim Potter 2000
8    Copyright (C) Jeremy Allison 2001.
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 "winbindd.h"
26
27 /* Fill a pwent structure with information we have obtained */
28
29 static BOOL winbindd_fill_pwent(char *domain_name, char *name, 
30                                 uint32 user_rid, uint32 group_rid, 
31                                 char *full_name, struct winbindd_pw *pw)
32 {
33         extern userdom_struct current_user_info;
34         fstring name_domain, name_user;
35         pstring homedir;
36         
37         if (!pw || !name)
38                 return False;
39         
40         /* Resolve the uid number */
41         
42         if (!winbindd_idmap_get_uid_from_rid(domain_name, user_rid, 
43                                              &pw->pw_uid)) {
44                 DEBUG(1, ("error getting user id for rid %d\n", user_rid));
45                 return False;
46         }
47         
48         /* Resolve the gid number */   
49         
50         if (!winbindd_idmap_get_gid_from_rid(domain_name, group_rid, 
51                                              &pw->pw_gid)) {
52                 DEBUG(1, ("error getting group id for rid %d\n", group_rid));
53                 return False;
54         }
55
56         /* Username */
57         
58         safe_strcpy(pw->pw_name, name, sizeof(pw->pw_name) - 1);
59         
60         /* Full name (gecos) */
61         
62         safe_strcpy(pw->pw_gecos, full_name, sizeof(pw->pw_gecos) - 1);
63
64         /* Home directory and shell - use template config parameters.  The
65            defaults are /tmp for the home directory and /bin/false for
66            shell. */
67         
68         if (!parse_domain_user(name, name_domain, name_user)) {
69                 DEBUG(1, ("error parsing domain user for %s\n", name_user ));
70                 return False;
71         }
72         
73         /* The substitution of %U and %D in the 'template homedir' is done
74            by lp_string() calling standard_sub_basic(). */
75
76         fstrcpy(current_user_info.smb_name, name_user);
77         fstrcpy(current_user_info.domain, name_domain);
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_ntdom 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         uint32 user_rid;
99         WINBIND_USERINFO user_info;
100         DOM_SID user_sid;
101         NTSTATUS status;
102         fstring name_domain, name_user, name;
103         enum SID_NAME_USE name_type;
104         struct winbindd_domain *domain;
105         TALLOC_CTX *mem_ctx;
106         
107         DEBUG(3, ("[%5d]: getpwnam %s\n", state->pid,
108                   state->request.data.username));
109         
110         /* Parse domain and username */
111
112         if (!parse_domain_user(state->request.data.username, name_domain, 
113                           name_user))
114                 return WINBINDD_ERROR;
115         
116         if ((domain = find_domain_from_name(name_domain)) == NULL) {
117                 DEBUG(5, ("no such domain: %s\n", name_domain));
118                 return WINBINDD_ERROR;
119         }
120
121         slprintf(name, sizeof(name) - 1, "%s\\%s", name_domain, name_user);
122         
123         /* Get rid and name type from name */
124
125         if (!winbindd_lookup_sid_by_name(domain, name, &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_named("winbindd_getpwnam(%s)", 
141                                           name_user))) {
142                 DEBUG(1, ("out of memory\n"));
143                 return WINBINDD_ERROR;
144         }
145
146         sid_split_rid(&user_sid, &user_rid);
147
148         status = domain->methods->query_user(domain, mem_ctx, user_rid, 
149                                              &user_info);
150
151         if (!NT_STATUS_IS_OK(status)) {
152                 DEBUG(1, ("error getting user info for user '%s'\n", 
153                           name_user));
154                 talloc_destroy(mem_ctx);
155                 return WINBINDD_ERROR;
156         }
157     
158         /* Now take all this information and fill in a passwd structure */      
159         if (!winbindd_fill_pwent(name_domain, state->request.data.username, 
160                                  user_rid, user_info.group_rid, 
161                                  user_info.full_name,
162                                  &state->response.data.pw)) {
163                 talloc_destroy(mem_ctx);
164                 return WINBINDD_ERROR;
165         }
166
167         talloc_destroy(mem_ctx);
168         
169         return WINBINDD_OK;
170 }       
171
172 /* Return a password structure given a uid number */
173
174 enum winbindd_result winbindd_getpwuid(struct winbindd_cli_state *state)
175 {
176         DOM_SID user_sid;
177         struct winbindd_domain *domain;
178         uint32 user_rid;
179         fstring user_name;
180         enum SID_NAME_USE name_type;
181         WINBIND_USERINFO user_info;
182         gid_t gid;
183         TALLOC_CTX *mem_ctx;
184         NTSTATUS status;
185         
186         /* Bug out if the uid isn't in the winbind range */
187
188         if ((state->request.data.uid < server_state.uid_low ) ||
189             (state->request.data.uid > server_state.uid_high))
190                 return WINBINDD_ERROR;
191
192         DEBUG(3, ("[%5d]: getpwuid %d\n", state->pid, 
193                   state->request.data.uid));
194         
195         /* Get rid from uid */
196
197         if (!winbindd_idmap_get_rid_from_uid(state->request.data.uid, 
198                                              &user_rid, &domain)) {
199                 DEBUG(1, ("could not convert uid %d to rid\n", 
200                           state->request.data.uid));
201                 return WINBINDD_ERROR;
202         }
203         
204         /* Get name and name type from rid */
205
206         sid_copy(&user_sid, &domain->sid);
207         sid_append_rid(&user_sid, user_rid);
208         
209         if (!winbindd_lookup_name_by_sid(&user_sid, user_name, &name_type)) {
210                 fstring temp;
211                 
212                 sid_to_string(temp, &user_sid);
213                 DEBUG(1, ("could not lookup sid %s\n", temp));
214                 return WINBINDD_ERROR;
215         }
216         
217         if (strcmp("\\", lp_winbind_separator()))
218                 string_sub(user_name, "\\", lp_winbind_separator(), 
219                            sizeof(fstring));
220         strip_domain_name_if_needed(&user_name);
221
222         /* Get some user info */
223         
224         if (!(mem_ctx = talloc_init_named("winbind_getpwuid(%d)",
225                                           state->request.data.uid))) {
226
227                 DEBUG(1, ("out of memory\n"));
228                 return WINBINDD_ERROR;
229         }
230
231         status = domain->methods->query_user(domain, mem_ctx, user_rid, 
232                                              &user_info);
233
234         if (!NT_STATUS_IS_OK(status)) {
235                 DEBUG(1, ("error getting user info for user '%s'\n", 
236                           user_name));
237                 return WINBINDD_ERROR;
238         }
239         
240         /* Resolve gid number */
241
242         if (!winbindd_idmap_get_gid_from_rid(domain->name, user_info.group_rid, &gid)) {
243                 DEBUG(1, ("error getting group id for user %s\n", user_name));
244                 return WINBINDD_ERROR;
245         }
246
247         /* Fill in password structure */
248
249         if (!winbindd_fill_pwent(domain->name, user_name, user_rid, user_info.group_rid,
250                                  user_info.full_name, &state->response.data.pw)) {
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                 /*
289                  * Skip domains other than WINBINDD_DOMAIN environment
290                  * variable.
291                  */
292                 
293                 if ((strcmp(state->request.domain, "") != 0) &&
294                                 !check_domain_env(state->request.domain, 
295                                                   domain->name))
296                         continue;
297
298                 /* Create a state record for this domain */
299                 
300                 if ((domain_state = (struct getent_state *)
301                      malloc(sizeof(struct getent_state))) == NULL)
302                         return WINBINDD_ERROR;
303                 
304                 ZERO_STRUCTP(domain_state);
305
306                 fstrcpy(domain_state->domain_name, domain->name);
307
308                 /* Add to list of open domains */
309                 
310                 DLIST_ADD(state->getpwent_state, domain_state);
311         }
312         
313         return WINBINDD_OK;
314 }
315
316 /* Close file pointer to ntdom passwd database */
317
318 enum winbindd_result winbindd_endpwent(struct winbindd_cli_state *state)
319 {
320         DEBUG(3, ("[%5d]: endpwent\n", state->pid));
321
322         free_getent_state(state->getpwent_state);    
323         state->getpwent_state = NULL;
324         
325         return WINBINDD_OK;
326 }
327
328 /* Get partial list of domain users for a domain.  We fill in the sam_entries,
329    and num_sam_entries fields with domain user information.  The dispinfo_ndx
330    field is incremented to the index of the next user to fetch.  Return True if
331    some users were returned, False otherwise. */
332
333 #define MAX_FETCH_SAM_ENTRIES 100
334
335 static BOOL get_sam_user_entries(struct getent_state *ent)
336 {
337         NTSTATUS status;
338         uint32 num_entries;
339         WINBIND_USERINFO *info;
340         struct getpwent_user *name_list = NULL;
341         BOOL result = False;
342         TALLOC_CTX *mem_ctx;
343         struct winbindd_domain *domain;
344         struct winbindd_methods *methods;
345         int i;
346
347         if (ent->num_sam_entries)
348                 return False;
349
350         if (!(mem_ctx = talloc_init_named("get_sam_user_entries(%s)",
351                                           ent->domain_name)))
352                 return False;
353
354         if (!(domain = find_domain_from_name(ent->domain_name))) {
355                 DEBUG(3, ("no such domain %s in get_sam_user_entries\n",
356                           ent->domain_name));
357                 return False;
358         }
359
360         methods = domain->methods;
361
362         /* Free any existing user info */
363
364         SAFE_FREE(ent->sam_entries);
365         ent->num_sam_entries = 0;
366         
367         /* Call query_user_list to get a list of usernames and user rids */
368
369         num_entries = 0;
370
371         status = methods->query_user_list(domain, mem_ctx, &num_entries, 
372                                           &info);
373                 
374         if (num_entries) {
375                 struct getpwent_user *tnl;
376                 
377                 tnl = (struct getpwent_user *)Realloc(name_list, 
378                                                       sizeof(struct getpwent_user) *
379                                                       (ent->num_sam_entries + 
380                                                        num_entries));
381                 
382                 if (!tnl) {
383                         DEBUG(0,("get_sam_user_entries realloc failed.\n"));
384                         SAFE_FREE(name_list);
385                         goto done;
386                 } else
387                         name_list = tnl;
388         }
389
390         for (i = 0; i < num_entries; i++) {
391                 /* Store account name and gecos */
392                 if (!info[i].acct_name) {
393                         fstrcpy(name_list[ent->num_sam_entries + i].name, "");
394                 } else {
395                         fstrcpy(name_list[ent->num_sam_entries + i].name, 
396                                 info[i].acct_name); 
397                 }
398                 if (!info[i].full_name) {
399                         fstrcpy(name_list[ent->num_sam_entries + i].gecos, "");
400                 } else {
401                         fstrcpy(name_list[ent->num_sam_entries + i].gecos, 
402                                 info[i].full_name); 
403                 }
404                 
405                 /* User and group ids */
406                 name_list[ent->num_sam_entries+i].user_rid = info[i].user_rid;
407                 name_list[ent->num_sam_entries+i].group_rid = info[i].group_rid;
408         }
409                 
410         ent->num_sam_entries += num_entries;
411         
412         /* Fill in remaining fields */
413         
414         ent->sam_entries = name_list;
415         ent->sam_entry_index = 0;
416         result = ent->num_sam_entries > 0;
417
418  done:
419
420         talloc_destroy(mem_ctx);
421
422         return result;
423 }
424
425 /* Fetch next passwd entry from ntdom database */
426
427 #define MAX_GETPWENT_USERS 500
428
429 enum winbindd_result winbindd_getpwent(struct winbindd_cli_state *state)
430 {
431         struct getent_state *ent;
432         struct winbindd_pw *user_list;
433         int num_users, user_list_ndx = 0, i;
434         char *sep;
435
436         DEBUG(3, ("[%5d]: getpwent\n", state->pid));
437
438         /* Check user has enabled this */
439
440         if (!lp_winbind_enum_users())
441                 return WINBINDD_ERROR;
442
443         /* Allocate space for returning a chunk of users */
444
445         num_users = MIN(MAX_GETPWENT_USERS, state->request.data.num_entries);
446         
447         if ((state->response.extra_data = 
448              malloc(num_users * sizeof(struct winbindd_pw))) == NULL)
449                 return WINBINDD_ERROR;
450
451         memset(state->response.extra_data, 0, num_users * 
452                sizeof(struct winbindd_pw));
453
454         user_list = (struct winbindd_pw *)state->response.extra_data;
455         sep = lp_winbind_separator();
456         
457         if (!(ent = state->getpwent_state))
458                 return WINBINDD_ERROR;
459
460         /* Start sending back users */
461
462         for (i = 0; i < num_users; i++) {
463                 struct getpwent_user *name_list = NULL;
464                 fstring domain_user_name;
465                 uint32 result;
466
467                 /* Do we need to fetch another chunk of users? */
468
469                 if (ent->num_sam_entries == ent->sam_entry_index) {
470
471                         while(ent && !get_sam_user_entries(ent)) {
472                                 struct getent_state *next_ent;
473
474                                 /* Free state information for this domain */
475
476                                 SAFE_FREE(ent->sam_entries);
477
478                                 next_ent = ent->next;
479                                 DLIST_REMOVE(state->getpwent_state, ent);
480
481                                 SAFE_FREE(ent);
482                                 ent = next_ent;
483                         }
484  
485                         /* No more domains */
486
487                         if (!ent) 
488                                 break;
489                 }
490
491                 name_list = ent->sam_entries;
492
493                 /* Skip machine accounts */
494
495                 if (name_list[ent->sam_entry_index].
496                     name[strlen(name_list[ent->sam_entry_index].name) - 1] 
497                     == '$') {
498                         ent->sam_entry_index++;
499                         continue;
500                 }
501
502                 /* Lookup user info */
503                 
504                 fill_domain_username(domain_user_name, ent->domain_name, 
505                                      name_list[ent->sam_entry_index].name);
506                 
507                 result = winbindd_fill_pwent(
508                         ent->domain_name, 
509                         domain_user_name,
510                         name_list[ent->sam_entry_index].user_rid,
511                         name_list[ent->sam_entry_index].group_rid,
512                         name_list[ent->sam_entry_index].gecos,
513                         &user_list[user_list_ndx]);
514                 
515                 ent->sam_entry_index++;
516                 
517                 /* Add user to return list */
518                 
519                 if (result) {
520                                 
521                         user_list_ndx++;
522                         state->response.data.num_entries++;
523                         state->response.length += 
524                                 sizeof(struct winbindd_pw);
525
526                 } else
527                         DEBUG(1, ("could not lookup domain user %s\n",
528                                   domain_user_name));
529         }
530
531         /* Out of domains */
532
533         return (user_list_ndx > 0) ? WINBINDD_OK : WINBINDD_ERROR;
534 }
535
536 /* List domain users without mapping to unix ids */
537
538 enum winbindd_result winbindd_list_users(struct winbindd_cli_state *state)
539 {
540         struct winbindd_domain *domain;
541         WINBIND_USERINFO *info;
542         uint32 num_entries = 0, total_entries = 0;
543         char *ted, *extra_data = NULL;
544         int extra_data_len = 0;
545         TALLOC_CTX *mem_ctx;
546         enum winbindd_result rv = WINBINDD_ERROR;
547
548         DEBUG(3, ("[%5d]: list users\n", state->pid));
549
550         if (!(mem_ctx = talloc_init_named("winbindd_list_users")))
551                 return WINBINDD_ERROR;
552
553         /* Enumerate over trusted domains */
554
555         for (domain = domain_list(); domain; domain = domain->next) {
556                 NTSTATUS status;
557                 struct winbindd_methods *methods;
558                 int i;
559
560                 /* Skip domains other than WINBINDD_DOMAIN environment
561                    variable */ 
562
563                 if ((strcmp(state->request.domain, "") != 0) &&
564                     !check_domain_env(state->request.domain, domain->name))
565                         continue;
566
567                 methods = domain->methods;
568
569                 /* Query display info */
570                 status = methods->query_user_list(domain, mem_ctx, 
571                                                   &num_entries, &info);
572
573                 if (num_entries == 0)
574                         continue;
575
576                 /* Allocate some memory for extra data */
577                 total_entries += num_entries;
578                         
579                 ted = Realloc(extra_data, sizeof(fstring) * total_entries);
580                         
581                 if (!ted) {
582                         DEBUG(0,("failed to enlarge buffer!\n"));
583                         SAFE_FREE(extra_data);
584                         goto done;
585                 } else 
586                         extra_data = ted;
587                         
588                 /* Pack user list into extra data fields */
589                         
590                 for (i = 0; i < num_entries; i++) {
591                         fstring acct_name, name;
592                         
593                         if (!info[i].acct_name) {
594                                 fstrcpy(acct_name, "");
595                         } else {
596                                 fstrcpy(acct_name, info[i].acct_name);
597                         }
598                         
599                         fill_domain_username(name, domain->name, acct_name);
600                         
601                                 /* Append to extra data */
602                         memcpy(&extra_data[extra_data_len], name, 
603                                strlen(name));
604                         extra_data_len += strlen(name);
605                         extra_data[extra_data_len++] = ',';
606                 }   
607         }
608
609         /* Assign extra_data fields in response structure */
610
611         if (extra_data) {
612                 extra_data[extra_data_len - 1] = '\0';
613                 state->response.extra_data = extra_data;
614                 state->response.length += extra_data_len;
615         }
616
617         /* No domains responded but that's still OK so don't return an
618            error. */
619
620         rv = WINBINDD_OK;
621
622  done:
623
624         talloc_destroy(mem_ctx);
625
626         return rv;
627 }