8ba73efcb6b78384abf31b5726c864ff4f3eedbc
[kopensolaris-gnu/glibc.git] / nss / nss_db / db-XXX.c
1 /* Common code for DB-based databases in nss_db module.
2    Copyright (C) 1996, 1997, 1998 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 <db.h>
21 #include <fcntl.h>
22 #include <bits/libc-lock.h>
23 #include "nsswitch.h"
24
25 /* These symbols are defined by the including source file:
26
27    ENTNAME -- database name of the structure and functions (hostent, pwent).
28    STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).
29    DATABASE -- database file name, ("hosts", "passwd")
30
31    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
32 */
33
34 #define ENTNAME_r       CONCAT(ENTNAME,_r)
35
36 #include <paths.h>
37 #define DBFILE          _PATH_VARDB DATABASE ".db"
38
39 #ifdef NEED_H_ERRNO
40 #define H_ERRNO_PROTO   , int *herrnop
41 #define H_ERRNO_ARG     , herrnop
42 #define H_ERRNO_SET(val) (*herrnop = (val))
43 #else
44 #define H_ERRNO_PROTO
45 #define H_ERRNO_ARG
46 #define H_ERRNO_SET(val) ((void) 0)
47 #endif
48
49 /* Locks the static variables in this file.  */
50 __libc_lock_define_initialized (static, lock)
51 \f
52 /* Maintenance of the shared handle open on the database.  */
53
54 static DB *db;
55 static int keep_db;
56 static unsigned int entidx;     /* Index for `getENTNAME'. */
57
58 /* Open database file if not already opened.  */
59 static enum nss_status
60 internal_setent (int stayopen)
61 {
62   enum nss_status status = NSS_STATUS_SUCCESS;
63   int err;
64
65   if (db == NULL)
66     {
67       err = __nss_db_open (DBFILE, DB_BTREE, DB_RDONLY, 0, NULL, NULL, &db);
68
69       if (err != 0)
70         {
71           __set_errno (err);
72           status = err == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
73         }
74       else
75         {
76           /* We have to make sure the file is  `closed on exec'.  */
77           int fd;
78           int result, flags;
79
80           err = db->fd (db, &fd);
81           if (err != 0)
82             {
83               __set_errno (err);
84               result = -1;
85             }
86           else
87             result = flags = fcntl (fd, F_GETFD, 0);
88           if (result >= 0)
89             {
90               flags |= FD_CLOEXEC;
91               result = fcntl (fd, F_SETFD, flags);
92             }
93           if (result < 0)
94             {
95               /* Something went wrong.  Close the stream and return a
96                  failure.  */
97               db->close (db, 0);
98               db = NULL;
99               status = NSS_STATUS_UNAVAIL;
100             }
101         }
102     }
103
104   /* Remember STAYOPEN flag.  */
105   if (db != NULL)
106     keep_db |= stayopen;
107
108   return status;
109 }
110
111
112 /* Thread-safe, exported version of that.  */
113 enum nss_status
114 CONCAT(_nss_db_set,ENTNAME) (int stayopen)
115 {
116   enum nss_status status;
117
118   __libc_lock_lock (lock);
119
120   status = internal_setent (stayopen);
121
122   /* Reset the sequential index.  */
123   entidx = 0;
124
125   __libc_lock_unlock (lock);
126
127   return status;
128 }
129
130
131 /* Close the database file.  */
132 static void
133 internal_endent (void)
134 {
135   if (db != NULL)
136     {
137       db->close (db, 0);
138       db = NULL;
139     }
140 }
141
142
143 /* Thread-safe, exported version of that.  */
144 enum nss_status
145 CONCAT(_nss_db_end,ENTNAME) (void)
146 {
147   __libc_lock_lock (lock);
148
149   internal_endent ();
150
151   /* Reset STAYOPEN flag.  */
152   keep_db = 0;
153
154   __libc_lock_unlock (lock);
155
156   return NSS_STATUS_SUCCESS;
157 }
158 \f
159 /* Do a database lookup for KEY.  */
160 static enum nss_status
161 lookup (DBT *key, struct STRUCTURE *result,
162         void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)
163 {
164   char *p;
165   enum nss_status status;
166   int err;
167   DBT value;
168
169   /* Open the database.  */
170   status = internal_setent (keep_db);
171   if (status != NSS_STATUS_SUCCESS)
172     {
173       *errnop = errno;
174       H_ERRNO_SET (NETDB_INTERNAL);
175       return status;
176     }
177
178   /* Succeed iff it matches a value that parses correctly.  */
179   value.flags = 0;
180   err = db->get (db, NULL, key, &value, 0);
181   if (err != 0)
182     {
183       if (err == DB_NOTFOUND)
184         {
185           H_ERRNO_SET (HOST_NOT_FOUND);
186           status = NSS_STATUS_NOTFOUND;
187         }
188       else
189         {
190           *errnop = err;
191           H_ERRNO_SET (NETDB_INTERNAL);
192           status = NSS_STATUS_UNAVAIL;
193         }
194     }
195   else if (buflen < value.size)
196     {
197       /* No room to copy the data to.  */
198       *errnop = ERANGE;
199       H_ERRNO_SET (NETDB_INTERNAL);
200       status = NSS_STATUS_TRYAGAIN;
201     }
202   else
203     {
204       /* Copy the result to a safe place.  */
205       p = (char *) memcpy (buffer, value.data, value.size);
206
207       /* Skip leading blanks.  */
208       while (isspace (*p))
209         ++p;
210
211       err = parse_line (p, result, buffer, buflen, errnop);
212
213       if (err == 0)
214         {
215           /* If the key begins with '0' we are trying to get the next
216              entry.  We want to ignore unparsable lines in this case.  */
217           if (((char *) key->data)[0] == '0')
218             {
219               /* Super magical return value.  We need to tell our caller
220                  that it should continue looping.  This value cannot
221                  happen in other cases.  */
222               status = NSS_STATUS_RETURN;
223             }
224           else
225             {
226               H_ERRNO_SET (HOST_NOT_FOUND);
227               status = NSS_STATUS_NOTFOUND;
228             }
229         }
230       else if (err < 0)
231         {
232           H_ERRNO_SET (NETDB_INTERNAL);
233           status = NSS_STATUS_TRYAGAIN;
234         }
235       else
236         status = NSS_STATUS_SUCCESS;
237     }
238
239   if (! keep_db)
240     internal_endent ();
241
242   return status;
243 }
244
245
246 /* Macro for defining lookup functions for this DB-based database.
247
248    NAME is the name of the lookup; e.g. `pwnam'.
249
250    KEYPATTERN gives `printf' args to construct a key string;
251    e.g. `(".%s", name)'.
252
253    KEYSIZE gives the allocation size of a buffer to construct it in;
254    e.g. `1 + strlen (name)'.
255
256    PROTO describes the arguments for the lookup key;
257    e.g. `const char *name'.
258
259    BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c.  */
260
261 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
262 enum nss_status                                                               \
263 _nss_db_get##name##_r (proto,                                                 \
264                        struct STRUCTURE *result,                              \
265                        char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\
266 {                                                                             \
267   DBT key;                                                                    \
268   enum nss_status status;                                                     \
269   const size_t size = (keysize) + 1;                                          \
270   key.data = __alloca (size);                                                 \
271   key.size = KEYPRINTF keypattern;                                            \
272   key.flags = 0;                                                              \
273   __libc_lock_lock (lock);                                                    \
274   status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);         \
275   __libc_lock_unlock (lock);                                                  \
276   return status;                                                              \
277 }
278
279 #define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args)
280 \f
281
282
283
284 /* Return the next entry from the database file, doing locking.  */
285 enum nss_status
286 CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
287                                size_t buflen, int *errnop H_ERRNO_PROTO)
288 {
289   /* Return next entry in host file.  */
290   enum nss_status status;
291   char buf[20];
292   DBT key;
293
294   __libc_lock_lock (lock);
295
296   /* Loop until we find a valid entry or hit EOF.  See above for the
297      special meaning of the status value.  */
298   do
299     {
300       key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
301       key.flags = 0;
302       status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);
303       if (status == NSS_STATUS_TRYAGAIN
304 #ifdef NEED_H_ERRNO
305           && *herrnop == NETDB_INTERNAL
306 #endif
307           && *errnop == ERANGE)
308         /* Give the user a chance to get the same entry with a larger
309            buffer.  */
310         --entidx;
311     }
312   while (status == NSS_STATUS_RETURN);
313
314   __libc_lock_unlock (lock);
315
316   return status;
317 }