1 /* 2 * Copyright (c) 1992/3 Theo de Raadt <deraadt@fsa.ca> 3 * 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. The name of the author may not be used to endorse or promote 14 * products derived from this software without specific prior written 15 * permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 18 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #ifndef LINT 31 static char rcsid[] = "$Id: ypbind.c,v 1.24 1997/04/10 14:18:03 wpaul Exp $"; 32 #endif 33 34 #include <sys/param.h> 35 #include <sys/types.h> 36 #include <sys/wait.h> 37 #include <sys/ioctl.h> 38 #include <sys/signal.h> 39 #include <sys/socket.h> 40 #include <sys/file.h> 41 #include <sys/fcntl.h> 42 #include <sys/stat.h> 43 #include <sys/uio.h> 44 #include <syslog.h> 45 #include <stdio.h> 46 #include <errno.h> 47 #include <ctype.h> 48 #include <dirent.h> 49 #include <netdb.h> 50 #include <string.h> 51 #include <rpc/rpc.h> 52 #include <rpc/xdr.h> 53 #include <net/if.h> 54 #include <netinet/in.h> 55 #include <arpa/inet.h> 56 #include <rpc/pmap_clnt.h> 57 #include <rpc/pmap_prot.h> 58 #include <rpc/pmap_rmt.h> 59 #include <unistd.h> 60 #include <stdlib.h> 61 #include <rpcsvc/yp.h> 62 struct dom_binding{}; 63 #include <rpcsvc/ypclnt.h> 64 #include "yp_ping.h" 65 66 #ifndef BINDINGDIR 67 #define BINDINGDIR "/var/yp/binding" 68 #endif 69 70 #ifndef YPBINDLOCK 71 #define YPBINDLOCK "/var/run/ypbind.lock" 72 #endif 73 74 struct _dom_binding { 75 struct _dom_binding *dom_pnext; 76 char dom_domain[YPMAXDOMAIN + 1]; 77 struct sockaddr_in dom_server_addr; 78 long int dom_vers; 79 int dom_lockfd; 80 int dom_alive; 81 int dom_broadcast_pid; 82 int dom_pipe_fds[2]; 83 int dom_default; 84 }; 85 86 #define READFD ypdb->dom_pipe_fds[0] 87 #define WRITEFD ypdb->dom_pipe_fds[1] 88 #define BROADFD broad_domain->dom_pipe_fds[1] 89 90 extern bool_t xdr_domainname(), xdr_ypbind_resp(); 91 extern bool_t xdr_ypreq_key(), xdr_ypresp_val(); 92 extern bool_t xdr_ypbind_setdom(); 93 94 void checkwork __P((void)); 95 void *ypbindproc_null_2 __P((SVCXPRT *, void *, CLIENT *)); 96 void *ypbindproc_setdom_2 __P((SVCXPRT *, struct ypbind_setdom *, CLIENT *)); 97 void rpc_received __P((char *, struct sockaddr_in *, int )); 98 void broadcast __P((struct _dom_binding *)); 99 int ping __P((struct _dom_binding *)); 100 int tell_parent __P((char *, struct sockaddr_in *)); 101 void handle_children __P(( struct _dom_binding * )); 102 void reaper __P((int)); 103 void terminate __P((int)); 104 void yp_restricted_mode __P((char *)); 105 int verify __P((struct in_addr)); 106 107 char *domain_name; 108 struct _dom_binding *ypbindlist; 109 static struct _dom_binding *broad_domain; 110 111 #define YPSET_NO 0 112 #define YPSET_LOCAL 1 113 #define YPSET_ALL 2 114 int ypsetmode = YPSET_NO; 115 int ypsecuremode = 0; 116 int ppid; 117 118 /* 119 * Special restricted mode variables: when in restricted mode, only the 120 * specified restricted_domain will be bound, and only the servers listed 121 * in restricted_addrs will be used for binding. 122 */ 123 #define RESTRICTED_SERVERS 10 124 int yp_restricted = 0; 125 int yp_manycast = 0; 126 struct in_addr restricted_addrs[RESTRICTED_SERVERS]; 127 128 /* No more than MAX_CHILDREN child broadcasters at a time. */ 129 #ifndef MAX_CHILDREN 130 #define MAX_CHILDREN 5 131 #endif 132 /* No more than MAX_DOMAINS simultaneous domains */ 133 #ifndef MAX_DOMAINS 134 #define MAX_DOMAINS 200 135 #endif 136 /* RPC timeout value */ 137 #ifndef FAIL_THRESHOLD 138 #define FAIL_THRESHOLD 20 139 #endif 140 141 /* Number of times to fish for a response froma particular set of hosts */ 142 #ifndef MAX_RETRIES 143 #define MAX_RETRIES 30 144 #endif 145 146 int retries = 0; 147 int children = 0; 148 int domains = 0; 149 int yplockfd; 150 fd_set fdsr; 151 152 SVCXPRT *udptransp, *tcptransp; 153 154 void * 155 ypbindproc_null_2(transp, argp, clnt) 156 SVCXPRT *transp; 157 void *argp; 158 CLIENT *clnt; 159 { 160 static char res; 161 162 bzero((char *)&res, sizeof(res)); 163 return (void *)&res; 164 } 165 166 struct ypbind_resp * 167 ypbindproc_domain_2(transp, argp, clnt) 168 SVCXPRT *transp; 169 domainname *argp; 170 CLIENT *clnt; 171 { 172 static struct ypbind_resp res; 173 struct _dom_binding *ypdb; 174 char path[MAXPATHLEN]; 175 176 bzero((char *)&res, sizeof res); 177 res.ypbind_status = YPBIND_FAIL_VAL; 178 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_NOSERV; 179 180 if (strchr(*argp, '/')) { 181 syslog(LOG_WARNING, "Domain name '%s' has embedded slash -- \ 182 rejecting.", *argp); 183 return(&res); 184 } 185 186 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) { 187 if( strcmp(ypdb->dom_domain, *argp) == 0) 188 break; 189 } 190 191 if(ypdb==NULL) { 192 if (yp_restricted) { 193 syslog(LOG_NOTICE, "Running in restricted mode -- request to bind domain \"%s\" rejected.\n", *argp); 194 return &res; 195 } 196 197 if (domains >= MAX_DOMAINS) { 198 syslog(LOG_WARNING, "domain limit (%d) exceeded", 199 MAX_DOMAINS); 200 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_RESC; 201 return &res; 202 } 203 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 204 if (ypdb == NULL) { 205 syslog(LOG_WARNING, "malloc: %m"); 206 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_RESC; 207 return &res; 208 } 209 bzero((char *)ypdb, sizeof *ypdb); 210 strncpy(ypdb->dom_domain, *argp, sizeof ypdb->dom_domain); 211 ypdb->dom_vers = YPVERS; 212 ypdb->dom_alive = 0; 213 ypdb->dom_default = 0; 214 ypdb->dom_lockfd = -1; 215 sprintf(path, "%s/%s.%ld", BINDINGDIR, 216 ypdb->dom_domain, ypdb->dom_vers); 217 unlink(path); 218 ypdb->dom_pnext = ypbindlist; 219 ypbindlist = ypdb; 220 domains++; 221 } 222 223 if (ping(ypdb)) { 224 return &res; 225 } 226 227 res.ypbind_status = YPBIND_SUCC_VAL; 228 res.ypbind_resp_u.ypbind_error = 0; /* Success */ 229 *(u_long *)&res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr = 230 ypdb->dom_server_addr.sin_addr.s_addr; 231 *(u_short *)&res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port = 232 ypdb->dom_server_addr.sin_port; 233 /*printf("domain %s at %s/%d\n", ypdb->dom_domain, 234 inet_ntoa(ypdb->dom_server_addr.sin_addr), 235 ntohs(ypdb->dom_server_addr.sin_port));*/ 236 return &res; 237 } 238 239 void * 240 ypbindproc_setdom_2(transp, argp, clnt) 241 SVCXPRT *transp; 242 ypbind_setdom *argp; 243 CLIENT *clnt; 244 { 245 struct sockaddr_in *fromsin, bindsin; 246 247 if (strchr(argp->ypsetdom_domain, '/')) { 248 syslog(LOG_WARNING, "Domain name '%s' has embedded slash -- \ 249 rejecting.", argp->ypsetdom_domain); 250 return; 251 } 252 fromsin = svc_getcaller(transp); 253 254 switch(ypsetmode) { 255 case YPSET_LOCAL: 256 if( fromsin->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) { 257 svcerr_noprog(transp); 258 return; 259 } 260 break; 261 case YPSET_ALL: 262 break; 263 case YPSET_NO: 264 default: 265 svcerr_noprog(transp); 266 return; 267 } 268 269 if(ntohs(fromsin->sin_port) >= IPPORT_RESERVED) { 270 svcerr_noprog(transp); 271 return; 272 } 273 274 if(argp->ypsetdom_vers != YPVERS) { 275 svcerr_noprog(transp); 276 return; 277 } 278 279 bzero((char *)&bindsin, sizeof bindsin); 280 bindsin.sin_family = AF_INET; 281 bindsin.sin_addr.s_addr = *(u_long *)argp->ypsetdom_binding.ypbind_binding_addr; 282 bindsin.sin_port = *(u_short *)argp->ypsetdom_binding.ypbind_binding_port; 283 rpc_received(argp->ypsetdom_domain, &bindsin, 1); 284 285 return; 286 } 287 288 static void 289 ypbindprog_2(rqstp, transp) 290 struct svc_req *rqstp; 291 register SVCXPRT *transp; 292 { 293 union { 294 domainname ypbindproc_domain_2_arg; 295 struct ypbind_setdom ypbindproc_setdom_2_arg; 296 } argument; 297 struct authunix_parms *creds; 298 char *result; 299 bool_t (*xdr_argument)(), (*xdr_result)(); 300 char *(*local)(); 301 302 switch (rqstp->rq_proc) { 303 case YPBINDPROC_NULL: 304 xdr_argument = xdr_void; 305 xdr_result = xdr_void; 306 local = (char *(*)()) ypbindproc_null_2; 307 break; 308 309 case YPBINDPROC_DOMAIN: 310 xdr_argument = xdr_domainname; 311 xdr_result = xdr_ypbind_resp; 312 local = (char *(*)()) ypbindproc_domain_2; 313 break; 314 315 case YPBINDPROC_SETDOM: 316 switch(rqstp->rq_cred.oa_flavor) { 317 case AUTH_UNIX: 318 creds = (struct authunix_parms *)rqstp->rq_clntcred; 319 if( creds->aup_uid != 0) { 320 svcerr_auth(transp, AUTH_BADCRED); 321 return; 322 } 323 break; 324 default: 325 svcerr_auth(transp, AUTH_TOOWEAK); 326 return; 327 } 328 329 xdr_argument = xdr_ypbind_setdom; 330 xdr_result = xdr_void; 331 local = (char *(*)()) ypbindproc_setdom_2; 332 break; 333 334 default: 335 svcerr_noproc(transp); 336 return; 337 } 338 bzero((char *)&argument, sizeof(argument)); 339 if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) { 340 svcerr_decode(transp); 341 return; 342 } 343 result = (*local)(transp, &argument, rqstp); 344 if (result != NULL && !svc_sendreply(transp, xdr_result, result)) { 345 svcerr_systemerr(transp); 346 } 347 return; 348 } 349 350 /* Jack the reaper */ 351 void reaper(sig) 352 int sig; 353 { 354 int st; 355 356 while(wait3(&st, WNOHANG, NULL) > 0) 357 children--; 358 } 359 360 void terminate(sig) 361 int sig; 362 { 363 struct _dom_binding *ypdb; 364 char path[MAXPATHLEN]; 365 366 if (ppid != getpid()) 367 exit(0); 368 369 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) { 370 close(ypdb->dom_lockfd); 371 if (ypdb->dom_broadcast_pid) 372 kill(ypdb->dom_broadcast_pid, SIGINT); 373 sprintf(path, "%s/%s.%ld", BINDINGDIR, 374 ypdb->dom_domain, ypdb->dom_vers); 375 unlink(path); 376 } 377 close(yplockfd); 378 unlink(YPBINDLOCK); 379 pmap_unset(YPBINDPROG, YPBINDVERS); 380 exit(0); 381 } 382 383 int 384 main(argc, argv) 385 int argc; 386 char **argv; 387 { 388 char path[MAXPATHLEN]; 389 struct timeval tv; 390 int i; 391 DIR *dird; 392 struct dirent *dirp; 393 struct _dom_binding *ypdb; 394 395 /* Check that another ypbind isn't already running. */ 396 if ((yplockfd = (open(YPBINDLOCK, O_RDONLY|O_CREAT, 0444))) == -1) { 397 perror(YPBINDLOCK); 398 exit(1); 399 } 400 401 if(flock(yplockfd, LOCK_EX|LOCK_NB) == -1 && errno == EWOULDBLOCK) { 402 fprintf (stderr, "Another ypbind is already running. Aborting.\n"); 403 exit(1); 404 } 405 406 /* XXX domainname will be overriden if we use restricted mode */ 407 yp_get_default_domain(&domain_name); 408 if( domain_name[0] == '\0') { 409 fprintf(stderr, "domainname not set. Aborting.\n"); 410 exit(1); 411 } 412 413 for(i=1; i<argc; i++) { 414 if( strcmp("-ypset", argv[i]) == 0) 415 ypsetmode = YPSET_ALL; 416 else if (strcmp("-ypsetme", argv[i]) == 0) 417 ypsetmode = YPSET_LOCAL; 418 else if (strcmp("-s", argv[i]) == 0) 419 ypsecuremode++; 420 else if (strcmp("-S", argv[i]) == 0 && argc > i) 421 yp_restricted_mode(argv[i+1]); 422 else if (strcmp("-m", argv[i]) == 0) 423 yp_manycast++; 424 } 425 426 /* blow away everything in BINDINGDIR (if it exists) */ 427 428 if ((dird = opendir(BINDINGDIR)) != NULL) { 429 char path[MAXPATHLEN]; 430 while ((dirp = readdir(dird)) != NULL) 431 if (strcmp(dirp->d_name, ".") && 432 strcmp(dirp->d_name, "..")) { 433 sprintf(path,"%s/%s",BINDINGDIR,dirp->d_name); 434 unlink(path); 435 } 436 closedir(dird); 437 } 438 439 #ifdef DAEMON 440 if (daemon(0,0)) { 441 perror("fork"); 442 exit(1); 443 } 444 #endif 445 446 pmap_unset(YPBINDPROG, YPBINDVERS); 447 448 udptransp = svcudp_create(RPC_ANYSOCK); 449 if (udptransp == NULL) { 450 fprintf(stderr, "cannot create udp service.\n"); 451 exit(1); 452 } 453 if (!svc_register(udptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 454 IPPROTO_UDP)) { 455 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, udp).\n"); 456 exit(1); 457 } 458 459 tcptransp = svctcp_create(RPC_ANYSOCK, 0, 0); 460 if (tcptransp == NULL) { 461 fprintf(stderr, "cannot create tcp service.\n"); 462 exit(1); 463 } 464 465 if (!svc_register(tcptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 466 IPPROTO_TCP)) { 467 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, tcp).\n"); 468 exit(1); 469 } 470 471 /* build initial domain binding, make it "unsuccessful" */ 472 ypbindlist = (struct _dom_binding *)malloc(sizeof *ypbindlist); 473 if (ypbindlist == NULL) { 474 perror("malloc"); 475 exit(1); 476 } 477 bzero((char *)ypbindlist, sizeof *ypbindlist); 478 strncpy(ypbindlist->dom_domain, domain_name, sizeof ypbindlist->dom_domain); 479 ypbindlist->dom_vers = YPVERS; 480 ypbindlist->dom_alive = 0; 481 ypbindlist->dom_lockfd = -1; 482 ypbindlist->dom_default = 1; 483 domains++; 484 485 signal(SIGCHLD, reaper); 486 signal(SIGTERM, terminate); 487 488 ppid = getpid(); /* Remember who we are. */ 489 490 openlog(argv[0], LOG_PID, LOG_DAEMON); 491 492 /* Kick off the default domain */ 493 broadcast(ypbindlist); 494 495 while(1) { 496 fdsr = svc_fdset; 497 498 tv.tv_sec = 60; 499 tv.tv_usec = 0; 500 501 switch(select(_rpc_dtablesize(), &fdsr, NULL, NULL, &tv)) { 502 case 0: 503 checkwork(); 504 break; 505 case -1: 506 if (errno != EINTR) 507 syslog(LOG_WARNING, "select: %m"); 508 break; 509 default: 510 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) { 511 if (READFD > 0 && FD_ISSET(READFD, &fdsr)) { 512 handle_children(ypdb); 513 if (children == (MAX_CHILDREN - 1)) 514 checkwork(); 515 } 516 } 517 svc_getreqset(&fdsr); 518 break; 519 } 520 } 521 522 /* NOTREACHED */ 523 exit(1); 524 } 525 526 void 527 checkwork() 528 { 529 struct _dom_binding *ypdb; 530 531 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) 532 ping(ypdb); 533 } 534 535 /* The clnt_broadcast() callback mechanism sucks. */ 536 537 /* 538 * Receive results from broadcaster. Don't worry about passing 539 * bogus info to rpc_received() -- it can handle it. Note that we 540 * must be sure to invalidate the dom_pipe_fds descriptors here: 541 * since descriptors can be re-used, we have to make sure we 542 * don't mistake one of the RPC descriptors for one of the pipes. 543 * What's weird is that forgetting to invalidate the pipe descriptors 544 * doesn't always result in an error (otherwise I would have caught 545 * the mistake much sooner), even though logically it should. 546 */ 547 void handle_children(ypdb) 548 struct _dom_binding *ypdb; 549 { 550 char buf[YPMAXDOMAIN + 1]; 551 struct sockaddr_in addr; 552 int d = 0, a = 0; 553 struct _dom_binding *y, *prev = NULL; 554 char path[MAXPATHLEN]; 555 556 if ((d = read(READFD, &buf, sizeof(buf))) <= 0) 557 syslog(LOG_WARNING, "could not read from child: %m"); 558 559 if ((a = read(READFD, &addr, sizeof(struct sockaddr_in))) < 0) 560 syslog(LOG_WARNING, "could not read from child: %m"); 561 562 close(READFD); 563 FD_CLR(READFD, &fdsr); 564 FD_CLR(READFD, &svc_fdset); 565 READFD = WRITEFD = -1; 566 if (d > 0 && a > 0) 567 rpc_received((char *)&buf, &addr, 0); 568 else { 569 for(y=ypbindlist; y; y=y->dom_pnext) { 570 if (y == ypdb) 571 break; 572 prev = y; 573 } 574 switch(ypdb->dom_default) { 575 case 0: 576 if (prev == NULL) 577 ypbindlist = y->dom_pnext; 578 else 579 prev->dom_pnext = y->dom_pnext; 580 sprintf(path, "%s/%s.%ld", BINDINGDIR, 581 ypdb->dom_domain, YPVERS); 582 close(ypdb->dom_lockfd); 583 unlink(path); 584 free(ypdb); 585 domains--; 586 return; 587 case 1: 588 ypdb->dom_broadcast_pid = 0; 589 ypdb->dom_alive = 0; 590 broadcast(ypdb); 591 return; 592 default: 593 break; 594 } 595 } 596 597 return; 598 } 599 600 /* 601 * Send our dying words back to our parent before we perish. 602 */ 603 int 604 tell_parent(dom, addr) 605 char *dom; 606 struct sockaddr_in *addr; 607 { 608 char buf[YPMAXDOMAIN + 1]; 609 struct timeval timeout; 610 fd_set fds; 611 612 timeout.tv_sec = 5; 613 timeout.tv_usec = 0; 614 615 sprintf(buf, "%s", broad_domain->dom_domain); 616 if (write(BROADFD, &buf, sizeof(buf)) < 0) 617 return(1); 618 619 /* 620 * Stay in sync with parent: wait for it to read our first 621 * message before sending the second. 622 */ 623 624 FD_ZERO(&fds); 625 FD_SET(BROADFD, &fds); 626 if (select(FD_SETSIZE, NULL, &fds, NULL, &timeout) == -1) 627 return(1); 628 if (FD_ISSET(BROADFD, &fds)) { 629 if (write(BROADFD, addr, sizeof(struct sockaddr_in)) < 0) 630 return(1); 631 } else { 632 return(1); 633 } 634 635 close(BROADFD); 636 return (0); 637 } 638 639 bool_t broadcast_result(out, addr) 640 bool_t *out; 641 struct sockaddr_in *addr; 642 { 643 if (retries >= MAX_RETRIES) { 644 bzero((char *)addr, sizeof(struct sockaddr_in)); 645 if (tell_parent(broad_domain->dom_domain, addr)) 646 syslog(LOG_WARNING, "lost connection to parent"); 647 return TRUE; 648 } 649 650 if (yp_restricted && verify(addr->sin_addr)) { 651 retries++; 652 syslog(LOG_NOTICE, "NIS server at %s not in restricted mode access list -- rejecting.\n",inet_ntoa(addr->sin_addr)); 653 return FALSE; 654 } else { 655 if (tell_parent(broad_domain->dom_domain, addr)) 656 syslog(LOG_WARNING, "lost connection to parent"); 657 return TRUE; 658 } 659 } 660 661 /* 662 * The right way to send RPC broadcasts. 663 * Use the clnt_broadcast() RPC service. Unfortunately, clnt_broadcast() 664 * blocks while waiting for replies, so we have to fork off seperate 665 * broadcaster processes that do the waiting and then transmit their 666 * results back to the parent for processing. We also have to remember 667 * to save the name of the domain we're trying to bind in a global 668 * variable since clnt_broadcast() provides no way to pass things to 669 * the 'eachresult' callback function. 670 */ 671 void 672 broadcast(ypdb) 673 struct _dom_binding *ypdb; 674 { 675 bool_t out = FALSE; 676 enum clnt_stat stat; 677 678 if (children >= MAX_CHILDREN || ypdb->dom_broadcast_pid) 679 return; 680 681 if (pipe(ypdb->dom_pipe_fds) < 0) { 682 syslog(LOG_WARNING, "pipe: %m"); 683 return; 684 } 685 686 if (ypdb->dom_vers = -1 && (long)ypdb->dom_server_addr.sin_addr.s_addr) 687 syslog(LOG_WARNING, "NIS server [%s] for domain \"%s\" not responding", 688 inet_ntoa(ypdb->dom_server_addr.sin_addr), ypdb->dom_domain); 689 690 broad_domain = ypdb; 691 flock(ypdb->dom_lockfd, LOCK_UN); 692 693 switch((ypdb->dom_broadcast_pid = fork())) { 694 case 0: 695 close(READFD); 696 signal(SIGCHLD, SIG_DFL); 697 signal(SIGTERM, SIG_DFL); 698 break; 699 case -1: 700 syslog(LOG_WARNING, "fork: %m"); 701 close(READFD); 702 close(WRITEFD); 703 return; 704 default: 705 close(WRITEFD); 706 FD_SET(READFD, &svc_fdset); 707 children++; 708 return; 709 } 710 711 /* Release all locks before doing anything else. */ 712 while(ypbindlist) { 713 close(ypbindlist->dom_lockfd); 714 ypbindlist = ypbindlist->dom_pnext; 715 } 716 close(yplockfd); 717 718 /* 719 * Special 'many-cast' behavior. If we're in restricted mode, 720 * we have a list of possible server addresses to try. What 721 * we can do is transmit to each ypserv's YPPROC_DOMAIN_NONACK 722 * procedure and time the replies. Whoever replies fastest 723 * gets to be our server. Note that this is not a broadcast 724 * operation: we transmit uni-cast datagrams only. 725 */ 726 if (yp_restricted && yp_manycast) { 727 short port; 728 int i; 729 struct sockaddr_in sin; 730 731 i = __yp_ping(restricted_addrs, yp_restricted, 732 ypdb->dom_domain, &port); 733 if (i == -1) { 734 bzero((char *)&ypdb->dom_server_addr, 735 sizeof(struct sockaddr_in)); 736 if (tell_parent(ypdb->dom_domain, 737 &ypdb->dom_server_addr)) 738 syslog(LOG_WARNING, "lost connection to parent"); 739 } else { 740 bzero((char *)&sin, sizeof(struct sockaddr_in)); 741 bcopy((char *)&restricted_addrs[i], 742 (char *)&sin.sin_addr, sizeof(struct in_addr)); 743 sin.sin_family = AF_INET; 744 sin.sin_port = port; 745 if (tell_parent(broad_domain->dom_domain, &sin)) 746 syslog(LOG_WARNING, 747 "lost connection to parent"); 748 } 749 _exit(0); 750 } 751 752 retries = 0; 753 754 { 755 char *ptr; 756 757 ptr = (char *)&ypdb->dom_domain; 758 stat = clnt_broadcast(YPPROG, YPVERS, YPPROC_DOMAIN_NONACK, 759 xdr_domainname, (char *)&ptr, xdr_bool, (char *)&out, 760 broadcast_result); 761 } 762 763 if (stat != RPC_SUCCESS) { 764 bzero((char *)&ypdb->dom_server_addr, 765 sizeof(struct sockaddr_in)); 766 if (tell_parent(ypdb->dom_domain, &ypdb->dom_server_addr)) 767 syslog(LOG_WARNING, "lost connection to parent"); 768 } 769 770 _exit(0); 771 } 772 773 /* 774 * The right way to check if a server is alive. 775 * Attempt to get a client handle pointing to the server and send a 776 * YPPROC_DOMAIN. If we can't get a handle or we get a reply of FALSE, 777 * we invalidate this binding entry and send out a broadcast to try to 778 * establish a new binding. Note that we treat non-default domains 779 * specially: once bound, we keep tabs on our server, but if it 780 * goes away and fails to respond after one round of broadcasting, we 781 * abandon it until a client specifically references it again. We make 782 * every effort to keep our default domain bound, however, since we 783 * need it to keep the system on its feet. 784 */ 785 int 786 ping(ypdb) 787 struct _dom_binding *ypdb; 788 { 789 bool_t out; 790 struct timeval interval, timeout; 791 enum clnt_stat stat; 792 int rpcsock = RPC_ANYSOCK; 793 CLIENT *client_handle; 794 time_t t; 795 796 interval.tv_sec = FAIL_THRESHOLD; 797 interval.tv_usec = 0; 798 timeout.tv_sec = FAIL_THRESHOLD; 799 timeout.tv_usec = 0; 800 801 if (ypdb->dom_broadcast_pid) 802 return(1); 803 804 if ((client_handle = clntudp_bufcreate(&ypdb->dom_server_addr, 805 YPPROG, YPVERS, interval, &rpcsock, RPCSMALLMSGSIZE, 806 RPCSMALLMSGSIZE)) == (CLIENT *)NULL) { 807 /* Can't get a handle: we're dead. */ 808 ypdb->dom_alive = 0; 809 ypdb->dom_vers = -1; 810 broadcast(ypdb); 811 return(1); 812 } 813 814 { 815 char *ptr; 816 817 ptr = (char *)&ypdb->dom_domain; 818 819 if ((stat = clnt_call(client_handle, YPPROC_DOMAIN, 820 xdr_domainname, (char *)&ptr, xdr_bool, (char *)&out, 821 timeout)) != RPC_SUCCESS || out == FALSE) { 822 ypdb->dom_alive = 0; 823 ypdb->dom_vers = -1; 824 clnt_destroy(client_handle); 825 broadcast(ypdb); 826 return(1); 827 } 828 } 829 830 clnt_destroy(client_handle); 831 return(0); 832 } 833 834 void rpc_received(dom, raddrp, force) 835 char *dom; 836 struct sockaddr_in *raddrp; 837 int force; 838 { 839 struct _dom_binding *ypdb, *prev = NULL; 840 struct iovec iov[2]; 841 struct ypbind_resp ybr; 842 char path[MAXPATHLEN]; 843 int fd; 844 845 /*printf("returned from %s/%d about %s\n", inet_ntoa(raddrp->sin_addr), 846 ntohs(raddrp->sin_port), dom);*/ 847 848 if(dom==NULL) 849 return; 850 851 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) { 852 if( strcmp(ypdb->dom_domain, dom) == 0) 853 break; 854 prev = ypdb; 855 } 856 857 if (ypdb && force) { 858 if (ypdb->dom_broadcast_pid) { 859 kill(ypdb->dom_broadcast_pid, SIGINT); 860 close(READFD); 861 FD_CLR(READFD, &fdsr); 862 FD_CLR(READFD, &svc_fdset); 863 READFD = WRITEFD = -1; 864 } 865 } 866 867 /* if in secure mode, check originating port number */ 868 if ((ypsecuremode && (ntohs(raddrp->sin_port) >= IPPORT_RESERVED))) { 869 syslog(LOG_WARNING, "Rejected NIS server on [%s/%d] for domain %s.", 870 inet_ntoa(raddrp->sin_addr), ntohs(raddrp->sin_port), 871 dom); 872 if (ypdb != NULL) { 873 ypdb->dom_broadcast_pid = 0; 874 ypdb->dom_alive = 0; 875 } 876 return; 877 } 878 879 if (raddrp->sin_addr.s_addr == (long)0) { 880 switch(ypdb->dom_default) { 881 case 0: 882 if (prev == NULL) 883 ypbindlist = ypdb->dom_pnext; 884 else 885 prev->dom_pnext = ypdb->dom_pnext; 886 sprintf(path, "%s/%s.%ld", BINDINGDIR, 887 ypdb->dom_domain, YPVERS); 888 close(ypdb->dom_lockfd); 889 unlink(path); 890 free(ypdb); 891 domains--; 892 return; 893 case 1: 894 ypdb->dom_broadcast_pid = 0; 895 ypdb->dom_alive = 0; 896 broadcast(ypdb); 897 return; 898 default: 899 break; 900 } 901 } 902 903 if(ypdb==NULL) { 904 if (force == 0) 905 return; 906 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 907 if (ypdb == NULL) { 908 syslog(LOG_WARNING, "malloc: %m"); 909 return; 910 } 911 bzero((char *)ypdb, sizeof *ypdb); 912 strncpy(ypdb->dom_domain, dom, sizeof ypdb->dom_domain); 913 ypdb->dom_lockfd = -1; 914 ypdb->dom_default = 0; 915 ypdb->dom_pnext = ypbindlist; 916 ypbindlist = ypdb; 917 } 918 919 /* We've recovered from a crash: inform the world. */ 920 if (ypdb->dom_vers = -1 && ypdb->dom_server_addr.sin_addr.s_addr) 921 syslog(LOG_WARNING, "NIS server [%s] for domain \"%s\" OK", 922 inet_ntoa(raddrp->sin_addr), ypdb->dom_domain); 923 924 bcopy((char *)raddrp, (char *)&ypdb->dom_server_addr, 925 sizeof ypdb->dom_server_addr); 926 927 ypdb->dom_vers = YPVERS; 928 ypdb->dom_alive = 1; 929 ypdb->dom_broadcast_pid = 0; 930 931 if(ypdb->dom_lockfd != -1) 932 close(ypdb->dom_lockfd); 933 934 sprintf(path, "%s/%s.%ld", BINDINGDIR, 935 ypdb->dom_domain, ypdb->dom_vers); 936 #ifdef O_SHLOCK 937 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) { 938 (void)mkdir(BINDINGDIR, 0755); 939 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) 940 return; 941 } 942 #else 943 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) { 944 (void)mkdir(BINDINGDIR, 0755); 945 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) 946 return; 947 } 948 flock(fd, LOCK_SH); 949 #endif 950 951 /* 952 * ok, if BINDINGDIR exists, and we can create the binding file, 953 * then write to it.. 954 */ 955 ypdb->dom_lockfd = fd; 956 957 iov[0].iov_base = (caddr_t)&(udptransp->xp_port); 958 iov[0].iov_len = sizeof udptransp->xp_port; 959 iov[1].iov_base = (caddr_t)&ybr; 960 iov[1].iov_len = sizeof ybr; 961 962 bzero(&ybr, sizeof ybr); 963 ybr.ypbind_status = YPBIND_SUCC_VAL; 964 *(u_long *)&ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr = raddrp->sin_addr.s_addr; 965 *(u_short *)&ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port = raddrp->sin_port; 966 967 if( writev(ypdb->dom_lockfd, iov, 2) != iov[0].iov_len + iov[1].iov_len) { 968 syslog(LOG_WARNING, "write: %m"); 969 close(ypdb->dom_lockfd); 970 ypdb->dom_lockfd = -1; 971 return; 972 } 973 } 974 975 /* 976 * Check address against list of allowed servers. Return 0 if okay, 977 * 1 if not matched. 978 */ 979 int 980 verify(addr) 981 struct in_addr addr; 982 { 983 int i; 984 985 for (i = 0; i < RESTRICTED_SERVERS; i++) 986 if (!bcmp((char *)&addr, (char *)&restricted_addrs[i], 987 sizeof(struct in_addr))) 988 return(0); 989 990 return(1); 991 } 992 993 /* 994 * Try to set restricted mode. We default to normal mode if we can't 995 * resolve the specified hostnames. 996 */ 997 void 998 yp_restricted_mode(args) 999 char *args; 1000 { 1001 struct hostent *h; 1002 int i = 0; 1003 char *s; 1004 1005 /* Find the restricted domain. */ 1006 if ((s = strsep(&args, ",")) == NULL) 1007 return; 1008 domain_name = s; 1009 1010 /* Get the addresses of the servers. */ 1011 while ((s = strsep(&args, ",")) != NULL && i < RESTRICTED_SERVERS) { 1012 if ((h = gethostbyname(s)) == NULL) 1013 return; 1014 bcopy ((char *)h->h_addr_list[0], (char *)&restricted_addrs[i], 1015 sizeof(struct in_addr)); 1016 i++; 1017 } 1018 1019 /* ypset and ypsetme not allowed with restricted mode */ 1020 ypsetmode = YPSET_NO; 1021 1022 yp_restricted = i; 1023 return; 1024 } 1025