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