Rewrite NIS code to allow empty keys.
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-proto.c
1 /* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.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 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 <nss.h>
21 #include <netdb.h>
22 #include <ctype.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <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   char *val;
41   struct response *next;
42 };
43
44 static struct response *start = NULL;
45 static struct response *next = NULL;
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 instatus;
53
54   if (inkey && inkeylen > 0 && inval && invallen > 0)
55     {
56       if (start == NULL)
57         {
58           start = malloc (sizeof (struct response));
59           next = start;
60         }
61       else
62         {
63           next->next = malloc (sizeof (struct response));
64           next = next->next;
65         }
66       next->next = NULL;
67       next->val = malloc (invallen + 1);
68       strncpy (next->val, inval, invallen);
69       next->val[invallen] = '\0';
70     }
71   
72   return 0;
73 }
74
75 enum nss_status
76 internal_nis_setprotoent (void)
77 {
78   char *domainname;
79   struct ypall_callback ypcb;
80   
81   yp_get_default_domain (&domainname);
82   
83   while (start != NULL)
84     {
85       if (start->val != NULL)
86         free (start->val);
87       next = start;
88       start = start->next;
89       free (next);
90     }
91   start = NULL;
92   
93   ypcb.foreach = saveit;
94   ypcb.data = NULL;
95   yp_all (domainname, "protocols.bynumber", &ypcb);
96   next = start;
97   
98   return NSS_STATUS_SUCCESS;
99 }
100
101 enum nss_status
102 _nss_nis_setprotoent (void)
103 {
104   enum nss_status status;
105
106   __libc_lock_lock (lock);
107
108   status = internal_nis_setprotoent ();
109
110   __libc_lock_unlock (lock);
111
112   return status;
113 }
114
115 enum nss_status
116 _nss_nis_endprotoent (void)
117 {
118   __libc_lock_lock (lock);
119
120   while (start != NULL)
121     {
122       if (start->val != NULL)
123         free (start->val);
124       next = start;
125       start = start->next;
126       free (next);
127     }
128   start = NULL;
129   next = NULL;
130   
131   __libc_lock_unlock (lock);
132   
133   return NSS_STATUS_SUCCESS;
134 }
135
136 static enum nss_status
137 internal_nis_getprotoent_r (struct protoent *proto,
138                             char *buffer, size_t buflen)
139 {
140   struct parser_data *data = (void *) buffer;
141   int parse_res;
142
143   if (start == NULL)
144     internal_nis_setprotoent ();
145
146   /* Get the next entry until we found a correct one. */
147   do
148     {
149       char *p;
150       
151       if (next == NULL)
152         return NSS_STATUS_NOTFOUND;
153       p = strcpy (buffer, next->val);
154       next = next->next;
155       
156       while (isspace (*p))
157         ++p;
158
159       parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
160       if (!parse_res && errno == ERANGE)
161         return NSS_STATUS_TRYAGAIN;
162     }
163   while (!parse_res);
164   
165   return NSS_STATUS_SUCCESS;
166 }
167
168 enum nss_status
169 _nss_nis_getprotoent_r (struct protoent *proto, char *buffer, size_t buflen)
170 {
171   enum nss_status status;
172
173   __libc_lock_lock (lock);
174
175   status = internal_nis_getprotoent_r (proto, buffer, buflen);
176
177   __libc_lock_unlock (lock);
178
179   return status;
180 }
181
182 enum nss_status
183 _nss_nis_getprotobyname_r (const char *name, struct protoent *proto,
184                            char *buffer, size_t buflen)
185 {
186   struct parser_data *data = (void *) buffer;
187   enum nss_status retval;
188   char *domain, *result, *p;
189   int len, parse_res;
190
191   if (name == NULL)
192     {
193       __set_errno (EINVAL);
194       return NSS_STATUS_UNAVAIL;
195     }
196
197   if (yp_get_default_domain (&domain))
198     return NSS_STATUS_UNAVAIL;
199
200   retval = yperr2nss (yp_match (domain, "protocols.byname", name,
201                                 strlen (name), &result, &len));
202
203   if (retval != NSS_STATUS_SUCCESS)
204     {
205       if (retval == NSS_STATUS_TRYAGAIN)
206         __set_errno (EAGAIN);
207       return retval;
208     }
209
210   if ((size_t) (len + 1) > buflen)
211     {
212       free (result);
213       __set_errno (ERANGE);
214       return NSS_STATUS_TRYAGAIN;
215     }
216
217   p = strncpy (buffer, result, len);
218   buffer[len] = '\0';
219   while (isspace (*p))
220     ++p;
221   free (result);
222
223   parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
224
225   if (!parse_res)
226     {
227       if (errno == ERANGE)
228         return NSS_STATUS_TRYAGAIN;
229       else
230         return NSS_STATUS_NOTFOUND;
231     }
232   else
233     return NSS_STATUS_SUCCESS;
234 }
235
236 enum nss_status
237 _nss_nis_getprotobynumber_r (int number, struct protoent *proto,
238                              char *buffer, size_t buflen)
239 {
240   struct parser_data *data = (void *) buffer;
241   enum nss_status retval;
242   char *domain, *result, *p;
243   int len, nlen, parse_res;
244   char buf[32];
245
246   if (yp_get_default_domain (&domain))
247     return NSS_STATUS_UNAVAIL;
248
249   nlen = sprintf (buf, "%d", number);
250
251   retval = yperr2nss (yp_match (domain, "protocols.bynumber", buf,
252                                 nlen, &result, &len));
253
254   if (retval != NSS_STATUS_SUCCESS)
255     {
256       if (retval == NSS_STATUS_TRYAGAIN)
257         __set_errno (EAGAIN);
258       return retval;
259     }
260
261   if ((size_t) (len + 1) > buflen)
262     {
263       free (result);
264       __set_errno (ERANGE);
265       return NSS_STATUS_TRYAGAIN;
266     }
267
268   p = strncpy (buffer, result, len);
269   buffer[len] = '\0';
270   while (isspace (*p))
271     ++p;
272   free (result);
273
274   parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
275
276   if (!parse_res)
277     {
278       if (errno == ERANGE)
279         return NSS_STATUS_TRYAGAIN;
280       else
281         return NSS_STATUS_NOTFOUND;
282     }
283   else
284     return NSS_STATUS_SUCCESS;
285 }