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 Library General Public
10 License as published by the Free Software Foundation; either
11 version 2 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 Library General Public
19 License along with this library; if not, write to the
20 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
24 #include "winbind_client.h"
26 /* Maximum number of users to pass back over the unix domain socket
27 per call. This is not a static limit on the total number of users
28 or groups returned in total. */
30 #define MAX_GETPWENT_USERS 250
31 #define MAX_GETGRENT_USERS 250
33 /* Prototypes from wb_common.c */
35 extern int winbindd_fd
;
37 /* Allocate some space from the nss static buffer. The buffer and buflen
38 are the pointers passed in by the C library to the _nss_ntdom_*
41 static char *get_static(char **buffer
, size_t *buflen
, size_t len
)
45 /* Error check. We return false if things aren't set up right, or
46 there isn't enough buffer space left. */
48 if ((buffer
== NULL
) || (buflen
== NULL
) || (*buflen
< len
)) {
52 /* Return an index into the static buffer */
61 /* I've copied the strtok() replacement function next_token() from
62 lib/util_str.c as I really don't want to have to link in any other
63 objects if I can possibly avoid it. */
65 BOOL
next_token(char **ptr
,char *buff
,char *sep
, size_t bufsize
)
71 if (!ptr
) return(False
);
75 /* default to simple separators */
76 if (!sep
) sep
= " \t\n\r";
78 /* find the first non sep char */
79 while (*s
&& strchr(sep
,*s
)) s
++;
82 if (! *s
) return(False
);
84 /* copy over the token */
85 for (quoted
= False
; len
< bufsize
&& *s
&& (quoted
|| !strchr(sep
,*s
)); s
++) {
94 *ptr
= (*s
) ? s
+1 : s
;
101 /* Fill a pwent structure from a winbindd_response structure. We use
102 the static data passed to us by libc to put strings and stuff in.
103 Return NSS_STATUS_TRYAGAIN if we run out of memory. */
105 static NSS_STATUS
fill_pwent(struct passwd
*result
,
106 struct winbindd_pw
*pw
,
107 char **buffer
, size_t *buflen
)
111 if ((result
->pw_name
=
112 get_static(buffer
, buflen
, strlen(pw
->pw_name
) + 1)) == NULL
) {
116 return NSS_STATUS_TRYAGAIN
;
119 strcpy(result
->pw_name
, pw
->pw_name
);
123 if ((result
->pw_passwd
=
124 get_static(buffer
, buflen
, strlen(pw
->pw_passwd
) + 1)) == NULL
) {
128 return NSS_STATUS_TRYAGAIN
;
131 strcpy(result
->pw_passwd
, pw
->pw_passwd
);
135 result
->pw_uid
= pw
->pw_uid
;
136 result
->pw_gid
= pw
->pw_gid
;
140 if ((result
->pw_gecos
=
141 get_static(buffer
, buflen
, strlen(pw
->pw_gecos
) + 1)) == NULL
) {
145 return NSS_STATUS_TRYAGAIN
;
148 strcpy(result
->pw_gecos
, pw
->pw_gecos
);
152 if ((result
->pw_dir
=
153 get_static(buffer
, buflen
, strlen(pw
->pw_dir
) + 1)) == NULL
) {
157 return NSS_STATUS_TRYAGAIN
;
160 strcpy(result
->pw_dir
, pw
->pw_dir
);
164 if ((result
->pw_shell
=
165 get_static(buffer
, buflen
, strlen(pw
->pw_shell
) + 1)) == NULL
) {
169 return NSS_STATUS_TRYAGAIN
;
172 strcpy(result
->pw_shell
, pw
->pw_shell
);
174 /* The struct passwd for Solaris has some extra fields which must
175 be initialised or nscd crashes. */
177 #if HAVE_PASSWD_PW_COMMENT
178 result
->pw_comment
= "";
181 #if HAVE_PASSWD_PW_AGE
185 return NSS_STATUS_SUCCESS
;
188 /* Fill a grent structure from a winbindd_response structure. We use
189 the static data passed to us by libc to put strings and stuff in.
190 Return NSS_STATUS_TRYAGAIN if we run out of memory. */
192 static NSS_STATUS
fill_grent(struct group
*result
, struct winbindd_gr
*gr
,
193 char *gr_mem
, char **buffer
, size_t *buflen
)
201 if ((result
->gr_name
=
202 get_static(buffer
, buflen
, strlen(gr
->gr_name
) + 1)) == NULL
) {
206 return NSS_STATUS_TRYAGAIN
;
209 strcpy(result
->gr_name
, gr
->gr_name
);
213 if ((result
->gr_passwd
=
214 get_static(buffer
, buflen
, strlen(gr
->gr_passwd
) + 1)) == NULL
) {
218 return NSS_STATUS_TRYAGAIN
;
221 strcpy(result
->gr_passwd
, gr
->gr_passwd
);
225 result
->gr_gid
= gr
->gr_gid
;
227 /* Group membership */
229 if ((gr
->num_gr_mem
< 0) || !gr_mem
) {
233 /* this next value is a pointer to a pointer so let's align it */
235 /* Calculate number of extra bytes needed to align on pointer size boundry */
236 if ((i
= (unsigned long)(*buffer
) % sizeof(char*)) != 0)
237 i
= sizeof(char*) - i
;
239 if ((tst
= get_static(buffer
, buflen
, ((gr
->num_gr_mem
+ 1) *
240 sizeof(char *)+i
))) == NULL
) {
244 return NSS_STATUS_TRYAGAIN
;
246 result
->gr_mem
= (char **)(tst
+ i
);
248 if (gr
->num_gr_mem
== 0) {
252 *(result
->gr_mem
) = NULL
;
253 return NSS_STATUS_SUCCESS
;
256 /* Start looking at extra data */
260 while(next_token((char **)&gr_mem
, name
, ",", sizeof(fstring
))) {
262 /* Allocate space for member */
264 if (((result
->gr_mem
)[i
] =
265 get_static(buffer
, buflen
, strlen(name
) + 1)) == NULL
) {
269 return NSS_STATUS_TRYAGAIN
;
272 strcpy((result
->gr_mem
)[i
], name
);
278 (result
->gr_mem
)[i
] = NULL
;
280 return NSS_STATUS_SUCCESS
;
287 static struct winbindd_response getpwent_response
;
289 static int ndx_pw_cache
; /* Current index into pwd cache */
290 static int num_pw_cache
; /* Current size of pwd cache */
292 /* Rewind "file pointer" to start of ntdom password database */
295 _nss_winbind_setpwent(void)
298 fprintf(stderr
, "[%5d]: setpwent\n", getpid());
301 if (num_pw_cache
> 0) {
302 ndx_pw_cache
= num_pw_cache
= 0;
303 free_response(&getpwent_response
);
306 return winbindd_request(WINBINDD_SETPWENT
, NULL
, NULL
);
309 /* Close ntdom password database "file pointer" */
312 _nss_winbind_endpwent(void)
315 fprintf(stderr
, "[%5d]: endpwent\n", getpid());
318 if (num_pw_cache
> 0) {
319 ndx_pw_cache
= num_pw_cache
= 0;
320 free_response(&getpwent_response
);
323 return winbindd_request(WINBINDD_ENDPWENT
, NULL
, NULL
);
326 /* Fetch the next password entry from ntdom password database */
329 _nss_winbind_getpwent_r(struct passwd
*result
, char *buffer
,
330 size_t buflen
, int *errnop
)
333 struct winbindd_request request
;
334 static int called_again
;
337 fprintf(stderr
, "[%5d]: getpwent\n", getpid());
340 /* Return an entry from the cache if we have one, or if we are
341 called again because we exceeded our static buffer. */
343 if ((ndx_pw_cache
< num_pw_cache
) || called_again
) {
347 /* Else call winbindd to get a bunch of entries */
349 if (num_pw_cache
> 0) {
350 free_response(&getpwent_response
);
353 ZERO_STRUCT(request
);
354 ZERO_STRUCT(getpwent_response
);
356 request
.data
.num_entries
= MAX_GETPWENT_USERS
;
358 ret
= winbindd_request(WINBINDD_GETPWENT
, &request
,
361 if (ret
== NSS_STATUS_SUCCESS
) {
362 struct winbindd_pw
*pw_cache
;
367 num_pw_cache
= getpwent_response
.data
.num_entries
;
369 /* Return a result */
373 pw_cache
= getpwent_response
.extra_data
;
375 /* Check data is valid */
377 if (pw_cache
== NULL
) {
378 return NSS_STATUS_NOTFOUND
;
381 ret
= fill_pwent(result
, &pw_cache
[ndx_pw_cache
],
384 /* Out of memory - try again */
386 if (ret
== NSS_STATUS_TRYAGAIN
) {
388 *errnop
= errno
= ERANGE
;
393 called_again
= False
;
396 /* If we've finished with this lot of results free cache */
398 if (ndx_pw_cache
== num_pw_cache
) {
399 ndx_pw_cache
= num_pw_cache
= 0;
400 free_response(&getpwent_response
);
407 /* Return passwd struct from uid */
410 _nss_winbind_getpwuid_r(uid_t uid
, struct passwd
*result
, char *buffer
,
411 size_t buflen
, int *errnop
)
414 static struct winbindd_response response
;
415 struct winbindd_request request
;
416 static int keep_response
=0;
418 /* If our static buffer needs to be expanded we are called again */
419 if (!keep_response
) {
421 /* Call for the first time */
423 ZERO_STRUCT(response
);
424 ZERO_STRUCT(request
);
426 request
.data
.uid
= uid
;
428 ret
= winbindd_request(WINBINDD_GETPWUID
, &request
, &response
);
430 if (ret
== NSS_STATUS_SUCCESS
) {
431 ret
= fill_pwent(result
, &response
.data
.pw
,
434 if (ret
== NSS_STATUS_TRYAGAIN
) {
435 keep_response
= True
;
436 *errnop
= errno
= ERANGE
;
443 /* We've been called again */
445 ret
= fill_pwent(result
, &response
.data
.pw
, &buffer
, &buflen
);
447 if (ret
== NSS_STATUS_TRYAGAIN
) {
448 keep_response
= True
;
449 *errnop
= errno
= ERANGE
;
453 keep_response
= False
;
457 free_response(&response
);
461 /* Return passwd struct from username */
464 _nss_winbind_getpwnam_r(const char *name
, struct passwd
*result
, char *buffer
,
465 size_t buflen
, int *errnop
)
468 static struct winbindd_response response
;
469 struct winbindd_request request
;
470 static int keep_response
;
473 fprintf(stderr
, "[%5d]: getpwnam %s\n", getpid(), name
);
476 /* If our static buffer needs to be expanded we are called again */
478 if (!keep_response
) {
480 /* Call for the first time */
482 ZERO_STRUCT(response
);
483 ZERO_STRUCT(request
);
485 strncpy(request
.data
.username
, name
,
486 sizeof(request
.data
.username
) - 1);
487 request
.data
.username
488 [sizeof(request
.data
.username
) - 1] = '\0';
490 ret
= winbindd_request(WINBINDD_GETPWNAM
, &request
, &response
);
492 if (ret
== NSS_STATUS_SUCCESS
) {
493 ret
= fill_pwent(result
, &response
.data
.pw
, &buffer
,
496 if (ret
== NSS_STATUS_TRYAGAIN
) {
497 keep_response
= True
;
498 *errnop
= errno
= ERANGE
;
505 /* We've been called again */
507 ret
= fill_pwent(result
, &response
.data
.pw
, &buffer
, &buflen
);
509 if (ret
== NSS_STATUS_TRYAGAIN
) {
510 keep_response
= True
;
511 *errnop
= errno
= ERANGE
;
515 keep_response
= False
;
519 free_response(&response
);
524 * NSS group functions
527 static struct winbindd_response getgrent_response
;
529 static int ndx_gr_cache
; /* Current index into grp cache */
530 static int num_gr_cache
; /* Current size of grp cache */
532 /* Rewind "file pointer" to start of ntdom group database */
535 _nss_winbind_setgrent(void)
538 fprintf(stderr
, "[%5d]: setgrent\n", getpid());
541 if (num_gr_cache
> 0) {
542 ndx_gr_cache
= num_gr_cache
= 0;
543 free_response(&getgrent_response
);
546 return winbindd_request(WINBINDD_SETGRENT
, NULL
, NULL
);
549 /* Close "file pointer" for ntdom group database */
552 _nss_winbind_endgrent(void)
555 fprintf(stderr
, "[%5d]: endgrent\n", getpid());
558 if (num_gr_cache
> 0) {
559 ndx_gr_cache
= num_gr_cache
= 0;
560 free_response(&getgrent_response
);
563 return winbindd_request(WINBINDD_ENDGRENT
, NULL
, NULL
);
566 /* Get next entry from ntdom group database */
569 winbind_getgrent(enum winbindd_cmd cmd
,
570 struct group
*result
,
571 char *buffer
, size_t buflen
, int *errnop
)
574 static struct winbindd_request request
;
575 static int called_again
;
579 fprintf(stderr
, "[%5d]: getgrent\n", getpid());
582 /* Return an entry from the cache if we have one, or if we are
583 called again because we exceeded our static buffer. */
585 if ((ndx_gr_cache
< num_gr_cache
) || called_again
) {
589 /* Else call winbindd to get a bunch of entries */
591 if (num_gr_cache
> 0) {
592 free_response(&getgrent_response
);
595 ZERO_STRUCT(request
);
596 ZERO_STRUCT(getgrent_response
);
598 request
.data
.num_entries
= MAX_GETGRENT_USERS
;
600 ret
= winbindd_request(cmd
, &request
,
603 if (ret
== NSS_STATUS_SUCCESS
) {
604 struct winbindd_gr
*gr_cache
;
610 num_gr_cache
= getgrent_response
.data
.num_entries
;
612 /* Return a result */
616 gr_cache
= getgrent_response
.extra_data
;
618 /* Check data is valid */
620 if (gr_cache
== NULL
) {
621 return NSS_STATUS_NOTFOUND
;
624 /* Fill group membership. The offset into the extra data
625 for the group membership is the reported offset plus the
626 size of all the winbindd_gr records returned. */
628 mem_ofs
= gr_cache
[ndx_gr_cache
].gr_mem_ofs
+
629 num_gr_cache
* sizeof(struct winbindd_gr
);
631 ret
= fill_grent(result
, &gr_cache
[ndx_gr_cache
],
632 ((char *)getgrent_response
.extra_data
)+mem_ofs
,
635 /* Out of memory - try again */
637 if (ret
== NSS_STATUS_TRYAGAIN
) {
639 *errnop
= errno
= ERANGE
;
644 called_again
= False
;
647 /* If we've finished with this lot of results free cache */
649 if (ndx_gr_cache
== num_gr_cache
) {
650 ndx_gr_cache
= num_gr_cache
= 0;
651 free_response(&getgrent_response
);
660 _nss_winbind_getgrent_r(struct group
*result
,
661 char *buffer
, size_t buflen
, int *errnop
)
663 return winbind_getgrent(WINBINDD_GETGRENT
, result
, buffer
, buflen
, errnop
);
667 _nss_winbind_getgrlst_r(struct group
*result
,
668 char *buffer
, size_t buflen
, int *errnop
)
670 return winbind_getgrent(WINBINDD_GETGRLST
, result
, buffer
, buflen
, errnop
);
673 /* Return group struct from group name */
676 _nss_winbind_getgrnam_r(const char *name
,
677 struct group
*result
, char *buffer
,
678 size_t buflen
, int *errnop
)
681 static struct winbindd_response response
;
682 struct winbindd_request request
;
683 static int keep_response
;
686 fprintf(stderr
, "[%5d]: getgrnam %s\n", getpid(), name
);
689 /* If our static buffer needs to be expanded we are called again */
691 if (!keep_response
) {
693 /* Call for the first time */
695 ZERO_STRUCT(request
);
696 ZERO_STRUCT(response
);
698 strncpy(request
.data
.groupname
, name
,
699 sizeof(request
.data
.groupname
));
700 request
.data
.groupname
701 [sizeof(request
.data
.groupname
) - 1] = '\0';
703 ret
= winbindd_request(WINBINDD_GETGRNAM
, &request
, &response
);
705 if (ret
== NSS_STATUS_SUCCESS
) {
706 ret
= fill_grent(result
, &response
.data
.gr
,
710 if (ret
== NSS_STATUS_TRYAGAIN
) {
711 keep_response
= True
;
712 *errnop
= errno
= ERANGE
;
719 /* We've been called again */
721 ret
= fill_grent(result
, &response
.data
.gr
,
722 response
.extra_data
, &buffer
, &buflen
);
724 if (ret
== NSS_STATUS_TRYAGAIN
) {
725 keep_response
= True
;
726 *errnop
= errno
= ERANGE
;
730 keep_response
= False
;
734 free_response(&response
);
738 /* Return group struct from gid */
741 _nss_winbind_getgrgid_r(gid_t gid
,
742 struct group
*result
, char *buffer
,
743 size_t buflen
, int *errnop
)
746 static struct winbindd_response response
;
747 struct winbindd_request request
;
748 static int keep_response
;
751 fprintf(stderr
, "[%5d]: getgrgid %d\n", getpid(), gid
);
754 /* If our static buffer needs to be expanded we are called again */
756 if (!keep_response
) {
758 /* Call for the first time */
760 ZERO_STRUCT(request
);
761 ZERO_STRUCT(response
);
763 request
.data
.gid
= gid
;
765 ret
= winbindd_request(WINBINDD_GETGRGID
, &request
, &response
);
767 if (ret
== NSS_STATUS_SUCCESS
) {
769 ret
= fill_grent(result
, &response
.data
.gr
,
773 if (ret
== NSS_STATUS_TRYAGAIN
) {
774 keep_response
= True
;
775 *errnop
= errno
= ERANGE
;
782 /* We've been called again */
784 ret
= fill_grent(result
, &response
.data
.gr
,
785 response
.extra_data
, &buffer
, &buflen
);
787 if (ret
== NSS_STATUS_TRYAGAIN
) {
788 keep_response
= True
;
789 *errnop
= errno
= ERANGE
;
793 keep_response
= False
;
797 free_response(&response
);
801 /* Initialise supplementary groups */
804 _nss_winbind_initgroups_dyn(char *user
, gid_t group
, long int *start
,
805 long int *size
, gid_t
**groups
, long int limit
,
809 struct winbindd_request request
;
810 struct winbindd_response response
;
814 fprintf(stderr
, "[%5d]: initgroups %s (%d)\n", getpid(),
818 ZERO_STRUCT(request
);
819 ZERO_STRUCT(response
);
821 strncpy(request
.data
.username
, user
,
822 sizeof(request
.data
.username
) - 1);
824 ret
= winbindd_request(WINBINDD_GETGROUPS
, &request
, &response
);
826 if (ret
== NSS_STATUS_SUCCESS
) {
827 int num_gids
= response
.data
.num_entries
;
828 gid_t
*gid_list
= (gid_t
*)response
.extra_data
;
830 /* Copy group list to client */
832 for (i
= 0; i
< num_gids
; i
++) {
834 /* Skip primary group */
836 if (gid_list
[i
] == group
) {
840 /* Filled buffer ? If so, resize. */
842 if (*start
== *size
) {
846 newsize
= 2 * (*size
);
848 if (*size
== limit
) {
851 if (newsize
> limit
) {
856 newgroups
= realloc((*groups
), newsize
* sizeof(**groups
));
859 ret
= NSS_STATUS_NOTFOUND
;
868 (*groups
)[*start
] = gid_list
[i
];
873 /* Back to your regularly scheduled programming */
880 /* return a list of group SIDs for a user SID */
882 _nss_winbind_getusersids(const char *user_sid
, char **group_sids
,
884 char *buffer
, size_t buf_size
, int *errnop
)
887 struct winbindd_request request
;
888 struct winbindd_response response
;
891 fprintf(stderr
, "[%5d]: getusersids %s\n", getpid(), user_sid
);
894 ZERO_STRUCT(request
);
895 ZERO_STRUCT(response
);
897 strncpy(request
.data
.sid
, user_sid
,sizeof(request
.data
.sid
) - 1);
898 request
.data
.sid
[sizeof(request
.data
.sid
) - 1] = '\0';
900 ret
= winbindd_request(WINBINDD_GETUSERSIDS
, &request
, &response
);
902 if (ret
!= NSS_STATUS_SUCCESS
) {
906 if (buf_size
< response
.length
- sizeof(response
)) {
907 ret
= NSS_STATUS_TRYAGAIN
;
908 errno
= *errnop
= ERANGE
;
912 *num_groups
= response
.data
.num_entries
;
913 *group_sids
= buffer
;
914 memcpy(buffer
, response
.extra_data
, response
.length
- sizeof(response
));
918 free_response(&response
);
923 /* map a user or group name to a SID string */
925 _nss_winbind_nametosid(const char *name
, char **sid
, char *buffer
,
926 size_t buflen
, int *errnop
)
929 struct winbindd_response response
;
930 struct winbindd_request request
;
933 fprintf(stderr
, "[%5d]: nametosid %s\n", getpid(), name
);
936 ZERO_STRUCT(response
);
937 ZERO_STRUCT(request
);
939 strncpy(request
.data
.name
.name
, name
,
940 sizeof(request
.data
.name
.name
) - 1);
941 request
.data
.name
.name
[sizeof(request
.data
.name
.name
) - 1] = '\0';
943 ret
= winbindd_request(WINBINDD_LOOKUPNAME
, &request
, &response
);
944 if (ret
!= NSS_STATUS_SUCCESS
) {
945 *errnop
= errno
= EINVAL
;
949 if (buflen
< strlen(response
.data
.sid
.sid
)+1) {
950 ret
= NSS_STATUS_TRYAGAIN
;
951 *errnop
= errno
= ERANGE
;
957 strcpy(*sid
, response
.data
.sid
.sid
);
960 free_response(&response
);
964 /* map a sid string to a user or group name */
966 _nss_winbind_sidtoname(const char *sid
, char **name
, char *buffer
,
967 size_t buflen
, int *errnop
)
970 struct winbindd_response response
;
971 struct winbindd_request request
;
972 static char sep_char
;
976 fprintf(stderr
, "[%5d]: sidtoname %s\n", getpid(), sid
);
979 /* we need to fetch the separator first time through */
981 ZERO_STRUCT(response
);
982 ZERO_STRUCT(request
);
984 ret
= winbindd_request(WINBINDD_INFO
, &request
, &response
);
985 if (ret
!= NSS_STATUS_SUCCESS
) {
986 *errnop
= errno
= EINVAL
;
990 sep_char
= response
.data
.info
.winbind_separator
;
991 free_response(&response
);
995 strncpy(request
.data
.sid
, sid
,
996 sizeof(request
.data
.sid
) - 1);
997 request
.data
.sid
[sizeof(request
.data
.sid
) - 1] = '\0';
999 ret
= winbindd_request(WINBINDD_LOOKUPSID
, &request
, &response
);
1000 if (ret
!= NSS_STATUS_SUCCESS
) {
1001 *errnop
= errno
= EINVAL
;
1006 strlen(response
.data
.name
.dom_name
) +
1007 strlen(response
.data
.name
.name
) + 2;
1009 if (buflen
< needed
) {
1010 ret
= NSS_STATUS_TRYAGAIN
;
1011 *errnop
= errno
= ERANGE
;
1015 snprintf(buffer
, needed
, "%s%c%s",
1016 response
.data
.name
.dom_name
,
1018 response
.data
.name
.name
);
1021 *errnop
= errno
= 0;
1024 free_response(&response
);
1028 /* map a sid to a uid */
1030 _nss_winbind_sidtouid(const char *sid
, uid_t
*uid
, int *errnop
)
1033 struct winbindd_response response
;
1034 struct winbindd_request request
;
1037 fprintf(stderr
, "[%5d]: sidtouid %s\n", getpid(), sid
);
1040 ZERO_STRUCT(request
);
1041 ZERO_STRUCT(response
);
1043 strncpy(request
.data
.sid
, sid
, sizeof(request
.data
.sid
) - 1);
1044 request
.data
.sid
[sizeof(request
.data
.sid
) - 1] = '\0';
1046 ret
= winbindd_request(WINBINDD_SID_TO_UID
, &request
, &response
);
1047 if (ret
!= NSS_STATUS_SUCCESS
) {
1048 *errnop
= errno
= EINVAL
;
1052 *uid
= response
.data
.uid
;
1058 /* map a sid to a gid */
1060 _nss_winbind_sidtogid(const char *sid
, gid_t
*gid
, int *errnop
)
1063 struct winbindd_response response
;
1064 struct winbindd_request request
;
1067 fprintf(stderr
, "[%5d]: sidtogid %s\n", getpid(), sid
);
1070 ZERO_STRUCT(request
);
1071 ZERO_STRUCT(response
);
1073 strncpy(request
.data
.sid
, sid
, sizeof(request
.data
.sid
) - 1);
1074 request
.data
.sid
[sizeof(request
.data
.sid
) - 1] = '\0';
1076 ret
= winbindd_request(WINBINDD_SID_TO_GID
, &request
, &response
);
1077 if (ret
!= NSS_STATUS_SUCCESS
) {
1078 *errnop
= errno
= EINVAL
;
1082 *gid
= response
.data
.gid
;
1088 /* map a uid to a SID string */
1090 _nss_winbind_uidtosid(uid_t uid
, char **sid
, char *buffer
,
1091 size_t buflen
, int *errnop
)
1094 struct winbindd_response response
;
1095 struct winbindd_request request
;
1098 fprintf(stderr
, "[%5u]: uidtosid %u\n", (unsigned int)getpid(), (unsigned int)uid
);
1101 ZERO_STRUCT(response
);
1102 ZERO_STRUCT(request
);
1104 request
.data
.uid
= uid
;
1106 ret
= winbindd_request(WINBINDD_UID_TO_SID
, &request
, &response
);
1107 if (ret
!= NSS_STATUS_SUCCESS
) {
1108 *errnop
= errno
= EINVAL
;
1112 if (buflen
< strlen(response
.data
.sid
.sid
)+1) {
1113 ret
= NSS_STATUS_TRYAGAIN
;
1114 *errnop
= errno
= ERANGE
;
1118 *errnop
= errno
= 0;
1120 strcpy(*sid
, response
.data
.sid
.sid
);
1123 free_response(&response
);
1127 /* map a gid to a SID string */
1129 _nss_winbind_gidtosid(gid_t gid
, char **sid
, char *buffer
,
1130 size_t buflen
, int *errnop
)
1133 struct winbindd_response response
;
1134 struct winbindd_request request
;
1137 fprintf(stderr
, "[%5u]: gidtosid %u\n", (unsigned int)getpid(), (unsigned int)gid
);
1140 ZERO_STRUCT(response
);
1141 ZERO_STRUCT(request
);
1143 request
.data
.gid
= gid
;
1145 ret
= winbindd_request(WINBINDD_GID_TO_SID
, &request
, &response
);
1146 if (ret
!= NSS_STATUS_SUCCESS
) {
1147 *errnop
= errno
= EINVAL
;
1151 if (buflen
< strlen(response
.data
.sid
.sid
)+1) {
1152 ret
= NSS_STATUS_TRYAGAIN
;
1153 *errnop
= errno
= ERANGE
;
1157 *errnop
= errno
= 0;
1159 strcpy(*sid
, response
.data
.sid
.sid
);
1162 free_response(&response
);