Fix stack initialization code
[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, 1999, 2000 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 Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the 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    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <dlfcn.h>
21 #include <fcntl.h>
22 #include <bits/libc-lock.h>
23 #include "nsswitch.h"
24 #include "nss_db.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 -- database file name, ("hosts", "passwd")
31
32    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
33 */
34
35 #define ENTNAME_r       CONCAT(ENTNAME,_r)
36
37 #include <paths.h>
38 #define DBFILE          _PATH_VARDB DATABASE ".db"
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 handle open on the database.  */
54
55 static NSS_DB *db;
56 static int keep_db;
57 static int entidx;
58
59
60 /* Open the database.  */
61 enum nss_status
62 CONCAT(_nss_db_set,ENTNAME) (int stayopen)
63 {
64   enum nss_status status;
65
66   __libc_lock_lock (lock);
67
68   status = internal_setent (DBFILE, &db);
69
70   /* Remember STAYOPEN flag.  */
71   if (db != NULL)
72     keep_db |= stayopen;
73   /* Reset the sequential index.  */
74   entidx = 0;
75
76   __libc_lock_unlock (lock);
77
78   return status;
79 }
80
81
82 /* Close it again.  */
83 enum nss_status
84 CONCAT(_nss_db_end,ENTNAME) (void)
85 {
86   __libc_lock_lock (lock);
87
88   internal_endent (&db);
89
90   /* Reset STAYOPEN flag.  */
91   keep_db = 0;
92
93   __libc_lock_unlock (lock);
94
95   return NSS_STATUS_SUCCESS;
96 }
97 \f
98 /* Do a database lookup for KEY.  */
99 static enum nss_status
100 lookup (DBT *key, struct STRUCTURE *result,
101         void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO EXTRA_ARGS_DECL)
102 {
103   char *p;
104   enum nss_status status;
105   int err;
106   DBT value;
107
108   /* Open the database.  */
109   if (db == NULL)
110     {
111       status = internal_setent (DBFILE, &db);
112       if (status != NSS_STATUS_SUCCESS)
113         {
114           *errnop = errno;
115           H_ERRNO_SET (NETDB_INTERNAL);
116           return status;
117         }
118     }
119
120   /* Succeed iff it matches a value that parses correctly.  */
121   value.flags = 0;
122   err = DL_CALL_FCT (db->get, (db->db, NULL, key, &value, 0));
123   if (err != 0)
124     {
125       if (err == db_notfound)
126         {
127           H_ERRNO_SET (HOST_NOT_FOUND);
128           status = NSS_STATUS_NOTFOUND;
129         }
130       else
131         {
132           *errnop = err;
133           H_ERRNO_SET (NETDB_INTERNAL);
134           status = NSS_STATUS_UNAVAIL;
135         }
136     }
137   else if (buflen < value.size)
138     {
139       /* No room to copy the data to.  */
140       *errnop = ERANGE;
141       H_ERRNO_SET (NETDB_INTERNAL);
142       status = NSS_STATUS_TRYAGAIN;
143     }
144   else
145     {
146       /* Copy the result to a safe place.  */
147       p = (char *) memcpy (buffer, value.data, value.size);
148
149       /* Skip leading blanks.  */
150       while (isspace (*p))
151         ++p;
152
153       err = parse_line (p, result, buffer, buflen, errnop EXTRA_ARGS);
154
155       if (err == 0)
156         {
157           /* If the key begins with '0' we are trying to get the next
158              entry.  We want to ignore unparsable lines in this case.  */
159           if (((char *) key->data)[0] == '0')
160             {
161               /* Super magical return value.  We need to tell our caller
162                  that it should continue looping.  This value cannot
163                  happen in other cases.  */
164               status = NSS_STATUS_RETURN;
165             }
166           else
167             {
168               H_ERRNO_SET (HOST_NOT_FOUND);
169               status = NSS_STATUS_NOTFOUND;
170             }
171         }
172       else if (err < 0)
173         {
174           H_ERRNO_SET (NETDB_INTERNAL);
175           status = NSS_STATUS_TRYAGAIN;
176         }
177       else
178         status = NSS_STATUS_SUCCESS;
179     }
180
181   if (! keep_db)
182     internal_endent (&db);
183
184   return status;
185 }
186
187
188 /* Macro for defining lookup functions for this DB-based database.
189
190    NAME is the name of the lookup; e.g. `pwnam'.
191
192    KEYPATTERN gives `printf' args to construct a key string;
193    e.g. `(".%s", name)'.
194
195    KEYSIZE gives the allocation size of a buffer to construct it in;
196    e.g. `1 + strlen (name)'.
197
198    PROTO describes the arguments for the lookup key;
199    e.g. `const char *name'.
200
201    BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c.  */
202
203 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
204 enum nss_status                                                               \
205 _nss_db_get##name##_r (proto,                                                 \
206                        struct STRUCTURE *result,                              \
207                        char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\
208 {                                                                             \
209   DBT key;                                                                    \
210   enum nss_status status;                                                     \
211   const size_t size = (keysize) + 1;                                          \
212   key.data = __alloca (size);                                                 \
213   key.size = KEYPRINTF keypattern;                                            \
214   key.flags = 0;                                                              \
215   __libc_lock_lock (lock);                                                    \
216   status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG           \
217                    EXTRA_ARGS_VALUE);                                         \
218   __libc_lock_unlock (lock);                                                  \
219   return status;                                                              \
220 }
221
222 #define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args)
223 \f
224
225
226
227 /* Return the next entry from the database file, doing locking.  */
228 enum nss_status
229 CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
230                                size_t buflen, int *errnop H_ERRNO_PROTO)
231 {
232   /* Return next entry in host file.  */
233   enum nss_status status;
234   char buf[20];
235   DBT key;
236
237   __libc_lock_lock (lock);
238
239   /* Loop until we find a valid entry or hit EOF.  See above for the
240      special meaning of the status value.  */
241   do
242     {
243       key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
244       key.flags = 0;
245       status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG
246                        EXTRA_ARGS_VALUE);
247       if (status == NSS_STATUS_TRYAGAIN
248 #ifdef NEED_H_ERRNO
249           && *herrnop == NETDB_INTERNAL
250 #endif
251           && *errnop == ERANGE)
252         /* Give the user a chance to get the same entry with a larger
253            buffer.  */
254         --entidx;
255     }
256   while (status == NSS_STATUS_RETURN);
257
258   __libc_lock_unlock (lock);
259
260   return status;
261 }