(saveit): Fix return codes in error case.
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-ethers.c
1 /* Copyright (C) 1996-2003, 2004 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
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 <nss.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <string.h>
24 #include <bits/libc-lock.h>
25 #include <rpcsvc/yp.h>
26 #include <rpcsvc/ypclnt.h>
27 #include <netinet/ether.h>
28 #include <netinet/if_ether.h>
29
30 #include "nss-nis.h"
31
32 /* Protect global state against multiple changers */
33 __libc_lock_define_initialized (static, lock)
34
35 /* Get the declaration of the parser function.  */
36 #define ENTNAME etherent
37 #define STRUCTURE etherent
38 #define EXTERN_PARSER
39 #include <nss/nss_files/files-parse.c>
40
41 struct response
42 {
43   struct response *next;
44   char val[0];
45 };
46
47 static struct response *start;
48 static struct response *next;
49
50 static int
51 saveit (int instatus, char *inkey, int inkeylen, char *inval,
52         int invallen, char *indata)
53 {
54   if (instatus != YP_TRUE)
55     return 1;
56
57   if (inkey && inkeylen > 0 && inval && invallen > 0)
58     {
59       struct response *newp = malloc (sizeof (struct response) + invallen + 1);
60       if (newp == NULL)
61         return 1; /* We have no error code for out of memory */
62
63       if (start == NULL)
64         start = newp;
65       else
66         next->next = newp;
67       next = newp;
68
69       newp->next = NULL;
70       *((char *) mempcpy (newp->val, inval, invallen)) = '\0';
71     }
72
73   return 0;
74 }
75
76 static void
77 internal_nis_endetherent (void)
78 {
79   while (start != NULL)
80     {
81       next = start;
82       start = start->next;
83       free (next);
84     }
85 }
86
87 enum nss_status
88 _nss_nis_endetherent (void)
89 {
90   __libc_lock_lock (lock);
91
92   internal_nis_endetherent ();
93   next = NULL;
94
95   __libc_lock_unlock (lock);
96
97   return NSS_STATUS_SUCCESS;
98 }
99
100 static enum nss_status
101 internal_nis_setetherent (void)
102 {
103   char *domainname;
104   struct ypall_callback ypcb;
105   enum nss_status status;
106
107   yp_get_default_domain (&domainname);
108
109   internal_nis_endetherent ();
110
111   ypcb.foreach = saveit;
112   ypcb.data = NULL;
113   status = yperr2nss (yp_all (domainname, "ethers.byname", &ypcb));
114   next = start;
115
116   return status;
117 }
118
119 enum nss_status
120 _nss_nis_setetherent (int stayopen)
121 {
122   enum nss_status result;
123
124   __libc_lock_lock (lock);
125
126   result = internal_nis_setetherent ();
127
128   __libc_lock_unlock (lock);
129
130   return result;
131 }
132
133 static enum nss_status
134 internal_nis_getetherent_r (struct etherent *eth, char *buffer, size_t buflen,
135                             int *errnop)
136 {
137   struct parser_data *data = (void *) buffer;
138   int parse_res;
139
140   if (start == NULL)
141     internal_nis_setetherent ();
142
143   /* Get the next entry until we found a correct one. */
144   do
145     {
146       char *p;
147
148       if (next == NULL)
149         return NSS_STATUS_NOTFOUND;
150
151       p = strncpy (buffer, next->val, buflen);
152
153       while (isspace (*p))
154         ++p;
155
156       parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
157       if (parse_res == -1)
158         return NSS_STATUS_TRYAGAIN;
159       next = next->next;
160     }
161   while (!parse_res);
162
163   return NSS_STATUS_SUCCESS;
164 }
165
166 enum nss_status
167 _nss_nis_getetherent_r (struct etherent *result, char *buffer, size_t buflen,
168                         int *errnop)
169 {
170   int status;
171
172   __libc_lock_lock (lock);
173
174   status = internal_nis_getetherent_r (result, buffer, buflen, errnop);
175
176   __libc_lock_unlock (lock);
177
178   return status;
179 }
180
181 enum nss_status
182 _nss_nis_gethostton_r (const char *name, struct etherent *eth,
183                        char *buffer, size_t buflen, int *errnop)
184 {
185   struct parser_data *data = (void *) buffer;
186   enum nss_status retval;
187   char *domain, *result, *p;
188   int len, parse_res;
189
190   if (name == NULL)
191     {
192       *errnop = EINVAL;
193       return NSS_STATUS_UNAVAIL;
194     }
195
196   if (yp_get_default_domain (&domain))
197     return NSS_STATUS_UNAVAIL;
198
199   retval = yperr2nss (yp_match (domain, "ethers.byname", name,
200                                 strlen (name), &result, &len));
201
202   if (retval != NSS_STATUS_SUCCESS)
203     {
204       if (retval == NSS_STATUS_TRYAGAIN)
205         *errnop = errno;
206       return retval;
207     }
208
209   if ((size_t) (len + 1) > buflen)
210     {
211       free (result);
212       *errnop = ERANGE;
213       return NSS_STATUS_TRYAGAIN;
214     }
215
216   p = strncpy (buffer, result, len);
217   buffer[len] = '\0';
218   while (isspace (*p))
219     ++p;
220   free (result);
221
222   parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
223   if (parse_res < 1)
224     {
225       if (parse_res == -1)
226         return NSS_STATUS_TRYAGAIN;
227       else
228         return NSS_STATUS_NOTFOUND;
229     }
230   return NSS_STATUS_SUCCESS;
231 }
232
233 enum nss_status
234 _nss_nis_getntohost_r (const struct ether_addr *addr, struct etherent *eth,
235                        char *buffer, size_t buflen, int *errnop)
236 {
237   struct parser_data *data = (void *) buffer;
238   enum nss_status retval;
239   char *domain, *result, *p;
240   int len, nlen, parse_res;
241   char buf[33];
242
243   if (addr == NULL)
244     {
245       *errnop = EINVAL;
246       return NSS_STATUS_UNAVAIL;
247     }
248
249   if (yp_get_default_domain (&domain))
250     return NSS_STATUS_UNAVAIL;
251
252   nlen = sprintf (buf, "%x:%x:%x:%x:%x:%x",
253                   (int) addr->ether_addr_octet[0],
254                   (int) addr->ether_addr_octet[1],
255                   (int) addr->ether_addr_octet[2],
256                   (int) addr->ether_addr_octet[3],
257                   (int) addr->ether_addr_octet[4],
258                   (int) addr->ether_addr_octet[5]);
259
260   retval = yperr2nss (yp_match (domain, "ethers.byaddr", buf,
261                                 nlen, &result, &len));
262
263   if (retval != NSS_STATUS_SUCCESS)
264     {
265       if (retval == NSS_STATUS_TRYAGAIN)
266         *errnop = errno;
267       return retval;
268     }
269
270   if ((size_t) (len + 1) > buflen)
271     {
272       free (result);
273       *errnop = ERANGE;
274       return NSS_STATUS_TRYAGAIN;
275     }
276
277   p = strncpy (buffer, result, len);
278   buffer[len] = '\0';
279   while (isspace (*p))
280     ++p;
281   free (result);
282
283   parse_res = _nss_files_parse_etherent (p, eth, data, buflen, errnop);
284   if (parse_res < 1)
285     {
286       if (parse_res == -1)
287         return NSS_STATUS_TRYAGAIN;
288       else
289         return NSS_STATUS_NOTFOUND;
290     }
291   return NSS_STATUS_SUCCESS;
292 }