Change everything to store error code through provided pointer and not
[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 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_185.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
64   if (db == NULL)
65     {
66       db = __dbopen (DBFILE, O_RDONLY, 0, DB_BTREE, NULL);
67
68       if (db == NULL)
69         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
70       else
71         {
72           /* We have to make sure the file is  `closed on exec'.  */
73           int result, flags;
74
75           result = flags = fcntl ((*db->fd) (db), F_GETFD, 0);
76           if (result >= 0)
77             {
78               flags |= FD_CLOEXEC;
79               result = fcntl ((*db->fd) (db), F_SETFD, flags);
80             }
81           if (result < 0)
82             {
83               /* Something went wrong.  Close the stream and return a
84                  failure.  */
85               (*db->close) (db);
86               db = NULL;
87               status = NSS_STATUS_UNAVAIL;
88             }
89         }
90     }
91
92   /* Remember STAYOPEN flag.  */
93   if (db != NULL)
94     keep_db |= stayopen;
95
96   return status;
97 }
98
99
100 /* Thread-safe, exported version of that.  */
101 enum nss_status
102 CONCAT(_nss_db_set,ENTNAME) (int stayopen)
103 {
104   enum nss_status status;
105
106   __libc_lock_lock (lock);
107
108   status = internal_setent (stayopen);
109
110   /* Reset the sequential index.  */
111   entidx = 0;
112
113   __libc_lock_unlock (lock);
114
115   return status;
116 }
117
118
119 /* Close the database file.  */
120 static void
121 internal_endent (void)
122 {
123   if (db != NULL)
124     {
125       (*db->close) (db);
126       db = NULL;
127     }
128 }
129
130
131 /* Thread-safe, exported version of that.  */
132 enum nss_status
133 CONCAT(_nss_db_end,ENTNAME) (void)
134 {
135   __libc_lock_lock (lock);
136
137   internal_endent ();
138
139   /* Reset STAYOPEN flag.  */
140   keep_db = 0;
141
142   __libc_lock_unlock (lock);
143
144   return NSS_STATUS_SUCCESS;
145 }
146 \f
147 /* Do a database lookup for KEY.  */
148 static enum nss_status
149 lookup (const DBT *key, struct STRUCTURE *result,
150         void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)
151 {
152   enum nss_status status;
153   int err;
154   DBT value;
155
156   /* Open the database.  */
157   status = internal_setent (keep_db);
158   if (status != NSS_STATUS_SUCCESS)
159     return status;
160
161   /* Succeed iff it matches a value that parses correctly.  */
162   err = ((*db->get) (db, key, &value, 0) == 0 &&
163          parse_line (value.data, result, buffer, buflen, errnop));
164   if (err == 0)
165     status = NSS_STATUS_SUCCESS;
166   else
167     status = err < 0 ? NSS_STATUS_TRYAGAIN : NSS_STATUS_NOTFOUND;
168
169   if (! keep_db)
170     internal_endent ();
171
172   return status;
173 }
174
175
176 /* Macro for defining lookup functions for this DB-based database.
177
178    NAME is the name of the lookup; e.g. `pwnam'.
179
180    KEYPATTERN gives `printf' args to construct a key string;
181    e.g. `(".%s", name)'.
182
183    KEYSIZE gives the allocation size of a buffer to construct it in;
184    e.g. `1 + strlen (name)'.
185
186    PROTO describes the arguments for the lookup key;
187    e.g. `const char *name'.
188
189    BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c.  */
190
191 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
192 enum nss_status                                                               \
193 _nss_db_get##name##_r (proto,                                                 \
194                        struct STRUCTURE *result,                              \
195                        char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\
196 {                                                                             \
197   DBT key;                                                                    \
198   enum nss_status status;                                                     \
199   const size_t size = (keysize);                                              \
200   key.data = __alloca (size);                                                 \
201   key.size = KEYPRINTF keypattern;                                            \
202   __libc_lock_lock (lock);                                                    \
203   status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);         \
204   __libc_lock_unlock (lock);                                                  \
205   return status;                                                              \
206 }
207
208 #define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args)
209 \f
210
211
212
213 /* Return the next entry from the database file, doing locking.  */
214 enum nss_status
215 CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
216                                size_t buflen, int *errnop H_ERRNO_PROTO)
217 {
218   /* Return next entry in host file.  */
219   enum nss_status status;
220   char buf[20];
221   DBT key;
222
223   __libc_lock_lock (lock);
224   key.size = 1 + snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
225   status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);
226   __libc_lock_unlock (lock);
227
228   return status;
229 }