7fa87c098a5c2eeae355f16960264ca9282c9130
[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 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
17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
18 Cambridge, MA 02139, USA.  */
19
20 #include <stdio.h>
21 #include <ctype.h>
22 #include <assert.h>
23 #include <libc-lock.h>
24 #include "nsswitch.h"
25
26 /* These symbols are defined by the including source file:
27
28    ENTNAME -- database name of the structure and functions (hostent, pwent).
29    STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).
30    DATABASE -- string of the database file's name ("hosts", "passwd").
31
32    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
33    MIDLINE_COMMENTS - defined iff # before \n terminates a database line.
34 */
35
36 #define ENTNAME_r       CONCAT(ENTNAME,_r)
37
38 #define DATAFILE        "/etc/" DATABASE
39
40 #ifdef NEED_H_ERRNO
41 #define H_ERRNO_PROTO   , int *herrnop
42 #define H_ERRNO_ARG     , herrnop
43 #define H_ERRNO_SET(val) (*herrnop = (val))
44 #else
45 #define H_ERRNO_PROTO
46 #define H_ERRNO_ARG
47 #define H_ERRNO_SET(val) ((void) 0)
48 #endif
49
50 /* Locks the static variables in this file.  */
51 __libc_lock_define_initialized (static, lock);
52 \f
53 /* Maintenance of the shared stream open on the database file.  */
54
55 static FILE *stream;
56 static int keep_stream;
57
58 /* Open database file if not already opened.  */
59 static int
60 internal_setent (int stayopen)
61 {
62   int status = NSS_STATUS_SUCCESS;
63
64   if (stream == NULL)
65     {
66       stream = fopen (DATAFILE, "r");
67
68       if (stream == NULL)
69         status = NSS_STATUS_UNAVAIL;
70     }
71   else
72     rewind (stream);
73
74   /* Remember STAYOPEN flag.  */
75   if (stream != NULL)
76     keep_stream |= stayopen;
77
78   return status;
79 }
80
81
82 /* Thread-safe, exported version of that.  */
83 int
84 CONCAT(_nss_files_set,ENTNAME) (int stayopen)
85 {
86   int status;
87
88   __libc_lock_lock (lock);
89
90   status = internal_setent (stayopen);
91
92   __libc_lock_unlock (lock);
93
94   return status;
95 }
96
97
98 /* Close the database file.  */
99 static void
100 internal_endent (void)
101 {
102   if (stream != NULL)
103     {
104       fclose (stream);
105       stream = NULL;
106     }
107 }
108
109
110 /* Thread-safe, exported version of that.  */
111 int
112 CONCAT(_nss_files_end,ENTNAME) (void)
113 {
114   __libc_lock_lock (lock);
115
116   internal_endent ();
117
118   /* Reset STAYOPEN flag.  */
119   keep_stream = 0;
120
121   __libc_lock_unlock (lock);
122
123   return NSS_STATUS_SUCCESS;
124 }
125 \f
126 /* Parsing the database file into `struct STRUCTURE' data structures.  */
127
128 static enum nss_status
129 internal_getent (struct STRUCTURE *result,
130                  char *buffer, int buflen H_ERRNO_PROTO)
131 {
132   char *p;
133   struct parser_data *data = (void *) buffer;
134   int linebuflen = buffer + buflen - data->linebuffer;
135
136   /* Be prepared that the set*ent function was not called before.  */
137   if (stream == NULL)
138     {
139       enum nss_status status;
140
141       status = internal_setent (0);
142       if (status != NSS_STATUS_SUCCESS)
143         return status;
144     }
145
146   if (buflen < (int) sizeof *data + 1)
147     {
148       errno = ERANGE;
149       return NSS_STATUS_TRYAGAIN;
150     }
151
152   do
153     {
154       p = fgets (data->linebuffer, linebuflen, stream);
155       if (p == NULL)
156         {
157           /* End of file or read error.  */
158           H_ERRNO_SET (HOST_NOT_FOUND);
159           return NSS_STATUS_NOTFOUND;
160         }
161
162       /* Terminate the line for any case.  */
163       data->linebuffer[linebuflen - 1] = '\0';
164
165       /* Skip leading blanks.  */
166       while (isspace (*p))
167         ++p;
168     } while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines.  */
169              /* Parse the line.  If it is invalid, loop to
170                 get the next line of the file to parse.  */
171              ! parse_line (p, result, data, buflen));
172
173   /* Filled in RESULT with the next entry from the database file.  */
174   return NSS_STATUS_SUCCESS;
175 }
176
177
178 /* Return the next entry from the database file, doing locking.  */
179 int
180 CONCAT(_nss_files_get,ENTNAME_r) (struct STRUCTURE *result,
181                                   char *buffer, int buflen H_ERRNO_PROTO)
182 {
183   /* Return next entry in host file.  */
184   int status;
185
186   __libc_lock_lock (lock);
187
188   status = internal_getent (result, buffer, buflen H_ERRNO_ARG);
189
190   __libc_lock_unlock (lock);
191
192   return status;
193 }
194 \f
195 /* Macro for defining lookup functions for this file-based database.
196
197    NAME is the name of the lookup; e.g. `hostbyname'.
198
199    KEYSIZE and KEYPATTERN are ignored here but used by ../nss_db/db-XXX.c.
200
201    PROTO describes the arguments for the lookup key;
202    e.g. `const char *hostname'.
203
204    BREAK_IF_MATCH is a block of code which compares `struct STRUCTURE *result'
205    to the lookup key arguments and does `break;' if they match.  */
206
207 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
208 enum nss_status                                                               \
209 _nss_files_get##name##_r (proto,                                              \
210                           struct STRUCTURE *result,                           \
211                           char *buffer, int buflen H_ERRNO_PROTO)             \
212 {                                                                             \
213   enum nss_status status;                                                     \
214                                                                               \
215   __libc_lock_lock (lock);                                                    \
216                                                                               \
217   /* Reset file pointer to beginning or open file.  */                        \
218   internal_setent (keep_stream);                                              \
219                                                                               \
220   while ((status = internal_getent (result, buffer, buflen H_ERRNO_ARG))      \
221          == NSS_STATUS_SUCCESS)                                               \
222     { break_if_match }                                                        \
223                                                                               \
224   if (! keep_stream)                                                          \
225     internal_endent ();                                                       \
226                                                                               \
227   __libc_lock_unlock (lock);                                                  \
228                                                                               \
229   return status;                                                              \
230 }