Updated to fedora-glibc-20060328T0900
[kopensolaris-gnu/glibc.git] / nis / nss_nisplus / nisplus-alias.c
1 /* Copyright (C) 1997, 1998, 2001, 2002, 2003, 2005, 2006
2    Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <atomic.h>
22 #include <nss.h>
23 #include <errno.h>
24 #include <ctype.h>
25 #include <string.h>
26 #include <aliases.h>
27 #include <bits/libc-lock.h>
28 #include <rpcsvc/nis.h>
29
30 #include "nss-nisplus.h"
31
32 __libc_lock_define_initialized (static, lock)
33
34 static nis_result *result;
35 static u_long next_entry;
36 static nis_name tablename_val;
37 static size_t tablename_len;
38
39 #define NISENTRYVAL(idx,col,res) \
40         ((res)->objects.objects_val[(idx)].EN_data.en_cols.en_cols_val[(col)].ec_value.ec_value_val)
41
42 #define NISENTRYLEN(idx,col,res) \
43         ((res)->objects.objects_val[(idx)].EN_data.en_cols.en_cols_val[(col)].ec_value.ec_value_len)
44
45 static enum nss_status
46 _nss_create_tablename (int *errnop)
47 {
48   if (tablename_val == NULL)
49     {
50       const char *local_dir = nis_local_directory ();
51       size_t local_dir_len = strlen (local_dir);
52       static const char prefix[] = "mail_aliases.org_dir.";
53
54       char *p = malloc (sizeof (prefix) + local_dir_len);
55       if (p == NULL)
56         {
57           *errnop = errno;
58           return NSS_STATUS_TRYAGAIN;
59         }
60
61       memcpy (__stpcpy (p, prefix), local_dir, local_dir_len + 1);
62
63       tablename_len = sizeof (prefix) - 1 + local_dir_len;
64
65       atomic_write_barrier ();
66
67       tablename_val = p;
68     }
69
70   return NSS_STATUS_SUCCESS;
71 }
72
73 static int
74 _nss_nisplus_parse_aliasent (nis_result *result, unsigned long entry,
75                              struct aliasent *alias, char *buffer,
76                              size_t buflen, int *errnop)
77 {
78   if (result == NULL)
79     return 0;
80
81   if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS)
82       || __type_of (&result->objects.objects_val[entry]) != NIS_ENTRY_OBJ
83       || strcmp (result->objects.objects_val[entry].EN_data.en_type,
84                  "mail_aliases") != 0
85       || result->objects.objects_val[entry].EN_data.en_cols.en_cols_len < 2)
86     return 0;
87
88   char *first_unused = buffer + NISENTRYLEN (0, 1, result) + 1;
89   size_t room_left = (buflen - (buflen % __alignof__ (char *))
90                       - NISENTRYLEN (0, 1, result) - 2);
91
92   if (NISENTRYLEN (entry, 1, result) >= buflen)
93     {
94       /* The line is too long for our buffer.  */
95     no_more_room:
96       *errnop = ERANGE;
97       return -1;
98     }
99
100   char *cp = __stpncpy (buffer, NISENTRYVAL (entry, 1, result),
101                         NISENTRYLEN (entry, 1, result));
102   *cp = '\0';
103
104   if (NISENTRYLEN(entry, 0, result) >= room_left)
105     goto no_more_room;
106
107   alias->alias_local = 0;
108   alias->alias_members_len = 0;
109   *first_unused = '\0';
110   ++first_unused;
111   cp = __stpncpy (first_unused, NISENTRYVAL (entry, 0, result),
112                   NISENTRYLEN (entry, 0, result));
113   *cp = '\0';
114   alias->alias_name = first_unused;
115
116   /* Terminate the line for any case.  */
117   cp = strpbrk (alias->alias_name, "#\n");
118   if (cp != NULL)
119     *cp = '\0';
120
121   first_unused += strlen (alias->alias_name) +1;
122   /* Adjust the pointer so it is aligned for
123      storing pointers.  */
124   first_unused += __alignof__ (char *) - 1;
125   first_unused -= ((first_unused - (char *) 0) % __alignof__ (char *));
126   alias->alias_members = (char **) first_unused;
127
128   char *line = buffer;
129   while (*line != '\0')
130     {
131       /* Skip leading blanks.  */
132       while (isspace (*line))
133         ++line;
134
135       if (*line == '\0')
136         break;
137
138       if (room_left < sizeof (char *))
139         goto no_more_room;
140       room_left -= sizeof (char *);
141       alias->alias_members[alias->alias_members_len] = line;
142
143       while (*line != '\0' && *line != ',')
144         ++line;
145
146       if (line != alias->alias_members[alias->alias_members_len])
147         {
148           *line++ = '\0';
149           alias->alias_members_len++;
150         }
151     }
152
153   return alias->alias_members_len == 0 ? 0 : 1;
154 }
155
156 static enum nss_status
157 internal_setaliasent (void)
158 {
159   enum nss_status status;
160   int err;
161
162   if (result !=  NULL)
163     {
164       nis_freeresult (result);
165       result = NULL;
166     }
167
168   if (_nss_create_tablename (&err) != NSS_STATUS_SUCCESS)
169     return NSS_STATUS_UNAVAIL;
170
171   next_entry = 0;
172   result = nis_list (tablename_val, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
173   if (result == NULL)
174     {
175       status = NSS_STATUS_TRYAGAIN;
176       __set_errno (ENOMEM);
177     }
178   else
179     {
180       status = niserr2nss (result->status);
181       if (status != NSS_STATUS_SUCCESS)
182         {
183           nis_freeresult (result);
184           result = NULL;
185         }
186     }
187   return status;
188 }
189
190 enum nss_status
191 _nss_nisplus_setaliasent (void)
192 {
193   enum nss_status status;
194
195   __libc_lock_lock (lock);
196
197   status = internal_setaliasent ();
198
199   __libc_lock_unlock (lock);
200
201   return status;
202 }
203
204 enum nss_status
205 _nss_nisplus_endaliasent (void)
206 {
207   __libc_lock_lock (lock);
208
209   if (result != NULL)
210     {
211       nis_freeresult (result);
212       result = NULL;
213     }
214   next_entry = 0;
215
216   __libc_lock_unlock (lock);
217
218   return NSS_STATUS_SUCCESS;
219 }
220
221 static enum nss_status
222 internal_nisplus_getaliasent_r (struct aliasent *alias,
223                                 char *buffer, size_t buflen, int *errnop)
224 {
225   int parse_res;
226
227   if (result == NULL)
228     {
229       enum nss_status status;
230
231       status = internal_setaliasent ();
232       if (result == NULL || status != NSS_STATUS_SUCCESS)
233         return status;
234     }
235
236   /* Get the next entry until we found a correct one. */
237   do
238     {
239       if (next_entry >= result->objects.objects_len)
240         return NSS_STATUS_NOTFOUND;
241
242       parse_res = _nss_nisplus_parse_aliasent (result, next_entry, alias,
243                                                buffer, buflen, errnop);
244       if (parse_res == -1)
245         return NSS_STATUS_TRYAGAIN;
246
247       ++next_entry;
248     }
249   while (!parse_res);
250
251   return NSS_STATUS_SUCCESS;
252 }
253
254 enum nss_status
255 _nss_nisplus_getaliasent_r (struct aliasent *result, char *buffer,
256                             size_t buflen, int *errnop)
257 {
258   int status;
259
260   __libc_lock_lock (lock);
261
262   status = internal_nisplus_getaliasent_r (result, buffer, buflen, errnop);
263
264   __libc_lock_unlock (lock);
265
266   return status;
267 }
268
269 enum nss_status
270 _nss_nisplus_getaliasbyname_r (const char *name, struct aliasent *alias,
271                             char *buffer, size_t buflen, int *errnop)
272 {
273   int parse_res;
274
275   if (tablename_val == NULL)
276     {
277       __libc_lock_lock (lock);
278
279       enum nss_status status = _nss_create_tablename (errnop);
280
281       __libc_lock_unlock (lock);
282
283       if (status != NSS_STATUS_SUCCESS)
284         return status;
285     }
286
287   if (name != NULL)
288     {
289       *errnop = EINVAL;
290       return NSS_STATUS_UNAVAIL;
291     }
292
293   char buf[strlen (name) + 9 + tablename_len];
294   int olderr = errno;
295
296   snprintf (buf, sizeof (buf), "[name=%s],%s", name, tablename_val);
297
298   nis_result *result = nis_list (buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
299
300   if (result == NULL)
301     {
302       *errnop = ENOMEM;
303       return NSS_STATUS_TRYAGAIN;
304     }
305
306   if (__builtin_expect (niserr2nss (result->status) != NSS_STATUS_SUCCESS, 0))
307     return niserr2nss (result->status);
308
309   parse_res = _nss_nisplus_parse_aliasent (result, 0, alias,
310                                            buffer, buflen, errnop);
311   if (__builtin_expect (parse_res < 1, 0))
312     {
313       __set_errno (olderr);
314
315       if (parse_res == -1)
316         return NSS_STATUS_TRYAGAIN;
317       else
318         return NSS_STATUS_NOTFOUND;
319     }
320
321   return NSS_STATUS_SUCCESS;
322 }