fd000bfd9ac1288c39ff2ab9f7a9e90f460e0473
[kopensolaris-gnu/glibc.git] / nss / nss_files / files-XXX.c
1 /* Common code for file-based databases in nss_files module.
2    Copyright (C) 1996,1997,1998,1999,2001,2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
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 <stdio.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <bits/libc-lock.h>
25 #include "nsswitch.h"
26
27 /* These symbols are defined by the including source file:
28
29    ENTNAME -- database name of the structure and functions (hostent, pwent).
30    STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).
31    DATABASE -- string of the database file's name ("hosts", "passwd").
32
33    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
34
35    Also see files-parse.c.
36 */
37
38 #define ENTNAME_r       CONCAT(ENTNAME,_r)
39
40 #define DATAFILE        "/etc/" DATABASE
41
42 #ifdef NEED_H_ERRNO
43 # include <netdb.h>
44 # define H_ERRNO_PROTO  , int *herrnop
45 # define H_ERRNO_ARG    , herrnop
46 # define H_ERRNO_SET(val) (*herrnop = (val))
47 #else
48 # define H_ERRNO_PROTO
49 # define H_ERRNO_ARG
50 # define H_ERRNO_SET(val) ((void) 0)
51 #endif
52
53 #ifndef EXTRA_ARGS
54 # define EXTRA_ARGS
55 # define EXTRA_ARGS_DECL
56 # define EXTRA_ARGS_VALUE
57 #endif
58
59 /* Locks the static variables in this file.  */
60 __libc_lock_define_initialized (static, lock)
61 \f
62 /* Maintenance of the shared stream open on the database file.  */
63
64 static FILE *stream;
65 static fpos_t position;
66 static enum { nouse, getent, getby } last_use;
67 static int keep_stream;
68
69 /* Open database file if not already opened.  */
70 static enum nss_status
71 internal_setent (int stayopen)
72 {
73   enum nss_status status = NSS_STATUS_SUCCESS;
74
75   if (stream == NULL)
76     {
77       stream = fopen (DATAFILE, "r");
78
79       if (stream == NULL)
80         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
81       else
82         {
83           /* We have to make sure the file is  `closed on exec'.  */
84           int result, flags;
85
86           result = flags = fcntl (fileno (stream), F_GETFD, 0);
87           if (result >= 0)
88             {
89               flags |= FD_CLOEXEC;
90               result = fcntl (fileno (stream), F_SETFD, flags);
91             }
92           if (result < 0)
93             {
94               /* Something went wrong.  Close the stream and return a
95                  failure.  */
96               fclose (stream);
97               stream = NULL;
98               status = NSS_STATUS_UNAVAIL;
99             }
100         }
101     }
102   else
103     rewind (stream);
104
105   /* Remember STAYOPEN flag.  */
106   if (stream != NULL)
107     keep_stream |= stayopen;
108
109   return status;
110 }
111
112
113 /* Thread-safe, exported version of that.  */
114 enum nss_status
115 CONCAT(_nss_files_set,ENTNAME) (int stayopen)
116 {
117   enum nss_status status;
118
119   __libc_lock_lock (lock);
120
121   status = internal_setent (stayopen);
122
123   if (status == NSS_STATUS_SUCCESS && fgetpos (stream, &position) < 0)
124     {
125       fclose (stream);
126       stream = NULL;
127       status = NSS_STATUS_UNAVAIL;
128     }
129
130   last_use = getent;
131
132   __libc_lock_unlock (lock);
133
134   return status;
135 }
136
137
138 /* Close the database file.  */
139 static void
140 internal_endent (void)
141 {
142   if (stream != NULL)
143     {
144       fclose (stream);
145       stream = NULL;
146     }
147 }
148
149
150 /* Thread-safe, exported version of that.  */
151 enum nss_status
152 CONCAT(_nss_files_end,ENTNAME) (void)
153 {
154   __libc_lock_lock (lock);
155
156   internal_endent ();
157
158   /* Reset STAYOPEN flag.  */
159   keep_stream = 0;
160
161   __libc_lock_unlock (lock);
162
163   return NSS_STATUS_SUCCESS;
164 }
165 \f
166 /* Parsing the database file into `struct STRUCTURE' data structures.  */
167
168 static enum nss_status
169 internal_getent (struct STRUCTURE *result,
170                  char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO
171                  EXTRA_ARGS_DECL)
172 {
173   char *p;
174   struct parser_data *data = (void *) buffer;
175   int linebuflen = buffer + buflen - data->linebuffer;
176   int parse_result;
177
178   if (buflen < sizeof *data + 2)
179     {
180       *errnop = ERANGE;
181       H_ERRNO_SET (NETDB_INTERNAL);
182       return NSS_STATUS_TRYAGAIN;
183     }
184
185   do
186     {
187       /* Terminate the line so that we can test for overflow.  */
188       ((unsigned char *) data->linebuffer)[linebuflen - 1] = '\xff';
189
190       p = fgets_unlocked (data->linebuffer, linebuflen, stream);
191       if (p == NULL)
192         {
193           /* End of file or read error.  */
194           H_ERRNO_SET (HOST_NOT_FOUND);
195           return NSS_STATUS_NOTFOUND;
196         }
197       else if (((unsigned char *) data->linebuffer)[linebuflen - 1] != 0xff)
198         {
199           /* The line is too long.  Give the user the opportunity to
200              enlarge the buffer.  */
201           *errnop = ERANGE;
202           H_ERRNO_SET (NETDB_INTERNAL);
203           return NSS_STATUS_TRYAGAIN;
204         }
205
206       /* Skip leading blanks.  */
207       while (isspace (*p))
208         ++p;
209     }
210   while (*p == '\0' || *p == '#' /* Ignore empty and comment lines.  */
211          /* Parse the line.  If it is invalid, loop to get the next
212             line of the file to parse.  */
213          || ! (parse_result = parse_line (p, result, data, buflen, errnop
214                                           EXTRA_ARGS)));
215
216   /* Filled in RESULT with the next entry from the database file.  */
217   return parse_result == -1 ? NSS_STATUS_TRYAGAIN : NSS_STATUS_SUCCESS;
218 }
219
220
221 /* Return the next entry from the database file, doing locking.  */
222 enum nss_status
223 CONCAT(_nss_files_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
224                                   size_t buflen, int *errnop H_ERRNO_PROTO)
225 {
226   /* Return next entry in host file.  */
227   enum nss_status status = NSS_STATUS_SUCCESS;
228
229   __libc_lock_lock (lock);
230
231   /* Be prepared that the set*ent function was not called before.  */
232   if (stream == NULL)
233     {
234       status = internal_setent (0);
235
236       if (status == NSS_STATUS_SUCCESS && fgetpos (stream, &position) < 0)
237         {
238           fclose (stream);
239           stream = NULL;
240           status = NSS_STATUS_UNAVAIL;
241         }
242     }
243
244   if (status == NSS_STATUS_SUCCESS)
245     {
246       /* If the last use was not by the getent function we need the
247          position the stream.  */
248       if (last_use != getent)
249         {
250           if (fsetpos (stream, &position) < 0)
251             status = NSS_STATUS_UNAVAIL;
252           else
253             last_use = getent;
254         }
255
256       if (status == NSS_STATUS_SUCCESS)
257         {
258           status = internal_getent (result, buffer, buflen, errnop
259                                     H_ERRNO_ARG EXTRA_ARGS_VALUE);
260
261           /* Remember this position if we were successful.  If the
262              operation failed we give the user a chance to repeat the
263              operation (perhaps the buffer was too small).  */
264           if (status == NSS_STATUS_SUCCESS)
265             fgetpos (stream, &position);
266           else
267             /* We must make sure we reposition the stream the next call.  */
268             last_use = nouse;
269         }
270     }
271
272   __libc_lock_unlock (lock);
273
274   return status;
275 }
276 \f
277 /* Macro for defining lookup functions for this file-based database.
278
279    NAME is the name of the lookup; e.g. `hostbyname'.
280
281    KEYSIZE and KEYPATTERN are ignored here but used by ../nss_db/db-XXX.c.
282
283    PROTO describes the arguments for the lookup key;
284    e.g. `const char *hostname'.
285
286    BREAK_IF_MATCH is a block of code which compares `struct STRUCTURE *result'
287    to the lookup key arguments and does `break;' if they match.  */
288
289 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
290 enum nss_status                                                               \
291 _nss_files_get##name##_r (proto,                                              \
292                           struct STRUCTURE *result, char *buffer,             \
293                           size_t buflen, int *errnop H_ERRNO_PROTO)           \
294 {                                                                             \
295   enum nss_status status;                                                     \
296                                                                               \
297   __libc_lock_lock (lock);                                                    \
298                                                                               \
299   /* Reset file pointer to beginning or open file.  */                        \
300   status = internal_setent (keep_stream);                                     \
301                                                                               \
302   if (status == NSS_STATUS_SUCCESS)                                           \
303     {                                                                         \
304       /* Tell getent function that we have repositioned the file pointer.  */ \
305       last_use = getby;                                                       \
306                                                                               \
307       while ((status = internal_getent (result, buffer, buflen, errnop        \
308                                         H_ERRNO_ARG EXTRA_ARGS_VALUE))        \
309              == NSS_STATUS_SUCCESS)                                           \
310         { break_if_match }                                                    \
311                                                                               \
312       if (! keep_stream)                                                      \
313         internal_endent ();                                                   \
314     }                                                                         \
315                                                                               \
316   __libc_lock_unlock (lock);                                                  \
317                                                                               \
318   return status;                                                              \
319 }