lib/libc/yp/yplib.c

   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
  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 | 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
 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
 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
 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
 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
 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
 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 }