ypbind.c revision 1.21
1 /* $NetBSD: ypbind.c,v 1.21 1996/05/29 20:11:10 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 Theo de Raadt <deraadt (at) 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 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Theo de Raadt. 18 * 4. The name of the author may not be used to endorse or promote 19 * products derived from this software without specific prior written 20 * permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 23 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 26 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #ifndef LINT 36 static char rcsid[] = "$NetBSD: ypbind.c,v 1.21 1996/05/29 20:11:10 thorpej Exp $"; 37 #endif 38 39 #include <sys/param.h> 40 #include <sys/types.h> 41 #include <sys/ioctl.h> 42 #include <sys/signal.h> 43 #include <sys/socket.h> 44 #include <sys/file.h> 45 #include <sys/fcntl.h> 46 #include <sys/uio.h> 47 #include <sys/syslog.h> 48 #include <stdio.h> 49 #include <stdlib.h> 50 #include <errno.h> 51 #include <ctype.h> 52 #include <dirent.h> 53 #include <netdb.h> 54 #include <string.h> 55 #include <rpc/rpc.h> 56 #include <rpc/xdr.h> 57 #include <net/if.h> 58 #include <arpa/inet.h> 59 #include <rpc/pmap_clnt.h> 60 #include <rpc/pmap_prot.h> 61 #include <rpc/pmap_rmt.h> 62 #include <unistd.h> 63 #include <rpcsvc/yp_prot.h> 64 #include <rpcsvc/ypclnt.h> 65 66 #define BINDINGDIR "/var/yp/binding" 67 #define YPBINDLOCK "/var/run/ypbind.lock" 68 69 struct _dom_binding { 70 struct _dom_binding *dom_pnext; 71 char dom_domain[YPMAXDOMAIN + 1]; 72 struct sockaddr_in dom_server_addr; 73 unsigned short int dom_server_port; 74 int dom_socket; 75 CLIENT *dom_client; 76 long int dom_vers; 77 time_t dom_check_t; 78 time_t dom_ask_t; 79 int dom_lockfd; 80 int dom_alive; 81 int dom_xid; 82 }; 83 84 char *domainname; 85 86 struct _dom_binding *ypbindlist; 87 int check; 88 89 #define YPSET_NO 0 90 #define YPSET_LOCAL 1 91 #define YPSET_ALL 2 92 int ypsetmode = YPSET_NO; 93 94 int rpcsock, pingsock; 95 struct rmtcallargs rmtca; 96 struct rmtcallres rmtcr; 97 char rmtcr_outval; 98 u_long rmtcr_port; 99 SVCXPRT *udptransp, *tcptransp; 100 101 struct _dom_binding *xid2ypdb __P((int xid)); 102 int unique_xid __P((struct _dom_binding *ypdb)); 103 104 void * 105 ypbindproc_null_2(transp, argp, clnt) 106 SVCXPRT *transp; 107 void *argp; 108 CLIENT *clnt; 109 { 110 static char res; 111 112 memset(&res, 0, sizeof(res)); 113 return (void *)&res; 114 } 115 116 struct ypbind_resp * 117 ypbindproc_domain_2(transp, argp, clnt) 118 SVCXPRT *transp; 119 char *argp; 120 CLIENT *clnt; 121 { 122 static struct ypbind_resp res; 123 struct _dom_binding *ypdb; 124 char path[MAXPATHLEN]; 125 time_t now; 126 127 memset(&res, 0, sizeof res); 128 res.ypbind_status = YPBIND_FAIL_VAL; 129 130 for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext) 131 if (!strcmp(ypdb->dom_domain, argp)) 132 break; 133 134 if (ypdb == NULL) { 135 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 136 memset(ypdb, 0, sizeof *ypdb); 137 strncpy(ypdb->dom_domain, argp, sizeof ypdb->dom_domain); 138 ypdb->dom_vers = YPVERS; 139 ypdb->dom_alive = 0; 140 ypdb->dom_lockfd = -1; 141 sprintf(path, "%s/%s.%d", BINDINGDIR, ypdb->dom_domain, ypdb->dom_vers); 142 unlink(path); 143 ypdb->dom_xid = unique_xid(ypdb); 144 ypdb->dom_pnext = ypbindlist; 145 ypbindlist = ypdb; 146 check++; 147 return NULL; 148 } 149 150 if (ypdb->dom_alive == 0) 151 return NULL; 152 153 #ifdef HEURISTIC 154 time(&now); 155 if (now < ypdb->dom_ask_t + 5) { 156 /* 157 * Hmm. More than 2 requests in 5 seconds have indicated 158 * that my binding is possibly incorrect. 159 * Ok, do an immediate poll of the server. 160 */ 161 if (ypdb->dom_check_t >= now) { 162 /* don't flood it */ 163 ypdb->dom_check_t = 0; 164 check++; 165 } 166 } 167 ypdb->dom_ask_t = now; 168 #endif 169 170 answer: 171 res.ypbind_status = YPBIND_SUCC_VAL; 172 res.ypbind_respbody.ypbind_bindinfo.ypbind_binding_addr.s_addr = 173 ypdb->dom_server_addr.sin_addr.s_addr; 174 res.ypbind_respbody.ypbind_bindinfo.ypbind_binding_port = 175 ypdb->dom_server_port; 176 /*printf("domain %s at %s/%d\n", ypdb->dom_domain, 177 inet_ntoa(ypdb->dom_server_addr.sin_addr), 178 ntohs(ypdb->dom_server_addr.sin_port));*/ 179 return &res; 180 } 181 182 bool_t * 183 ypbindproc_setdom_2(transp, argp, clnt) 184 SVCXPRT *transp; 185 struct ypbind_setdom *argp; 186 CLIENT *clnt; 187 { 188 struct sockaddr_in *fromsin, bindsin; 189 static bool_t res; 190 191 memset(&res, 0, sizeof(res)); 192 fromsin = svc_getcaller(transp); 193 194 switch (ypsetmode) { 195 case YPSET_LOCAL: 196 if (fromsin->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) 197 return (bool_t *)NULL; 198 break; 199 case YPSET_ALL: 200 break; 201 case YPSET_NO: 202 default: 203 return (bool_t *)NULL; 204 } 205 206 if (ntohs(fromsin->sin_port) >= IPPORT_RESERVED) 207 return &res; 208 209 if (argp->ypsetdom_vers != YPVERS) 210 return &res; 211 212 memset(&bindsin, 0, sizeof bindsin); 213 bindsin.sin_family = AF_INET; 214 bindsin.sin_len = sizeof(bindsin); 215 bindsin.sin_addr = argp->ypsetdom_addr; 216 bindsin.sin_port = argp->ypsetdom_port; 217 rpc_received(argp->ypsetdom_domain, &bindsin, 1); 218 219 res = 1; 220 return &res; 221 } 222 223 static void 224 ypbindprog_2(rqstp, transp) 225 struct svc_req *rqstp; 226 register SVCXPRT *transp; 227 { 228 union { 229 char ypbindproc_domain_2_arg[MAXHOSTNAMELEN]; 230 struct ypbind_setdom ypbindproc_setdom_2_arg; 231 } argument; 232 struct authunix_parms *creds; 233 char *result; 234 bool_t (*xdr_argument)(), (*xdr_result)(); 235 char *(*local)(); 236 237 switch (rqstp->rq_proc) { 238 case YPBINDPROC_NULL: 239 xdr_argument = xdr_void; 240 xdr_result = xdr_void; 241 local = (char *(*)()) ypbindproc_null_2; 242 break; 243 244 case YPBINDPROC_DOMAIN: 245 xdr_argument = xdr_ypdomain_wrap_string; 246 xdr_result = xdr_ypbind_resp; 247 local = (char *(*)()) ypbindproc_domain_2; 248 break; 249 250 case YPBINDPROC_SETDOM: 251 switch (rqstp->rq_cred.oa_flavor) { 252 case AUTH_UNIX: 253 creds = (struct authunix_parms *)rqstp->rq_clntcred; 254 if (creds->aup_uid != 0) { 255 svcerr_auth(transp, AUTH_BADCRED); 256 return; 257 } 258 break; 259 default: 260 svcerr_auth(transp, AUTH_TOOWEAK); 261 return; 262 } 263 264 xdr_argument = xdr_ypbind_setdom; 265 xdr_result = xdr_void; 266 local = (char *(*)()) ypbindproc_setdom_2; 267 break; 268 269 default: 270 svcerr_noproc(transp); 271 return; 272 } 273 memset(&argument, 0, sizeof(argument)); 274 if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) { 275 svcerr_decode(transp); 276 return; 277 } 278 result = (*local)(transp, &argument, rqstp); 279 if (result != NULL && !svc_sendreply(transp, xdr_result, result)) { 280 svcerr_systemerr(transp); 281 } 282 return; 283 } 284 285 main(argc, argv) 286 int argc; 287 char *argv[]; 288 { 289 char path[MAXPATHLEN]; 290 struct timeval tv; 291 fd_set fdsr; 292 int width, lockfd; 293 int evil = 0, one; 294 295 yp_get_default_domain(&domainname); 296 if (domainname[0] == '\0') { 297 fprintf(stderr, "domainname not set. Aborting.\n"); 298 exit(1); 299 } 300 301 while (--argc) { 302 ++argv; 303 if (!strcmp("-ypset", *argv)) 304 ypsetmode = YPSET_ALL; 305 else if (!strcmp("-ypsetme", *argv)) 306 ypsetmode = YPSET_LOCAL; 307 } 308 309 /* blow away everything in BINDINGDIR */ 310 311 #ifdef O_SHLOCK 312 if ((lockfd = open(YPBINDLOCK, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) { 313 fprintf(stderr, "ypbind: cannot create %s\n", YPBINDLOCK); 314 exit(1); 315 } 316 #else 317 if ((lockfd = open(YPBINDLOCK, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) { 318 fprintf(stderr, "ypbind: cannot create %s\n", YPBINDLOCK); 319 exit(1); 320 } 321 flock(lockfd, LOCK_SH); 322 #endif 323 324 (void)pmap_unset(YPBINDPROG, YPBINDVERS); 325 326 udptransp = svcudp_create(RPC_ANYSOCK); 327 if (udptransp == NULL) { 328 fprintf(stderr, "cannot create udp service."); 329 exit(1); 330 } 331 if (!svc_register(udptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 332 IPPROTO_UDP)) { 333 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, udp)."); 334 exit(1); 335 } 336 337 tcptransp = svctcp_create(RPC_ANYSOCK, 0, 0); 338 if (tcptransp == NULL) { 339 fprintf(stderr, "cannot create tcp service."); 340 exit(1); 341 } 342 if (!svc_register(tcptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 343 IPPROTO_TCP)) { 344 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, tcp)."); 345 exit(1); 346 } 347 348 if ((rpcsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { 349 perror("socket"); 350 return -1; 351 } 352 if ((pingsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { 353 perror("socket"); 354 return -1; 355 } 356 357 fcntl(rpcsock, F_SETFL, fcntl(rpcsock, F_GETFL, 0) | FNDELAY); 358 fcntl(pingsock, F_SETFL, fcntl(rpcsock, F_GETFL, 0) | FNDELAY); 359 one = 1; 360 setsockopt(rpcsock, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)); 361 rmtca.prog = YPPROG; 362 rmtca.vers = YPVERS; 363 rmtca.proc = YPPROC_DOMAIN_NONACK; 364 rmtca.xdr_args = NULL; /* set at call time */ 365 rmtca.args_ptr = NULL; /* set at call time */ 366 rmtcr.port_ptr = &rmtcr_port; 367 rmtcr.xdr_results = xdr_bool; 368 rmtcr.results_ptr = (caddr_t)&rmtcr_outval; 369 370 /* build initial domain binding, make it "unsuccessful" */ 371 ypbindlist = (struct _dom_binding *)malloc(sizeof *ypbindlist); 372 memset(ypbindlist, 0, sizeof *ypbindlist); 373 strncpy(ypbindlist->dom_domain, domainname, sizeof ypbindlist->dom_domain); 374 ypbindlist->dom_vers = YPVERS; 375 ypbindlist->dom_alive = 0; 376 ypbindlist->dom_lockfd = -1; 377 sprintf(path, "%s/%s.%d", BINDINGDIR, ypbindlist->dom_domain, 378 ypbindlist->dom_vers); 379 (void)unlink(path); 380 381 checkwork(); 382 383 while (1) { 384 width = svc_maxfd; 385 if (rpcsock > width) 386 width = rpcsock; 387 if (pingsock > width) 388 width = pingsock; 389 width++; 390 391 fdsr = svc_fdset; 392 FD_SET(rpcsock, &fdsr); 393 FD_SET(pingsock, &fdsr); 394 tv.tv_sec = 1; 395 tv.tv_usec = 0; 396 397 switch (select(width, &fdsr, NULL, NULL, &tv)) { 398 case 0: 399 checkwork(); 400 break; 401 case -1: 402 perror("select\n"); 403 break; 404 default: 405 if (FD_ISSET(rpcsock, &fdsr)) 406 handle_replies(); 407 if (FD_ISSET(pingsock, &fdsr)) 408 handle_ping(); 409 svc_getreqset(&fdsr); 410 if (check) 411 checkwork(); 412 break; 413 } 414 415 if (!evil && ypbindlist->dom_alive) { 416 evil = 1; 417 daemon(0, 0); 418 } 419 } 420 } 421 422 /* 423 * State transition is done like this: 424 * 425 * STATE EVENT ACTION NEWSTATE TIMEOUT 426 * no binding timeout broadcast no binding 5 sec 427 * no binding answer -- binding 60 sec 428 * binding timeout ping server checking 5 sec 429 * checking timeout ping server + broadcast checking 5 sec 430 * checking answer -- binding 60 sec 431 */ 432 checkwork() 433 { 434 struct _dom_binding *ypdb; 435 time_t t; 436 437 check = 0; 438 439 time(&t); 440 for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext) { 441 if (ypdb->dom_check_t < t) { 442 if (ypdb->dom_alive == 1) 443 ping(ypdb); 444 else 445 broadcast(ypdb); 446 time(&t); 447 ypdb->dom_check_t = t + 5; 448 } 449 } 450 } 451 452 ping(ypdb) 453 struct _dom_binding *ypdb; 454 { 455 char *dom = ypdb->dom_domain; 456 struct rpc_msg msg; 457 char buf[1400]; 458 enum clnt_stat st; 459 int outlen; 460 AUTH *rpcua; 461 XDR xdr; 462 463 memset(&xdr, 0, sizeof xdr); 464 memset(&msg, 0, sizeof msg); 465 466 rpcua = authunix_create_default(); 467 if (rpcua == (AUTH *)NULL) { 468 /*printf("cannot get unix auth\n");*/ 469 return RPC_SYSTEMERROR; 470 } 471 msg.rm_direction = CALL; 472 msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 473 msg.rm_call.cb_prog = YPPROG; 474 msg.rm_call.cb_vers = YPVERS; 475 msg.rm_call.cb_proc = YPPROC_DOMAIN_NONACK; 476 msg.rm_call.cb_cred = rpcua->ah_cred; 477 msg.rm_call.cb_verf = rpcua->ah_verf; 478 479 msg.rm_xid = ypdb->dom_xid; 480 xdrmem_create(&xdr, buf, sizeof buf, XDR_ENCODE); 481 if (!xdr_callmsg(&xdr, &msg)) { 482 st = RPC_CANTENCODEARGS; 483 AUTH_DESTROY(rpcua); 484 return st; 485 } 486 if (xdr_ypdomain_wrap_string(&xdr, &dom)) { 487 st = RPC_CANTENCODEARGS; 488 AUTH_DESTROY(rpcua); 489 return st; 490 } 491 outlen = (int)xdr_getpos(&xdr); 492 xdr_destroy(&xdr); 493 if (outlen < 1) { 494 st = RPC_CANTENCODEARGS; 495 AUTH_DESTROY(rpcua); 496 return st; 497 } 498 AUTH_DESTROY(rpcua); 499 500 ypdb->dom_alive = 2; 501 if (sendto(pingsock, buf, outlen, 0, 502 (struct sockaddr *)&ypdb->dom_server_addr, 503 sizeof ypdb->dom_server_addr) < 0) 504 perror("sendto"); 505 return 0; 506 507 } 508 509 broadcast(ypdb) 510 struct _dom_binding *ypdb; 511 { 512 char *dom = ypdb->dom_domain; 513 struct rpc_msg msg; 514 char buf[1400], inbuf[8192]; 515 char path[MAXPATHLEN]; 516 enum clnt_stat st; 517 int outlen, i, sock, len; 518 struct sockaddr_in bindsin; 519 struct ifconf ifc; 520 struct ifreq ifreq, *ifr; 521 struct in_addr in; 522 AUTH *rpcua; 523 XDR xdr; 524 525 rmtca.xdr_args = xdr_ypdomain_wrap_string; 526 rmtca.args_ptr = (char *)&dom; 527 528 memset(&xdr, 0, sizeof xdr); 529 memset(&msg, 0, sizeof msg); 530 531 rpcua = authunix_create_default(); 532 if (rpcua == (AUTH *)NULL) { 533 /*printf("cannot get unix auth\n");*/ 534 return RPC_SYSTEMERROR; 535 } 536 msg.rm_direction = CALL; 537 msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 538 msg.rm_call.cb_prog = PMAPPROG; 539 msg.rm_call.cb_vers = PMAPVERS; 540 msg.rm_call.cb_proc = PMAPPROC_CALLIT; 541 msg.rm_call.cb_cred = rpcua->ah_cred; 542 msg.rm_call.cb_verf = rpcua->ah_verf; 543 544 msg.rm_xid = ypdb->dom_xid; 545 xdrmem_create(&xdr, buf, sizeof buf, XDR_ENCODE); 546 if (!xdr_callmsg(&xdr, &msg)) { 547 st = RPC_CANTENCODEARGS; 548 AUTH_DESTROY(rpcua); 549 return st; 550 } 551 if (!xdr_rmtcall_args(&xdr, &rmtca)) { 552 st = RPC_CANTENCODEARGS; 553 AUTH_DESTROY(rpcua); 554 return st; 555 } 556 outlen = (int)xdr_getpos(&xdr); 557 xdr_destroy(&xdr); 558 if (outlen < 1) { 559 st = RPC_CANTENCODEARGS; 560 AUTH_DESTROY(rpcua); 561 return st; 562 } 563 AUTH_DESTROY(rpcua); 564 565 if (ypdb->dom_lockfd != -1) { 566 close(ypdb->dom_lockfd); 567 ypdb->dom_lockfd = -1; 568 sprintf(path, "%s/%s.%d", BINDINGDIR, 569 ypdb->dom_domain, ypdb->dom_vers); 570 unlink(path); 571 } 572 573 memset(&bindsin, 0, sizeof bindsin); 574 bindsin.sin_family = AF_INET; 575 bindsin.sin_len = sizeof(bindsin); 576 bindsin.sin_port = htons(PMAPPORT); 577 578 if (ypdb->dom_alive == 2) { 579 /* 580 * This resolves the following situation: 581 * ypserver on other subnet was once bound, 582 * but rebooted and is now using a different port 583 */ 584 bindsin.sin_addr = ypdb->dom_server_addr.sin_addr; 585 if (sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bindsin, 586 sizeof bindsin) < 0) 587 perror("sendto"); 588 } 589 /* find all networks and send the RPC packet out them all */ 590 if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { 591 perror("socket"); 592 return -1; 593 } 594 595 ifc.ifc_len = sizeof inbuf; 596 ifc.ifc_buf = inbuf; 597 if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) { 598 close(sock); 599 perror("ioctl(SIOCGIFCONF)"); 600 return -1; 601 } 602 ifr = ifc.ifc_req; 603 ifreq.ifr_name[0] = '\0'; 604 for (i = 0; i < ifc.ifc_len; i += len, ifr = (struct ifreq *)((caddr_t)ifr + len)) { 605 #if defined(BSD) && BSD >= 199103 606 len = sizeof ifr->ifr_name + ifr->ifr_addr.sa_len; 607 #else 608 len = sizeof ifc.ifc_len / sizeof(struct ifreq); 609 #endif 610 ifreq = *ifr; 611 if (ifreq.ifr_addr.sa_family != AF_INET) 612 continue; 613 if (ioctl(sock, SIOCGIFFLAGS, &ifreq) < 0) { 614 perror("ioctl(SIOCGIFFLAGS)"); 615 continue; 616 } 617 if ((ifreq.ifr_flags & IFF_UP) == 0) 618 continue; 619 620 ifreq.ifr_flags &= (IFF_LOOPBACK | IFF_BROADCAST); 621 if (ifreq.ifr_flags == IFF_BROADCAST) { 622 if (ioctl(sock, SIOCGIFBRDADDR, &ifreq) < 0) { 623 perror("ioctl(SIOCGIFBRDADDR)"); 624 continue; 625 } 626 } else if (ifreq.ifr_flags == IFF_LOOPBACK) { 627 if (ioctl(sock, SIOCGIFADDR, &ifreq) < 0) { 628 perror("ioctl(SIOCGIFADDR)"); 629 continue; 630 } 631 } else 632 continue; 633 634 in = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr; 635 bindsin.sin_addr = in; 636 if (sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bindsin, 637 sizeof bindsin) < 0) 638 perror("sendto"); 639 } 640 close(sock); 641 return 0; 642 } 643 644 /*enum clnt_stat*/ 645 handle_replies() 646 { 647 char buf[1400]; 648 int fromlen, inlen; 649 struct _dom_binding *ypdb; 650 struct sockaddr_in raddr; 651 struct rpc_msg msg; 652 XDR xdr; 653 654 recv_again: 655 memset(&xdr, 0, sizeof(xdr)); 656 memset(&msg, 0, sizeof(msg)); 657 msg.acpted_rply.ar_verf = _null_auth; 658 msg.acpted_rply.ar_results.where = (caddr_t)&rmtcr; 659 msg.acpted_rply.ar_results.proc = xdr_rmtcallres; 660 661 try_again: 662 fromlen = sizeof (struct sockaddr); 663 inlen = recvfrom(rpcsock, buf, sizeof buf, 0, 664 (struct sockaddr *)&raddr, &fromlen); 665 if (inlen < 0) { 666 if (errno == EINTR) 667 goto try_again; 668 return RPC_CANTRECV; 669 } 670 if (inlen < sizeof(u_int32_t)) 671 goto recv_again; 672 673 /* 674 * see if reply transaction id matches sent id. 675 * If so, decode the results. 676 */ 677 xdrmem_create(&xdr, buf, (u_int)inlen, XDR_DECODE); 678 if (xdr_replymsg(&xdr, &msg)) { 679 if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) && 680 (msg.acpted_rply.ar_stat == SUCCESS)) { 681 raddr.sin_port = htons((u_short)rmtcr_port); 682 ypdb = xid2ypdb(msg.rm_xid); 683 if (ypdb != NULL) 684 rpc_received(ypdb->dom_domain, &raddr, 0); 685 } 686 } 687 xdr.x_op = XDR_FREE; 688 msg.acpted_rply.ar_results.proc = xdr_void; 689 xdr_destroy(&xdr); 690 691 return RPC_SUCCESS; 692 } 693 694 /*enum clnt_stat*/ 695 handle_ping() 696 { 697 char buf[1400]; 698 int fromlen, inlen; 699 struct _dom_binding *ypdb; 700 struct sockaddr_in raddr; 701 struct rpc_msg msg; 702 XDR xdr; 703 bool_t res; 704 705 recv_again: 706 memset(&xdr, 0, sizeof(xdr)); 707 memset(&msg, 0, sizeof(msg)); 708 msg.acpted_rply.ar_verf = _null_auth; 709 msg.acpted_rply.ar_results.where = (caddr_t)&res; 710 msg.acpted_rply.ar_results.proc = xdr_bool; 711 712 try_again: 713 fromlen = sizeof (struct sockaddr); 714 inlen = recvfrom(pingsock, buf, sizeof buf, 0, 715 (struct sockaddr *)&raddr, &fromlen); 716 if (inlen < 0) { 717 if (errno == EINTR) 718 goto try_again; 719 return RPC_CANTRECV; 720 } 721 if (inlen < sizeof(u_int32_t)) 722 goto recv_again; 723 724 /* 725 * see if reply transaction id matches sent id. 726 * If so, decode the results. 727 */ 728 xdrmem_create(&xdr, buf, (u_int)inlen, XDR_DECODE); 729 if (xdr_replymsg(&xdr, &msg)) { 730 if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) && 731 (msg.acpted_rply.ar_stat == SUCCESS)) { 732 ypdb = xid2ypdb(msg.rm_xid); 733 if (ypdb != NULL) 734 rpc_received(ypdb->dom_domain, &raddr, 0); 735 } 736 } 737 xdr.x_op = XDR_FREE; 738 msg.acpted_rply.ar_results.proc = xdr_void; 739 xdr_destroy(&xdr); 740 741 return RPC_SUCCESS; 742 } 743 744 /* 745 * LOOPBACK IS MORE IMPORTANT: PUT IN HACK 746 */ 747 rpc_received(dom, raddrp, force) 748 char *dom; 749 struct sockaddr_in *raddrp; 750 int force; 751 { 752 struct _dom_binding *ypdb; 753 struct iovec iov[2]; 754 struct ypbind_resp ybr; 755 char path[MAXPATHLEN]; 756 int fd; 757 758 /*printf("returned from %s about %s\n", inet_ntoa(raddrp->sin_addr), dom);*/ 759 760 if (dom == NULL) 761 return; 762 763 for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext) 764 if (!strcmp(ypdb->dom_domain, dom)) 765 break; 766 767 if (ypdb == NULL) { 768 if (force == 0) 769 return; 770 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 771 memset(ypdb, 0, sizeof *ypdb); 772 strncpy(ypdb->dom_domain, dom, sizeof ypdb->dom_domain); 773 ypdb->dom_lockfd = -1; 774 ypdb->dom_pnext = ypbindlist; 775 ypbindlist = ypdb; 776 } 777 778 /* soft update, alive */ 779 if (ypdb->dom_alive == 1 && force == 0) { 780 if (!memcmp(&ypdb->dom_server_addr, raddrp, 781 sizeof ypdb->dom_server_addr)) { 782 ypdb->dom_alive = 1; 783 ypdb->dom_check_t = time(NULL) + 60; /* recheck binding in 60 sec */ 784 } 785 return; 786 } 787 788 memcpy(&ypdb->dom_server_addr, raddrp, sizeof ypdb->dom_server_addr); 789 ypdb->dom_check_t = time(NULL) + 60; /* recheck binding in 60 seconds */ 790 ypdb->dom_vers = YPVERS; 791 ypdb->dom_alive = 1; 792 793 if (ypdb->dom_lockfd != -1) 794 close(ypdb->dom_lockfd); 795 796 sprintf(path, "%s/%s.%d", BINDINGDIR, 797 ypdb->dom_domain, ypdb->dom_vers); 798 #ifdef O_SHLOCK 799 if ((fd = open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) { 800 (void)mkdir(BINDINGDIR, 0755); 801 if ((fd = open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) 802 return; 803 } 804 #else 805 if ((fd = open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) { 806 (void)mkdir(BINDINGDIR, 0755); 807 if ((fd = open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) 808 return; 809 } 810 flock(fd, LOCK_SH); 811 #endif 812 813 /* 814 * ok, if BINDINGDIR exists, and we can create the binding file, 815 * then write to it.. 816 */ 817 ypdb->dom_lockfd = fd; 818 819 iov[0].iov_base = (caddr_t)&(udptransp->xp_port); 820 iov[0].iov_len = sizeof udptransp->xp_port; 821 iov[1].iov_base = (caddr_t)&ybr; 822 iov[1].iov_len = sizeof ybr; 823 824 memset(&ybr, 0, sizeof ybr); 825 ybr.ypbind_status = YPBIND_SUCC_VAL; 826 ybr.ypbind_respbody.ypbind_bindinfo.ypbind_binding_addr = raddrp->sin_addr; 827 ybr.ypbind_respbody.ypbind_bindinfo.ypbind_binding_port = raddrp->sin_port; 828 829 if (writev(ypdb->dom_lockfd, iov, 2) != iov[0].iov_len + iov[1].iov_len) { 830 perror("write"); 831 close(ypdb->dom_lockfd); 832 unlink(path); 833 ypdb->dom_lockfd = -1; 834 return; 835 } 836 } 837 838 struct _dom_binding * 839 xid2ypdb(xid) 840 int xid; 841 { 842 struct _dom_binding *ypdb; 843 844 for (ypdb = ypbindlist; ypdb; ypdb = ypdb->dom_pnext) 845 if (ypdb->dom_xid == xid) 846 break; 847 return (ypdb); 848 } 849 850 int 851 unique_xid(ypdb) 852 struct _dom_binding *ypdb; 853 { 854 int tmp_xid; 855 856 tmp_xid = (long)ypdb & 0xffffffff; 857 while (xid2ypdb(tmp_xid) != NULL) 858 tmp_xid++; 859 860 return tmp_xid; 861 } 862
Indexes created Tue Sep 30 20:09:53 GMT 2025