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