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