lib/libc/yp/yplib.c

   1 /*      $NetBSD: yplib.c,v 1.45 2012/03/20 16:30:26 matt 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.45 2012/03/20 16:30:26 matt 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
  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
  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)) == -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)) == -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 #ifndef __minix
 186                         ysd->dom_server_addr.sin_len =
 187                                 sizeof(struct sockaddr_in);
 188 #endif /* !__minix */
 189                         ysd->dom_server_addr.sin_family = AF_INET;
 190                         bn = &ybr.ypbind_respbody.ypbind_bindinfo;
 191                         ysd->dom_server_addr.sin_port =
 192                                 bn->ypbind_binding_port;
 193
 194                         ysd->dom_server_addr.sin_addr =
 195                                 bn->ypbind_binding_addr;
 196
 197                         ysd->dom_server_port = ysd->dom_server_addr.sin_port;
 198                         (void)close(fd);
 199                         goto gotit;
 200                 } else {
 201                         /* no lock on binding file, YP is dead. */
 202                         (void)close(fd);
 203                         if (new)
 204                                 free(ysd);
 205                         return YPERR_YPBIND;
 206                 }
 207         }
 208 trynet:
 209         if (ysd->dom_vers == -1 || ysd->dom_vers == 0) {
 210                 struct ypbind_binding *bn;
 211                 (void)memset(&clnt_sin, 0, sizeof clnt_sin);
 212 #ifndef __minix
 213                 clnt_sin.sin_len = sizeof(struct sockaddr_in);
 214 #endif /* !__minix */
 215                 clnt_sin.sin_family = AF_INET;
 216                 clnt_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 217
 218                 clnt_sock = RPC_ANYSOCK;
 219                 client = clnttcp_create(&clnt_sin, YPBINDPROG, YPBINDVERS,
 220                                         &clnt_sock, 0, 0);
 221                 if (client == NULL) {
 222                         clnt_pcreateerror("clnttcp_create");
 223                         if (new)
 224                                 free(ysd);
 225                         return YPERR_YPBIND;
 226                 }
 227                 r = clnt_call(client, (rpcproc_t)YPBINDPROC_DOMAIN,
 228                     (xdrproc_t)xdr_ypdomain_wrap_string, &dom,
 229                     (xdrproc_t)xdr_ypbind_resp, &ypbr, _yplib_timeout);
 230                 if (r != RPC_SUCCESS) {
 231                         if (_yplib_bindtries <= 0 && new == 0 &&
 232                             ++nerrs == _yplib_nerrs) {
 233                                 nerrs = 0;
 234                                 fprintf(stderr,
 235                     "YP server for domain %s not responding, still trying\n",
 236                                     dom);
 237                         }
 238                         else if (_yplib_bindtries > 0 &&
 239                                  ++nerrs == _yplib_bindtries) {
 240                                 free(ysd);
 241                                 return YPERR_YPBIND;
 242                         }
 243                         clnt_destroy(client);
 244                         ysd->dom_vers = -1;
 245                         goto again;
 246                 }
 247                 clnt_destroy(client);
 248
 249                 (void)memset(&ysd->dom_server_addr, 0,
 250                              sizeof ysd->dom_server_addr);
 251 #ifndef __minix
 252                 ysd->dom_server_addr.sin_len = sizeof(struct sockaddr_in);
 253 #endif /* !__minix */
 254                 ysd->dom_server_addr.sin_family = AF_INET;
 255                 bn = &ypbr.ypbind_respbody.ypbind_bindinfo;
 256                 ysd->dom_server_addr.sin_port =
 257                         bn->ypbind_binding_port;
 258                 ysd->dom_server_addr.sin_addr.s_addr =
 259                         bn->ypbind_binding_addr.s_addr;
 260                 ysd->dom_server_port =
 261                         bn->ypbind_binding_port;
 262 gotit:
 263                 ysd->dom_vers = YPVERS;
 264                 (void)strlcpy(ysd->dom_domain, dom, sizeof(ysd->dom_domain));
 265         }
 266         if (ysd->dom_client)
 267                 clnt_destroy(ysd->dom_client);
 268         ysd->dom_socket = RPC_ANYSOCK;
 269         ysd->dom_client = clntudp_create(&ysd->dom_server_addr,
 270             YPPROG, YPVERS, _yplib_rpc_timeout, &ysd->dom_socket);
 271         if (ysd->dom_client == NULL) {
 272                 clnt_pcreateerror("clntudp_create");
 273                 ysd->dom_vers = -1;
 274                 goto again;
 275         }
 276         if (fcntl(ysd->dom_socket, F_SETFD, FD_CLOEXEC) == -1)
 277                 perror("fcntl: F_SETFD");
 278
 279         if (new) {
 280                 ysd->dom_pnext = _ypbindlist;
 281                 _ypbindlist = ysd;
 282         }
 283         if (ypdb != NULL)
 284                 *ypdb = ysd;
 285         return 0;
 286 }
 287
 288 void
 289 __yp_unbind(struct dom_binding *ypb)
 290 {
 291
 292         _DIAGASSERT(ypb != NULL);
 293
 294         clnt_destroy(ypb->dom_client);
 295         ypb->dom_client = NULL;
 296         ypb->dom_socket = -1;
 297 }
 298
 299 int
 300 yp_bind(const char *dom)
 301 {
 302         if (_yp_invalid_domain(dom))
 303                 return YPERR_BADARGS;
 304
 305         return _yp_dobind(dom, NULL);
 306 }
 307
 308 void
 309 yp_unbind(const char *dom)
 310 {
 311         struct dom_binding *ypb, *ypbp;
 312
 313         if (_yp_invalid_domain(dom))
 314                 return;
 315
 316         ypbp = NULL;
 317         for (ypb = _ypbindlist; ypb; ypb = ypb->dom_pnext) {
 318                 if (strcmp(dom, ypb->dom_domain) == 0) {
 319                         clnt_destroy(ypb->dom_client);
 320                         if (ypbp)
 321                                 ypbp->dom_pnext = ypb->dom_pnext;
 322                         else
 323                                 _ypbindlist = ypb->dom_pnext;
 324                         free(ypb);
 325                         return;
 326                 }
 327                 ypbp = ypb;
 328         }
 329         return;
 330 }
 331
 332 int
 333 yp_get_default_domain(char **domp)
 334 {
 335         if (domp == NULL)
 336                 return YPERR_BADARGS;
 337         *domp = NULL;
 338         if (_yp_domain[0] == '\0')
 339                 if (getdomainname(_yp_domain, sizeof _yp_domain))
 340                         return YPERR_NODOM;
 341         *domp = _yp_domain;
 342         return 0;
 343 }
 344
 345 int
 346 _yp_check(char **dom)
 347 {
 348         char           *unused;
 349         int             good;
 350
 351         YPLOCK();
 352
 353         if (_yp_domain[0] == '\0')
 354                 if (yp_get_default_domain(&unused)) {
 355                         good = 0;
 356                         goto done;
 357                 }
 358         if (dom)
 359                 *dom = _yp_domain;
 360
 361         good = yp_bind(_yp_domain) == 0;
 362 done:
 363         YPUNLOCK();
 364         return good;
 365 }
 366
 367 /*
 368  * _yp_invalid_domain: check if given domainname isn't legal.
 369  * returns non-zero if invalid
 370  */
 371 int
 372 _yp_invalid_domain(const char *dom)
 373 {
 374         if (dom == NULL || *dom == '\0')
 375                 return 1;
 376
 377         if (strlen(dom) > YPMAXDOMAIN)
 378                 return 1;
 379
 380         if (strchr(dom, '/') != NULL)
 381                 return 1;
 382
 383         return 0;
 384 }