2 * Copyright (c) 1992/3 Theo de Raadt <deraadt@fsa.ca>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
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
31 static const char rcsid[] =
35 #include <sys/param.h>
36 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/signal.h>
40 #include <sys/socket.h>
42 #include <sys/fcntl.h>
59 #include <netinet/in.h>
60 #include <arpa/inet.h>
61 #include <rpc/pmap_clnt.h>
62 #include <rpc/pmap_prot.h>
63 #include <rpc/pmap_rmt.h>
64 #include <rpc/rpc_com.h>
65 #include <rpcsvc/yp.h>
67 #include <rpcsvc/ypclnt.h>
71 #define BINDINGDIR "/var/yp/binding"
75 #define YPBINDLOCK "/var/run/ypbind.lock"
79 struct _dom_binding *dom_pnext;
80 char dom_domain[YPMAXDOMAIN + 1];
81 struct sockaddr_in dom_server_addr;
85 int dom_broadcast_pid;
90 #define READFD ypdb->dom_pipe_fds[0]
91 #define WRITEFD ypdb->dom_pipe_fds[1]
92 #define BROADFD broad_domain->dom_pipe_fds[1]
94 extern bool_t xdr_domainname(), xdr_ypbind_resp();
95 extern bool_t xdr_ypreq_key(), xdr_ypresp_val();
96 extern bool_t xdr_ypbind_setdom();
98 void checkwork __P((void));
99 void *ypbindproc_null_2_yp __P((SVCXPRT *, void *, CLIENT *));
100 void *ypbindproc_setdom_2_yp __P((SVCXPRT *, struct ypbind_setdom *, CLIENT *));
101 void rpc_received __P((char *, struct sockaddr_in *, int ));
102 void broadcast __P((struct _dom_binding *));
103 int ping __P((struct _dom_binding *));
104 int tell_parent __P((char *, struct sockaddr_in *));
105 void handle_children __P(( struct _dom_binding * ));
106 void reaper __P((int));
107 void terminate __P((int));
108 void yp_restricted_mode __P((char *));
109 int verify __P((struct in_addr));
112 struct _dom_binding *ypbindlist;
113 static struct _dom_binding *broad_domain;
116 #define YPSET_LOCAL 1
118 int ypsetmode = YPSET_NO;
119 int ypsecuremode = 0;
123 * Special restricted mode variables: when in restricted mode, only the
124 * specified restricted_domain will be bound, and only the servers listed
125 * in restricted_addrs will be used for binding.
127 #define RESTRICTED_SERVERS 10
128 int yp_restricted = 0;
130 struct in_addr restricted_addrs[RESTRICTED_SERVERS];
132 /* No more than MAX_CHILDREN child broadcasters at a time. */
134 #define MAX_CHILDREN 5
136 /* No more than MAX_DOMAINS simultaneous domains */
138 #define MAX_DOMAINS 200
140 /* RPC timeout value */
141 #ifndef FAIL_THRESHOLD
142 #define FAIL_THRESHOLD 20
145 /* Number of times to fish for a response froma particular set of hosts */
147 #define MAX_RETRIES 30
156 SVCXPRT *udptransp, *tcptransp;
159 ypbindproc_null_2_yp(transp, argp, clnt)
166 bzero((char *)&res, sizeof(res));
171 ypbindproc_domain_2_yp(transp, argp, clnt)
176 static struct ypbind_resp res;
177 struct _dom_binding *ypdb;
178 char path[MAXPATHLEN];
180 bzero((char *)&res, sizeof res);
181 res.ypbind_status = YPBIND_FAIL_VAL;
182 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_NOSERV;
184 if (strchr(*argp, '/')) {
185 syslog(LOG_WARNING, "Domain name '%s' has embedded slash -- \
190 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) {
191 if( strcmp(ypdb->dom_domain, *argp) == 0)
197 syslog(LOG_NOTICE, "Running in restricted mode -- request to bind domain \"%s\" rejected.\n", *argp);
201 if (domains >= MAX_DOMAINS) {
202 syslog(LOG_WARNING, "domain limit (%d) exceeded",
204 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_RESC;
207 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb);
209 syslog(LOG_WARNING, "malloc: %m");
210 res.ypbind_resp_u.ypbind_error = YPBIND_ERR_RESC;
213 bzero((char *)ypdb, sizeof *ypdb);
214 strncpy(ypdb->dom_domain, *argp, sizeof ypdb->dom_domain);
215 ypdb->dom_vers = YPVERS;
217 ypdb->dom_default = 0;
218 ypdb->dom_lockfd = -1;
219 sprintf(path, "%s/%s.%ld", BINDINGDIR,
220 ypdb->dom_domain, ypdb->dom_vers);
222 ypdb->dom_pnext = ypbindlist;
231 res.ypbind_status = YPBIND_SUCC_VAL;
232 res.ypbind_resp_u.ypbind_error = 0; /* Success */
233 *(u_int32_t *)&res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr =
234 ypdb->dom_server_addr.sin_addr.s_addr;
235 *(u_short *)&res.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port =
236 ypdb->dom_server_addr.sin_port;
237 /*printf("domain %s at %s/%d\n", ypdb->dom_domain,
238 inet_ntoa(ypdb->dom_server_addr.sin_addr),
239 ntohs(ypdb->dom_server_addr.sin_port));*/
244 ypbindproc_setdom_2_yp(transp, argp, clnt)
249 struct sockaddr_in *fromsin, bindsin;
250 static char *result = NULL;
252 if (strchr(argp->ypsetdom_domain, '/')) {
253 syslog(LOG_WARNING, "Domain name '%s' has embedded slash -- \
254 rejecting.", argp->ypsetdom_domain);
257 fromsin = svc_getcaller(transp);
261 if( fromsin->sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
262 svcerr_noprog(transp);
270 svcerr_noprog(transp);
274 if(ntohs(fromsin->sin_port) >= IPPORT_RESERVED) {
275 svcerr_noprog(transp);
279 if(argp->ypsetdom_vers != YPVERS) {
280 svcerr_noprog(transp);
284 bzero((char *)&bindsin, sizeof bindsin);
285 bindsin.sin_family = AF_INET;
286 bindsin.sin_addr.s_addr = *(u_int32_t *)argp->ypsetdom_binding.ypbind_binding_addr;
287 bindsin.sin_port = *(u_short *)argp->ypsetdom_binding.ypbind_binding_port;
288 rpc_received(argp->ypsetdom_domain, &bindsin, 1);
290 return((void *) &result);
294 ypbindprog_2(rqstp, transp)
295 struct svc_req *rqstp;
296 register SVCXPRT *transp;
299 domainname ypbindproc_domain_2_arg;
300 struct ypbind_setdom ypbindproc_setdom_2_arg;
302 struct authunix_parms *creds;
304 bool_t (*xdr_argument)(), (*xdr_result)();
307 switch (rqstp->rq_proc) {
308 case YPBINDPROC_NULL:
309 xdr_argument = xdr_void;
310 xdr_result = xdr_void;
311 local = (char *(*)()) ypbindproc_null_2_yp;
314 case YPBINDPROC_DOMAIN:
315 xdr_argument = xdr_domainname;
316 xdr_result = xdr_ypbind_resp;
317 local = (char *(*)()) ypbindproc_domain_2_yp;
320 case YPBINDPROC_SETDOM:
321 switch(rqstp->rq_cred.oa_flavor) {
323 creds = (struct authunix_parms *)rqstp->rq_clntcred;
324 if( creds->aup_uid != 0) {
325 svcerr_auth(transp, AUTH_BADCRED);
330 svcerr_auth(transp, AUTH_TOOWEAK);
334 xdr_argument = xdr_ypbind_setdom;
335 xdr_result = xdr_void;
336 local = (char *(*)()) ypbindproc_setdom_2_yp;
340 svcerr_noproc(transp);
343 bzero((char *)&argument, sizeof(argument));
344 if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) {
345 svcerr_decode(transp);
348 result = (*local)(transp, &argument, rqstp);
349 if (result != NULL && !svc_sendreply(transp, xdr_result, result)) {
350 svcerr_systemerr(transp);
355 /* Jack the reaper */
361 while(wait3(&st, WNOHANG, NULL) > 0)
368 struct _dom_binding *ypdb;
369 char path[MAXPATHLEN];
371 if (ppid != getpid())
374 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) {
375 close(ypdb->dom_lockfd);
376 if (ypdb->dom_broadcast_pid)
377 kill(ypdb->dom_broadcast_pid, SIGINT);
378 sprintf(path, "%s/%s.%ld", BINDINGDIR,
379 ypdb->dom_domain, ypdb->dom_vers);
384 pmap_unset(YPBINDPROG, YPBINDVERS);
397 struct _dom_binding *ypdb;
399 /* Check that another ypbind isn't already running. */
400 if ((yplockfd = (open(YPBINDLOCK, O_RDONLY|O_CREAT, 0444))) == -1)
401 err(1, "%s", YPBINDLOCK);
403 if(flock(yplockfd, LOCK_EX|LOCK_NB) == -1 && errno == EWOULDBLOCK)
404 errx(1, "another ypbind is already running. Aborting");
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 errx(1, "domainname not set. Aborting");
411 for(i=1; i<argc; i++) {
412 if( strcmp("-ypset", argv[i]) == 0)
413 ypsetmode = YPSET_ALL;
414 else if (strcmp("-ypsetme", argv[i]) == 0)
415 ypsetmode = YPSET_LOCAL;
416 else if (strcmp("-s", argv[i]) == 0)
418 else if (strcmp("-S", argv[i]) == 0 && argc > i)
419 yp_restricted_mode(argv[i+1]);
420 else if (strcmp("-m", argv[i]) == 0)
424 /* blow away everything in BINDINGDIR (if it exists) */
426 if ((dird = opendir(BINDINGDIR)) != NULL) {
427 char path[MAXPATHLEN];
428 while ((dirp = readdir(dird)) != NULL)
429 if (strcmp(dirp->d_name, ".") &&
430 strcmp(dirp->d_name, "..")) {
431 sprintf(path,"%s/%s",BINDINGDIR,dirp->d_name);
442 pmap_unset(YPBINDPROG, YPBINDVERS);
444 udptransp = svcudp_create(RPC_ANYSOCK);
445 if (udptransp == NULL)
446 errx(1, "cannot create udp service");
447 if (!svc_register(udptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2,
449 errx(1, "unable to register (YPBINDPROG, YPBINDVERS, udp)");
451 tcptransp = svctcp_create(RPC_ANYSOCK, 0, 0);
452 if (tcptransp == NULL)
453 errx(1, "cannot create tcp service");
455 if (!svc_register(tcptransp, YPBINDPROG, YPBINDVERS, ypbindprog_2,
457 errx(1, "unable to register (YPBINDPROG, YPBINDVERS, tcp)");
459 /* build initial domain binding, make it "unsuccessful" */
460 ypbindlist = (struct _dom_binding *)malloc(sizeof *ypbindlist);
461 if (ypbindlist == NULL)
463 bzero((char *)ypbindlist, sizeof *ypbindlist);
464 strncpy(ypbindlist->dom_domain, domain_name, sizeof ypbindlist->dom_domain);
465 ypbindlist->dom_vers = YPVERS;
466 ypbindlist->dom_alive = 0;
467 ypbindlist->dom_lockfd = -1;
468 ypbindlist->dom_default = 1;
471 signal(SIGCHLD, reaper);
472 signal(SIGTERM, terminate);
474 ppid = getpid(); /* Remember who we are. */
476 openlog(argv[0], LOG_PID, LOG_DAEMON);
478 /* Kick off the default domain */
479 broadcast(ypbindlist);
487 switch(select(_rpc_dtablesize(), &fdsr, NULL, NULL, &tv)) {
493 syslog(LOG_WARNING, "select: %m");
496 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) {
497 if (READFD > 0 && FD_ISSET(READFD, &fdsr)) {
498 handle_children(ypdb);
499 if (children == (MAX_CHILDREN - 1))
503 svc_getreqset(&fdsr);
515 struct _dom_binding *ypdb;
517 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext)
521 /* The clnt_broadcast() callback mechanism sucks. */
524 * Receive results from broadcaster. Don't worry about passing
525 * bogus info to rpc_received() -- it can handle it. Note that we
526 * must be sure to invalidate the dom_pipe_fds descriptors here:
527 * since descriptors can be re-used, we have to make sure we
528 * don't mistake one of the RPC descriptors for one of the pipes.
529 * What's weird is that forgetting to invalidate the pipe descriptors
530 * doesn't always result in an error (otherwise I would have caught
531 * the mistake much sooner), even though logically it should.
533 void handle_children(ypdb)
534 struct _dom_binding *ypdb;
536 char buf[YPMAXDOMAIN + 1];
537 struct sockaddr_in addr;
539 struct _dom_binding *y, *prev = NULL;
540 char path[MAXPATHLEN];
542 if ((d = read(READFD, &buf, sizeof(buf))) <= 0)
543 syslog(LOG_WARNING, "could not read from child: %m");
545 if ((a = read(READFD, &addr, sizeof(struct sockaddr_in))) < 0)
546 syslog(LOG_WARNING, "could not read from child: %m");
549 FD_CLR(READFD, &fdsr);
550 FD_CLR(READFD, &svc_fdset);
551 READFD = WRITEFD = -1;
553 rpc_received((char *)&buf, &addr, 0);
555 for(y=ypbindlist; y; y=y->dom_pnext) {
560 switch(ypdb->dom_default) {
563 ypbindlist = y->dom_pnext;
565 prev->dom_pnext = y->dom_pnext;
566 sprintf(path, "%s/%s.%ld", BINDINGDIR,
567 ypdb->dom_domain, YPVERS);
568 close(ypdb->dom_lockfd);
574 ypdb->dom_broadcast_pid = 0;
587 * Send our dying words back to our parent before we perish.
590 tell_parent(dom, addr)
592 struct sockaddr_in *addr;
594 char buf[YPMAXDOMAIN + 1];
595 struct timeval timeout;
601 sprintf(buf, "%s", broad_domain->dom_domain);
602 if (write(BROADFD, &buf, sizeof(buf)) < 0)
606 * Stay in sync with parent: wait for it to read our first
607 * message before sending the second.
611 FD_SET(BROADFD, &fds);
612 if (select(FD_SETSIZE, NULL, &fds, NULL, &timeout) == -1)
614 if (FD_ISSET(BROADFD, &fds)) {
615 if (write(BROADFD, addr, sizeof(struct sockaddr_in)) < 0)
625 bool_t broadcast_result(out, addr)
627 struct sockaddr_in *addr;
629 if (retries >= MAX_RETRIES) {
630 bzero((char *)addr, sizeof(struct sockaddr_in));
631 if (tell_parent(broad_domain->dom_domain, addr))
632 syslog(LOG_WARNING, "lost connection to parent");
636 if (yp_restricted && verify(addr->sin_addr)) {
638 syslog(LOG_NOTICE, "NIS server at %s not in restricted mode access list -- rejecting.\n",inet_ntoa(addr->sin_addr));
641 if (tell_parent(broad_domain->dom_domain, addr))
642 syslog(LOG_WARNING, "lost connection to parent");
648 * The right way to send RPC broadcasts.
649 * Use the clnt_broadcast() RPC service. Unfortunately, clnt_broadcast()
650 * blocks while waiting for replies, so we have to fork off seperate
651 * broadcaster processes that do the waiting and then transmit their
652 * results back to the parent for processing. We also have to remember
653 * to save the name of the domain we're trying to bind in a global
654 * variable since clnt_broadcast() provides no way to pass things to
655 * the 'eachresult' callback function.
659 struct _dom_binding *ypdb;
664 if (children >= MAX_CHILDREN || ypdb->dom_broadcast_pid)
667 if (pipe(ypdb->dom_pipe_fds) < 0) {
668 syslog(LOG_WARNING, "pipe: %m");
672 if (ypdb->dom_vers == -1 && (long)ypdb->dom_server_addr.sin_addr.s_addr)
673 syslog(LOG_WARNING, "NIS server [%s] for domain \"%s\" not responding",
674 inet_ntoa(ypdb->dom_server_addr.sin_addr), ypdb->dom_domain);
677 flock(ypdb->dom_lockfd, LOCK_UN);
679 switch((ypdb->dom_broadcast_pid = fork())) {
682 signal(SIGCHLD, SIG_DFL);
683 signal(SIGTERM, SIG_DFL);
686 syslog(LOG_WARNING, "fork: %m");
692 FD_SET(READFD, &svc_fdset);
697 /* Release all locks before doing anything else. */
699 close(ypbindlist->dom_lockfd);
700 ypbindlist = ypbindlist->dom_pnext;
705 * Special 'many-cast' behavior. If we're in restricted mode,
706 * we have a list of possible server addresses to try. What
707 * we can do is transmit to each ypserv's YPPROC_DOMAIN_NONACK
708 * procedure and time the replies. Whoever replies fastest
709 * gets to be our server. Note that this is not a broadcast
710 * operation: we transmit uni-cast datagrams only.
712 if (yp_restricted && yp_manycast) {
715 struct sockaddr_in sin;
717 i = __yp_ping(restricted_addrs, yp_restricted,
718 ypdb->dom_domain, &port);
720 bzero((char *)&ypdb->dom_server_addr,
721 sizeof(struct sockaddr_in));
722 if (tell_parent(ypdb->dom_domain,
723 &ypdb->dom_server_addr))
724 syslog(LOG_WARNING, "lost connection to parent");
726 bzero((char *)&sin, sizeof(struct sockaddr_in));
727 bcopy((char *)&restricted_addrs[i],
728 (char *)&sin.sin_addr, sizeof(struct in_addr));
729 sin.sin_family = AF_INET;
731 if (tell_parent(broad_domain->dom_domain, &sin))
733 "lost connection to parent");
743 ptr = (char *)&ypdb->dom_domain;
744 stat = clnt_broadcast(YPPROG, YPVERS, YPPROC_DOMAIN_NONACK,
745 xdr_domainname, (char *)&ptr, xdr_bool, (char *)&out,
749 if (stat != RPC_SUCCESS) {
750 bzero((char *)&ypdb->dom_server_addr,
751 sizeof(struct sockaddr_in));
752 if (tell_parent(ypdb->dom_domain, &ypdb->dom_server_addr))
753 syslog(LOG_WARNING, "lost connection to parent");
760 * The right way to check if a server is alive.
761 * Attempt to get a client handle pointing to the server and send a
762 * YPPROC_DOMAIN. If we can't get a handle or we get a reply of FALSE,
763 * we invalidate this binding entry and send out a broadcast to try to
764 * establish a new binding. Note that we treat non-default domains
765 * specially: once bound, we keep tabs on our server, but if it
766 * goes away and fails to respond after one round of broadcasting, we
767 * abandon it until a client specifically references it again. We make
768 * every effort to keep our default domain bound, however, since we
769 * need it to keep the system on its feet.
773 struct _dom_binding *ypdb;
776 struct timeval interval, timeout;
778 int rpcsock = RPC_ANYSOCK;
779 CLIENT *client_handle;
781 interval.tv_sec = FAIL_THRESHOLD;
782 interval.tv_usec = 0;
783 timeout.tv_sec = FAIL_THRESHOLD;
786 if (ypdb->dom_broadcast_pid)
789 if ((client_handle = clntudp_bufcreate(&ypdb->dom_server_addr,
790 YPPROG, YPVERS, interval, &rpcsock, RPCSMALLMSGSIZE,
791 RPCSMALLMSGSIZE)) == (CLIENT *)NULL) {
792 /* Can't get a handle: we're dead. */
802 ptr = (char *)&ypdb->dom_domain;
804 if ((stat = clnt_call(client_handle, YPPROC_DOMAIN,
805 xdr_domainname, (char *)&ptr, xdr_bool, (char *)&out,
806 timeout)) != RPC_SUCCESS || out == FALSE) {
809 clnt_destroy(client_handle);
815 clnt_destroy(client_handle);
819 void rpc_received(dom, raddrp, force)
821 struct sockaddr_in *raddrp;
824 struct _dom_binding *ypdb, *prev = NULL;
826 struct ypbind_resp ybr;
827 char path[MAXPATHLEN];
830 /*printf("returned from %s/%d about %s\n", inet_ntoa(raddrp->sin_addr),
831 ntohs(raddrp->sin_port), dom);*/
836 for(ypdb=ypbindlist; ypdb; ypdb=ypdb->dom_pnext) {
837 if( strcmp(ypdb->dom_domain, dom) == 0)
843 if (ypdb->dom_broadcast_pid) {
844 kill(ypdb->dom_broadcast_pid, SIGINT);
846 FD_CLR(READFD, &fdsr);
847 FD_CLR(READFD, &svc_fdset);
848 READFD = WRITEFD = -1;
852 /* if in secure mode, check originating port number */
853 if ((ypsecuremode && (ntohs(raddrp->sin_port) >= IPPORT_RESERVED))) {
854 syslog(LOG_WARNING, "Rejected NIS server on [%s/%d] for domain %s.",
855 inet_ntoa(raddrp->sin_addr), ntohs(raddrp->sin_port),
858 ypdb->dom_broadcast_pid = 0;
864 if (raddrp->sin_addr.s_addr == (long)0) {
865 switch(ypdb->dom_default) {
868 ypbindlist = ypdb->dom_pnext;
870 prev->dom_pnext = ypdb->dom_pnext;
871 sprintf(path, "%s/%s.%ld", BINDINGDIR,
872 ypdb->dom_domain, YPVERS);
873 close(ypdb->dom_lockfd);
879 ypdb->dom_broadcast_pid = 0;
891 ypdb = (struct _dom_binding *)malloc(sizeof *ypdb);
893 syslog(LOG_WARNING, "malloc: %m");
896 bzero((char *)ypdb, sizeof *ypdb);
897 strncpy(ypdb->dom_domain, dom, sizeof ypdb->dom_domain);
898 ypdb->dom_lockfd = -1;
899 ypdb->dom_default = 0;
900 ypdb->dom_pnext = ypbindlist;
904 /* We've recovered from a crash: inform the world. */
905 if (ypdb->dom_vers == -1 && ypdb->dom_server_addr.sin_addr.s_addr)
906 syslog(LOG_WARNING, "NIS server [%s] for domain \"%s\" OK",
907 inet_ntoa(raddrp->sin_addr), ypdb->dom_domain);
909 bcopy((char *)raddrp, (char *)&ypdb->dom_server_addr,
910 sizeof ypdb->dom_server_addr);
912 ypdb->dom_vers = YPVERS;
914 ypdb->dom_broadcast_pid = 0;
916 if(ypdb->dom_lockfd != -1)
917 close(ypdb->dom_lockfd);
919 sprintf(path, "%s/%s.%ld", BINDINGDIR,
920 ypdb->dom_domain, ypdb->dom_vers);
922 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1) {
923 (void)mkdir(BINDINGDIR, 0755);
924 if( (fd=open(path, O_CREAT|O_SHLOCK|O_RDWR|O_TRUNC, 0644)) == -1)
928 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1) {
929 (void)mkdir(BINDINGDIR, 0755);
930 if( (fd=open(path, O_CREAT|O_RDWR|O_TRUNC, 0644)) == -1)
937 * ok, if BINDINGDIR exists, and we can create the binding file,
940 ypdb->dom_lockfd = fd;
942 iov[0].iov_base = (caddr_t)&(udptransp->xp_port);
943 iov[0].iov_len = sizeof udptransp->xp_port;
944 iov[1].iov_base = (caddr_t)&ybr;
945 iov[1].iov_len = sizeof ybr;
947 bzero(&ybr, sizeof ybr);
948 ybr.ypbind_status = YPBIND_SUCC_VAL;
949 *(u_int32_t *)&ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_addr = raddrp->sin_addr.s_addr;
950 *(u_short *)&ybr.ypbind_resp_u.ypbind_bindinfo.ypbind_binding_port = raddrp->sin_port;
952 if( writev(ypdb->dom_lockfd, iov, 2) != iov[0].iov_len + iov[1].iov_len) {
953 syslog(LOG_WARNING, "write: %m");
954 close(ypdb->dom_lockfd);
955 ypdb->dom_lockfd = -1;
961 * Check address against list of allowed servers. Return 0 if okay,
970 for (i = 0; i < RESTRICTED_SERVERS; i++)
971 if (!bcmp((char *)&addr, (char *)&restricted_addrs[i],
972 sizeof(struct in_addr)))
979 * Try to set restricted mode. We default to normal mode if we can't
980 * resolve the specified hostnames.
983 yp_restricted_mode(args)
990 /* Find the restricted domain. */
991 if ((s = strsep(&args, ",")) == NULL)
995 /* Get the addresses of the servers. */
996 while ((s = strsep(&args, ",")) != NULL && i < RESTRICTED_SERVERS) {
997 if ((h = gethostbyname(s)) == NULL)
999 bcopy ((char *)h->h_addr_list[0], (char *)&restricted_addrs[i],
1000 sizeof(struct in_addr));
1004 /* ypset and ypsetme not allowed with restricted mode */
1005 ypsetmode = YPSET_NO;