9af3858454b3648898e66b740307084ce4c69916
[kopensolaris-gnu/glibc.git] / nscd / nscd_getpw_r.c
1 /* Copyright (C) 1998, 1999, 2003, 2004 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@uni-paderborn.de>, 1998.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <assert.h>
21 #include <errno.h>
22 #include <pwd.h>
23 #include <stdint.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/mman.h>
29 #include <sys/socket.h>
30 #include <sys/uio.h>
31 #include <sys/un.h>
32 #include <not-cancel.h>
33 #include <stdio-common/_itoa.h>
34
35 #include "nscd-client.h"
36 #include "nscd_proto.h"
37
38 int __nss_not_use_nscd_passwd;
39
40 static int nscd_getpw_r (const char *key, size_t keylen, request_type type,
41                          struct passwd *resultbuf, char *buffer,
42                          size_t buflen, struct passwd **result)
43      internal_function;
44
45 int
46 __nscd_getpwnam_r (const char *name, struct passwd *resultbuf, char *buffer,
47                    size_t buflen, struct passwd **result)
48 {
49   if (name == NULL)
50     return -1;
51
52   return nscd_getpw_r (name, strlen (name) + 1, GETPWBYNAME, resultbuf,
53                        buffer, buflen, result);
54 }
55
56 int
57 __nscd_getpwuid_r (uid_t uid, struct passwd *resultbuf, char *buffer,
58                    size_t buflen, struct passwd **result)
59 {
60   char buf[3 * sizeof (uid_t)];
61   buf[sizeof (buf) - 1] = '\0';
62   char *cp = _itoa_word (uid, buf + sizeof (buf) - 1, 10, 0);
63
64   return nscd_getpw_r (cp, buf + sizeof (buf) - cp, GETPWBYUID, resultbuf,
65                        buffer, buflen, result);
66 }
67
68
69 libc_locked_map_ptr (map_handle);
70 /* Note that we only free the structure if necessary.  The memory
71    mapping is not removed since it is not visible to the malloc
72    handling.  */
73 libc_freeres_fn (gr_map_free)
74 {
75
76   if (map_handle.mapped != NO_MAPPING)
77     free (map_handle.mapped);
78 }
79
80
81 static int
82 internal_function
83 nscd_getpw_r (const char *key, size_t keylen, request_type type,
84               struct passwd *resultbuf, char *buffer, size_t buflen,
85               struct passwd **result)
86 {
87   int gc_cycle;
88   /* If the mapping is available, try to search there instead of
89      communicating with the nscd.  */
90   struct mapped_database *mapped;
91   mapped = __nscd_get_map_ref (GETFDPW, "passwd", &map_handle, &gc_cycle);
92
93  retry:;
94   const pw_response_header *pw_resp = NULL;
95   const char *pw_name = NULL;
96   int retval = -1;
97   const char *recend = (const char *) ~UINTMAX_C (0);
98
99   if (mapped != NO_MAPPING)
100     {
101       const struct datahead *found = __nscd_cache_search (type, key, keylen,
102                                                           mapped);
103       if (found != NULL)
104         {
105           pw_resp = &found->data[0].pwdata;
106           pw_name = (const char *) (pw_resp + 1);
107           recend = (const char *) found->data + found->recsize;
108         }
109     }
110
111   pw_response_header pw_resp_mem;
112   int sock = -1;
113   if (pw_resp == NULL)
114     {
115       sock = __nscd_open_socket (key, keylen, type, &pw_resp_mem,
116                                  sizeof (pw_resp_mem));
117       if (sock == -1)
118         {
119           __nss_not_use_nscd_passwd = 1;
120           goto out;
121         }
122
123       pw_resp = &pw_resp_mem;
124     }
125
126   /* No value found so far.  */
127   *result = NULL;
128
129   if (__builtin_expect (pw_resp->found == -1, 0))
130     {
131       /* The daemon does not cache this database.  */
132       __nss_not_use_nscd_passwd = 1;
133       goto out_close;
134     }
135
136   if (pw_resp->found == 1)
137     {
138       /* Set the information we already have.  */
139       resultbuf->pw_uid = pw_resp->pw_uid;
140       resultbuf->pw_gid = pw_resp->pw_gid;
141
142       char *p = buffer;
143       /* get pw_name */
144       resultbuf->pw_name = p;
145       p += pw_resp->pw_name_len;
146       /* get pw_passwd */
147       resultbuf->pw_passwd = p;
148       p += pw_resp->pw_passwd_len;
149       /* get pw_gecos */
150       resultbuf->pw_gecos = p;
151       p += pw_resp->pw_gecos_len;
152       /* get pw_dir */
153       resultbuf->pw_dir = p;
154       p += pw_resp->pw_dir_len;
155       /* get pw_pshell */
156       resultbuf->pw_shell = p;
157       p += pw_resp->pw_shell_len;
158
159       ssize_t total = p - buffer;
160       if (__builtin_expect (pw_name + total > recend, 0))
161         goto out_close;
162       if (__builtin_expect (buflen < total, 0))
163         {
164           __set_errno (ERANGE);
165           retval = ERANGE;
166           goto out_close;
167         }
168
169       retval = 0;
170       if (pw_name == NULL)
171         {
172           ssize_t nbytes = TEMP_FAILURE_RETRY (__read (sock, buffer, total));
173
174           if (__builtin_expect (nbytes != total, 0))
175             {
176               /* The `errno' to some value != ERANGE.  */
177               __set_errno (ENOENT);
178               retval = ENOENT;
179             }
180           else
181             *result = resultbuf;
182         }
183       else
184         {
185           /* Copy the various strings.  */
186           memcpy (resultbuf->pw_name, pw_name, total);
187
188           *result = resultbuf;
189         }
190     }
191   else
192     {
193       /* The `errno' to some value != ERANGE.  */
194       __set_errno (ENOENT);
195       /* Even though we have not found anything, the result is zero.  */
196       retval = 0;
197     }
198
199  out_close:
200   if (sock != -1)
201     close_not_cancel_no_status (sock);
202  out:
203   if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
204     {
205       /* When we come here this means there has been a GC cycle while we
206          were looking for the data.  This means the data might have been
207          inconsistent.  Retry if possible.  */
208       if ((gc_cycle & 1) != 0)
209         {
210           /* nscd is just running gc now.  Disable using the mapping.  */
211           __nscd_unmap (mapped);
212           mapped = NO_MAPPING;
213         }
214
215       free (resultbuf);
216
217       goto retry;
218     }
219
220   return retval;
221 }