file_server: Use samba4 auth module for guest logins as well
[nivanova/samba-autobuild/.git] / nsswitch / winbind_nss_linux.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Windows NT Domain nsswitch module
5
6    Copyright (C) Tim Potter 2000
7
8    This library is free software; you can redistribute it and/or
9    modify it under the terms of the GNU Lesser General Public
10    License as published by the Free Software Foundation; either
11    version 3 of the License, or (at your option) any later version.
12
13    This library is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16    Library General Public License for more details.
17
18    You should have received a copy of the GNU Lesser General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "winbind_client.h"
23
24 #if HAVE_PTHREAD_H
25 #include <pthread.h>
26 #endif
27
28 #if HAVE_PTHREAD
29 static pthread_mutex_t winbind_nss_mutex = PTHREAD_MUTEX_INITIALIZER;
30 #endif
31
32 /* Maximum number of users to pass back over the unix domain socket
33    per call. This is not a static limit on the total number of users
34    or groups returned in total. */
35
36 #define MAX_GETPWENT_USERS 250
37 #define MAX_GETGRENT_USERS 250
38
39 NSS_STATUS _nss_winbind_setpwent(void);
40 NSS_STATUS _nss_winbind_endpwent(void);
41 NSS_STATUS _nss_winbind_getpwent_r(struct passwd *result, char *buffer,
42                                    size_t buflen, int *errnop);
43 NSS_STATUS _nss_winbind_getpwuid_r(uid_t uid, struct passwd *result,
44                                    char *buffer, size_t buflen, int *errnop);
45 NSS_STATUS _nss_winbind_getpwnam_r(const char *name, struct passwd *result,
46                                    char *buffer, size_t buflen, int *errnop);
47 NSS_STATUS _nss_winbind_setgrent(void);
48 NSS_STATUS _nss_winbind_endgrent(void);
49 NSS_STATUS _nss_winbind_getgrent_r(struct group *result, char *buffer,
50                                    size_t buflen, int *errnop);
51 NSS_STATUS _nss_winbind_getgrlst_r(struct group *result, char *buffer,
52                                    size_t buflen, int *errnop);
53 NSS_STATUS _nss_winbind_getgrnam_r(const char *name, struct group *result,
54                                    char *buffer, size_t buflen, int *errnop);
55 NSS_STATUS _nss_winbind_getgrgid_r(gid_t gid, struct group *result, char *buffer,
56                                    size_t buflen, int *errnop);
57 NSS_STATUS _nss_winbind_initgroups_dyn(char *user, gid_t group, long int *start,
58                                        long int *size, gid_t **groups,
59                                        long int limit, int *errnop);
60 NSS_STATUS _nss_winbind_getusersids(const char *user_sid, char **group_sids,
61                                     int *num_groups, char *buffer, size_t buf_size,
62                                     int *errnop);
63 NSS_STATUS _nss_winbind_nametosid(const char *name, char **sid, char *buffer,
64                                   size_t buflen, int *errnop);
65 NSS_STATUS _nss_winbind_sidtoname(const char *sid, char **name, char *buffer,
66                                   size_t buflen, int *errnop);
67 NSS_STATUS _nss_winbind_sidtouid(const char *sid, uid_t *uid, int *errnop);
68 NSS_STATUS _nss_winbind_sidtogid(const char *sid, gid_t *gid, int *errnop);
69 NSS_STATUS _nss_winbind_uidtosid(uid_t uid, char **sid, char *buffer,
70                                  size_t buflen, int *errnop);
71 NSS_STATUS _nss_winbind_gidtosid(gid_t gid, char **sid, char *buffer,
72                                  size_t buflen, int *errnop);
73
74 /*************************************************************************
75  ************************************************************************/
76
77 #ifdef DEBUG_NSS
78 static const char *nss_err_str(NSS_STATUS ret)
79 {
80         switch (ret) {
81                 case NSS_STATUS_TRYAGAIN:
82                         return "NSS_STATUS_TRYAGAIN";
83                 case NSS_STATUS_SUCCESS:
84                         return "NSS_STATUS_SUCCESS";
85                 case NSS_STATUS_NOTFOUND:
86                         return "NSS_STATUS_NOTFOUND";
87                 case NSS_STATUS_UNAVAIL:
88                         return "NSS_STATUS_UNAVAIL";
89 #ifdef NSS_STATUS_RETURN
90                 case NSS_STATUS_RETURN:
91                         return "NSS_STATUS_RETURN";
92 #endif
93                 default:
94                         return "UNKNOWN RETURN CODE!!!!!!!";
95         }
96 }
97 #endif
98
99 /* Prototypes from wb_common.c */
100
101 /* Allocate some space from the nss static buffer.  The buffer and buflen
102    are the pointers passed in by the C library to the _nss_ntdom_*
103    functions. */
104
105 static char *get_static(char **buffer, size_t *buflen, size_t len)
106 {
107         char *result;
108
109         /* Error check.  We return false if things aren't set up right, or
110            there isn't enough buffer space left. */
111
112         if ((buffer == NULL) || (buflen == NULL) || (*buflen < len)) {
113                 return NULL;
114         }
115
116         /* Return an index into the static buffer */
117
118         result = *buffer;
119         *buffer += len;
120         *buflen -= len;
121
122         return result;
123 }
124
125 /* I've copied the strtok() replacement function next_token_Xalloc() from
126    lib/util_str.c as I really don't want to have to link in any other
127    objects if I can possibly avoid it. */
128
129 static bool next_token_alloc(const char **ptr,
130                                 char **pp_buff,
131                                 const char *sep)
132 {
133         const char *s;
134         const char *saved_s;
135         char *pbuf;
136         bool quoted;
137         size_t len=1;
138
139         *pp_buff = NULL;
140         if (!ptr) {
141                 return(false);
142         }
143
144         s = *ptr;
145
146         /* default to simple separators */
147         if (!sep) {
148                 sep = " \t\n\r";
149         }
150
151         /* find the first non sep char */
152         while (*s && strchr(sep,*s)) {
153                 s++;
154         }
155
156         /* nothing left? */
157         if (!*s) {
158                 return false;
159         }
160
161         /* When restarting we need to go from here. */
162         saved_s = s;
163
164         /* Work out the length needed. */
165         for (quoted = false; *s &&
166                         (quoted || !strchr(sep,*s)); s++) {
167                 if (*s == '\"') {
168                         quoted = !quoted;
169                 } else {
170                         len++;
171                 }
172         }
173
174         /* We started with len = 1 so we have space for the nul. */
175         *pp_buff = (char *)malloc(len);
176         if (!*pp_buff) {
177                 return false;
178         }
179
180         /* copy over the token */
181         pbuf = *pp_buff;
182         s = saved_s;
183         for (quoted = false; *s &&
184                         (quoted || !strchr(sep,*s)); s++) {
185                 if ( *s == '\"' ) {
186                         quoted = !quoted;
187                 } else {
188                         *pbuf++ = *s;
189                 }
190         }
191
192         *ptr = (*s) ? s+1 : s;
193         *pbuf = 0;
194
195         return true;
196 }
197
198 /* Fill a pwent structure from a winbindd_response structure.  We use
199    the static data passed to us by libc to put strings and stuff in.
200    Return NSS_STATUS_TRYAGAIN if we run out of memory. */
201
202 static NSS_STATUS fill_pwent(struct passwd *result,
203                                   struct winbindd_pw *pw,
204                                   char **buffer, size_t *buflen)
205 {
206         /* User name */
207
208         if ((result->pw_name =
209              get_static(buffer, buflen, strlen(pw->pw_name) + 1)) == NULL) {
210
211                 /* Out of memory */
212
213                 return NSS_STATUS_TRYAGAIN;
214         }
215
216         strcpy(result->pw_name, pw->pw_name);
217
218         /* Password */
219
220         if ((result->pw_passwd =
221              get_static(buffer, buflen, strlen(pw->pw_passwd) + 1)) == NULL) {
222
223                 /* Out of memory */
224
225                 return NSS_STATUS_TRYAGAIN;
226         }
227
228         strcpy(result->pw_passwd, pw->pw_passwd);
229
230         /* [ug]id */
231
232         result->pw_uid = pw->pw_uid;
233         result->pw_gid = pw->pw_gid;
234
235         /* GECOS */
236
237         if ((result->pw_gecos =
238              get_static(buffer, buflen, strlen(pw->pw_gecos) + 1)) == NULL) {
239
240                 /* Out of memory */
241
242                 return NSS_STATUS_TRYAGAIN;
243         }
244
245         strcpy(result->pw_gecos, pw->pw_gecos);
246
247         /* Home directory */
248
249         if ((result->pw_dir =
250              get_static(buffer, buflen, strlen(pw->pw_dir) + 1)) == NULL) {
251
252                 /* Out of memory */
253
254                 return NSS_STATUS_TRYAGAIN;
255         }
256
257         strcpy(result->pw_dir, pw->pw_dir);
258
259         /* Logon shell */
260
261         if ((result->pw_shell =
262              get_static(buffer, buflen, strlen(pw->pw_shell) + 1)) == NULL) {
263
264                 /* Out of memory */
265
266                 return NSS_STATUS_TRYAGAIN;
267         }
268
269         strcpy(result->pw_shell, pw->pw_shell);
270
271         /* The struct passwd for Solaris has some extra fields which must
272            be initialised or nscd crashes. */
273
274 #if HAVE_PASSWD_PW_COMMENT
275         result->pw_comment = "";
276 #endif
277
278 #if HAVE_PASSWD_PW_AGE
279         result->pw_age = "";
280 #endif
281
282         return NSS_STATUS_SUCCESS;
283 }
284
285 /* Fill a grent structure from a winbindd_response structure.  We use
286    the static data passed to us by libc to put strings and stuff in.
287    Return NSS_STATUS_TRYAGAIN if we run out of memory. */
288
289 static NSS_STATUS fill_grent(struct group *result, struct winbindd_gr *gr,
290                       char *gr_mem, char **buffer, size_t *buflen)
291 {
292         char *name;
293         int i;
294         char *tst;
295
296         /* Group name */
297
298         if ((result->gr_name =
299              get_static(buffer, buflen, strlen(gr->gr_name) + 1)) == NULL) {
300
301                 /* Out of memory */
302
303                 return NSS_STATUS_TRYAGAIN;
304         }
305
306         strcpy(result->gr_name, gr->gr_name);
307
308         /* Password */
309
310         if ((result->gr_passwd =
311              get_static(buffer, buflen, strlen(gr->gr_passwd) + 1)) == NULL) {
312
313                 /* Out of memory */
314                 return NSS_STATUS_TRYAGAIN;
315         }
316
317         strcpy(result->gr_passwd, gr->gr_passwd);
318
319         /* gid */
320
321         result->gr_gid = gr->gr_gid;
322
323         /* Group membership */
324
325         if (!gr_mem) {
326                 gr->num_gr_mem = 0;
327         }
328
329         /* this next value is a pointer to a pointer so let's align it */
330
331         /* Calculate number of extra bytes needed to align on pointer size boundry */
332         if ((i = (unsigned long)(*buffer) % sizeof(char*)) != 0)
333                 i = sizeof(char*) - i;
334
335         if ((tst = get_static(buffer, buflen, ((gr->num_gr_mem + 1) *
336                                  sizeof(char *)+i))) == NULL) {
337
338                 /* Out of memory */
339
340                 return NSS_STATUS_TRYAGAIN;
341         }
342         result->gr_mem = (char **)(tst + i);
343
344         if (gr->num_gr_mem == 0) {
345
346                 /* Group is empty */
347
348                 *(result->gr_mem) = NULL;
349                 return NSS_STATUS_SUCCESS;
350         }
351
352         /* Start looking at extra data */
353
354         i = 0;
355
356         while(next_token_alloc((const char **)&gr_mem, &name, ",")) {
357                 /* Allocate space for member */
358                 if (((result->gr_mem)[i] =
359                      get_static(buffer, buflen, strlen(name) + 1)) == NULL) {
360                         free(name);
361                         /* Out of memory */
362                         return NSS_STATUS_TRYAGAIN;
363                 }
364                 strcpy((result->gr_mem)[i], name);
365                 free(name);
366                 i++;
367         }
368
369         /* Terminate list */
370
371         (result->gr_mem)[i] = NULL;
372
373         return NSS_STATUS_SUCCESS;
374 }
375
376 /*
377  * NSS user functions
378  */
379
380 static struct winbindd_response getpwent_response;
381
382 static int ndx_pw_cache;                 /* Current index into pwd cache */
383 static int num_pw_cache;                 /* Current size of pwd cache */
384
385 /* Rewind "file pointer" to start of ntdom password database */
386
387 NSS_STATUS
388 _nss_winbind_setpwent(void)
389 {
390         NSS_STATUS ret;
391 #ifdef DEBUG_NSS
392         fprintf(stderr, "[%5d]: setpwent\n", getpid());
393 #endif
394
395 #if HAVE_PTHREAD
396         pthread_mutex_lock(&winbind_nss_mutex);
397 #endif
398
399         if (num_pw_cache > 0) {
400                 ndx_pw_cache = num_pw_cache = 0;
401                 winbindd_free_response(&getpwent_response);
402         }
403
404         ret = winbindd_request_response(WINBINDD_SETPWENT, NULL, NULL);
405 #ifdef DEBUG_NSS
406         fprintf(stderr, "[%5d]: setpwent returns %s (%d)\n", getpid(),
407                 nss_err_str(ret), ret);
408 #endif
409
410 #if HAVE_PTHREAD
411         pthread_mutex_unlock(&winbind_nss_mutex);
412 #endif
413         return ret;
414 }
415
416 /* Close ntdom password database "file pointer" */
417
418 NSS_STATUS
419 _nss_winbind_endpwent(void)
420 {
421         NSS_STATUS ret;
422 #ifdef DEBUG_NSS
423         fprintf(stderr, "[%5d]: endpwent\n", getpid());
424 #endif
425
426 #if HAVE_PTHREAD
427         pthread_mutex_lock(&winbind_nss_mutex);
428 #endif
429
430         if (num_pw_cache > 0) {
431                 ndx_pw_cache = num_pw_cache = 0;
432                 winbindd_free_response(&getpwent_response);
433         }
434
435         ret = winbindd_request_response(WINBINDD_ENDPWENT, NULL, NULL);
436 #ifdef DEBUG_NSS
437         fprintf(stderr, "[%5d]: endpwent returns %s (%d)\n", getpid(),
438                 nss_err_str(ret), ret);
439 #endif
440
441 #if HAVE_PTHREAD
442         pthread_mutex_unlock(&winbind_nss_mutex);
443 #endif
444
445         return ret;
446 }
447
448 /* Fetch the next password entry from ntdom password database */
449
450 NSS_STATUS
451 _nss_winbind_getpwent_r(struct passwd *result, char *buffer,
452                         size_t buflen, int *errnop)
453 {
454         NSS_STATUS ret;
455         struct winbindd_request request;
456         static int called_again;
457
458 #ifdef DEBUG_NSS
459         fprintf(stderr, "[%5d]: getpwent\n", getpid());
460 #endif
461
462 #if HAVE_PTHREAD
463         pthread_mutex_lock(&winbind_nss_mutex);
464 #endif
465
466         /* Return an entry from the cache if we have one, or if we are
467            called again because we exceeded our static buffer.  */
468
469         if ((ndx_pw_cache < num_pw_cache) || called_again) {
470                 goto return_result;
471         }
472
473         /* Else call winbindd to get a bunch of entries */
474
475         if (num_pw_cache > 0) {
476                 winbindd_free_response(&getpwent_response);
477         }
478
479         ZERO_STRUCT(request);
480         ZERO_STRUCT(getpwent_response);
481
482         request.data.num_entries = MAX_GETPWENT_USERS;
483
484         ret = winbindd_request_response(WINBINDD_GETPWENT, &request,
485                                &getpwent_response);
486
487         if (ret == NSS_STATUS_SUCCESS) {
488                 struct winbindd_pw *pw_cache;
489
490                 /* Fill cache */
491
492                 ndx_pw_cache = 0;
493                 num_pw_cache = getpwent_response.data.num_entries;
494
495                 /* Return a result */
496
497         return_result:
498
499                 pw_cache = (struct winbindd_pw *)
500                         getpwent_response.extra_data.data;
501
502                 /* Check data is valid */
503
504                 if (pw_cache == NULL) {
505                         ret = NSS_STATUS_NOTFOUND;
506                         goto done;
507                 }
508
509                 ret = fill_pwent(result, &pw_cache[ndx_pw_cache],
510                                  &buffer, &buflen);
511
512                 /* Out of memory - try again */
513
514                 if (ret == NSS_STATUS_TRYAGAIN) {
515                         called_again = true;
516                         *errnop = errno = ERANGE;
517                         goto done;
518                 }
519
520                 *errnop = errno = 0;
521                 called_again = false;
522                 ndx_pw_cache++;
523
524                 /* If we've finished with this lot of results free cache */
525
526                 if (ndx_pw_cache == num_pw_cache) {
527                         ndx_pw_cache = num_pw_cache = 0;
528                         winbindd_free_response(&getpwent_response);
529                 }
530         }
531         done:
532 #ifdef DEBUG_NSS
533         fprintf(stderr, "[%5d]: getpwent returns %s (%d)\n", getpid(),
534                 nss_err_str(ret), ret);
535 #endif
536
537 #if HAVE_PTHREAD
538         pthread_mutex_unlock(&winbind_nss_mutex);
539 #endif
540         return ret;
541 }
542
543 /* Return passwd struct from uid */
544
545 NSS_STATUS
546 _nss_winbind_getpwuid_r(uid_t uid, struct passwd *result, char *buffer,
547                         size_t buflen, int *errnop)
548 {
549         NSS_STATUS ret;
550         static struct winbindd_response response;
551         struct winbindd_request request;
552         static int keep_response;
553
554 #ifdef DEBUG_NSS
555         fprintf(stderr, "[%5d]: getpwuid_r %d\n", getpid(), (unsigned int)uid);
556 #endif
557
558 #if HAVE_PTHREAD
559         pthread_mutex_lock(&winbind_nss_mutex);
560 #endif
561
562         /* If our static buffer needs to be expanded we are called again */
563         if (!keep_response || uid != response.data.pw.pw_uid) {
564
565                 /* Call for the first time */
566
567                 ZERO_STRUCT(response);
568                 ZERO_STRUCT(request);
569
570                 request.data.uid = uid;
571
572                 ret = winbindd_request_response(WINBINDD_GETPWUID, &request, &response);
573
574                 if (ret == NSS_STATUS_SUCCESS) {
575                         ret = fill_pwent(result, &response.data.pw,
576                                          &buffer, &buflen);
577
578                         if (ret == NSS_STATUS_TRYAGAIN) {
579                                 keep_response = true;
580                                 *errnop = errno = ERANGE;
581                                 goto done;
582                         }
583                 }
584
585         } else {
586
587                 /* We've been called again */
588
589                 ret = fill_pwent(result, &response.data.pw, &buffer, &buflen);
590
591                 if (ret == NSS_STATUS_TRYAGAIN) {
592                         *errnop = errno = ERANGE;
593                         goto done;
594                 }
595
596                 keep_response = false;
597                 *errnop = errno = 0;
598         }
599
600         winbindd_free_response(&response);
601
602         done:
603
604 #ifdef DEBUG_NSS
605         fprintf(stderr, "[%5d]: getpwuid %d returns %s (%d)\n", getpid(),
606                 (unsigned int)uid, nss_err_str(ret), ret);
607 #endif
608
609 #if HAVE_PTHREAD
610         pthread_mutex_unlock(&winbind_nss_mutex);
611 #endif
612
613         return ret;
614 }
615
616 /* Return passwd struct from username */
617 NSS_STATUS
618 _nss_winbind_getpwnam_r(const char *name, struct passwd *result, char *buffer,
619                         size_t buflen, int *errnop)
620 {
621         NSS_STATUS ret;
622         static struct winbindd_response response;
623         struct winbindd_request request;
624         static int keep_response;
625
626 #ifdef DEBUG_NSS
627         fprintf(stderr, "[%5d]: getpwnam_r %s\n", getpid(), name);
628 #endif
629
630 #if HAVE_PTHREAD
631         pthread_mutex_lock(&winbind_nss_mutex);
632 #endif
633
634         /* If our static buffer needs to be expanded we are called again */
635
636         if (!keep_response || strcmp(name,response.data.pw.pw_name) != 0) {
637
638                 /* Call for the first time */
639
640                 ZERO_STRUCT(response);
641                 ZERO_STRUCT(request);
642
643                 strncpy(request.data.username, name,
644                         sizeof(request.data.username) - 1);
645                 request.data.username
646                         [sizeof(request.data.username) - 1] = '\0';
647
648                 ret = winbindd_request_response(WINBINDD_GETPWNAM, &request, &response);
649
650                 if (ret == NSS_STATUS_SUCCESS) {
651                         ret = fill_pwent(result, &response.data.pw, &buffer,
652                                          &buflen);
653
654                         if (ret == NSS_STATUS_TRYAGAIN) {
655                                 keep_response = true;
656                                 *errnop = errno = ERANGE;
657                                 goto done;
658                         }
659                 }
660
661         } else {
662
663                 /* We've been called again */
664
665                 ret = fill_pwent(result, &response.data.pw, &buffer, &buflen);
666
667                 if (ret == NSS_STATUS_TRYAGAIN) {
668                         keep_response = true;
669                         *errnop = errno = ERANGE;
670                         goto done;
671                 }
672
673                 keep_response = false;
674                 *errnop = errno = 0;
675         }
676
677         winbindd_free_response(&response);
678         done:
679 #ifdef DEBUG_NSS
680         fprintf(stderr, "[%5d]: getpwnam %s returns %s (%d)\n", getpid(),
681                 name, nss_err_str(ret), ret);
682 #endif
683
684 #if HAVE_PTHREAD
685         pthread_mutex_unlock(&winbind_nss_mutex);
686 #endif
687
688         return ret;
689 }
690
691 /*
692  * NSS group functions
693  */
694
695 static struct winbindd_response getgrent_response;
696
697 static int ndx_gr_cache;                 /* Current index into grp cache */
698 static int num_gr_cache;                 /* Current size of grp cache */
699
700 /* Rewind "file pointer" to start of ntdom group database */
701
702 NSS_STATUS
703 _nss_winbind_setgrent(void)
704 {
705         NSS_STATUS ret;
706 #ifdef DEBUG_NSS
707         fprintf(stderr, "[%5d]: setgrent\n", getpid());
708 #endif
709
710 #if HAVE_PTHREAD
711         pthread_mutex_lock(&winbind_nss_mutex);
712 #endif
713
714         if (num_gr_cache > 0) {
715                 ndx_gr_cache = num_gr_cache = 0;
716                 winbindd_free_response(&getgrent_response);
717         }
718
719         ret = winbindd_request_response(WINBINDD_SETGRENT, NULL, NULL);
720 #ifdef DEBUG_NSS
721         fprintf(stderr, "[%5d]: setgrent returns %s (%d)\n", getpid(),
722                 nss_err_str(ret), ret);
723 #endif
724
725 #if HAVE_PTHREAD
726         pthread_mutex_unlock(&winbind_nss_mutex);
727 #endif
728
729         return ret;
730 }
731
732 /* Close "file pointer" for ntdom group database */
733
734 NSS_STATUS
735 _nss_winbind_endgrent(void)
736 {
737         NSS_STATUS ret;
738 #ifdef DEBUG_NSS
739         fprintf(stderr, "[%5d]: endgrent\n", getpid());
740 #endif
741
742 #if HAVE_PTHREAD
743         pthread_mutex_lock(&winbind_nss_mutex);
744 #endif
745
746         if (num_gr_cache > 0) {
747                 ndx_gr_cache = num_gr_cache = 0;
748                 winbindd_free_response(&getgrent_response);
749         }
750
751         ret = winbindd_request_response(WINBINDD_ENDGRENT, NULL, NULL);
752 #ifdef DEBUG_NSS
753         fprintf(stderr, "[%5d]: endgrent returns %s (%d)\n", getpid(),
754                 nss_err_str(ret), ret);
755 #endif
756
757 #if HAVE_PTHREAD
758         pthread_mutex_unlock(&winbind_nss_mutex);
759 #endif
760
761         return ret;
762 }
763
764 /* Get next entry from ntdom group database */
765
766 static NSS_STATUS
767 winbind_getgrent(enum winbindd_cmd cmd,
768                  struct group *result,
769                  char *buffer, size_t buflen, int *errnop)
770 {
771         NSS_STATUS ret;
772         static struct winbindd_request request;
773         static int called_again;
774
775
776 #ifdef DEBUG_NSS
777         fprintf(stderr, "[%5d]: getgrent\n", getpid());
778 #endif
779
780 #if HAVE_PTHREAD
781         pthread_mutex_lock(&winbind_nss_mutex);
782 #endif
783
784         /* Return an entry from the cache if we have one, or if we are
785            called again because we exceeded our static buffer.  */
786
787         if ((ndx_gr_cache < num_gr_cache) || called_again) {
788                 goto return_result;
789         }
790
791         /* Else call winbindd to get a bunch of entries */
792
793         if (num_gr_cache > 0) {
794                 winbindd_free_response(&getgrent_response);
795         }
796
797         ZERO_STRUCT(request);
798         ZERO_STRUCT(getgrent_response);
799
800         request.data.num_entries = MAX_GETGRENT_USERS;
801
802         ret = winbindd_request_response(cmd, &request,
803                                &getgrent_response);
804
805         if (ret == NSS_STATUS_SUCCESS) {
806                 struct winbindd_gr *gr_cache;
807                 int mem_ofs;
808
809                 /* Fill cache */
810
811                 ndx_gr_cache = 0;
812                 num_gr_cache = getgrent_response.data.num_entries;
813
814                 /* Return a result */
815
816         return_result:
817
818                 gr_cache = (struct winbindd_gr *)
819                         getgrent_response.extra_data.data;
820
821                 /* Check data is valid */
822
823                 if (gr_cache == NULL) {
824                         ret = NSS_STATUS_NOTFOUND;
825                         goto done;
826                 }
827
828                 /* Fill group membership.  The offset into the extra data
829                    for the group membership is the reported offset plus the
830                    size of all the winbindd_gr records returned. */
831
832                 mem_ofs = gr_cache[ndx_gr_cache].gr_mem_ofs +
833                         num_gr_cache * sizeof(struct winbindd_gr);
834
835                 ret = fill_grent(result, &gr_cache[ndx_gr_cache],
836                                  ((char *)getgrent_response.extra_data.data)+mem_ofs,
837                                  &buffer, &buflen);
838
839                 /* Out of memory - try again */
840
841                 if (ret == NSS_STATUS_TRYAGAIN) {
842                         called_again = true;
843                         *errnop = errno = ERANGE;
844                         goto done;
845                 }
846
847                 *errnop = 0;
848                 called_again = false;
849                 ndx_gr_cache++;
850
851                 /* If we've finished with this lot of results free cache */
852
853                 if (ndx_gr_cache == num_gr_cache) {
854                         ndx_gr_cache = num_gr_cache = 0;
855                         winbindd_free_response(&getgrent_response);
856                 }
857         }
858         done:
859 #ifdef DEBUG_NSS
860         fprintf(stderr, "[%5d]: getgrent returns %s (%d)\n", getpid(),
861                 nss_err_str(ret), ret);
862 #endif
863
864 #if HAVE_PTHREAD
865         pthread_mutex_unlock(&winbind_nss_mutex);
866 #endif
867
868         return ret;
869 }
870
871
872 NSS_STATUS
873 _nss_winbind_getgrent_r(struct group *result,
874                         char *buffer, size_t buflen, int *errnop)
875 {
876         return winbind_getgrent(WINBINDD_GETGRENT, result, buffer, buflen, errnop);
877 }
878
879 NSS_STATUS
880 _nss_winbind_getgrlst_r(struct group *result,
881                         char *buffer, size_t buflen, int *errnop)
882 {
883         return winbind_getgrent(WINBINDD_GETGRLST, result, buffer, buflen, errnop);
884 }
885
886 /* Return group struct from group name */
887
888 NSS_STATUS
889 _nss_winbind_getgrnam_r(const char *name,
890                         struct group *result, char *buffer,
891                         size_t buflen, int *errnop)
892 {
893         NSS_STATUS ret;
894         static struct winbindd_response response;
895         struct winbindd_request request;
896         static int keep_response;
897
898 #ifdef DEBUG_NSS
899         fprintf(stderr, "[%5d]: getgrnam %s\n", getpid(), name);
900 #endif
901
902 #if HAVE_PTHREAD
903         pthread_mutex_lock(&winbind_nss_mutex);
904 #endif
905
906         /* If our static buffer needs to be expanded we are called again */
907         /* Or if the stored response group name differs from the request. */
908
909         if (!keep_response || strcmp(name,response.data.gr.gr_name) != 0) {
910
911                 /* Call for the first time */
912
913                 ZERO_STRUCT(request);
914                 ZERO_STRUCT(response);
915
916                 strncpy(request.data.groupname, name,
917                         sizeof(request.data.groupname));
918                 request.data.groupname
919                         [sizeof(request.data.groupname) - 1] = '\0';
920
921                 ret = winbindd_request_response(WINBINDD_GETGRNAM, &request, &response);
922
923                 if (ret == NSS_STATUS_SUCCESS) {
924                         ret = fill_grent(result, &response.data.gr,
925                                          (char *)response.extra_data.data,
926                                          &buffer, &buflen);
927
928                         if (ret == NSS_STATUS_TRYAGAIN) {
929                                 keep_response = true;
930                                 *errnop = errno = ERANGE;
931                                 goto done;
932                         }
933                 }
934
935         } else {
936
937                 /* We've been called again */
938
939                 ret = fill_grent(result, &response.data.gr,
940                                  (char *)response.extra_data.data, &buffer,
941                                  &buflen);
942
943                 if (ret == NSS_STATUS_TRYAGAIN) {
944                         keep_response = true;
945                         *errnop = errno = ERANGE;
946                         goto done;
947                 }
948
949                 keep_response = false;
950                 *errnop = 0;
951         }
952
953         winbindd_free_response(&response);
954         done:
955 #ifdef DEBUG_NSS
956         fprintf(stderr, "[%5d]: getgrnam %s returns %s (%d)\n", getpid(),
957                 name, nss_err_str(ret), ret);
958 #endif
959
960 #if HAVE_PTHREAD
961         pthread_mutex_unlock(&winbind_nss_mutex);
962 #endif
963
964         return ret;
965 }
966
967 /* Return group struct from gid */
968
969 NSS_STATUS
970 _nss_winbind_getgrgid_r(gid_t gid,
971                         struct group *result, char *buffer,
972                         size_t buflen, int *errnop)
973 {
974         NSS_STATUS ret;
975         static struct winbindd_response response;
976         struct winbindd_request request;
977         static int keep_response;
978
979 #ifdef DEBUG_NSS
980         fprintf(stderr, "[%5d]: getgrgid %d\n", getpid(), gid);
981 #endif
982
983 #if HAVE_PTHREAD
984         pthread_mutex_lock(&winbind_nss_mutex);
985 #endif
986
987         /* If our static buffer needs to be expanded we are called again */
988         /* Or if the stored response group name differs from the request. */
989
990         if (!keep_response || gid != response.data.gr.gr_gid) {
991
992                 /* Call for the first time */
993
994                 ZERO_STRUCT(request);
995                 ZERO_STRUCT(response);
996
997                 request.data.gid = gid;
998
999                 ret = winbindd_request_response(WINBINDD_GETGRGID, &request, &response);
1000
1001                 if (ret == NSS_STATUS_SUCCESS) {
1002
1003                         ret = fill_grent(result, &response.data.gr,
1004                                          (char *)response.extra_data.data,
1005                                          &buffer, &buflen);
1006
1007                         if (ret == NSS_STATUS_TRYAGAIN) {
1008                                 keep_response = true;
1009                                 *errnop = errno = ERANGE;
1010                                 goto done;
1011                         }
1012                 }
1013
1014         } else {
1015
1016                 /* We've been called again */
1017
1018                 ret = fill_grent(result, &response.data.gr,
1019                                  (char *)response.extra_data.data, &buffer,
1020                                  &buflen);
1021
1022                 if (ret == NSS_STATUS_TRYAGAIN) {
1023                         keep_response = true;
1024                         *errnop = errno = ERANGE;
1025                         goto done;
1026                 }
1027
1028                 keep_response = false;
1029                 *errnop = 0;
1030         }
1031
1032         winbindd_free_response(&response);
1033         done:
1034 #ifdef DEBUG_NSS
1035         fprintf(stderr, "[%5d]: getgrgid %d returns %s (%d)\n", getpid(),
1036                 (unsigned int)gid, nss_err_str(ret), ret);
1037 #endif
1038
1039 #if HAVE_PTHREAD
1040         pthread_mutex_unlock(&winbind_nss_mutex);
1041 #endif
1042         return ret;
1043 }
1044
1045 /* Initialise supplementary groups */
1046
1047 NSS_STATUS
1048 _nss_winbind_initgroups_dyn(char *user, gid_t group, long int *start,
1049                             long int *size, gid_t **groups, long int limit,
1050                             int *errnop)
1051 {
1052         NSS_STATUS ret;
1053         struct winbindd_request request;
1054         struct winbindd_response response;
1055         int i;
1056
1057 #ifdef DEBUG_NSS
1058         fprintf(stderr, "[%5d]: initgroups %s (%d)\n", getpid(),
1059                 user, group);
1060 #endif
1061
1062 #if HAVE_PTHREAD
1063         pthread_mutex_lock(&winbind_nss_mutex);
1064 #endif
1065
1066         ZERO_STRUCT(request);
1067         ZERO_STRUCT(response);
1068
1069         strncpy(request.data.username, user,
1070                 sizeof(request.data.username) - 1);
1071
1072         ret = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
1073
1074         if (ret == NSS_STATUS_SUCCESS) {
1075                 int num_gids = response.data.num_entries;
1076                 gid_t *gid_list = (gid_t *)response.extra_data.data;
1077
1078 #ifdef DEBUG_NSS
1079                 fprintf(stderr, "[%5d]: initgroups %s: got NSS_STATUS_SUCCESS "
1080                                 "and %d gids\n", getpid(),
1081                                 user, num_gids);
1082 #endif
1083                 if (gid_list == NULL) {
1084                         ret = NSS_STATUS_NOTFOUND;
1085                         goto done;
1086                 }
1087
1088                 /* Copy group list to client */
1089
1090                 for (i = 0; i < num_gids; i++) {
1091
1092 #ifdef DEBUG_NSS
1093                         fprintf(stderr, "[%5d]: initgroups %s (%d): "
1094                                         "processing gid %d \n", getpid(),
1095                                         user, group, gid_list[i]);
1096 #endif
1097
1098                         /* Skip primary group */
1099
1100                         if (gid_list[i] == group) {
1101                                 continue;
1102                         }
1103
1104                         /* Filled buffer ? If so, resize. */
1105
1106                         if (*start == *size) {
1107                                 long int newsize;
1108                                 gid_t *newgroups;
1109
1110                                 newsize = 2 * (*size);
1111                                 if (limit > 0) {
1112                                         if (*size == limit) {
1113                                                 goto done;
1114                                         }
1115                                         if (newsize > limit) {
1116                                                 newsize = limit;
1117                                         }
1118                                 }
1119
1120                                 newgroups = (gid_t *)
1121                                         realloc((*groups),
1122                                                 newsize * sizeof(**groups));
1123                                 if (!newgroups) {
1124                                         *errnop = ENOMEM;
1125                                         ret = NSS_STATUS_NOTFOUND;
1126                                         goto done;
1127                                 }
1128                                 *groups = newgroups;
1129                                 *size = newsize;
1130                         }
1131
1132                         /* Add to buffer */
1133
1134                         (*groups)[*start] = gid_list[i];
1135                         *start += 1;
1136                 }
1137         }
1138
1139         /* Back to your regularly scheduled programming */
1140
1141  done:
1142 #ifdef DEBUG_NSS
1143         fprintf(stderr, "[%5d]: initgroups %s returns %s (%d)\n", getpid(),
1144                 user, nss_err_str(ret), ret);
1145 #endif
1146
1147 #if HAVE_PTHREAD
1148         pthread_mutex_unlock(&winbind_nss_mutex);
1149 #endif
1150
1151         return ret;
1152 }
1153
1154
1155 /* return a list of group SIDs for a user SID */
1156 NSS_STATUS
1157 _nss_winbind_getusersids(const char *user_sid, char **group_sids,
1158                          int *num_groups,
1159                          char *buffer, size_t buf_size, int *errnop)
1160 {
1161         NSS_STATUS ret;
1162         struct winbindd_request request;
1163         struct winbindd_response response;
1164
1165 #ifdef DEBUG_NSS
1166         fprintf(stderr, "[%5d]: getusersids %s\n", getpid(), user_sid);
1167 #endif
1168
1169 #if HAVE_PTHREAD
1170         pthread_mutex_lock(&winbind_nss_mutex);
1171 #endif
1172
1173         ZERO_STRUCT(request);
1174         ZERO_STRUCT(response);
1175
1176         strncpy(request.data.sid, user_sid,sizeof(request.data.sid) - 1);
1177         request.data.sid[sizeof(request.data.sid) - 1] = '\0';
1178
1179         ret = winbindd_request_response(WINBINDD_GETUSERSIDS, &request, &response);
1180
1181         if (ret != NSS_STATUS_SUCCESS) {
1182                 goto done;
1183         }
1184
1185         if (buf_size < response.length - sizeof(response)) {
1186                 ret = NSS_STATUS_TRYAGAIN;
1187                 errno = *errnop = ERANGE;
1188                 goto done;
1189         }
1190
1191         *num_groups = response.data.num_entries;
1192         *group_sids = buffer;
1193         memcpy(buffer, response.extra_data.data, response.length - sizeof(response));
1194         errno = *errnop = 0;
1195
1196  done:
1197         winbindd_free_response(&response);
1198
1199 #if HAVE_PTHREAD
1200         pthread_mutex_unlock(&winbind_nss_mutex);
1201 #endif
1202
1203         return ret;
1204 }
1205
1206
1207 /* map a user or group name to a SID string */
1208 NSS_STATUS
1209 _nss_winbind_nametosid(const char *name, char **sid, char *buffer,
1210                        size_t buflen, int *errnop)
1211 {
1212         NSS_STATUS ret;
1213         struct winbindd_response response;
1214         struct winbindd_request request;
1215
1216 #ifdef DEBUG_NSS
1217         fprintf(stderr, "[%5d]: nametosid %s\n", getpid(), name);
1218 #endif
1219
1220 #if HAVE_PTHREAD
1221         pthread_mutex_lock(&winbind_nss_mutex);
1222 #endif
1223
1224         ZERO_STRUCT(response);
1225         ZERO_STRUCT(request);
1226
1227         strncpy(request.data.name.name, name,
1228                 sizeof(request.data.name.name) - 1);
1229         request.data.name.name[sizeof(request.data.name.name) - 1] = '\0';
1230
1231         ret = winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response);
1232         if (ret != NSS_STATUS_SUCCESS) {
1233                 *errnop = errno = EINVAL;
1234                 goto failed;
1235         }
1236
1237         if (buflen < strlen(response.data.sid.sid)+1) {
1238                 ret = NSS_STATUS_TRYAGAIN;
1239                 *errnop = errno = ERANGE;
1240                 goto failed;
1241         }
1242
1243         *errnop = errno = 0;
1244         *sid = buffer;
1245         strcpy(*sid, response.data.sid.sid);
1246
1247 failed:
1248         winbindd_free_response(&response);
1249
1250 #if HAVE_PTHREAD
1251         pthread_mutex_unlock(&winbind_nss_mutex);
1252 #endif
1253
1254         return ret;
1255 }
1256
1257 /* map a sid string to a user or group name */
1258 NSS_STATUS
1259 _nss_winbind_sidtoname(const char *sid, char **name, char *buffer,
1260                        size_t buflen, int *errnop)
1261 {
1262         NSS_STATUS ret;
1263         struct winbindd_response response;
1264         struct winbindd_request request;
1265         static char sep_char;
1266         unsigned needed;
1267
1268 #ifdef DEBUG_NSS
1269         fprintf(stderr, "[%5d]: sidtoname %s\n", getpid(), sid);
1270 #endif
1271
1272 #if HAVE_PTHREAD
1273         pthread_mutex_lock(&winbind_nss_mutex);
1274 #endif
1275
1276         ZERO_STRUCT(response);
1277         ZERO_STRUCT(request);
1278
1279         /* we need to fetch the separator first time through */
1280         if (!sep_char) {
1281                 ret = winbindd_request_response(WINBINDD_INFO, &request, &response);
1282                 if (ret != NSS_STATUS_SUCCESS) {
1283                         *errnop = errno = EINVAL;
1284                         goto failed;
1285                 }
1286
1287                 sep_char = response.data.info.winbind_separator;
1288                 winbindd_free_response(&response);
1289         }
1290
1291
1292         strncpy(request.data.sid, sid,
1293                 sizeof(request.data.sid) - 1);
1294         request.data.sid[sizeof(request.data.sid) - 1] = '\0';
1295
1296         ret = winbindd_request_response(WINBINDD_LOOKUPSID, &request, &response);
1297         if (ret != NSS_STATUS_SUCCESS) {
1298                 *errnop = errno = EINVAL;
1299                 goto failed;
1300         }
1301
1302         needed =
1303                 strlen(response.data.name.dom_name) +
1304                 strlen(response.data.name.name) + 2;
1305
1306         if (buflen < needed) {
1307                 ret = NSS_STATUS_TRYAGAIN;
1308                 *errnop = errno = ERANGE;
1309                 goto failed;
1310         }
1311
1312         snprintf(buffer, needed, "%s%c%s",
1313                  response.data.name.dom_name,
1314                  sep_char,
1315                  response.data.name.name);
1316
1317         *name = buffer;
1318         *errnop = errno = 0;
1319
1320 failed:
1321         winbindd_free_response(&response);
1322
1323 #if HAVE_PTHREAD
1324         pthread_mutex_unlock(&winbind_nss_mutex);
1325 #endif
1326
1327         return ret;
1328 }
1329
1330 /* map a sid to a uid */
1331 NSS_STATUS
1332 _nss_winbind_sidtouid(const char *sid, uid_t *uid, int *errnop)
1333 {
1334         NSS_STATUS ret;
1335         struct winbindd_response response;
1336         struct winbindd_request request;
1337
1338 #ifdef DEBUG_NSS
1339         fprintf(stderr, "[%5d]: sidtouid %s\n", getpid(), sid);
1340 #endif
1341
1342 #if HAVE_PTHREAD
1343         pthread_mutex_lock(&winbind_nss_mutex);
1344 #endif
1345
1346         ZERO_STRUCT(request);
1347         ZERO_STRUCT(response);
1348
1349         strncpy(request.data.sid, sid, sizeof(request.data.sid) - 1);
1350         request.data.sid[sizeof(request.data.sid) - 1] = '\0';
1351
1352         ret = winbindd_request_response(WINBINDD_SID_TO_UID, &request, &response);
1353         if (ret != NSS_STATUS_SUCCESS) {
1354                 *errnop = errno = EINVAL;
1355                 goto failed;
1356         }
1357
1358         *uid = response.data.uid;
1359
1360 failed:
1361
1362 #if HAVE_PTHREAD
1363         pthread_mutex_unlock(&winbind_nss_mutex);
1364 #endif
1365
1366         return ret;
1367 }
1368
1369 /* map a sid to a gid */
1370 NSS_STATUS
1371 _nss_winbind_sidtogid(const char *sid, gid_t *gid, int *errnop)
1372 {
1373         NSS_STATUS ret;
1374         struct winbindd_response response;
1375         struct winbindd_request request;
1376
1377 #ifdef DEBUG_NSS
1378         fprintf(stderr, "[%5d]: sidtogid %s\n", getpid(), sid);
1379 #endif
1380
1381 #if HAVE_PTHREAD
1382         pthread_mutex_lock(&winbind_nss_mutex);
1383 #endif
1384
1385         ZERO_STRUCT(request);
1386         ZERO_STRUCT(response);
1387
1388         strncpy(request.data.sid, sid, sizeof(request.data.sid) - 1);
1389         request.data.sid[sizeof(request.data.sid) - 1] = '\0';
1390
1391         ret = winbindd_request_response(WINBINDD_SID_TO_GID, &request, &response);
1392         if (ret != NSS_STATUS_SUCCESS) {
1393                 *errnop = errno = EINVAL;
1394                 goto failed;
1395         }
1396
1397         *gid = response.data.gid;
1398
1399 failed:
1400
1401 #if HAVE_PTHREAD
1402         pthread_mutex_unlock(&winbind_nss_mutex);
1403 #endif
1404
1405         return ret;
1406 }
1407
1408 /* map a uid to a SID string */
1409 NSS_STATUS
1410 _nss_winbind_uidtosid(uid_t uid, char **sid, char *buffer,
1411                       size_t buflen, int *errnop)
1412 {
1413         NSS_STATUS ret;
1414         struct winbindd_response response;
1415         struct winbindd_request request;
1416
1417 #ifdef DEBUG_NSS
1418         fprintf(stderr, "[%5u]: uidtosid %u\n", (unsigned int)getpid(), (unsigned int)uid);
1419 #endif
1420
1421 #if HAVE_PTHREAD
1422         pthread_mutex_lock(&winbind_nss_mutex);
1423 #endif
1424
1425         ZERO_STRUCT(response);
1426         ZERO_STRUCT(request);
1427
1428         request.data.uid = uid;
1429
1430         ret = winbindd_request_response(WINBINDD_UID_TO_SID, &request, &response);
1431         if (ret != NSS_STATUS_SUCCESS) {
1432                 *errnop = errno = EINVAL;
1433                 goto failed;
1434         }
1435
1436         if (buflen < strlen(response.data.sid.sid)+1) {
1437                 ret = NSS_STATUS_TRYAGAIN;
1438                 *errnop = errno = ERANGE;
1439                 goto failed;
1440         }
1441
1442         *errnop = errno = 0;
1443         *sid = buffer;
1444         strcpy(*sid, response.data.sid.sid);
1445
1446 failed:
1447         winbindd_free_response(&response);
1448
1449 #if HAVE_PTHREAD
1450         pthread_mutex_unlock(&winbind_nss_mutex);
1451 #endif
1452
1453         return ret;
1454 }
1455
1456 /* map a gid to a SID string */
1457 NSS_STATUS
1458 _nss_winbind_gidtosid(gid_t gid, char **sid, char *buffer,
1459                       size_t buflen, int *errnop)
1460 {
1461         NSS_STATUS ret;
1462         struct winbindd_response response;
1463         struct winbindd_request request;
1464
1465 #ifdef DEBUG_NSS
1466         fprintf(stderr, "[%5u]: gidtosid %u\n", (unsigned int)getpid(), (unsigned int)gid);
1467 #endif
1468
1469 #if HAVE_PTHREAD
1470         pthread_mutex_lock(&winbind_nss_mutex);
1471 #endif
1472
1473         ZERO_STRUCT(response);
1474         ZERO_STRUCT(request);
1475
1476         request.data.gid = gid;
1477
1478         ret = winbindd_request_response(WINBINDD_GID_TO_SID, &request, &response);
1479         if (ret != NSS_STATUS_SUCCESS) {
1480                 *errnop = errno = EINVAL;
1481                 goto failed;
1482         }
1483
1484         if (buflen < strlen(response.data.sid.sid)+1) {
1485                 ret = NSS_STATUS_TRYAGAIN;
1486                 *errnop = errno = ERANGE;
1487                 goto failed;
1488         }
1489
1490         *errnop = errno = 0;
1491         *sid = buffer;
1492         strcpy(*sid, response.data.sid.sid);
1493
1494 failed:
1495         winbindd_free_response(&response);
1496
1497 #if HAVE_PTHREAD
1498         pthread_mutex_unlock(&winbind_nss_mutex);
1499 #endif
1500
1501         return ret;
1502 }