Don't use relative include paths, use <...>.
[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   enum nss_status status;
81
82   yp_get_default_domain (&domainname);
83
84   while (start != NULL)
85     {
86       if (start->val != NULL)
87         free (start->val);
88       next = start;
89       start = start->next;
90       free (next);
91     }
92   start = NULL;
93
94   ypcb.foreach = saveit;
95   ypcb.data = NULL;
96   status = yperr2nss (yp_all (domainname, "protocols.bynumber", &ypcb));
97   next = start;
98
99   return status;
100 }
101
102 enum nss_status
103 _nss_nis_setprotoent (void)
104 {
105   enum nss_status status;
106
107   __libc_lock_lock (lock);
108
109   status = internal_nis_setprotoent ();
110
111   __libc_lock_unlock (lock);
112
113   return status;
114 }
115
116 enum nss_status
117 _nss_nis_endprotoent (void)
118 {
119   __libc_lock_lock (lock);
120
121   while (start != NULL)
122     {
123       if (start->val != NULL)
124         free (start->val);
125       next = start;
126       start = start->next;
127       free (next);
128     }
129   start = NULL;
130   next = NULL;
131
132   __libc_lock_unlock (lock);
133
134   return NSS_STATUS_SUCCESS;
135 }
136
137 static enum nss_status
138 internal_nis_getprotoent_r (struct protoent *proto,
139                             char *buffer, size_t buflen)
140 {
141   struct parser_data *data = (void *) buffer;
142   int parse_res;
143
144   if (start == NULL)
145     internal_nis_setprotoent ();
146
147   /* Get the next entry until we found a correct one. */
148   do
149     {
150       char *p;
151
152       if (next == NULL)
153         return NSS_STATUS_NOTFOUND;
154       p = strcpy (buffer, next->val);
155       next = next->next;
156
157       while (isspace (*p))
158         ++p;
159
160       parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
161       if (!parse_res && errno == ERANGE)
162         return NSS_STATUS_TRYAGAIN;
163     }
164   while (!parse_res);
165
166   return NSS_STATUS_SUCCESS;
167 }
168
169 enum nss_status
170 _nss_nis_getprotoent_r (struct protoent *proto, char *buffer, size_t buflen)
171 {
172   enum nss_status status;
173
174   __libc_lock_lock (lock);
175
176   status = internal_nis_getprotoent_r (proto, buffer, buflen);
177
178   __libc_lock_unlock (lock);
179
180   return status;
181 }
182
183 enum nss_status
184 _nss_nis_getprotobyname_r (const char *name, struct protoent *proto,
185                            char *buffer, size_t buflen)
186 {
187   struct parser_data *data = (void *) buffer;
188   enum nss_status retval;
189   char *domain, *result, *p;
190   int len, parse_res;
191
192   if (name == NULL)
193     {
194       __set_errno (EINVAL);
195       return NSS_STATUS_UNAVAIL;
196     }
197
198   if (yp_get_default_domain (&domain))
199     return NSS_STATUS_UNAVAIL;
200
201   retval = yperr2nss (yp_match (domain, "protocols.byname", name,
202                                 strlen (name), &result, &len));
203
204   if (retval != NSS_STATUS_SUCCESS)
205     {
206       if (retval == NSS_STATUS_TRYAGAIN)
207         __set_errno (EAGAIN);
208       return retval;
209     }
210
211   if ((size_t) (len + 1) > buflen)
212     {
213       free (result);
214       __set_errno (ERANGE);
215       return NSS_STATUS_TRYAGAIN;
216     }
217
218   p = strncpy (buffer, result, len);
219   buffer[len] = '\0';
220   while (isspace (*p))
221     ++p;
222   free (result);
223
224   parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
225
226   if (!parse_res)
227     {
228       if (errno == ERANGE)
229         return NSS_STATUS_TRYAGAIN;
230       else
231         return NSS_STATUS_NOTFOUND;
232     }
233   else
234     return NSS_STATUS_SUCCESS;
235 }
236
237 enum nss_status
238 _nss_nis_getprotobynumber_r (int number, struct protoent *proto,
239                              char *buffer, size_t buflen)
240 {
241   struct parser_data *data = (void *) buffer;
242   enum nss_status retval;
243   char *domain, *result, *p;
244   int len, nlen, parse_res;
245   char buf[32];
246
247   if (yp_get_default_domain (&domain))
248     return NSS_STATUS_UNAVAIL;
249
250   nlen = sprintf (buf, "%d", number);
251
252   retval = yperr2nss (yp_match (domain, "protocols.bynumber", buf,
253                                 nlen, &result, &len));
254
255   if (retval != NSS_STATUS_SUCCESS)
256     {
257       if (retval == NSS_STATUS_TRYAGAIN)
258         __set_errno (EAGAIN);
259       return retval;
260     }
261
262   if ((size_t) (len + 1) > buflen)
263     {
264       free (result);
265       __set_errno (ERANGE);
266       return NSS_STATUS_TRYAGAIN;
267     }
268
269   p = strncpy (buffer, result, len);
270   buffer[len] = '\0';
271   while (isspace (*p))
272     ++p;
273   free (result);
274
275   parse_res = _nss_files_parse_protoent (p, proto, data, buflen);
276
277   if (!parse_res)
278     {
279       if (errno == ERANGE)
280         return NSS_STATUS_TRYAGAIN;
281       else
282         return NSS_STATUS_NOTFOUND;
283     }
284   else
285     return NSS_STATUS_SUCCESS;
286 }