ypbind.c revision 1.8
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.8 1994/07/01 19:40:23 deraadt 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 <errno.h> 48 #include <ctype.h> 49 #include <dirent.h> 50 #include <netdb.h> 51 #include <string.h> 52 #include <rpc/rpc.h> 53 #include <rpc/xdr.h> 54 #include <net/if.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 <rpcsvc/yp_prot.h> 61 #include <rpcsvc/ypclnt.h> 62 63 #ifndef BINDINGDIR 64 #define BINDINGDIR "/var/yp/binding" 65 #endif 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 int dom_lockfd; 77 int dom_alive; 78 }; 79 80 extern bool_t xdr_domainname(), xdr_ypbind_resp(); 81 extern bool_t xdr_ypreq_key(), xdr_ypresp_val(); 82 extern bool_t xdr_ypbind_setdom(); 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; 95 struct rmtcallargs rmtca; 96 struct rmtcallres rmtcr; 97 char rmtcr_outval; 98 u_long rmtcr_port; 99 SVCXPRT *udptransp, *tcptransp; 100 101 void * 102 ypbindproc_null_2(transp, argp, clnt) 103 SVCXPRT *transp; 104 void *argp; 105 CLIENT *clnt; 106 { 107 static char res; 108 109 bzero((char *)&res, sizeof(res)); 110 return (void *)&res; 111 } 112 113 struct ypbind_resp * 114 ypbindproc_domain_2(transp, argp, clnt) 115 SVCXPRT *transp; 116 char *argp; 117 CLIENT *clnt; 118 { 119 static struct ypbind_resp res; 120 struct _dom_binding *ypdb; 121 char path[MAXPATHLEN]; 122 123 bzero((char *)&res, sizeof res); 124 res.ypbind_status = YPBIND_FAIL_VAL; 125 126 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) 127 if( strcmp(ypdb->dom_domain, argp) == 0) 128 break; 129 130 if(ypdb==NULL) { 131 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 132 bzero((char *)ypdb, sizeof *ypdb); 133 strncpy(ypdb->dom_domain, argp, sizeof ypdb->dom_domain); 134 ypdb->dom_vers = YPVERS; 135 ypdb->dom_alive = 0; 136 ypdb->dom_lockfd = -1; 137 sprintf(path, "%s/%s.%d", BINDINGDIR, ypdb->dom_domain, ypdb->dom_vers); 138 unlink(path); 139 ypdb->dom_pnext = ypbindlist; 140 ypbindlist = ypdb; 141 check++; 142 return NULL; 143 } 144 145 if(ypdb->dom_alive==0) 146 return NULL; 147 148 #if 0 149 delta = ypdb->dom_check_t - ypdb->dom_ask_t; 150 if( !(ypdb->dom_ask_t==0 || delta > 5)) { 151 ypdb->dom_ask_t = time(NULL); 152 /* 153 * Hmm. More than 2 requests in 5 seconds have indicated that my 154 * binding is possibly incorrect. Ok, make myself unalive, and 155 * find out what the actual state is. 156 */ 157 if(ypdb->dom_lockfd!=-1) 158 close(ypdb->dom_lockfd); 159 ypdb->dom_lockfd = -1; 160 ypdb->dom_alive = 0; 161 ypdb->dom_lockfd = -1; 162 sprintf(path, "%s/%s.%d", BINDINGDIR, ypdb->dom_domain, ypdb->dom_vers); 163 unlink(path); 164 check++; 165 return NULL; 166 } 167 #endif 168 169 answer: 170 res.ypbind_status = YPBIND_SUCC_VAL; 171 res.ypbind_respbody.ypbind_bindinfo.ypbind_binding_addr.s_addr = 172 ypdb->dom_server_addr.sin_addr.s_addr; 173 res.ypbind_respbody.ypbind_bindinfo.ypbind_binding_port = 174 ypdb->dom_server_port; 175 /*printf("domain %s at %s/%d\n", ypdb->dom_domain, 176 inet_ntoa(ypdb->dom_server_addr.sin_addr), 177 ntohs(ypdb->dom_server_addr.sin_port));*/ 178 return &res; 179 } 180 181 bool_t * 182 ypbindproc_setdom_2(transp, argp, clnt) 183 SVCXPRT *transp; 184 struct ypbind_setdom *argp; 185 CLIENT *clnt; 186 { 187 struct sockaddr_in *fromsin, bindsin; 188 char res; 189 190 bzero((char *)&res, sizeof(res)); 191 fromsin = svc_getcaller(transp); 192 193 switch(ypsetmode) { 194 case YPSET_LOCAL: 195 if( fromsin->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) 196 return (void *)NULL; 197 break; 198 case YPSET_ALL: 199 break; 200 case YPSET_NO: 201 default: 202 return (void *)NULL; 203 } 204 205 if(ntohs(fromsin->sin_port) >= IPPORT_RESERVED) 206 return (void *)&res; 207 208 if(argp->ypsetdom_vers != YPVERS) 209 return (void *)&res; 210 211 bzero((char *)&bindsin, sizeof bindsin); 212 bindsin.sin_family = AF_INET; 213 bindsin.sin_addr.s_addr = argp->ypsetdom_addr.s_addr; 214 bindsin.sin_port = argp->ypsetdom_port; 215 rpc_received(argp->ypsetdom_domain, &bindsin, 1); 216 217 res = 1; 218 return (void *)&res; 219 } 220 221 static void 222 ypbindprog_2(rqstp, transp) 223 struct svc_req *rqstp; 224 register SVCXPRT *transp; 225 { 226 union { 227 char ypbindproc_domain_2_arg[MAXHOSTNAMELEN]; 228 struct ypbind_setdom ypbindproc_setdom_2_arg; 229 } argument; 230 struct authunix_parms *creds; 231 char *result; 232 bool_t (*xdr_argument)(), (*xdr_result)(); 233 char *(*local)(); 234 235 switch (rqstp->rq_proc) { 236 case YPBINDPROC_NULL: 237 xdr_argument = xdr_void; 238 xdr_result = xdr_void; 239 local = (char *(*)()) ypbindproc_null_2; 240 break; 241 242 case YPBINDPROC_DOMAIN: 243 xdr_argument = xdr_domainname; 244 xdr_result = xdr_ypbind_resp; 245 local = (char *(*)()) ypbindproc_domain_2; 246 break; 247 248 case YPBINDPROC_SETDOM: 249 switch(rqstp->rq_cred.oa_flavor) { 250 case AUTH_UNIX: 251 creds = (struct authunix_parms *)rqstp->rq_clntcred; 252 if( creds->aup_uid != 0) { 253 svcerr_auth(transp, AUTH_BADCRED); 254 return; 255 } 256 break; 257 default: 258 svcerr_auth(transp, AUTH_TOOWEAK); 259 return; 260 } 261 262 xdr_argument = xdr_ypbind_setdom; 263 xdr_result = xdr_void; 264 local = (char *(*)()) ypbindproc_setdom_2; 265 break; 266 267 default: 268 svcerr_noproc(transp); 269 return; 270 } 271 bzero((char *)&argument, sizeof(argument)); 272 if (!svc_getargs(transp, xdr_argument, &argument)) { 273 svcerr_decode(transp); 274 return; 275 } 276 result = (*local)(transp, &argument, rqstp); 277 if (result != NULL && !svc_sendreply(transp, xdr_result, result)) { 278 svcerr_systemerr(transp); 279 } 280 return; 281 } 282 283 main(argc, argv) 284 char **argv; 285 { 286 char path[MAXPATHLEN]; 287 struct timeval tv; 288 fd_set fdsr; 289 int width; 290 int i; 291 292 yp_get_default_domain(&domainname); 293 if( domainname[0] == '\0') { 294 fprintf(stderr, "domainname not set. Aborting.\n"); 295 exit(1); 296 } 297 298 for(i=1; i<argc; i++) { 299 if( strcmp("-ypset", argv[i]) == 0) 300 ypsetmode = YPSET_ALL; 301 else if (strcmp("-ypsetme", argv[i]) == 0) 302 ypsetmode = YPSET_LOCAL; 303 } 304 305 /* blow away everything in BINDINGDIR */ 306 307 308 309 #ifdef DAEMON 310 switch(fork()) { 311 case 0: 312 break; 313 case -1: 314 perror("fork"); 315 exit(1); 316 default: 317 exit(0); 318 } 319 setsid(); 320 #endif 321 322 pmap_unset(YPBINDPROG, YPBINDVERS); 323 324 udptransp = svcudp_create(RPC_ANYSOCK); 325 if (udptransp == NULL) { 326 fprintf(stderr, "cannot create udp service."); 327 exit(1); 328 } 329 if (!svc_register(udptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 330 IPPROTO_UDP)) { 331 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, udp)."); 332 exit(1); 333 } 334 335 tcptransp = svctcp_create(RPC_ANYSOCK, 0, 0); 336 if (tcptransp == NULL) { 337 fprintf(stderr, "cannot create tcp service."); 338 exit(1); 339 } 340 341 if (!svc_register(tcptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2, 342 IPPROTO_TCP)) { 343 fprintf(stderr, "unable to register (YPBINDPROG, YPBINDVERS, tcp)."); 344 exit(1); 345 } 346 347 if( (rpcsock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { 348 perror("socket"); 349 return -1; 350 } 351 352 fcntl(rpcsock, F_SETFL, fcntl(rpcsock, F_GETFL, 0) | FNDELAY); 353 i = 1; 354 setsockopt(rpcsock, SOL_SOCKET, SO_BROADCAST, &i, sizeof(i)); 355 rmtca.prog = YPPROG; 356 rmtca.vers = YPVERS; 357 rmtca.proc = YPPROC_DOMAIN_NONACK; 358 rmtca.xdr_args = NULL; /* set at call time */ 359 rmtca.args_ptr = NULL; /* set at call time */ 360 rmtcr.port_ptr = &rmtcr_port; 361 rmtcr.xdr_results = xdr_bool; 362 rmtcr.results_ptr = (caddr_t)&rmtcr_outval; 363 364 /* build initial domain binding, make it "unsuccessful" */ 365 ypbindlist = (struct _dom_binding *)malloc(sizeof *ypbindlist); 366 bzero((char *)ypbindlist, sizeof *ypbindlist); 367 strncpy(ypbindlist->dom_domain, domainname, sizeof ypbindlist->dom_domain); 368 ypbindlist->dom_vers = YPVERS; 369 ypbindlist->dom_alive = 0; 370 ypbindlist->dom_lockfd = -1; 371 sprintf(path, "%s/%s.%d", BINDINGDIR, ypbindlist->dom_domain, 372 ypbindlist->dom_vers); 373 (void)unlink(path); 374 375 width = getdtablesize(); 376 while(1) { 377 fdsr = svc_fdset; 378 FD_SET(rpcsock, &fdsr); 379 tv.tv_sec = 1; 380 tv.tv_usec = 0; 381 382 switch(select(width, &fdsr, NULL, NULL, &tv)) { 383 case 0: 384 checkwork(); 385 break; 386 case -1: 387 perror("select\n"); 388 break; 389 default: 390 if(FD_ISSET(rpcsock, &fdsr)) { 391 FD_CLR(rpcsock, &fdsr); 392 handle_replies(); 393 } 394 svc_getreqset(&fdsr); 395 if(check) 396 checkwork(); 397 break; 398 } 399 } 400 } 401 402 /* 403 * STATE EVENT ACTION NEWSTATE TIMEOUT 404 * 1 no binding timeout broadcast no binding 5 sec 405 * 2 no binding answer -- binding 60 sec 406 * 3 binding timeout check server checking 5 sec 407 * 4 checking answer -- binding 60 sec 408 * 5 checking timeout broadcast no binding 5 sec 409 */ 410 checkwork() 411 { 412 struct _dom_binding *ypdb; 413 time_t t; 414 415 check = 0; 416 417 time(&t); 418 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) { 419 if(ypdb->dom_alive!=1 || ypdb->dom_check_t < t) { 420 ping(ypdb); 421 time(&t); 422 ypdb->dom_check_t = t + 5; 423 } 424 } 425 } 426 427 ping(ypdb) 428 struct _dom_binding *ypdb; 429 { 430 char *dom = ypdb->dom_domain; 431 struct rpc_msg rpcmsg; 432 char buf[1400], inbuf[8192]; 433 enum clnt_stat st; 434 struct timeval tv; 435 int outlen, i, sock, len; 436 struct sockaddr_in bsin; 437 struct ifconf ifc; 438 struct ifreq ifreq, *ifr; 439 struct in_addr in; 440 AUTH *rpcua; 441 XDR rpcxdr; 442 443 rmtca.xdr_args = xdr_domainname; 444 rmtca.args_ptr = dom; 445 446 bzero((char *)&bsin, sizeof bsin); 447 bsin.sin_family = AF_INET; 448 bsin.sin_port = htons(PMAPPORT); 449 450 bzero((char *)&rpcxdr, sizeof rpcxdr); 451 bzero((char *)&rpcmsg, sizeof rpcmsg); 452 453 rpcua = authunix_create_default(); 454 if( rpcua == (AUTH *)NULL) { 455 /*printf("cannot get unix auth\n");*/ 456 return RPC_SYSTEMERROR; 457 } 458 rpcmsg.rm_direction = CALL; 459 rpcmsg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 460 rpcmsg.rm_call.cb_prog = PMAPPROG; 461 rpcmsg.rm_call.cb_vers = PMAPVERS; 462 rpcmsg.rm_call.cb_proc = PMAPPROC_CALLIT; 463 rpcmsg.rm_call.cb_cred = rpcua->ah_cred; 464 rpcmsg.rm_call.cb_verf = rpcua->ah_verf; 465 466 gettimeofday(&tv, (struct timezone *)0); 467 rpcmsg.rm_xid = (int)dom; 468 tv.tv_usec = 0; 469 xdrmem_create(&rpcxdr, buf, sizeof buf, XDR_ENCODE); 470 if( (!xdr_callmsg(&rpcxdr, &rpcmsg)) ) { 471 st = RPC_CANTENCODEARGS; 472 AUTH_DESTROY(rpcua); 473 return st; 474 } 475 if( (!xdr_rmtcall_args(&rpcxdr, &rmtca)) ) { 476 st = RPC_CANTENCODEARGS; 477 AUTH_DESTROY(rpcua); 478 return st; 479 } 480 outlen = (int)xdr_getpos(&rpcxdr); 481 xdr_destroy(&rpcxdr); 482 if(outlen<1) { 483 AUTH_DESTROY(rpcua); 484 return st; 485 } 486 AUTH_DESTROY(rpcua); 487 488 if (ypdb->dom_alive == 1) { 489 /* no need to broadcast, only send to my server */ 490 ypdb->dom_alive = 2; 491 if (sendto(rpcsock, buf, outlen, 0, 492 (struct sockaddr *)&ypdb->dom_server_addr, 493 sizeof ypdb->dom_server_addr) < 0) 494 perror("sendto"); 495 return 0; 496 } 497 498 ypdb->dom_alive = 0; 499 500 /* find all networks and send the RPC packet out them all */ 501 if( (sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { 502 perror("socket"); 503 return -1; 504 } 505 506 ifc.ifc_len = sizeof inbuf; 507 ifc.ifc_buf = inbuf; 508 if( ioctl(sock, SIOCGIFCONF, &ifc) < 0) { 509 close(sock); 510 perror("ioctl(SIOCGIFCONF)"); 511 return -1; 512 } 513 ifr = ifc.ifc_req; 514 ifreq.ifr_name[0] = '\0'; 515 for(i=0; i<ifc.ifc_len; i+=len, ifr=(struct ifreq *)((caddr_t)ifr+len)) { 516 #if defined(BSD) && BSD >= 199103 517 len = sizeof ifr->ifr_name + ifr->ifr_addr.sa_len; 518 #else 519 len = sizeof ifc.ifc_len / sizeof(struct ifreq); 520 #endif 521 ifreq = *ifr; 522 if( ifreq.ifr_addr.sa_family != AF_INET) 523 continue; 524 if( ioctl(sock, SIOCGIFFLAGS, &ifreq) < 0) { 525 perror("ioctl(SIOCGIFFLAGS)"); 526 continue; 527 } 528 if( (ifreq.ifr_flags & IFF_UP) == 0) 529 continue; 530 531 ifreq.ifr_flags &= (IFF_LOOPBACK | IFF_BROADCAST); 532 if( ifreq.ifr_flags==IFF_BROADCAST ) { 533 if( ioctl(sock, SIOCGIFBRDADDR, &ifreq) < 0 ) { 534 perror("ioctl(SIOCGIFBRDADDR)"); 535 continue; 536 } 537 } else if( ifreq.ifr_flags==IFF_LOOPBACK ) { 538 if( ioctl(sock, SIOCGIFADDR, &ifreq) < 0 ) { 539 perror("ioctl(SIOCGIFADDR)"); 540 continue; 541 } 542 } else 543 continue; 544 545 in = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr; 546 bsin.sin_addr = in; 547 if( sendto(rpcsock, buf, outlen, 0, (struct sockaddr *)&bsin, 548 sizeof bsin) < 0 ) 549 perror("sendto"); 550 } 551 close(sock); 552 return 0; 553 } 554 555 /*enum clnt_stat*/ 556 handle_replies() 557 { 558 char buf[1400]; 559 int fromlen, inlen; 560 struct sockaddr_in raddr; 561 struct rpc_msg msg; 562 XDR xdr; 563 564 recv_again: 565 bzero((char *)&xdr, sizeof(xdr)); 566 bzero((char *)&msg, sizeof(msg)); 567 msg.acpted_rply.ar_verf = _null_auth; 568 msg.acpted_rply.ar_results.where = (caddr_t)&rmtcr; 569 msg.acpted_rply.ar_results.proc = xdr_rmtcallres; 570 571 try_again: 572 fromlen = sizeof (struct sockaddr); 573 inlen = recvfrom(rpcsock, buf, sizeof buf, 0, 574 (struct sockaddr *)&raddr, &fromlen); 575 if(inlen<0) { 576 if(errno==EINTR) 577 goto try_again; 578 return RPC_CANTRECV; 579 } 580 if(inlen<sizeof(u_long)) 581 goto recv_again; 582 583 /* 584 * see if reply transaction id matches sent id. 585 * If so, decode the results. 586 */ 587 xdrmem_create(&xdr, buf, (u_int)inlen, XDR_DECODE); 588 if( xdr_replymsg(&xdr, &msg)) { 589 if( (msg.rm_reply.rp_stat == MSG_ACCEPTED) && 590 (msg.acpted_rply.ar_stat == SUCCESS)) { 591 raddr.sin_port = htons((u_short)rmtcr_port); 592 rpc_received(msg.rm_xid, &raddr, 0); 593 } 594 } 595 xdr.x_op = XDR_FREE; 596 msg.acpted_rply.ar_results.proc = xdr_void; 597 xdr_destroy(&xdr); 598 599 return RPC_SUCCESS; 600 } 601 602 /* 603 * LOOPBACK IS MORE IMPORTANT: PUT IN HACK 604 */ 605 rpc_received(dom, raddrp, force) 606 char *dom; 607 struct sockaddr_in *raddrp; 608 int force; 609 { 610 struct _dom_binding *ypdb; 611 struct iovec iov[2]; 612 struct ypbind_resp ybr; 613 char path[MAXPATHLEN]; 614 int fd; 615 616 /*printf("returned from %s about %s\n", inet_ntoa(raddrp->sin_addr), dom);*/ 617 618 if(dom==NULL) 619 return; 620 621 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) 622 if( strcmp(ypdb->dom_domain, dom) == 0) 623 break; 624 625 if(ypdb==NULL) { 626 if(force==0) 627 return; 628 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb); 629 bzero((char *)ypdb, sizeof *ypdb); 630 strncpy(ypdb->dom_domain, dom, sizeof ypdb->dom_domain); 631 ypdb->dom_lockfd = -1; 632 ypdb->dom_pnext = ypbindlist; 633 ypbindlist = ypdb; 634 } 635 636 /* soft update, alive */ 637 if(ypdb->dom_alive!=0 && force==0) { 638 if (bcmp((char *)raddrp, (char *)&ypdb->dom_server_addr, 639 sizeof ypdb->dom_server_addr) == 0) { 640 ypdb->dom_alive = 1; 641 /* recheck binding in 60 sec */ 642 ypdb->dom_check_t = time(NULL) + 60; 643 } 644 return; 645 } 646 647 bcopy((char *)raddrp, (char *)&ypdb->dom_server_addr, 648 sizeof ypdb->dom_server_addr); 649 ypdb->dom_check_t = time(NULL) + 60; /* recheck binding in 60 seconds */ 650 ypdb->dom_vers = YPVERS; 651 ypdb->dom_alive = 1; 652 653 if(ypdb->dom_lockfd != -1) 654 close(ypdb->dom_lockfd); 655 656 sprintf(path, "%s/%s.%d", BINDINGDIR, 657 ypdb->dom_domain, ypdb->dom_vers); 658 #ifdef O_SHLOCK 659 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) { 660 (void)mkdir(BINDINGDIR, 0755); 661 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) 662 return; 663 } 664 #else 665 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) { 666 (void)mkdir(BINDINGDIR, 0755); 667 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) 668 return; 669 } 670 flock(fd, LOCK_SH); 671 #endif 672 673 /* 674 * ok, if BINDINGDIR exists, and we can create the binding file, 675 * then write to it.. 676 */ 677 ypdb->dom_lockfd = fd; 678 679 iov[0].iov_base = (caddr_t)&(udptransp->xp_port); 680 iov[0].iov_len = sizeof udptransp->xp_port; 681 iov[1].iov_base = (caddr_t)&ybr; 682 iov[1].iov_len = sizeof ybr; 683 684 bzero(&ybr, sizeof ybr); 685 ybr.ypbind_status = YPBIND_SUCC_VAL; 686 ybr.ypbind_respbody.ypbind_bindinfo.ypbind_binding_addr = raddrp->sin_addr; 687 ybr.ypbind_respbody.ypbind_bindinfo.ypbind_binding_port = raddrp->sin_port; 688 689 if( writev(ypdb->dom_lockfd, iov, 2) != iov[0].iov_len + iov[1].iov_len) { 690 perror("write"); 691 close(ypdb->dom_lockfd); 692 ypdb->dom_lockfd = -1; 693 return; 694 } 695 } 696
Indexes created Tue Sep 30 17:09:57 GMT 2025