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