2 Unix SMB/CIFS implementation.
4 Windows NT Domain nsswitch module
6 Copyright (C) Tim Potter 2000
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.
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.
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/>.
22 #include "winbind_client.h"
29 static pthread_mutex_t winbind_nss_mutex = PTHREAD_MUTEX_INITIALIZER;
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. */
36 #define MAX_GETPWENT_USERS 250
37 #define MAX_GETGRENT_USERS 250
39 /*************************************************************************
40 ************************************************************************/
43 static const char *nss_err_str(NSS_STATUS ret)
46 case NSS_STATUS_TRYAGAIN:
47 return "NSS_STATUS_TRYAGAIN";
48 case NSS_STATUS_SUCCESS:
49 return "NSS_STATUS_SUCCESS";
50 case NSS_STATUS_NOTFOUND:
51 return "NSS_STATUS_NOTFOUND";
52 case NSS_STATUS_UNAVAIL:
53 return "NSS_STATUS_UNAVAIL";
54 #ifdef NSS_STATUS_RETURN
55 case NSS_STATUS_RETURN:
56 return "NSS_STATUS_RETURN";
59 return "UNKNOWN RETURN CODE!!!!!!!";
64 /* Prototypes from wb_common.c */
66 /* Allocate some space from the nss static buffer. The buffer and buflen
67 are the pointers passed in by the C library to the _nss_ntdom_*
70 static char *get_static(char **buffer, size_t *buflen, size_t len)
74 /* Error check. We return false if things aren't set up right, or
75 there isn't enough buffer space left. */
77 if ((buffer == NULL) || (buflen == NULL) || (*buflen < len)) {
81 /* Return an index into the static buffer */
90 /* I've copied the strtok() replacement function next_token_Xalloc() from
91 lib/util_str.c as I really don't want to have to link in any other
92 objects if I can possibly avoid it. */
94 static bool next_token_alloc(const char **ptr,
111 /* default to simple separators */
116 /* find the first non sep char */
117 while (*s && strchr(sep,*s)) {
126 /* When restarting we need to go from here. */
129 /* Work out the length needed. */
130 for (quoted = false; *s &&
131 (quoted || !strchr(sep,*s)); s++) {
139 /* We started with len = 1 so we have space for the nul. */
140 *pp_buff = (char *)malloc(len);
145 /* copy over the token */
148 for (quoted = false; *s &&
149 (quoted || !strchr(sep,*s)); s++) {
157 *ptr = (*s) ? s+1 : s;
163 /* Fill a pwent structure from a winbindd_response structure. We use
164 the static data passed to us by libc to put strings and stuff in.
165 Return NSS_STATUS_TRYAGAIN if we run out of memory. */
167 static NSS_STATUS fill_pwent(struct passwd *result,
168 struct winbindd_pw *pw,
169 char **buffer, size_t *buflen)
174 len = strlen(pw->pw_name) + 1;
176 if ((result->pw_name =
177 get_static(buffer, buflen, len)) == NULL) {
181 return NSS_STATUS_TRYAGAIN;
184 memcpy(result->pw_name, pw->pw_name, len);
187 len = strlen(pw->pw_passwd) + 1;
189 if ((result->pw_passwd =
190 get_static(buffer, buflen, len)) == NULL) {
194 return NSS_STATUS_TRYAGAIN;
197 memcpy(result->pw_passwd, pw->pw_passwd, len);
201 result->pw_uid = pw->pw_uid;
202 result->pw_gid = pw->pw_gid;
205 len = strlen(pw->pw_gecos) + 1;
207 if ((result->pw_gecos =
208 get_static(buffer, buflen, len)) == NULL) {
212 return NSS_STATUS_TRYAGAIN;
215 memcpy(result->pw_gecos, pw->pw_gecos, len);
218 len = strlen(pw->pw_dir) + 1;
220 if ((result->pw_dir =
221 get_static(buffer, buflen, len)) == NULL) {
225 return NSS_STATUS_TRYAGAIN;
228 memcpy(result->pw_dir, pw->pw_dir, len);
231 len = strlen(pw->pw_shell) + 1;
233 if ((result->pw_shell =
234 get_static(buffer, buflen, len)) == NULL) {
238 return NSS_STATUS_TRYAGAIN;
241 memcpy(result->pw_shell, pw->pw_shell, len);
243 /* The struct passwd for Solaris has some extra fields which must
244 be initialised or nscd crashes. */
246 #ifdef HAVE_PASSWD_PW_COMMENT
247 result->pw_comment = "";
250 #ifdef HAVE_PASSWD_PW_AGE
254 return NSS_STATUS_SUCCESS;
257 /* Fill a grent structure from a winbindd_response structure. We use
258 the static data passed to us by libc to put strings and stuff in.
259 Return NSS_STATUS_TRYAGAIN if we run out of memory. */
261 static NSS_STATUS fill_grent(struct group *result, struct winbindd_gr *gr,
262 const char *gr_mem, char **buffer, size_t *buflen)
270 len = strlen(gr->gr_name) + 1;
272 if ((result->gr_name =
273 get_static(buffer, buflen, len)) == NULL) {
277 return NSS_STATUS_TRYAGAIN;
280 memcpy(result->gr_name, gr->gr_name, len);
283 len = strlen(gr->gr_passwd) + 1;
285 if ((result->gr_passwd =
286 get_static(buffer, buflen, len)) == NULL) {
289 return NSS_STATUS_TRYAGAIN;
292 memcpy(result->gr_passwd, gr->gr_passwd, len);
296 result->gr_gid = gr->gr_gid;
298 /* Group membership */
304 /* this next value is a pointer to a pointer so let's align it */
306 /* Calculate number of extra bytes needed to align on pointer size boundry */
307 if ((i = (unsigned long)(*buffer) % sizeof(char*)) != 0)
308 i = sizeof(char*) - i;
310 if ((tst = get_static(buffer, buflen, ((gr->num_gr_mem + 1) *
311 sizeof(char *)+i))) == NULL) {
315 return NSS_STATUS_TRYAGAIN;
317 result->gr_mem = (char **)(tst + i);
319 if (gr->num_gr_mem == 0) {
323 *(result->gr_mem) = NULL;
324 return NSS_STATUS_SUCCESS;
327 /* Start looking at extra data */
331 while(next_token_alloc((const char **)&gr_mem, &name, ",")) {
332 /* Allocate space for member */
333 len = strlen(name) + 1;
335 if (((result->gr_mem)[i] =
336 get_static(buffer, buflen, len)) == NULL) {
339 return NSS_STATUS_TRYAGAIN;
341 memcpy((result->gr_mem)[i], name, len);
348 (result->gr_mem)[i] = NULL;
350 return NSS_STATUS_SUCCESS;
357 static struct winbindd_response getpwent_response;
359 static int ndx_pw_cache; /* Current index into pwd cache */
360 static int num_pw_cache; /* Current size of pwd cache */
362 /* Rewind "file pointer" to start of ntdom password database */
365 _nss_winbind_setpwent(void)
369 fprintf(stderr, "[%5d]: setpwent\n", getpid());
373 pthread_mutex_lock(&winbind_nss_mutex);
376 if (num_pw_cache > 0) {
377 ndx_pw_cache = num_pw_cache = 0;
378 winbindd_free_response(&getpwent_response);
381 winbind_set_client_name("nss_winbind");
382 ret = winbindd_request_response(NULL, WINBINDD_SETPWENT, NULL, NULL);
384 fprintf(stderr, "[%5d]: setpwent returns %s (%d)\n", getpid(),
385 nss_err_str(ret), ret);
389 pthread_mutex_unlock(&winbind_nss_mutex);
394 /* Close ntdom password database "file pointer" */
397 _nss_winbind_endpwent(void)
401 fprintf(stderr, "[%5d]: endpwent\n", getpid());
405 pthread_mutex_lock(&winbind_nss_mutex);
408 if (num_pw_cache > 0) {
409 ndx_pw_cache = num_pw_cache = 0;
410 winbindd_free_response(&getpwent_response);
413 winbind_set_client_name("nss_winbind");
414 ret = winbindd_request_response(NULL, WINBINDD_ENDPWENT, NULL, NULL);
416 fprintf(stderr, "[%5d]: endpwent returns %s (%d)\n", getpid(),
417 nss_err_str(ret), ret);
421 pthread_mutex_unlock(&winbind_nss_mutex);
427 /* Fetch the next password entry from ntdom password database */
430 _nss_winbind_getpwent_r(struct passwd *result, char *buffer,
431 size_t buflen, int *errnop)
434 struct winbindd_request request;
435 static int called_again;
438 fprintf(stderr, "[%5d]: getpwent\n", getpid());
442 pthread_mutex_lock(&winbind_nss_mutex);
445 /* Return an entry from the cache if we have one, or if we are
446 called again because we exceeded our static buffer. */
448 if ((ndx_pw_cache < num_pw_cache) || called_again) {
452 /* Else call winbindd to get a bunch of entries */
454 if (num_pw_cache > 0) {
455 winbindd_free_response(&getpwent_response);
458 ZERO_STRUCT(request);
459 ZERO_STRUCT(getpwent_response);
461 request.data.num_entries = MAX_GETPWENT_USERS;
463 winbind_set_client_name("nss_winbind");
464 ret = winbindd_request_response(NULL, WINBINDD_GETPWENT, &request,
467 if (ret == NSS_STATUS_SUCCESS) {
468 struct winbindd_pw *pw_cache;
473 num_pw_cache = getpwent_response.data.num_entries;
475 /* Return a result */
479 pw_cache = (struct winbindd_pw *)
480 getpwent_response.extra_data.data;
482 /* Check data is valid */
484 if (pw_cache == NULL) {
485 ret = NSS_STATUS_NOTFOUND;
489 ret = fill_pwent(result, &pw_cache[ndx_pw_cache],
492 /* Out of memory - try again */
494 if (ret == NSS_STATUS_TRYAGAIN) {
496 *errnop = errno = ERANGE;
501 called_again = false;
504 /* If we've finished with this lot of results free cache */
506 if (ndx_pw_cache == num_pw_cache) {
507 ndx_pw_cache = num_pw_cache = 0;
508 winbindd_free_response(&getpwent_response);
513 fprintf(stderr, "[%5d]: getpwent returns %s (%d)\n", getpid(),
514 nss_err_str(ret), ret);
518 pthread_mutex_unlock(&winbind_nss_mutex);
523 /* Return passwd struct from uid */
526 _nss_winbind_getpwuid_r(uid_t uid, struct passwd *result, char *buffer,
527 size_t buflen, int *errnop)
530 static struct winbindd_response response;
531 struct winbindd_request request;
532 static int keep_response;
535 fprintf(stderr, "[%5d]: getpwuid_r %d\n", getpid(), (unsigned int)uid);
539 pthread_mutex_lock(&winbind_nss_mutex);
542 /* If our static buffer needs to be expanded we are called again */
543 if (!keep_response || uid != response.data.pw.pw_uid) {
545 /* Call for the first time */
547 response = (struct winbindd_response) {
550 request = (struct winbindd_request) {
551 .wb_flags = WBFLAG_FROM_NSS,
557 winbind_set_client_name("nss_winbind");
558 ret = winbindd_request_response(NULL, WINBINDD_GETPWUID, &request, &response);
560 if (ret == NSS_STATUS_SUCCESS) {
561 ret = fill_pwent(result, &response.data.pw,
564 if (ret == NSS_STATUS_TRYAGAIN) {
565 keep_response = true;
566 *errnop = errno = ERANGE;
573 /* We've been called again */
575 ret = fill_pwent(result, &response.data.pw, &buffer, &buflen);
577 if (ret == NSS_STATUS_TRYAGAIN) {
578 *errnop = errno = ERANGE;
582 keep_response = false;
586 winbindd_free_response(&response);
591 fprintf(stderr, "[%5d]: getpwuid %d returns %s (%d)\n", getpid(),
592 (unsigned int)uid, nss_err_str(ret), ret);
596 pthread_mutex_unlock(&winbind_nss_mutex);
602 /* Return passwd struct from username */
604 _nss_winbind_getpwnam_r(const char *name, struct passwd *result, char *buffer,
605 size_t buflen, int *errnop)
608 static struct winbindd_response response;
609 struct winbindd_request request;
610 static int keep_response;
613 fprintf(stderr, "[%5d]: getpwnam_r %s\n", getpid(), name);
617 pthread_mutex_lock(&winbind_nss_mutex);
620 /* If our static buffer needs to be expanded we are called again */
622 if (!keep_response || strcmp(name,response.data.pw.pw_name) != 0) {
624 /* Call for the first time */
626 response = (struct winbindd_response) {
629 request = (struct winbindd_request) {
630 .wb_flags = WBFLAG_FROM_NSS,
633 strncpy(request.data.username, name,
634 sizeof(request.data.username) - 1);
635 request.data.username
636 [sizeof(request.data.username) - 1] = '\0';
638 winbind_set_client_name("nss_winbind");
639 ret = winbindd_request_response(NULL, WINBINDD_GETPWNAM, &request, &response);
641 if (ret == NSS_STATUS_SUCCESS) {
642 ret = fill_pwent(result, &response.data.pw, &buffer,
645 if (ret == NSS_STATUS_TRYAGAIN) {
646 keep_response = true;
647 *errnop = errno = ERANGE;
654 /* We've been called again */
656 ret = fill_pwent(result, &response.data.pw, &buffer, &buflen);
658 if (ret == NSS_STATUS_TRYAGAIN) {
659 keep_response = true;
660 *errnop = errno = ERANGE;
664 keep_response = false;
668 winbindd_free_response(&response);
671 fprintf(stderr, "[%5d]: getpwnam %s returns %s (%d)\n", getpid(),
672 name, nss_err_str(ret), ret);
676 pthread_mutex_unlock(&winbind_nss_mutex);
683 * NSS group functions
686 static struct winbindd_response getgrent_response;
688 static int ndx_gr_cache; /* Current index into grp cache */
689 static int num_gr_cache; /* Current size of grp cache */
691 /* Rewind "file pointer" to start of ntdom group database */
694 _nss_winbind_setgrent(void)
698 fprintf(stderr, "[%5d]: setgrent\n", getpid());
702 pthread_mutex_lock(&winbind_nss_mutex);
705 if (num_gr_cache > 0) {
706 ndx_gr_cache = num_gr_cache = 0;
707 winbindd_free_response(&getgrent_response);
710 winbind_set_client_name("nss_winbind");
711 ret = winbindd_request_response(NULL, WINBINDD_SETGRENT, NULL, NULL);
713 fprintf(stderr, "[%5d]: setgrent returns %s (%d)\n", getpid(),
714 nss_err_str(ret), ret);
718 pthread_mutex_unlock(&winbind_nss_mutex);
724 /* Close "file pointer" for ntdom group database */
727 _nss_winbind_endgrent(void)
731 fprintf(stderr, "[%5d]: endgrent\n", getpid());
735 pthread_mutex_lock(&winbind_nss_mutex);
738 if (num_gr_cache > 0) {
739 ndx_gr_cache = num_gr_cache = 0;
740 winbindd_free_response(&getgrent_response);
743 winbind_set_client_name("nss_winbind");
744 ret = winbindd_request_response(NULL, WINBINDD_ENDGRENT, NULL, NULL);
746 fprintf(stderr, "[%5d]: endgrent returns %s (%d)\n", getpid(),
747 nss_err_str(ret), ret);
751 pthread_mutex_unlock(&winbind_nss_mutex);
757 /* Get next entry from ntdom group database */
760 winbind_getgrent(enum winbindd_cmd cmd,
761 struct group *result,
762 char *buffer, size_t buflen, int *errnop)
765 static struct winbindd_request request;
766 static int called_again;
770 fprintf(stderr, "[%5d]: getgrent\n", getpid());
774 pthread_mutex_lock(&winbind_nss_mutex);
777 /* Return an entry from the cache if we have one, or if we are
778 called again because we exceeded our static buffer. */
780 if ((ndx_gr_cache < num_gr_cache) || called_again) {
784 /* Else call winbindd to get a bunch of entries */
786 if (num_gr_cache > 0) {
787 winbindd_free_response(&getgrent_response);
790 ZERO_STRUCT(request);
791 ZERO_STRUCT(getgrent_response);
793 request.data.num_entries = MAX_GETGRENT_USERS;
795 winbind_set_client_name("nss_winbind");
796 ret = winbindd_request_response(NULL, cmd, &request,
799 if (ret == NSS_STATUS_SUCCESS) {
800 struct winbindd_gr *gr_cache;
806 num_gr_cache = getgrent_response.data.num_entries;
808 /* Return a result */
812 gr_cache = (struct winbindd_gr *)
813 getgrent_response.extra_data.data;
815 /* Check data is valid */
817 if (gr_cache == NULL) {
818 ret = NSS_STATUS_NOTFOUND;
822 /* Fill group membership. The offset into the extra data
823 for the group membership is the reported offset plus the
824 size of all the winbindd_gr records returned. */
826 mem_ofs = gr_cache[ndx_gr_cache].gr_mem_ofs +
827 num_gr_cache * sizeof(struct winbindd_gr);
829 ret = fill_grent(result, &gr_cache[ndx_gr_cache],
830 ((char *)getgrent_response.extra_data.data)+mem_ofs,
833 /* Out of memory - try again */
835 if (ret == NSS_STATUS_TRYAGAIN) {
837 *errnop = errno = ERANGE;
842 called_again = false;
845 /* If we've finished with this lot of results free cache */
847 if (ndx_gr_cache == num_gr_cache) {
848 ndx_gr_cache = num_gr_cache = 0;
849 winbindd_free_response(&getgrent_response);
854 fprintf(stderr, "[%5d]: getgrent returns %s (%d)\n", getpid(),
855 nss_err_str(ret), ret);
859 pthread_mutex_unlock(&winbind_nss_mutex);
867 _nss_winbind_getgrent_r(struct group *result,
868 char *buffer, size_t buflen, int *errnop)
870 return winbind_getgrent(WINBINDD_GETGRENT, result, buffer, buflen, errnop);
874 _nss_winbind_getgrlst_r(struct group *result,
875 char *buffer, size_t buflen, int *errnop)
877 return winbind_getgrent(WINBINDD_GETGRLST, result, buffer, buflen, errnop);
880 /* Return group struct from group name */
883 _nss_winbind_getgrnam_r(const char *name,
884 struct group *result, char *buffer,
885 size_t buflen, int *errnop)
888 static struct winbindd_response response;
889 struct winbindd_request request;
890 static int keep_response;
893 fprintf(stderr, "[%5d]: getgrnam %s\n", getpid(), name);
897 pthread_mutex_lock(&winbind_nss_mutex);
900 /* If our static buffer needs to be expanded we are called again */
901 /* Or if the stored response group name differs from the request. */
903 if (!keep_response || strcmp(name,response.data.gr.gr_name) != 0) {
905 /* Call for the first time */
907 response = (struct winbindd_response) {
910 request = (struct winbindd_request) {
911 .wb_flags = WBFLAG_FROM_NSS,
914 strncpy(request.data.groupname, name,
915 sizeof(request.data.groupname));
916 request.data.groupname
917 [sizeof(request.data.groupname) - 1] = '\0';
919 winbind_set_client_name("nss_winbind");
920 ret = winbindd_request_response(NULL, WINBINDD_GETGRNAM,
921 &request, &response);
923 if (ret == NSS_STATUS_SUCCESS) {
924 ret = fill_grent(result, &response.data.gr,
925 (char *)response.extra_data.data,
928 if (ret == NSS_STATUS_TRYAGAIN) {
929 keep_response = true;
930 *errnop = errno = ERANGE;
937 /* We've been called again */
939 ret = fill_grent(result, &response.data.gr,
940 (char *)response.extra_data.data, &buffer,
943 if (ret == NSS_STATUS_TRYAGAIN) {
944 keep_response = true;
945 *errnop = errno = ERANGE;
949 keep_response = false;
953 winbindd_free_response(&response);
956 fprintf(stderr, "[%5d]: getgrnam %s returns %s (%d)\n", getpid(),
957 name, nss_err_str(ret), ret);
961 pthread_mutex_unlock(&winbind_nss_mutex);
967 /* Return group struct from gid */
970 _nss_winbind_getgrgid_r(gid_t gid,
971 struct group *result, char *buffer,
972 size_t buflen, int *errnop)
975 static struct winbindd_response response;
976 struct winbindd_request request;
977 static int keep_response;
980 fprintf(stderr, "[%5d]: getgrgid %d\n", getpid(), gid);
984 pthread_mutex_lock(&winbind_nss_mutex);
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. */
990 if (!keep_response || gid != response.data.gr.gr_gid) {
992 /* Call for the first time */
994 response = (struct winbindd_response) {
997 request = (struct winbindd_request) {
998 .wb_flags = WBFLAG_FROM_NSS,
1002 request.data.gid = gid;
1004 winbind_set_client_name("nss_winbind");
1005 ret = winbindd_request_response(NULL, WINBINDD_GETGRGID,
1006 &request, &response);
1008 if (ret == NSS_STATUS_SUCCESS) {
1010 ret = fill_grent(result, &response.data.gr,
1011 (char *)response.extra_data.data,
1014 if (ret == NSS_STATUS_TRYAGAIN) {
1015 keep_response = true;
1016 *errnop = errno = ERANGE;
1023 /* We've been called again */
1025 ret = fill_grent(result, &response.data.gr,
1026 (char *)response.extra_data.data, &buffer,
1029 if (ret == NSS_STATUS_TRYAGAIN) {
1030 keep_response = true;
1031 *errnop = errno = ERANGE;
1035 keep_response = false;
1039 winbindd_free_response(&response);
1042 fprintf(stderr, "[%5d]: getgrgid %d returns %s (%d)\n", getpid(),
1043 (unsigned int)gid, nss_err_str(ret), ret);
1047 pthread_mutex_unlock(&winbind_nss_mutex);
1052 /* Initialise supplementary groups */
1055 _nss_winbind_initgroups_dyn(const char *user, gid_t group, long int *start,
1056 long int *size, gid_t **groups, long int limit,
1060 struct winbindd_request request;
1061 struct winbindd_response response;
1065 fprintf(stderr, "[%5d]: initgroups %s (%d)\n", getpid(),
1070 pthread_mutex_lock(&winbind_nss_mutex);
1073 ZERO_STRUCT(request);
1074 ZERO_STRUCT(response);
1076 strncpy(request.data.username, user,
1077 sizeof(request.data.username) - 1);
1079 winbind_set_client_name("nss_winbind");
1080 ret = winbindd_request_response(NULL, WINBINDD_GETGROUPS,
1081 &request, &response);
1083 if (ret == NSS_STATUS_SUCCESS) {
1084 int num_gids = response.data.num_entries;
1085 gid_t *gid_list = (gid_t *)response.extra_data.data;
1088 fprintf(stderr, "[%5d]: initgroups %s: got NSS_STATUS_SUCCESS "
1089 "and %d gids\n", getpid(),
1092 if (gid_list == NULL) {
1093 ret = NSS_STATUS_NOTFOUND;
1097 /* Copy group list to client */
1099 for (i = 0; i < num_gids; i++) {
1102 fprintf(stderr, "[%5d]: initgroups %s (%d): "
1103 "processing gid %d \n", getpid(),
1104 user, group, gid_list[i]);
1107 /* Skip primary group */
1109 if (gid_list[i] == group) {
1113 /* Skip groups without a mapping */
1114 if (gid_list[i] == (uid_t)-1) {
1118 /* Filled buffer ? If so, resize. */
1120 if (*start == *size) {
1124 newsize = 2 * (*size);
1126 if (*size == limit) {
1129 if (newsize > limit) {
1134 newgroups = (gid_t *)
1136 newsize * sizeof(**groups));
1139 ret = NSS_STATUS_NOTFOUND;
1142 *groups = newgroups;
1148 (*groups)[*start] = gid_list[i];
1153 /* Back to your regularly scheduled programming */
1157 fprintf(stderr, "[%5d]: initgroups %s returns %s (%d)\n", getpid(),
1158 user, nss_err_str(ret), ret);
1162 pthread_mutex_unlock(&winbind_nss_mutex);