1 /* $NetBSD: yplib.c,v 1.46 2014/09/18 13:58:20 christos Exp $ */
2
3 /*
4 * Copyright (c) 1992, 1993 Theo de Raadt <deraadt@fsa.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #if defined(LIBC_SCCS) && !defined(lint)
31 __RCSID("$NetBSD: yplib.c,v 1.46 2014/09/18 13:58:20 christos Exp $");
32 #endif
33
34 #include "namespace.h"
35 #include "reentrant.h"
36
37 #include <sys/param.h>
38 #include <sys/socket.h>
39 #include <sys/file.h>
40 #include <sys/uio.h>
41
42 #include <arpa/nameser.h>
43
44 #include <assert.h>
45 #include <errno.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <unistd.h>
50
51 #include <rpc/rpc.h>
52 #include <rpc/xdr.h>
53 #include <rpcsvc/yp_prot.h>
54 #include <rpcsvc/ypclnt.h>
55 #include "local.h"
56
57 #define BINDINGDIR "/var/yp/binding"
58 #define YPBINDLOCK "/var/run/ypbind.lock"
59
60 struct dom_binding *_ypbindlist;
61 char _yp_domain[MAXHOSTNAMELEN];
62
63 #define YPLIB_TIMEOUT 10
64 #define YPLIB_RPC_RETRIES 4
65
66 struct timeval _yplib_timeout = { YPLIB_TIMEOUT, 0 };
67 struct timeval _yplib_rpc_timeout = { YPLIB_TIMEOUT / YPLIB_RPC_RETRIES,
68 1000000 * (YPLIB_TIMEOUT % YPLIB_RPC_RETRIES) / YPLIB_RPC_RETRIES };
69 int _yplib_nerrs = 5;
70 int _yplib_bindtries = 0;
71
72 #ifdef __weak_alias
73 __weak_alias(yp_bind, _yp_bind)
74 __weak_alias(yp_unbind, _yp_unbind)
75 __weak_alias(yp_get_default_domain, _yp_get_default_domain)
76 __weak_alias(yp_setbindtries, _yp_setbindtries)
77 #endif
78
79 #ifdef _REENTRANT
80 static mutex_t _ypmutex = MUTEX_INITIALIZER;
81 #define YPLOCK() mutex_lock(&_ypmutex)
82 #define YPUNLOCK() mutex_unlock(&_ypmutex)
83 #else
84 #define YPLOCK()
85 #define YPUNLOCK()
86 #endif
87
88 int
yp_setbindtries(int ntries)89 yp_setbindtries(int ntries)
90 {
91 int old_val = _yplib_bindtries;
92
93 if (ntries >= 0)
94 _yplib_bindtries = ntries;
95 return old_val;
96 }
97
98 int
_yp_dobind(const char * dom,struct dom_binding ** ypdb)99 _yp_dobind(const char *dom, struct dom_binding **ypdb)
100 {
101 static int pid = -1;
102 char path[MAXPATHLEN];
103 struct dom_binding *ysd, *ysd2;
104 struct ypbind_resp ypbr;
105 struct sockaddr_in clnt_sin;
106 int clnt_sock, fd, gpid;
107 CLIENT *client;
108 int new = 0;
109 int nerrs = 0;
110 ssize_t r;
111
112 if (dom == NULL || *dom == '\0')
113 return YPERR_BADARGS;
114
115 /*
116 * test if YP is running or not
117 */
118 if ((fd = open(YPBINDLOCK, O_RDONLY | O_CLOEXEC)) == -1)
119 return YPERR_YPBIND;
120 if (!(flock(fd, LOCK_EX | LOCK_NB) == -1 && errno == EWOULDBLOCK)) {
121 (void)close(fd);
122 return YPERR_YPBIND;
123 }
124 (void)close(fd);
125
126 gpid = getpid();
127 if (!(pid == -1 || pid == gpid)) {
128 ysd = _ypbindlist;
129 while (ysd) {
130 if (ysd->dom_client)
131 clnt_destroy(ysd->dom_client);
132 ysd2 = ysd->dom_pnext;
133 free(ysd);
134 ysd = ysd2;
135 }
136 _ypbindlist = NULL;
137 }
138 pid = gpid;
139
140 if (ypdb != NULL)
141 *ypdb = NULL;
142
143 for (ysd = _ypbindlist; ysd; ysd = ysd->dom_pnext)
144 if (strcmp(dom, ysd->dom_domain) == 0)
145 break;
146 if (ysd == NULL) {
147 if ((ysd = malloc(sizeof *ysd)) == NULL)
148 return YPERR_YPERR;
149 (void)memset(ysd, 0, sizeof *ysd);
150 ysd->dom_socket = -1;
151 ysd->dom_vers = 0;
152 new = 1;
153 }
154 again:
155 if (ysd->dom_vers == 0) {
156 (void) snprintf(path, sizeof(path), "%s/%s.%d",
157 BINDINGDIR, dom, 2);
158 if ((fd = open(path, O_RDONLY | O_CLOEXEC)) == -1) {
159 /*
160 * no binding file, YP is dead, or not yet fully
161 * alive.
162 */
163 goto trynet;
164 }
165 if (flock(fd, LOCK_EX | LOCK_NB) == -1 &&
166 errno == EWOULDBLOCK) {
167 struct iovec iov[2];
168 struct ypbind_resp ybr;
169 u_short ypb_port;
170 struct ypbind_binding *bn;
171
172 iov[0].iov_base = &ypb_port;
173 iov[0].iov_len = sizeof ypb_port;
174 iov[1].iov_base = &ybr;
175 iov[1].iov_len = sizeof ybr;
176
177 r = readv(fd, iov, 2);
178 if (r != (ssize_t)(iov[0].iov_len + iov[1].iov_len)) {
179 (void)close(fd);
180 ysd->dom_vers = -1;
181 goto again;
182 }
183 (void)memset(&ysd->dom_server_addr, 0,
184 sizeof ysd->dom_server_addr);
185 ysd->dom_server_addr.sin_len =
186 sizeof(struct sockaddr_in);
187 ysd->dom_server_addr.sin_family = AF_INET;
188 bn = &ybr.ypbind_respbody.ypbind_bindinfo;
189 ysd->dom_server_addr.sin_port =
190 bn->ypbind_binding_port;
191
192 ysd->dom_server_addr.sin_addr =
193 bn->ypbind_binding_addr;
194
195 ysd->dom_server_port = ysd->dom_server_addr.sin_port;
196 (void)close(fd);
197 goto gotit;
198 } else {
199 /* no lock on binding file, YP is dead. */
200 (void)close(fd);
201 if (new)
202 free(ysd);
203 return YPERR_YPBIND;
204 }
205 }
206 trynet:
207 if (ysd->dom_vers == -1 || ysd->dom_vers == 0) {
208 struct ypbind_binding *bn;
209 (void)memset(&clnt_sin, 0, sizeof clnt_sin);
210 clnt_sin.sin_len = sizeof(struct sockaddr_in);
211 clnt_sin.sin_family = AF_INET;
212 clnt_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
213
214 clnt_sock = RPC_ANYSOCK;
215 client = clnttcp_create(&clnt_sin, YPBINDPROG, YPBINDVERS,
216 &clnt_sock, 0, 0);
217 if (client == NULL) {
218 clnt_pcreateerror("clnttcp_create");
219 if (new)
220 free(ysd);
221 return YPERR_YPBIND;
222 }
223 r = clnt_call(client, (rpcproc_t)YPBINDPROC_DOMAIN,
224 (xdrproc_t)xdr_ypdomain_wrap_string, &dom,
225 (xdrproc_t)xdr_ypbind_resp, &ypbr, _yplib_timeout);
226 if (r != RPC_SUCCESS) {
227 if (_yplib_bindtries <= 0 && new == 0 &&
228 ++nerrs == _yplib_nerrs) {
229 nerrs = 0;
230 fprintf(stderr,
231 "YP server for domain %s not responding, still trying\n",
232 dom);
233 }
234 else if (_yplib_bindtries > 0 &&
235 ++nerrs == _yplib_bindtries) {
236 free(ysd);
237 return YPERR_YPBIND;
238 }
239 clnt_destroy(client);
240 ysd->dom_vers = -1;
241 goto again;
242 }
243 clnt_destroy(client);
244
245 (void)memset(&ysd->dom_server_addr, 0,
246 sizeof ysd->dom_server_addr);
247 ysd->dom_server_addr.sin_len = sizeof(struct sockaddr_in);
248 ysd->dom_server_addr.sin_family = AF_INET;
249 bn = &ypbr.ypbind_respbody.ypbind_bindinfo;
250 ysd->dom_server_addr.sin_port =
251 bn->ypbind_binding_port;
252 ysd->dom_server_addr.sin_addr.s_addr =
253 bn->ypbind_binding_addr.s_addr;
254 ysd->dom_server_port =
255 bn->ypbind_binding_port;
256 gotit:
257 ysd->dom_vers = YPVERS;
258 (void)strlcpy(ysd->dom_domain, dom, sizeof(ysd->dom_domain));
259 }
260 if (ysd->dom_client)
261 clnt_destroy(ysd->dom_client);
262 ysd->dom_socket = RPC_ANYSOCK;
263 ysd->dom_client = clntudp_create(&ysd->dom_server_addr,
264 YPPROG, YPVERS, _yplib_rpc_timeout, &ysd->dom_socket);
265 if (ysd->dom_client == NULL) {
266 clnt_pcreateerror("clntudp_create");
267 ysd->dom_vers = -1;
268 goto again;
269 }
270 if (fcntl(ysd->dom_socket, F_SETFD, FD_CLOEXEC) == -1)
271 perror("fcntl: F_SETFD");
272
273 if (new) {
274 ysd->dom_pnext = _ypbindlist;
275 _ypbindlist = ysd;
276 }
277 if (ypdb != NULL)
278 *ypdb = ysd;
279 return 0;
280 }
281
282 void
__yp_unbind(struct dom_binding * ypb)283 __yp_unbind(struct dom_binding *ypb)
284 {
285
286 _DIAGASSERT(ypb != NULL);
287
288 clnt_destroy(ypb->dom_client);
289 ypb->dom_client = NULL;
290 ypb->dom_socket = -1;
291 }
292
293 int
yp_bind(const char * dom)294 yp_bind(const char *dom)
295 {
296 if (_yp_invalid_domain(dom))
297 return YPERR_BADARGS;
298
299 return _yp_dobind(dom, NULL);
300 }
301
302 void
yp_unbind(const char * dom)303 yp_unbind(const char *dom)
304 {
305 struct dom_binding *ypb, *ypbp;
306
307 if (_yp_invalid_domain(dom))
308 return;
309
310 ypbp = NULL;
311 for (ypb = _ypbindlist; ypb; ypb = ypb->dom_pnext) {
312 if (strcmp(dom, ypb->dom_domain) == 0) {
313 clnt_destroy(ypb->dom_client);
314 if (ypbp)
315 ypbp->dom_pnext = ypb->dom_pnext;
316 else
317 _ypbindlist = ypb->dom_pnext;
318 free(ypb);
319 return;
320 }
321 ypbp = ypb;
322 }
323 return;
324 }
325
326 int
yp_get_default_domain(char ** domp)327 yp_get_default_domain(char **domp)
328 {
329 if (domp == NULL)
330 return YPERR_BADARGS;
331 *domp = NULL;
332 if (_yp_domain[0] == '\0')
333 if (getdomainname(_yp_domain, sizeof _yp_domain))
334 return YPERR_NODOM;
335 *domp = _yp_domain;
336 return 0;
337 }
338
339 int
_yp_check(char ** dom)340 _yp_check(char **dom)
341 {
342 char *unused;
343 int good;
344
345 YPLOCK();
346
347 if (_yp_domain[0] == '\0')
348 if (yp_get_default_domain(&unused)) {
349 good = 0;
350 goto done;
351 }
352 if (dom)
353 *dom = _yp_domain;
354
355 good = yp_bind(_yp_domain) == 0;
356 done:
357 YPUNLOCK();
358 return good;
359 }
360
361 /*
362 * _yp_invalid_domain: check if given domainname isn't legal.
363 * returns non-zero if invalid
364 */
365 int
_yp_invalid_domain(const char * dom)366 _yp_invalid_domain(const char *dom)
367 {
368 if (dom == NULL || *dom == '\0')
369 return 1;
370
371 if (strlen(dom) > YPMAXDOMAIN)
372 return 1;
373
374 if (strchr(dom, '/') != NULL)
375 return 1;
376
377 return 0;
378 }
379