usr.sbin/ypserv/yp_server.c

   1 /*
   2  * Copyright (c) 1995
   3  *      Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "yp.h"
  38 #include "yp_extern.h"
  39 #include <dirent.h>
  40 #include <errno.h>
  41 #include <stdlib.h>
  42 #include <sys/stat.h>
  43 #include <sys/param.h>
  44 #include <sys/types.h>
  45 #include <sys/socket.h>
  46 #include <netinet/in.h>
  47 #include <arpa/inet.h>
  48 #include <rpc/rpc.h>
  49
  50 int children = 0;
  51
  52 #define MASTER_STRING   "YP_MASTER_NAME"
  53 #define MASTER_SZ       sizeof(MASTER_STRING) - 1
  54 #define ORDER_STRING    "YP_LAST_MODIFIED"
  55 #define ORDER_SZ        sizeof(ORDER_STRING) - 1
  56
  57 static pid_t
  58 yp_fork(void)
  59 {
  60         if (yp_pid != getpid()) {
  61                 yp_error("child %d trying to fork!", getpid());
  62                 errno = EEXIST;
  63                 return(-1);
  64         }
  65
  66         return(fork());
  67 }
  68
  69 /*
  70  * NIS v2 support. This is where most of the action happens.
  71  */
  72
  73 void *
  74 ypproc_null_2_svc(void *argp, struct svc_req *rqstp)
  75 {
  76         static char * result;
  77         static char rval = 0;
  78
  79 #ifdef DB_CACHE
  80         if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
  81 #else
  82         if (yp_access(NULL, (struct svc_req *)rqstp))
  83 #endif
  84                 return(NULL);
  85
  86         result = &rval;
  87
  88         return((void *) &result);
  89 }
  90
  91 bool_t *
  92 ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp)
  93 {
  94         static bool_t  result;
  95
  96 #ifdef DB_CACHE
  97         if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
  98 #else
  99         if (yp_access(NULL, (struct svc_req *)rqstp)) {
 100 #endif
 101                 result = FALSE;
 102                 return (&result);
 103         }
 104
 105         if (argp == NULL || yp_validdomain(*argp))
 106                 result = FALSE;
 107         else
 108                 result = TRUE;
 109
 110         return (&result);
 111 }
 112
 113 bool_t *
 114 ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp)
 115 {
 116         static bool_t  result;
 117
 118 #ifdef DB_CACHE
 119         if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
 120 #else
 121         if (yp_access(NULL, (struct svc_req *)rqstp))
 122 #endif
 123                 return (NULL);
 124
 125         if (argp == NULL || yp_validdomain(*argp))
 126                 return (NULL);
 127         else
 128                 result = TRUE;
 129
 130         return (&result);
 131 }
 132
 133 ypresp_val *
 134 ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp)
 135 {
 136         static ypresp_val  result;
 137
 138         result.val.valdat_val = "";
 139         result.val.valdat_len = 0;
 140
 141 #ifdef DB_CACHE
 142         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 143 #else
 144         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 145 #endif
 146                 result.stat = YP_YPERR;
 147                 return (&result);
 148         }
 149
 150         if (argp->domain == NULL || argp->map == NULL) {
 151                 result.stat = YP_BADARGS;
 152                 return (&result);
 153         }
 154
 155         if (yp_select_map(argp->map, argp->domain, NULL, 1) != YP_TRUE) {
 156                 result.stat = yp_errno;
 157                 return(&result);
 158         }
 159
 160         result.stat = yp_getbykey(&argp->key, &result.val);
 161
 162         /*
 163          * Do DNS lookups for hosts maps if database lookup failed.
 164          */
 165
 166 #ifdef DB_CACHE
 167         if (do_dns && result.stat != YP_TRUE &&
 168             (yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) ||
 169             (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes")))) {
 170 #else
 171         if (do_dns && result.stat != YP_TRUE &&
 172             (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes"))) {
 173 #endif
 174                 char                    nbuf[YPMAXRECORD];
 175
 176                 /* NUL terminate! NUL terminate!! NUL TERMINATE!!! */
 177                 bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len);
 178                 nbuf[argp->key.keydat_len] = '\0';
 179
 180                 if (debug)
 181                         yp_error("doing DNS lookup of %s", nbuf);
 182
 183                 if (!strcmp(argp->map, "hosts.byname"))
 184                         result.stat = yp_async_lookup_name(rqstp, nbuf,
 185                             AF_INET);
 186                 else if (!strcmp(argp->map, "hosts.byaddr"))
 187                         result.stat = yp_async_lookup_addr(rqstp, nbuf,
 188                             AF_INET);
 189                 else if (!strcmp(argp->map, "ipnodes.byname"))
 190                         result.stat = yp_async_lookup_name(rqstp, nbuf,
 191                             AF_INET6);
 192                 else if (!strcmp(argp->map, "ipnodes.byaddr"))
 193                         result.stat = yp_async_lookup_addr(rqstp, nbuf,
 194                             AF_INET6);
 195
 196                 if (result.stat == YP_TRUE)
 197                         return(NULL);
 198         }
 199
 200         return (&result);
 201 }
 202
 203 ypresp_key_val *
 204 ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
 205 {
 206         static ypresp_key_val  result;
 207
 208         result.val.valdat_val = result.key.keydat_val = "";
 209         result.val.valdat_len = result.key.keydat_len = 0;
 210
 211 #ifdef DB_CACHE
 212         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 213 #else
 214         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 215 #endif
 216                 result.stat = YP_YPERR;
 217                 return (&result);
 218         }
 219
 220         if (argp->domain == NULL) {
 221                 result.stat = YP_BADARGS;
 222                 return (&result);
 223         }
 224
 225         if (yp_select_map(argp->map, argp->domain, NULL, 0) != YP_TRUE) {
 226                 result.stat = yp_errno;
 227                 return(&result);
 228         }
 229
 230         result.stat = yp_firstbykey(&result.key, &result.val);
 231
 232         return (&result);
 233 }
 234
 235 ypresp_key_val *
 236 ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp)
 237 {
 238         static ypresp_key_val  result;
 239
 240         result.val.valdat_val = result.key.keydat_val = "";
 241         result.val.valdat_len = result.key.keydat_len = 0;
 242
 243 #ifdef DB_CACHE
 244         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 245 #else
 246         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 247 #endif
 248                 result.stat = YP_YPERR;
 249                 return (&result);
 250         }
 251
 252         if (argp->domain == NULL || argp->map == NULL) {
 253                 result.stat = YP_BADARGS;
 254                 return (&result);
 255         }
 256
 257         if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) {
 258                 result.stat = yp_errno;
 259                 return(&result);
 260         }
 261
 262         result.key.keydat_len = argp->key.keydat_len;
 263         result.key.keydat_val = argp->key.keydat_val;
 264
 265         result.stat = yp_nextbykey(&result.key, &result.val);
 266
 267         return (&result);
 268 }
 269
 270 static void
 271 ypxfr_callback(ypxfrstat rval, struct sockaddr_in *addr, unsigned int transid,
 272     unsigned int prognum, unsigned long port)
 273 {
 274         CLIENT *clnt;
 275         int sock = RPC_ANYSOCK;
 276         struct timeval timeout;
 277         yppushresp_xfr ypxfr_resp;
 278         struct rpc_err err;
 279
 280         timeout.tv_sec = 5;
 281         timeout.tv_usec = 0;
 282         addr->sin_port = htons(port);
 283
 284         if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) {
 285                 yp_error("%s: %s", inet_ntoa(addr->sin_addr),
 286                   clnt_spcreateerror("failed to establish callback handle"));
 287                 return;
 288         }
 289
 290         ypxfr_resp.status = rval;
 291         ypxfr_resp.transid = transid;
 292
 293         /* Turn the timeout off -- we don't want to block. */
 294         timeout.tv_sec = 0;
 295         if (clnt_control(clnt, CLSET_TIMEOUT, &timeout) == FALSE)
 296                 yp_error("failed to set timeout on ypproc_xfr callback");
 297
 298         if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) {
 299                 clnt_geterr(clnt, &err);
 300                 if (err.re_status != RPC_SUCCESS &&
 301                     err.re_status != RPC_TIMEDOUT)
 302                         yp_error("%s", clnt_sperror(clnt,
 303                                 "ypxfr callback failed"));
 304         }
 305
 306         clnt_destroy(clnt);
 307         return;
 308 }
 309
 310 #define YPXFR_RETURN(CODE)                                              \
 311         /* Order is important: send regular RPC reply, then callback */ \
 312         result.xfrstat = CODE;                                          \
 313         svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_ypresp_xfr, &result); \
 314         ypxfr_callback(CODE,rqhost,argp->transid,                       \
 315                                         argp->prog,argp->port);         \
 316         return(NULL);
 317
 318 ypresp_xfr *
 319 ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp)
 320 {
 321         static ypresp_xfr  result;
 322         struct sockaddr_in *rqhost;
 323         ypresp_master *mres;
 324         ypreq_nokey mreq;
 325
 326         result.transid = argp->transid;
 327         rqhost = svc_getcaller(rqstp->rq_xprt);
 328
 329 #ifdef DB_CACHE
 330         if (yp_access(argp->map_parms.map,
 331                         argp->map_parms.domain, (struct svc_req *)rqstp)) {
 332 #else
 333         if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) {
 334 #endif
 335                 YPXFR_RETURN(YPXFR_REFUSED)
 336         }
 337
 338
 339         if (argp->map_parms.domain == NULL) {
 340                 YPXFR_RETURN(YPXFR_BADARGS)
 341         }
 342
 343         if (yp_validdomain(argp->map_parms.domain)) {
 344                 YPXFR_RETURN(YPXFR_NODOM)
 345         }
 346
 347         /*
 348          * Determine the master host ourselves. The caller may
 349          * be up to no good. This has the side effect of verifying
 350          * that the requested map and domain actually exist.
 351          */
 352
 353         mreq.domain = argp->map_parms.domain;
 354         mreq.map = argp->map_parms.map;
 355
 356         mres = ypproc_master_2_svc(&mreq, rqstp);
 357
 358         if (mres->stat != YP_TRUE) {
 359                 yp_error("couldn't find master for map %s@%s",
 360                                                 argp->map_parms.map,
 361                                                 argp->map_parms.domain);
 362                 yp_error("host at %s (%s) may be pulling my leg",
 363                                                 argp->map_parms.peer,
 364                                                 inet_ntoa(rqhost->sin_addr));
 365                 YPXFR_RETURN(YPXFR_REFUSED)
 366         }
 367
 368         switch (yp_fork()) {
 369         case 0:
 370         {
 371                 char g[11], t[11], p[11];
 372                 char ypxfr_command[MAXPATHLEN + 2];
 373
 374                 snprintf (ypxfr_command, sizeof(ypxfr_command), "%sypxfr", _PATH_LIBEXEC);
 375                 snprintf (t, sizeof(t), "%u", argp->transid);
 376                 snprintf (g, sizeof(g), "%u", argp->prog);
 377                 snprintf (p, sizeof(p), "%u", argp->port);
 378                 if (debug) {
 379                         close(0); close(1); close(2);
 380                 }
 381                 if (strcmp(yp_dir, _PATH_YP)) {
 382                         execl(ypxfr_command, "ypxfr",
 383                         "-d", argp->map_parms.domain,
 384                         "-h", mres->peer,
 385                         "-p", yp_dir, "-C", t,
 386                         g, inet_ntoa(rqhost->sin_addr),
 387                         p, argp->map_parms.map,
 388                         NULL);
 389                 } else {
 390                         execl(ypxfr_command, "ypxfr",
 391                         "-d", argp->map_parms.domain,
 392                         "-h", mres->peer,
 393                         "-C", t,
 394                         g, inet_ntoa(rqhost->sin_addr),
 395                         p, argp->map_parms.map,
 396                         NULL);
 397                 }
 398                 yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno));
 399                 YPXFR_RETURN(YPXFR_XFRERR)
 400                 /*
 401                  * Just to safe, prevent PR #10970 from biting us in
 402                  * the unlikely case that execing ypxfr fails. We don't
 403                  * want to have any child processes spawned from this
 404                  * child process.
 405                  */
 406                 _exit(0);
 407                 break;
 408         }
 409         case -1:
 410                 yp_error("ypxfr fork(): %s", strerror(errno));
 411                 YPXFR_RETURN(YPXFR_XFRERR)
 412                 break;
 413         default:
 414                 result.xfrstat = YPXFR_SUCC;
 415                 children++;
 416                 break;
 417         }
 418
 419         return (&result);
 420 }
 421 #undef YPXFR_RETURN
 422
 423 void *
 424 ypproc_clear_2_svc(void *argp, struct svc_req *rqstp)
 425 {
 426         static char * result;
 427         static char rval = 0;
 428
 429 #ifdef DB_CACHE
 430         if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
 431 #else
 432         if (yp_access(NULL, (struct svc_req *)rqstp))
 433 #endif
 434                 return (NULL);
 435 #ifdef DB_CACHE
 436         /* clear out the database cache */
 437         yp_flush_all();
 438 #endif
 439         /* Re-read the securenets database for the hell of it. */
 440         load_securenets();
 441
 442         result = &rval;
 443         return((void *) &result);
 444 }
 445
 446 /*
 447  * For ypproc_all, we have to send a stream of ypresp_all structures
 448  * via TCP, but the XDR filter generated from the yp.x protocol
 449  * definition file only serializes one such structure. This means that
 450  * to send the whole stream, you need a wrapper which feeds all the
 451  * records into the underlying XDR routine until it hits an 'EOF.'
 452  * But to use the wrapper, you have to violate the boundaries between
 453  * RPC layers by calling svc_sendreply() directly from the ypproc_all
 454  * service routine instead of letting the RPC dispatcher do it.
 455  *
 456  * Bleah.
 457  */
 458
 459 /*
 460  * Custom XDR routine for serialzing results of ypproc_all: keep
 461  * reading from the database and spew until we run out of records
 462  * or encounter an error.
 463  */
 464 static bool_t
 465 xdr_my_ypresp_all(register XDR *xdrs, ypresp_all *objp)
 466 {
 467         while (1) {
 468                 /* Get a record. */
 469                 if ((objp->ypresp_all_u.val.stat =
 470                         yp_nextbykey(&objp->ypresp_all_u.val.key,
 471                                      &objp->ypresp_all_u.val.val)) == YP_TRUE) {
 472                         objp->more = TRUE;
 473                 } else {
 474                         objp->more = FALSE;
 475                 }
 476
 477                 /* Serialize. */
 478                 if (!xdr_ypresp_all(xdrs, objp))
 479                         return(FALSE);
 480                 if (objp->more == FALSE)
 481                         return(TRUE);
 482         }
 483 }
 484
 485 ypresp_all *
 486 ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
 487 {
 488         static ypresp_all  result;
 489
 490         /*
 491          * Set this here so that the client will be forced to make
 492          * at least one attempt to read from us even if all we're
 493          * doing is returning an error.
 494          */
 495         result.more = TRUE;
 496         result.ypresp_all_u.val.key.keydat_len = 0;
 497         result.ypresp_all_u.val.key.keydat_val = "";
 498
 499 #ifdef DB_CACHE
 500         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 501 #else
 502         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 503 #endif
 504                 result.ypresp_all_u.val.stat = YP_YPERR;
 505                 return (&result);
 506         }
 507
 508         if (argp->domain == NULL || argp->map == NULL) {
 509                 result.ypresp_all_u.val.stat = YP_BADARGS;
 510                 return (&result);
 511         }
 512
 513         /*
 514          * XXX If we hit the child limit, fail the request.
 515          * If we don't, and the map is large, we could block for
 516          * a long time in the parent.
 517          */
 518         if (children >= MAX_CHILDREN) {
 519                 result.ypresp_all_u.val.stat = YP_YPERR;
 520                 return(&result);
 521         }
 522
 523         /*
 524          * The ypproc_all procedure can take a while to complete.
 525          * Best to handle it in a subprocess so the parent doesn't
 526          * block. (Is there a better way to do this? Maybe with
 527          * async socket I/O?)
 528          */
 529         if (!debug) {
 530                 switch (yp_fork()) {
 531                 case 0:
 532                         break;
 533                 case -1:
 534                         yp_error("ypall fork(): %s", strerror(errno));
 535                         result.ypresp_all_u.val.stat = YP_YPERR;
 536                         return(&result);
 537                         break;
 538                 default:
 539                         children++;
 540                         return (NULL);
 541                         break;
 542                 }
 543         }
 544
 545         /*
 546          * Fix for PR #10971: don't let the child ypserv share
 547          * DB handles with the parent process.
 548          */
 549 #ifdef DB_CACHE
 550         yp_flush_all();
 551 #endif
 552
 553         if (yp_select_map(argp->map, argp->domain,
 554                                 &result.ypresp_all_u.val.key, 0) != YP_TRUE) {
 555                 result.ypresp_all_u.val.stat = yp_errno;
 556                 return(&result);
 557         }
 558
 559         /* Kick off the actual data transfer. */
 560         svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_my_ypresp_all, &result);
 561
 562         /*
 563          * Proper fix for PR #10970: exit here so that we don't risk
 564          * having a child spawned from this sub-process.
 565          */
 566         if (!debug)
 567                 _exit(0);
 568
 569         return &result;
 570 }
 571
 572 ypresp_master *
 573 ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
 574 {
 575         static ypresp_master  result;
 576         static char ypvalbuf[YPMAXRECORD];
 577         keydat key = { MASTER_SZ, MASTER_STRING };
 578         valdat val;
 579
 580         result.peer = "";
 581
 582 #ifdef DB_CACHE
 583         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 584 #else
 585         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 586 #endif
 587                 result.stat = YP_YPERR;
 588                 return(&result);
 589         }
 590
 591         if (argp->domain == NULL) {
 592                 result.stat = YP_BADARGS;
 593                 return (&result);
 594         }
 595
 596         if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
 597                 result.stat = yp_errno;
 598                 return(&result);
 599         }
 600
 601         /*
 602          * Note that we copy the data retrieved from the database to
 603          * a private buffer and NUL terminate the buffer rather than
 604          * terminating the data in place. We do this because by stuffing
 605          * a '\0' into data.data, we will actually be corrupting memory
 606          * allocated by the DB package. This is a bad thing now that we
 607          * cache DB handles rather than closing the database immediately.
 608          */
 609         result.stat = yp_getbykey(&key, &val);
 610         if (result.stat == YP_TRUE) {
 611                 bcopy(val.valdat_val, &ypvalbuf, val.valdat_len);
 612                 ypvalbuf[val.valdat_len] = '\0';
 613                 result.peer = ypvalbuf;
 614         } else
 615                 result.peer = "";
 616
 617         return (&result);
 618 }
 619
 620 ypresp_order *
 621 ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
 622 {
 623         static ypresp_order  result;
 624         keydat key = { ORDER_SZ, ORDER_STRING };
 625         valdat val;
 626
 627         result.ordernum = 0;
 628
 629 #ifdef DB_CACHE
 630         if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
 631 #else
 632         if (yp_access(argp->map, (struct svc_req *)rqstp)) {
 633 #endif
 634                 result.stat = YP_YPERR;
 635                 return(&result);
 636         }
 637
 638         if (argp->domain == NULL) {
 639                 result.stat = YP_BADARGS;
 640                 return (&result);
 641         }
 642
 643         /*
 644          * We could just check the timestamp on the map file,
 645          * but that's a hack: we'll only know the last time the file
 646          * was touched, not the last time the database contents were
 647          * updated.
 648          */
 649
 650         if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
 651                 result.stat = yp_errno;
 652                 return(&result);
 653         }
 654
 655         result.stat = yp_getbykey(&key, &val);
 656
 657         if (result.stat == YP_TRUE)
 658                 result.ordernum = atoi(val.valdat_val);
 659         else
 660                 result.ordernum = 0;
 661
 662         return (&result);
 663 }
 664
 665 static void yp_maplist_free(struct ypmaplist *yp_maplist)
 666 {
 667         register struct ypmaplist *next;
 668
 669         while (yp_maplist) {
 670                 next = yp_maplist->next;
 671                 free(yp_maplist->map);
 672                 free(yp_maplist);
 673                 yp_maplist = next;
 674         }
 675         return;
 676 }
 677
 678 static struct ypmaplist *
 679 yp_maplist_create(const char *domain)
 680 {
 681         char yp_mapdir[MAXPATHLEN + 2];
 682         char yp_mapname[MAXPATHLEN + 2];
 683         struct ypmaplist *cur = NULL;
 684         struct ypmaplist *yp_maplist = NULL;
 685         DIR *dird;
 686         struct dirent *dirp;
 687         struct stat statbuf;
 688
 689         snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
 690
 691         if ((dird = opendir(yp_mapdir)) == NULL) {
 692                 yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
 693                 return(NULL);
 694         }
 695
 696         while ((dirp = readdir(dird)) != NULL) {
 697                 if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
 698                         snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
 699                                                         yp_mapdir,dirp->d_name);
 700                         if (stat(yp_mapname, &statbuf) < 0 ||
 701                                                 !S_ISREG(statbuf.st_mode))
 702                                 continue;
 703                         if ((cur = (struct ypmaplist *)
 704                                 malloc(sizeof(struct ypmaplist))) == NULL) {
 705                                 yp_error("malloc() failed");
 706                                 closedir(dird);
 707                                 yp_maplist_free(yp_maplist);
 708                                 return(NULL);
 709                         }
 710                         if ((cur->map = strdup(dirp->d_name)) == NULL) {
 711                                 yp_error("strdup() failed: %s",strerror(errno));
 712                                 closedir(dird);
 713                                 yp_maplist_free(yp_maplist);
 714                                 return(NULL);
 715                         }
 716                         cur->next = yp_maplist;
 717                         yp_maplist = cur;
 718                         if (debug)
 719                                 yp_error("map: %s", yp_maplist->map);
 720                 }
 721
 722         }
 723         closedir(dird);
 724         return(yp_maplist);
 725 }
 726
 727 ypresp_maplist *
 728 ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
 729 {
 730         static ypresp_maplist  result = { 0, NULL };
 731
 732 #ifdef DB_CACHE
 733         if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
 734 #else
 735         if (yp_access(NULL, (struct svc_req *)rqstp)) {
 736 #endif
 737                 result.stat = YP_YPERR;
 738                 return(&result);
 739         }
 740
 741         if (argp == NULL) {
 742                 result.stat = YP_BADARGS;
 743                 return (&result);
 744         }
 745
 746         if (yp_validdomain(*argp)) {
 747                 result.stat = YP_NODOM;
 748                 return (&result);
 749         }
 750
 751         /*
 752          * We have to construct a linked list for the ypproc_maplist
 753          * procedure using dynamically allocated memory. Since the XDR
 754          * layer won't free this list for us, we have to deal with it
 755          * ourselves. We call yp_maplist_free() first to free any
 756          * previously allocated data we may have accumulated to insure
 757          * that we have only one linked list in memory at any given
 758          * time.
 759          */
 760
 761         yp_maplist_free(result.maps);
 762
 763         if ((result.maps = yp_maplist_create(*argp)) == NULL) {
 764                 yp_error("yp_maplist_create failed");
 765                 result.stat = YP_YPERR;
 766                 return(&result);
 767         } else
 768                 result.stat = YP_TRUE;
 769
 770         return (&result);
 771 }
 772
 773 /*
 774  * NIS v1 support. The nullproc, domain and domain_nonack
 775  * functions from v1 are identical to those in v2, so all
 776  * we have to do is hand off to them.
 777  *
 778  * The other functions are mostly just wrappers around their v2
 779  * counterparts. For example, for the v1 'match' procedure, we
 780  * crack open the argument structure, make a request to the v2
 781  * 'match' function, repackage the data into a v1 response and
 782  * then send it on its way.
 783  *
 784  * Note that we don't support the pull, push and get procedures.
 785  * There's little documentation available to show what they
 786  * do, and I suspect they're meant largely for map transfers
 787  * between master and slave servers.
 788  */
 789
 790 void *
 791 ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
 792 {
 793         return(ypproc_null_2_svc(argp, rqstp));
 794 }
 795
 796 bool_t *
 797 ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
 798 {
 799         return(ypproc_domain_2_svc(argp, rqstp));
 800 }
 801
 802 bool_t *
 803 ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
 804 {
 805         return (ypproc_domain_nonack_2_svc(argp, rqstp));
 806 }
 807
 808 /*
 809  * the 'match' procedure sends a response of type YPRESP_VAL
 810  */
 811 ypresponse *
 812 ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
 813 {
 814         static ypresponse  result;
 815         ypresp_val *v2_result;
 816
 817         result.yp_resptype = YPRESP_VAL;
 818         result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
 819         result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
 820
 821         if (argp->yp_reqtype != YPREQ_KEY) {
 822                 result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
 823                 return(&result);
 824         }
 825
 826         v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
 827         if (v2_result == NULL)
 828                 return(NULL);
 829
 830         bcopy(v2_result, &result.ypresponse_u.yp_resp_valtype,
 831               sizeof(ypresp_val));
 832
 833         return (&result);
 834 }
 835
 836 /*
 837  * the 'first' procedure sends a response of type YPRESP_KEY_VAL
 838  */
 839 ypresponse *
 840 ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
 841 {
 842         static ypresponse  result;
 843         ypresp_key_val *v2_result;
 844
 845         result.yp_resptype = YPRESP_KEY_VAL;
 846         result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
 847         result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
 848         result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
 849         result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
 850
 851         if (argp->yp_reqtype != YPREQ_NOKEY) {
 852                 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
 853                 return(&result);
 854         }
 855
 856         v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
 857                                                                         rqstp);
 858         if (v2_result == NULL)
 859                 return(NULL);
 860
 861         bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
 862               sizeof(ypresp_key_val));
 863
 864         return (&result);
 865 }
 866
 867 /*
 868  * the 'next' procedure sends a response of type YPRESP_KEY_VAL
 869  */
 870 ypresponse *
 871 ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
 872 {
 873         static ypresponse  result;
 874         ypresp_key_val *v2_result;
 875
 876         result.yp_resptype = YPRESP_KEY_VAL;
 877         result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
 878         result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
 879         result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
 880         result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
 881
 882         if (argp->yp_reqtype != YPREQ_KEY) {
 883                 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
 884                 return(&result);
 885         }
 886
 887         v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
 888         if (v2_result == NULL)
 889                 return(NULL);
 890
 891         bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
 892               sizeof(ypresp_key_val));
 893
 894         return (&result);
 895 }
 896
 897 /*
 898  * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
 899  */
 900 ypresponse *
 901 ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
 902 {
 903         static ypresponse  result;
 904         ypresp_master *v2_result1;
 905         ypresp_order *v2_result2;
 906
 907         result.yp_resptype = YPRESP_MAP_PARMS;
 908         result.ypresponse_u.yp_resp_map_parmstype.domain =
 909                 argp->yprequest_u.yp_req_nokeytype.domain;
 910         result.ypresponse_u.yp_resp_map_parmstype.map =
 911                 argp->yprequest_u.yp_req_nokeytype.map;
 912         /*
 913          * Hmm... there is no 'status' value in the
 914          * yp_resp_map_parmstype structure, so I have to
 915          * guess at what to do to indicate a failure.
 916          * I hope this is right.
 917          */
 918         result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
 919         result.ypresponse_u.yp_resp_map_parmstype.peer = "";
 920
 921         if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
 922                 return(&result);
 923         }
 924
 925         v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
 926                                                                         rqstp);
 927         if (v2_result1 == NULL)
 928                 return(NULL);
 929
 930         if (v2_result1->stat != YP_TRUE) {
 931                 return(&result);
 932         }
 933
 934         v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
 935                                                                         rqstp);
 936         if (v2_result2 == NULL)
 937                 return(NULL);
 938
 939         if (v2_result2->stat != YP_TRUE) {
 940                 return(&result);
 941         }
 942
 943         result.ypresponse_u.yp_resp_map_parmstype.peer =
 944                 v2_result1->peer;
 945         result.ypresponse_u.yp_resp_map_parmstype.ordernum =
 946                 v2_result2->ordernum;
 947
 948         return (&result);
 949 }
 950
 951 ypresponse *
 952 ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
 953 {
 954         static ypresponse  result;
 955
 956         /*
 957          * Not implemented.
 958          */
 959
 960         return (&result);
 961 }
 962
 963 ypresponse *
 964 ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
 965 {
 966         static ypresponse  result;
 967
 968         /*
 969          * Not implemented.
 970          */
 971
 972         return (&result);
 973 }
 974
 975 ypresponse *
 976 ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
 977 {
 978         static ypresponse  result;
 979
 980         /*
 981          * Not implemented.
 982          */
 983
 984         return (&result);
 985 }