Use addr, not p for inet_pton call.
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-service.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
32 /* The parser is defined in a different module.  */
33 extern int _nss_files_parse_servent (char *line, struct servent *result,
34                                      char *data, size_t datalen);
35
36
37
38 __libc_lock_define_initialized (static, lock)
39
40 struct response_t
41 {
42   char *val;
43   struct response_t *next;
44 };
45
46 struct intern_t
47 {
48   struct response_t *start;
49   struct response_t *next;
50 };
51 typedef struct intern_t intern_t;
52
53 static intern_t intern = { NULL, NULL };
54
55 static int
56 saveit (int instatus, char *inkey, int inkeylen, char *inval,
57         int invallen, char *indata)
58 {
59   intern_t *intern = (intern_t *) indata;
60
61   if (instatus != YP_TRUE)
62     return instatus;
63
64   if (inkey && inkeylen > 0 && inval && invallen > 0)
65     {
66       if (intern->start == NULL)
67         {
68           intern->start = malloc (sizeof (struct response_t));
69           intern->next = intern->start;
70         }
71       else
72         {
73           intern->next->next = malloc (sizeof (struct response_t));
74           intern->next = intern->next->next;
75         }
76       intern->next->next = NULL;
77       intern->next->val = malloc (invallen + 1);
78       strncpy (intern->next->val, inval, invallen);
79       intern->next->val[invallen] = '\0';
80     }
81
82   return 0;
83 }
84
85 static enum nss_status
86 internal_nis_setservent (intern_t *intern)
87 {
88   char *domainname;
89   struct ypall_callback ypcb;
90   enum nss_status status;
91
92   if (yp_get_default_domain (&domainname))
93     return NSS_STATUS_UNAVAIL;
94
95   while (intern->start != NULL)
96     {
97       if (intern->start->val != NULL)
98         free (intern->start->val);
99       intern->next = intern->start;
100       intern->start = intern->start->next;
101       free (intern->next);
102     }
103   intern->start = NULL;
104
105   ypcb.foreach = saveit;
106   ypcb.data = (char *) intern;
107   status = yperr2nss (yp_all (domainname, "services.byname", &ypcb));
108   intern->next = intern->start;
109
110   return status;
111 }
112 enum nss_status
113 _nss_nis_setservent (void)
114 {
115   enum nss_status status;
116
117   __libc_lock_lock (lock);
118
119   status = internal_nis_setservent (&intern);
120
121   __libc_lock_unlock (lock);
122
123   return status;
124 }
125
126 static enum nss_status
127 internal_nis_endservent (intern_t * intern)
128 {
129   while (intern->start != NULL)
130     {
131       if (intern->start->val != NULL)
132         free (intern->start->val);
133       intern->next = intern->start;
134       intern->start = intern->start->next;
135       free (intern->next);
136     }
137   intern->start = NULL;
138
139   return NSS_STATUS_SUCCESS;
140 }
141
142 enum nss_status
143 _nss_nis_endservent (void)
144 {
145   enum nss_status status;
146
147   __libc_lock_lock (lock);
148
149   status = internal_nis_endservent (&intern);
150
151   __libc_lock_unlock (lock);
152
153   return status;
154 }
155
156 static enum nss_status
157 internal_nis_getservent_r (struct servent *serv, char *buffer,
158                            size_t buflen, intern_t *data)
159 {
160   int parse_res;
161   char *p;
162
163   if (data->start == NULL)
164     internal_nis_setservent (data);
165
166   /* Get the next entry until we found a correct one. */
167   do
168     {
169       if (data->next == NULL)
170         return NSS_STATUS_NOTFOUND;
171       p = strcpy (buffer, data->next->val);
172       data->next = data->next->next;
173       while (isspace (*p))
174         ++p;
175
176       parse_res = _nss_files_parse_servent (p, serv, buffer, buflen);
177       if (!parse_res && errno == ERANGE)
178         return NSS_STATUS_TRYAGAIN;
179     }
180   while (!parse_res);
181
182   return NSS_STATUS_SUCCESS;
183 }
184
185 enum nss_status
186 _nss_nis_getservent_r (struct servent *serv, char *buffer, size_t buflen)
187 {
188   enum nss_status status;
189
190   __libc_lock_lock (lock);
191
192   status = internal_nis_getservent_r (serv, buffer, buflen, &intern);
193
194   __libc_lock_unlock (lock);
195
196   return status;
197 }
198
199 enum nss_status
200 _nss_nis_getservbyname_r (const char *name, char *protocol,
201                           struct servent *serv, char *buffer, size_t buflen)
202 {
203   intern_t data = { NULL, NULL };
204   enum nss_status status;
205   int found;
206
207   if (name == NULL)
208     {
209       __set_errno (EINVAL);
210       return NSS_STATUS_UNAVAIL;
211     }
212
213   status = internal_nis_setservent (&data);
214   if (status != NSS_STATUS_SUCCESS)
215     return status;
216
217   found = 0;
218   while (!found &&
219          ((status = internal_nis_getservent_r (serv, buffer, buflen, &data))
220           == NSS_STATUS_SUCCESS))
221     {
222       if (protocol == NULL || strcmp (serv->s_proto, protocol) == 0)
223         {
224           char **cp;
225
226           if (strcmp (serv->s_name, name) == 0)
227             found = 1;
228           else
229             for (cp = serv->s_aliases; *cp; cp++)
230               if (strcmp (name, *cp) == 0)
231                 found = 1;
232         }
233     }
234
235   internal_nis_endservent (&data);
236
237   if (!found && status == NSS_STATUS_SUCCESS)
238     return NSS_STATUS_NOTFOUND;
239   else
240     return status;
241 }
242
243 enum nss_status
244 _nss_nis_getservbyport_r (int port, char *protocol, struct servent *serv,
245                           char *buffer, size_t buflen)
246 {
247   intern_t data = { NULL, NULL };
248   enum nss_status status;
249   int found;
250
251   if (protocol == NULL)
252     {
253       __set_errno (EINVAL);
254       return NSS_STATUS_UNAVAIL;
255     }
256
257   status = internal_nis_setservent (&data);
258   if (status != NSS_STATUS_SUCCESS)
259     return status;
260
261   found = 0;
262   while (!found &&
263          ((status = internal_nis_getservent_r (serv, buffer, buflen, &data))
264           == NSS_STATUS_SUCCESS))
265     {
266       if (htons (serv->s_port) == port)
267         {
268           if  (strcmp (serv->s_proto, protocol) == 0)
269             {
270               found = 1;
271             }
272         }
273     }
274
275   internal_nis_endservent (&data);
276
277   if (!found && status == NSS_STATUS_SUCCESS)
278     return NSS_STATUS_NOTFOUND;
279   else
280     return status;
281 }