xref: /illumos-gate/usr/src/cmd/ypcmd/ypxfr.c (revision 48bbca81)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  *
22  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright (c) 2016 by Delphix. All rights reserved.
25  */
26 
27 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /*	  All Rights Reserved   */
29 
30 /*
31  * Portions of this source code were derived from Berkeley
32  * under license from the Regents of the University of
33  * California.
34  */
35 
36 /*
37  * This is a user command which gets a NIS data base from some running
38  * server, and gets it to the local site by using the normal NIS client
39  * enumeration functions.  The map is copied to a temp name, then the real
40  * map is removed and the temp map is moved to the real name.  ypxfr then
41  * sends a "YPPROC_CLEAR" message to the local server to insure that it will
42  * not hold a removed map open, so serving an obsolete version.
43  *
44  * ypxfr [ -h <host> ] [ -d <domainname> ]
45  *		[ -s <domainname> ] [-f] [-c] [-C tid prot name] map
46  *
47  * If the host is ommitted, ypxfr will attempt to discover the master by
48  * using normal NIS services.  If it can't get the record, it will use
49  * the address of the callback, if specified. If the host is specified
50  * as an internet address, no NIS services need to be locally available.
51  *
52  * If the domain is not specified, the default domain of the local machine
53  * is used.
54  *
55  * If the -f flag is used, the transfer will be done even if the master's
56  * copy is not newer than the local copy.
57  *
58  * The -c flag suppresses the YPPROC_CLEAR request to the local ypserv.  It
59  * may be used if ypserv isn't currently running to suppress the error message.
60  *
61  * The -C flag is used to pass callback information to ypxfr when it is
62  * activated by ypserv.  The callback information is used to send a
63  * yppushresp_xfr message with transaction id "tid" to a yppush process
64  * speaking a transient protocol number "prot".  The yppush program is
65  * running on the host "name".
66  *
67  * The -s option is used to specify a source domain which may be
68  * different from the destination domain, for transfer of maps
69  * that are identical in different domains (e.g. services.byname)
70  *
71  */
72 
73 #include <ndbm.h>
74 #define	DATUM
75 
76 #include <stdio.h>
77 #include <errno.h>
78 #include <time.h>
79 #include <ctype.h>
80 #include <netdb.h>
81 #include <netconfig.h>
82 #include <netdir.h>
83 #include <rpc/rpc.h>
84 #include <sys/file.h>
85 #include <sys/stat.h>
86 #include <dirent.h>
87 #include <rpcsvc/ypclnt.h>
88 #include <rpcsvc/yp_prot.h>
89 #include <unistd.h>
90 #include <stdlib.h>
91 #include <rpcsvc/nis.h>
92 #include "ypdefs.h"
93 #include "yp_b.h"
94 #include "shim.h"
95 #include "yptol.h"
96 
97 USE_YP_MASTER_NAME
98 USE_YP_SECURE
99 USE_YP_INTERDOMAIN
100 USE_YP_LAST_MODIFIED
101 USE_YPDBPATH
102 USE_DBM
103 
104 #define	PARANOID 1	/* make sure maps have the right # entries */
105 
106 #define	CALLINTER_TRY 10		/* Seconds between callback tries */
107 #define	CALLTIMEOUT CALLINTER_TRY*6	/* Total timeout for callback */
108 
109 DBM *db;
110 
111 /* ypxfr never uses N2L mode */
112 bool_t yptol_mode = FALSE;
113 
114 int	debug = FALSE;
115 int	treepush = FALSE;
116 #define	TREEPUSH 1
117 int	defwrite = TRUE;
118 
119 char *domain = NULL;
120 char *source = NULL;
121 char *map = NULL;
122 char *master = NULL;
123 char *pushhost = NULL;
124 /*
125  * The name of the xfer peer as specified as a
126  * -h option, -C name option or from querying the NIS
127  */
128 struct dom_binding master_server; /* To talk to above */
129 unsigned int master_prog_vers;	/* YPVERS (barfs at YPOLDVERS !) */
130 char *master_name = NULL;	/* Map's master as contained in the map */
131 unsigned *master_version = NULL; /* Order number as contained in the map */
132 char *master_ascii_version;	/* ASCII order number as contained in the map */
133 bool fake_master_version = FALSE;
134 /*
135  * TRUE only if there's no order number in
136  *  the map, and the user specified -f
137  */
138 bool force = FALSE;		/* TRUE iff user specified -f flag */
139 bool logging = FALSE;		/* TRUE iff no tty, but log file exists */
140 bool check_count = FALSE;	/* TRUE causes counts to be checked */
141 bool send_clear = TRUE;		/* FALSE iff user specified -c flag */
142 bool callback = FALSE;
143 /*
144  * TRUE iff -C flag set.  tid, proto and name
145  * will be set to point to the command line args.
146  */
147 bool secure_map = FALSE;	/* TRUE if there is yp_secure in the map */
148 bool interdomain_map = FALSE;
149 /*
150  * TRUE if there is yp_interdomain in either
151  * the local or the master version of the map
152  */
153 int interdomain_sz = 0;		/* Size of the interdomain value */
154 #define	UDPINTER_TRY 10		/* Seconds between tries for udp */
155 #define	UDPTIMEOUT UDPINTER_TRY*4	/* Total timeout for udp */
156 #define	CALLINTER_TRY 10	/* Seconds between callback tries */
157 #define	CALLTIMEOUT CALLINTER_TRY*6	/* Total timeout for callback */
158 struct timeval udp_timeout = { UDPTIMEOUT, 0};
159 struct timeval tcp_timeout = { 180, 0}; /* Timeout for map enumeration */
160 
161 char *interdomain_value; 	/* place to store the interdomain value */
162 char *tid;
163 char *proto;
164 int entry_count;		/* counts entries in the map */
165 char logfile[] = "/var/yp/ypxfr.log";
166 static char err_usage[] =
167 "Usage:\n\
168 ypxfr [-f] [ -h host ] [ -d domainname ]\n\
169 	[ -s domainname ] [-c] [-C tid prot servname ] map\n\n\
170 where\n\
171 	-f forces transfer even if the master's copy is not newer.\n\
172 	host is the server from where the map should be transfered\n\
173 	-d domainname is specified if other than the default domain\n\
174 	-s domainname is a source for the map that is same across domains\n\
175 	-c inhibits sending a \"Clear map\" message to the local ypserv.\n\
176 	-C is for use only by ypserv to pass callback information.\n";
177 char err_bad_args[] =
178 	"%s argument is bad.\n";
179 char err_cant_get_kname[] =
180 	"Can't get %s back from system call.\n";
181 char err_null_kname[] =
182 	"%s hasn't been set on this machine.\n";
183 char err_bad_hostname[] = "hostname";
184 char err_bad_mapname[] = "mapname";
185 char err_bad_domainname[] = "domainname";
186 char err_udp_failure[] =
187 	"Can't set up a udp connection to ypserv on host %s.\n";
188 char yptempname_prefix[] = "ypxfr_map.";
189 char ypbkupname_prefix[] = "ypxfr_bkup.";
190 
191 void get_command_line_args();
192 bool bind_to_server();
193 bool ping_server();
194 bool  get_private_recs();
195 bool get_order();
196 bool get_v1order();
197 bool get_v2order();
198 bool get_misc_recs();
199 bool get_master_name();
200 bool get_v1master_name();
201 bool get_v2master_name();
202 void find_map_master();
203 bool move_map();
204 unsigned get_local_version();
205 void mkfilename();
206 void mk_tmpname();
207 bool get_map();
208 bool add_private_entries();
209 bool new_mapfiles();
210 void del_mapfiles();
211 void set_output();
212 void logprintf();
213 bool send_ypclear();
214 void xfr_exit();
215 void send_callback();
216 int ypall_callback();
217 int map_yperr_to_pusherr();
218 extern CLIENT *__yp_clnt_create_rsvdport();
219 
220 bool_t is_yptol_mode();
221 
222 extern int errno;
223 
224 
225 /*
226  * This is the mainline for the ypxfr process.
227  */
228 
229 int
main(argc,argv)230 main(argc, argv)
231 	int argc;
232 	char **argv;
233 
234 {
235 
236 	static char default_domain_name[YPMAXDOMAIN];
237 	static unsigned big = 0xffffffff;
238 	int status;
239 
240 	set_output();
241 
242 	/*
243 	 * Inter-process lock synchronization structure. Since slave servers
244 	 * get their maps from another NIS server rather than LDAP they can
245 	 * never run in N2L mode. We thus do not have to init the update
246 	 * locking mechanism.
247 	 */
248 	if (init_lock_map() == FALSE) {
249 		exit(1);
250 	}
251 
252 	get_command_line_args(argc, argv);
253 
254 	if (!domain) {
255 
256 		if (!getdomainname(default_domain_name, YPMAXDOMAIN)) {
257 			domain = default_domain_name;
258 		} else {
259 			logprintf(err_cant_get_kname,
260 			    err_bad_domainname);
261 			xfr_exit(YPPUSH_RSRC);
262 		}
263 
264 		if (strlen(domain) == 0) {
265 			logprintf(err_null_kname,
266 			    err_bad_domainname);
267 			xfr_exit(YPPUSH_RSRC);
268 		}
269 	}
270 	if (!source)
271 		source = domain;
272 
273 	if (!master) {
274 		find_map_master();
275 	}
276 	/*
277 	 * if we were unable to get the master name, either from
278 	 * the -h option or from -C "name" option or from NIS,
279 	 * we are doomed !
280 	 */
281 	if (!master) {
282 		xfr_exit(YPPUSH_MADDR);
283 	}
284 
285 	if (!bind_to_server(master, &master_server,
286 	    &master_prog_vers, &status)) {
287 		xfr_exit(status);
288 	}
289 
290 	if (!get_private_recs(&status)) {
291 		xfr_exit(status);
292 	}
293 
294 	if (!master_version) {
295 
296 		if (force) {
297 			master_version = &big;
298 			fake_master_version = TRUE;
299 		} else {
300 			logprintf(
301 "Can't get order number for map %s from server at %s: use the -f flag.\n",
302 			    map, master);
303 			xfr_exit(YPPUSH_FORCE);
304 		}
305 	}
306 
307 	if (!move_map(&status)) {
308 		xfr_exit(status);
309 	}
310 
311 	if (send_clear && !send_ypclear(&status)) {
312 		xfr_exit(status);
313 	}
314 
315 	if (logging) {
316 		logprintf("Transferred map %s from %s (%d entries).\n",
317 		    map, master, entry_count);
318 	}
319 
320 	xfr_exit(YPPUSH_SUCC);
321 	return (0);
322 	/* NOTREACHED */
323 }
324 
325 /*
326  * This decides whether we're being run interactively or not, and, if not,
327  * whether we're supposed to be logging or not.  If we are logging, it sets
328  * up stderr to point to the log file, and sets the "logging"
329  * variable.  If there's no logging, the output goes in the bit bucket.
330  * Logging output differs from interactive output in the presence of a
331  * timestamp, present only in the log file.  stderr is reset, too, because it
332  * it's used by various library functions, including clnt_perror.
333  */
334 void
set_output()335 set_output()
336 {
337 	if (!isatty(1)) {
338 		if (access(logfile, W_OK)) {
339 			(void) freopen("/dev/null", "w", stderr);
340 		} else {
341 			(void) freopen(logfile, "a", stderr);
342 			logging = TRUE;
343 		}
344 	}
345 }
346 /*
347  * This constructs a logging record.
348  */
349 void
logprintf(arg1,arg2,arg3,arg4,arg5,arg6,arg7)350 logprintf(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
351 /*VARARGS*/
352 {
353 	struct timeval t;
354 
355 	fseek(stderr, 0, 2);
356 	if (logging) {
357 		(void) gettimeofday(&t, NULL);
358 		(void) fprintf(stderr, "%19.19s: ", ctime(&t.tv_sec));
359 	}
360 	(void) fprintf(stderr, (char *)arg1, arg2, arg3, arg4, arg5,
361 				arg6, arg7);
362 	fflush(stderr);
363 }
364 
365 /*
366  * This does the command line argument processing.
367  */
368 void
get_command_line_args(argc,argv)369 get_command_line_args(argc, argv)
370 	int argc;
371 	char **argv;
372 
373 {
374 	argv++;
375 
376 	if (argc < 2) {
377 		logprintf(err_usage);
378 		xfr_exit(YPPUSH_BADARGS);
379 	}
380 
381 	while (--argc) {
382 
383 		if ((*argv)[0] == '-') {
384 
385 			switch ((*argv)[1]) {
386 
387 			case 'f': {
388 				force = TRUE;
389 				argv++;
390 				break;
391 			}
392 
393 			case 'D': {
394 				debug = TRUE;
395 				argv++;
396 				break;
397 			}
398 
399 			case 'T': {
400 				treepush = TRUE;
401 				argv++;
402 				break;
403 			}
404 			case 'P': {
405 				check_count = TRUE;
406 				argv++;
407 				break;
408 			}
409 			case 'W': {
410 				defwrite = FALSE;
411 				argv++;
412 				break;
413 			}
414 			case 'c': {
415 				send_clear = FALSE;
416 				argv++;
417 				break;
418 			}
419 
420 			case 'h': {
421 
422 				if (argc > 1) {
423 					argv++;
424 					argc--;
425 					master = *argv;
426 					argv++;
427 
428 					if (strlen(master) > 256) {
429 						logprintf(
430 						    err_bad_args,
431 						    err_bad_hostname);
432 						xfr_exit(YPPUSH_BADARGS);
433 					}
434 
435 				} else {
436 					logprintf(err_usage);
437 					xfr_exit(YPPUSH_BADARGS);
438 				}
439 
440 				break;
441 			}
442 
443 			case 'd':
444 				if (argc > 1) {
445 					argv++;
446 					argc--;
447 					domain = *argv;
448 					argv++;
449 
450 					if (strlen(domain) > YPMAXDOMAIN) {
451 						logprintf(
452 						    err_bad_args,
453 						    err_bad_domainname);
454 						xfr_exit(YPPUSH_BADARGS);
455 					}
456 
457 				} else {
458 					logprintf(err_usage);
459 					xfr_exit(YPPUSH_BADARGS);
460 				}
461 				break;
462 
463 			case 's':
464 				if (argc > 1) {
465 					argv++;
466 					argc--;
467 					source = *argv;
468 					argv++;
469 
470 					if (strlen(source) > YPMAXDOMAIN) {
471 						logprintf(
472 						    err_bad_args,
473 						    err_bad_domainname);
474 						xfr_exit(YPPUSH_BADARGS);
475 					}
476 
477 				} else {
478 					logprintf(err_usage);
479 					xfr_exit(YPPUSH_BADARGS);
480 				}
481 				break;
482 
483 			case 'C':
484 			    if (argc > 3) {
485 				callback = TRUE;
486 				tid = *(++argv);
487 				proto = *(++argv);
488 				pushhost = *(++argv);
489 				if (strlen(pushhost) > 256) {
490 				    logprintf(err_bad_args, err_bad_hostname);
491 
492 				    xfr_exit(YPPUSH_BADARGS);
493 				}
494 				argc -= 3;
495 				argv++;
496 			    } else {
497 				logprintf(err_usage);
498 				xfr_exit(YPPUSH_BADARGS);
499 			    }
500 			    break;
501 
502 			case 'b': {
503 				interdomain_map = TRUE;
504 				interdomain_value = "";
505 				interdomain_sz = 0;
506 				argv++;
507 				break;
508 			}
509 
510 
511 			default: {
512 				logprintf(err_usage);
513 				xfr_exit(YPPUSH_BADARGS);
514 			}
515 
516 			}
517 
518 		} else {
519 
520 			if (!map) {
521 				map = *argv;
522 				argv++;
523 
524 				if (strlen(map) > YPMAXMAP) {
525 					logprintf(err_bad_args,
526 					err_bad_mapname);
527 					xfr_exit(YPPUSH_BADARGS);
528 				}
529 
530 			} else {
531 				logprintf(err_usage);
532 				xfr_exit(YPPUSH_BADARGS);
533 			}
534 		}
535 	}
536 
537 	if (!map) {
538 		logprintf(err_usage);
539 		xfr_exit(YPPUSH_BADARGS);
540 	}
541 }
542 
543 /*
544  * This tries to get the master name for the named map, from any
545  * server's version, using the vanilla NIS client interface.  If we get a
546  * name back, the global "master" gets pointed to it.
547  */
548 void
find_map_master()549 find_map_master()
550 {
551 	int err;
552 
553 	if (err = __yp_master_rsvdport(source, map, &master)) {
554 		logprintf("Can't get master of %s. Reason: %s.\n", map,
555 		    yperr_string(err));
556 	}
557 
558 	yp_unbind(source);
559 }
560 
561 #ifdef TREEPUSH
562 int
chk_treepush(name)563 chk_treepush(name)
564 char *name;
565 {
566 	char inmap[256];
567 	char inkey[256];
568 	int inkeylen;
569 	char *outval;
570 	int outvallen;
571 	int err;
572 	outval = NULL;
573 	inkey[0] = 0;
574 	strcpy(inmap, "ypslaves.");
575 	strcat(inmap, name);
576 	gethostname(inkey, 256);
577 	inkeylen = strlen(inkey);
578 
579 	err = yp_match(source, inmap, inkey, inkeylen, &outval, &outvallen);
580 	yp_unbind(source);
581 	return (err);
582 }
583 #endif
584 
585 /*
586  * This sets up a udp connection to speak the correct program and version
587  * to a NIS server.  vers is set to YPVERS, doesn't give a damn about
588  * YPOLDVERS.
589  */
590 bool
bind_to_server(host,pdomb,vers,status)591 bind_to_server(host, pdomb, vers, status)
592 	char *host;
593 	struct dom_binding *pdomb;
594 	unsigned int *vers;
595 	int *status;
596 {
597 	if (ping_server(host, pdomb, YPVERS, status)) {
598 		*vers = YPVERS;
599 		return (TRUE);
600 	} else
601 		return (FALSE);
602 }
603 
604 /*
605  * This sets up a UDP channel to a server which is assumed to speak an input
606  * version of YPPROG.  The channel is tested by pinging the server.  In all
607  * error cases except "Program Version Number Mismatch", the error is
608  * reported, and in all error cases, the client handle is destroyed and the
609  * socket associated with the channel is closed.
610  */
611 bool
ping_server(host,pdomb,vers,status)612 ping_server(host, pdomb, vers, status)
613 	char *host;
614 	struct dom_binding *pdomb;
615 	unsigned int vers;
616 	int *status;
617 {
618 	enum clnt_stat rpc_stat;
619 
620 	if ((pdomb->dom_client = __yp_clnt_create_rsvdport(host, YPPROG, vers,
621 							0, 0, 0)) != 0) {
622 
623 		/*
624 		 * if we are on a c2 system, we should only accept data
625 		 * from a server which is on a reserved port.
626 		 */
627 	/*
628 	 * NUKE this for 5.0DR.
629 	 *
630 	 *	if (issecure() &&
631 	 *	    (pdomb->dom_server_addr.sin_family != AF_INET ||
632 	 *	    pdomb->dom_server_addr.sin_port >= IPPORT_RESERVED)) {
633 	 *		clnt_destroy(pdomb->dom_client);
634 	 *		close(pdomb->dom_socket);
635 	 *		(void) logprintf("bind_to_server: \
636 	 *			server is not using a privileged port\n");
637 	 *		*status = YPPUSH_YPERR;
638 	 *		return (FALSE);
639 	 *	}
640 	 */
641 
642 		rpc_stat = clnt_call(pdomb->dom_client, YPBINDPROC_NULL,
643 		    xdr_void, 0, xdr_void, 0, udp_timeout);
644 
645 		if (rpc_stat == RPC_SUCCESS) {
646 			return (TRUE);
647 		} else {
648 			clnt_destroy(pdomb->dom_client);
649 			if (rpc_stat != RPC_PROGVERSMISMATCH) {
650 				(void) clnt_perror(pdomb->dom_client,
651 				    "ypxfr: bind_to_server clnt_call error");
652 			}
653 
654 			*status = YPPUSH_RPC;
655 			return (FALSE);
656 		}
657 	} else {
658 		logprintf("bind_to_server __clnt_create_rsvd error");
659 		(void) clnt_pcreateerror("");
660 		fflush(stderr);
661 		*status = YPPUSH_RPC;
662 		return (FALSE);
663 	}
664 }
665 
666 /*
667  * This gets values for the YP_LAST_MODIFIED and YP_MASTER_NAME keys from the
668  * master server's version of the map.  Values are held in static variables
669  * here.  In the success cases, global pointer variables are set to point at
670  * the local statics.
671  */
672 bool
get_private_recs(pushstat)673 get_private_recs(pushstat)
674 	int *pushstat;
675 {
676 	static char anumber[20];
677 	static unsigned number;
678 	static char name[YPMAXPEER + 1];
679 	int status;
680 
681 	status = 0;
682 
683 	if (get_order(anumber, &number, &status)) {
684 		master_version = &number;
685 		master_ascii_version = anumber;
686 		if (debug) fprintf(stderr,
687 			"ypxfr: Master Version is %s\n", master_ascii_version);
688 	} else {
689 
690 		if (status != 0) {
691 			*pushstat = status;
692 			if (debug) fprintf(stderr,
693 		"ypxfr: Couldn't get map's master version number, \
694 		status was %d\n", status);
695 			return (FALSE);
696 		}
697 	}
698 
699 	if (get_master_name(name, &status)) {
700 		master_name = name;
701 		if (debug) fprintf(stderr,
702 			"ypxfr: Maps master is '%s'\n", master_name);
703 	} else {
704 
705 		if (status != 0) {
706 			*pushstat = status;
707 			if (debug) fprintf(stderr,
708 		"ypxfr: Couldn't get map's master name, status was %d\n",
709 			status);
710 			return (FALSE);
711 		}
712 		master_name = master;
713 	}
714 
715 	if (debug)
716 		fprintf(stderr,
717 			"ypxfr: Getting private records from master.\n");
718 	if (get_misc_recs(&status)) {
719 		if (debug)
720 			fprintf(stderr,
721 		    "ypxfr: Masters map %s secure and %s an interdomain map.\n",
722 			(secure_map) ? "is" : "is not",
723 			(interdomain_map) ? "is" : "is not");
724 	} else {
725 		if (status != 0) {
726 			*pushstat = status;
727 			if (debug)
728 				fprintf(stderr,
729 	"ypxfr: Couldn't get state of secure and interdomain flags in map.\n");
730 			return (FALSE);
731 		}
732 	}
733 
734 	return (TRUE);
735 }
736 
737 /*
738  * This gets the map's order number from the master server
739  */
740 bool
get_order(an,n,pushstat)741 get_order(an, n, pushstat)
742 	char *an;
743 	unsigned *n;
744 	int *pushstat;
745 {
746 	if (master_prog_vers == YPVERS) {
747 		return (get_v2order(an, n, pushstat));
748 	} else
749 		return (FALSE);
750 }
751 
752 bool
get_v2order(an,n,pushstat)753 get_v2order(an, n, pushstat)
754 	char *an;
755 	unsigned *n;
756 	int *pushstat;
757 {
758 	struct ypreq_nokey req;
759 	struct ypresp_order resp;
760 	int retval;
761 
762 	req.domain = source;
763 	req.map = map;
764 
765 	/*
766 	 * Get the map''s order number, null-terminate it and store it,
767 	 * and convert it to binary and store it again.
768 	 */
769 	retval = FALSE;
770 
771 	if ((enum clnt_stat) clnt_call(master_server.dom_client,
772 	    YPPROC_ORDER, (xdrproc_t)xdr_ypreq_nokey, (char *)&req,
773 	    (xdrproc_t)xdr_ypresp_order, (char *)&resp,
774 	    udp_timeout) == RPC_SUCCESS) {
775 
776 		if (resp.status == YP_TRUE) {
777 			sprintf(an, "%d", resp.ordernum);
778 			*n = resp.ordernum;
779 			retval = TRUE;
780 		} else if (resp.status != YP_BADDB) {
781 			*pushstat = ypprot_err(resp.status);
782 
783 			if (!logging) {
784 				logprintf(
785 	"(info) Can't get order number from ypserv at %s.  Reason: %s.\n",
786 				    master, yperr_string(
787 				    ypprot_err(resp.status)));
788 			}
789 		}
790 
791 		CLNT_FREERES(master_server.dom_client,
792 			(xdrproc_t)xdr_ypresp_order,
793 		    (char *)&resp);
794 	} else {
795 		*pushstat = YPPUSH_RPC;
796 		logprintf("ypxfr(get_v2order) RPC call to %s failed", master);
797 		clnt_perror(master_server.dom_client, "");
798 	}
799 
800 	return (retval);
801 }
802 
803 /*
804  * Pick up the state of the YP_SECURE and YP_INTERDOMAIN records from the
805  * master. Only works on 4.0 V2 masters that will match a YP_ private key
806  * when asked to explicitly.
807  */
808 bool
get_misc_recs(pushstat)809 get_misc_recs(pushstat)
810 	int *pushstat;
811 {
812 	struct ypreq_key req;
813 	struct ypresp_val resp;
814 	int retval;
815 
816 	req.domain = source;
817 	req.map = map;
818 	req.keydat.dptr   = yp_secure;
819 	req.keydat.dsize  = yp_secure_sz;
820 
821 	resp.valdat.dptr = NULL;
822 	resp.valdat.dsize = 0;
823 
824 	/*
825 	 * Get the value of the IS_SECURE key in the map.
826 	 */
827 	retval = FALSE;
828 
829 	if (debug)
830 		fprintf(stderr, "ypxfr: Checking masters secure key.\n");
831 	if ((enum clnt_stat) clnt_call(master_server.dom_client,
832 	    YPPROC_MATCH, (xdrproc_t)xdr_ypreq_key, (char *)&req,
833 	(xdrproc_t)xdr_ypresp_val, (char *)&resp,
834 	    udp_timeout) == RPC_SUCCESS) {
835 		if (resp.status == YP_TRUE) {
836 			if (debug)
837 				fprintf(stderr, "ypxfr: SECURE\n");
838 			secure_map = TRUE;
839 			retval = TRUE;
840 		} else if ((resp.status != YP_NOKEY) &&
841 			    (resp.status != YP_VERS) &&
842 			    (resp.status != YP_NOMORE)) {
843 			*pushstat = ypprot_err(resp.status);
844 
845 			if (!logging) {
846 				logprintf(
847 	"(info) Can't get secure flag from ypserv at %s.  Reason: %s.\n",
848 				    master, yperr_string(
849 				    ypprot_err(resp.status)));
850 			}
851 		}
852 
853 		CLNT_FREERES(master_server.dom_client,
854 			(xdrproc_t)xdr_ypresp_val,
855 		    (char *)&resp);
856 	} else {
857 		*pushstat = YPPUSH_RPC;
858 		logprintf("ypxfr(get_misc_recs) RPC call to %s failed", master);
859 		clnt_perror(master_server.dom_client, "");
860 	}
861 
862 	if (debug)
863 		fprintf(stderr, "ypxfr: Checking masters INTERDOMAIN key.\n");
864 	req.keydat.dptr   = yp_interdomain;
865 	req.keydat.dsize  = yp_interdomain_sz;
866 
867 	resp.valdat.dptr = NULL;
868 	resp.valdat.dsize = 0;
869 
870 	/*
871 	 * Get the value of the INTERDOMAIN key in the map.
872 	 */
873 
874 	if ((enum clnt_stat) clnt_call(master_server.dom_client,
875 	    YPPROC_MATCH, (xdrproc_t)xdr_ypreq_key, (char *)&req,
876 	(xdrproc_t)xdr_ypresp_val, (char *)&resp,
877 	    udp_timeout) == RPC_SUCCESS) {
878 		if (resp.status == YP_TRUE) {
879 			if (debug)
880 				fprintf(stderr, "ypxfr: INTERDOMAIN\n");
881 			interdomain_map = TRUE;
882 			interdomain_value = (char *)malloc(resp.valdat.dsize+1);
883 			(void) memmove(interdomain_value, resp.valdat.dptr,
884 					resp.valdat.dsize);
885 			*(interdomain_value+resp.valdat.dsize) = '\0';
886 			interdomain_sz = resp.valdat.dsize;
887 			retval = TRUE;
888 		} else if ((resp.status != YP_NOKEY) &&
889 			    (resp.status != YP_VERS) &&
890 			    (resp.status != YP_NOMORE)) {
891 			*pushstat = ypprot_err(resp.status);
892 
893 			if (!logging) {
894 				logprintf(
895 	"(info) Can't get interdomain flag from ypserv at %s.  Reason: %s.\n",
896 				    master, yperr_string(
897 				    ypprot_err(resp.status)));
898 			}
899 		}
900 
901 		CLNT_FREERES(master_server.dom_client,
902 			(xdrproc_t)xdr_ypresp_val,
903 		    (char *)&resp);
904 	} else {
905 		*pushstat = YPPUSH_RPC;
906 		logprintf("ypxfr(get_misc_recs) RPC call to %s failed", master);
907 		clnt_perror(master_server.dom_client, "");
908 	}
909 
910 
911 	return (retval);
912 }
913 
914 /*
915  * This gets the map's master name from the master server
916  */
917 bool
get_master_name(name,pushstat)918 get_master_name(name, pushstat)
919 	char *name;
920 	int *pushstat;
921 {
922 	if (master_prog_vers == YPVERS) {
923 		return (get_v2master_name(name, pushstat));
924 	} else
925 		return (FALSE);
926 }
927 
928 bool
get_v2master_name(name,pushstat)929 get_v2master_name(name, pushstat)
930 	char *name;
931 	int *pushstat;
932 {
933 	struct ypreq_nokey req;
934 	struct ypresp_master resp;
935 	int retval;
936 
937 	req.domain = source;
938 	req.map = map;
939 	resp.master = NULL;
940 	retval = FALSE;
941 
942 	if ((enum clnt_stat) clnt_call(master_server.dom_client,
943 	    YPPROC_MASTER, (xdrproc_t)xdr_ypreq_nokey, (char *)&req,
944 	    (xdrproc_t)xdr_ypresp_master, (char *)&resp,
945 	    udp_timeout) == RPC_SUCCESS) {
946 
947 		if (resp.status == YP_TRUE) {
948 			strcpy(name, resp.master);
949 			retval = TRUE;
950 		} else if (resp.status != YP_BADDB) {
951 			*pushstat = ypprot_err(resp.status);
952 
953 			if (!logging) {
954 				logprintf(
955 "(info) Can't get master name from ypserv at %s. Reason: %s.\n",
956 				    master, yperr_string(
957 				    ypprot_err(resp.status)));
958 			}
959 		}
960 
961 		CLNT_FREERES(master_server.dom_client,
962 			(xdrproc_t)xdr_ypresp_master,
963 		    (char *)&resp);
964 	} else {
965 		*pushstat = YPPUSH_RPC;
966 		logprintf(
967 		    "ypxfr(get_v2master_name) RPC call to %s failed", master);
968 		clnt_perror(master_server.dom_client, "");
969 	}
970 
971 	return (retval);
972 }
973 
974 /*
975  * This does the work of transferring the map.
976  */
977 bool
move_map(pushstat)978 move_map(pushstat)
979 	int *pushstat;
980 {
981 	unsigned local_version;
982 	char map_name[MAXNAMLEN + 1];
983 	char tmp_name[MAXNAMLEN + 1];
984 	char bkup_name[MAXNAMLEN + 1];
985 	char an[11];
986 	unsigned n;
987 	datum key;
988 	datum val;
989 	int  hgstatus;
990 
991 	mkfilename(map_name);
992 
993 	if (!force) {
994 		local_version = get_local_version(map_name);
995 		if (debug) fprintf(stderr,
996 			"ypxfr: Local version of map '%s' is %d\n",
997 			map_name, local_version);
998 
999 		if (local_version >= *master_version) {
1000 			logprintf(
1001 			    "Map %s at %s is not more recent than local.\n",
1002 			    map, master);
1003 			*pushstat = YPPUSH_AGE;
1004 			return (FALSE);
1005 		}
1006 	}
1007 
1008 	mk_tmpname(yptempname_prefix, tmp_name);
1009 
1010 	if (!new_mapfiles(tmp_name)) {
1011 		logprintf(
1012 		    "Can't create temp map %s.\n", tmp_name);
1013 		*pushstat = YPPUSH_FILE;
1014 		return (FALSE);
1015 	}
1016 
1017 	if ((hgstatus = ypxfrd_getdbm(tmp_name, master, source, map)) < 0)
1018 	{
1019 	logprintf(
1020 "(info) %s %s %s ypxfrd getdbm failed (reason = %d) -- using ypxfr\n",
1021 		master, domain, map, hgstatus);
1022 
1023 	    db = dbm_open(tmp_name, O_RDWR + O_CREAT + O_TRUNC, 0644);
1024 	if (db == NULL) {
1025 		logprintf(
1026 		    "Can't dbm init temp map %s.\n", tmp_name);
1027 		del_mapfiles(tmp_name);
1028 		*pushstat = YPPUSH_DBM;
1029 		return (FALSE);
1030 	}
1031 	if (defwrite) dbm_setdefwrite(db);
1032 
1033 	if (!get_map(tmp_name, pushstat)) {
1034 		del_mapfiles(tmp_name);
1035 		return (FALSE);
1036 	}
1037 
1038 	if (!add_private_entries(tmp_name)) {
1039 		del_mapfiles(tmp_name);
1040 		*pushstat = YPPUSH_DBM;
1041 		return (FALSE);
1042 	}
1043 
1044 	/*
1045 	 * Decide whether the map just transferred is a secure map.
1046 	 * If we already know the local version was secure, we do not
1047 	 * need to check this version.
1048 	 */
1049 	if (!secure_map) {
1050 		key.dptr = yp_secure;
1051 		key.dsize = yp_secure_sz;
1052 		val = dbm_fetch(db, key);
1053 		if (val.dptr != NULL) {
1054 			secure_map = TRUE;
1055 		}
1056 	}
1057 
1058 	if (dbm_close_status(db) < 0) {
1059 		logprintf(
1060 		    "Can't do dbm close operation on temp map %s.\n",
1061 		    tmp_name);
1062 		del_mapfiles(tmp_name);
1063 		*pushstat = YPPUSH_DBM;
1064 		return (FALSE);
1065 	}
1066 
1067 	if (!get_order(an, &n, pushstat)) {
1068 		return (FALSE);
1069 	}
1070 	if (n != *master_version) {
1071 		logprintf(
1072 		    "Version skew at %s while transferring map %s.\n",
1073 		    master, map);
1074 		del_mapfiles(tmp_name);
1075 		*pushstat = YPPUSH_SKEW;
1076 		return (FALSE);
1077 	}
1078 
1079 	if (check_count)
1080 	if (!count_mismatch(tmp_name, entry_count)) {
1081 		del_mapfiles(tmp_name);
1082 		*pushstat = YPPUSH_DBM;
1083 		return (FALSE);
1084 	}
1085 	} else {
1086 	/* touch up the map */
1087 	    db = dbm_open(tmp_name, 2, 0644);
1088 	if (db == NULL) {
1089 		logprintf(
1090 		    "Can't dbm init temp map %s.\n", tmp_name);
1091 		del_mapfiles(tmp_name);
1092 		*pushstat = YPPUSH_DBM;
1093 		return (FALSE);
1094 		}
1095 
1096 
1097 	if (!add_private_entries(tmp_name)) {
1098 		del_mapfiles(tmp_name);
1099 		*pushstat = YPPUSH_DBM;
1100 		return (FALSE);
1101 	}
1102 
1103 	/*
1104 	 * Decide whether the map just transferred is a secure map.
1105 	 * If we already know the local version was secure, we do not
1106 	 * need to check this version.
1107 	 */
1108 	if (!secure_map) {
1109 		key.dptr = yp_secure;
1110 		key.dsize = yp_secure_sz;
1111 		val = dbm_fetch(db, key);
1112 		if (val.dptr != NULL) {
1113 			secure_map = TRUE;
1114 		}
1115 	}
1116 
1117 	if (dbm_close_status(db) < 0) {
1118 		logprintf(
1119 		    "Can't do dbm close operation on temp map %s.\n",
1120 		    tmp_name);
1121 		del_mapfiles(tmp_name);
1122 		*pushstat = YPPUSH_DBM;
1123 		return (FALSE);
1124 	}
1125 
1126 	}
1127 
1128 	if (lock_map(map_name) == 0) {
1129 		del_mapfiles(tmp_name);
1130 		logprintf("Lock error on %s\n", map_name);
1131 		*pushstat = YPPUSH_FILE;
1132 		return (FALSE);
1133 	}
1134 	if (!check_map_existence(map_name)) {
1135 
1136 		if (!rename_map(tmp_name, map_name, secure_map)) {
1137 			del_mapfiles(tmp_name);
1138 			logprintf(
1139 			    "Rename error:  couldn't mv %s to %s.\n",
1140 			    tmp_name, map_name);
1141 			*pushstat = YPPUSH_FILE;
1142 			unlock_map(map_name);
1143 			return (FALSE);
1144 		}
1145 
1146 	} else {
1147 		mk_tmpname(ypbkupname_prefix, bkup_name);
1148 
1149 		if (!rename_map(map_name, bkup_name, secure_map)) {
1150 			(void) rename_map(bkup_name, map_name, secure_map);
1151 			logprintf(
1152 		"Rename error:  check that old %s is still intact.\n",
1153 		map_name);
1154 			del_mapfiles(tmp_name);
1155 			*pushstat = YPPUSH_FILE;
1156 			unlock_map(map_name);
1157 			return (FALSE);
1158 		}
1159 
1160 		if (rename_map(tmp_name, map_name, secure_map)) {
1161 			del_mapfiles(bkup_name);
1162 		} else {
1163 			del_mapfiles(tmp_name);
1164 			(void) rename_map(bkup_name, map_name, secure_map);
1165 				logprintf(
1166 		"Rename error:  check that old %s is still intact.\n",
1167 			    map_name);
1168 			*pushstat = YPPUSH_FILE;
1169 			unlock_map(map_name);
1170 			return (FALSE);
1171 		}
1172 	}
1173 	if (unlock_map(map_name) == 0)
1174 		return (FALSE);
1175 
1176 	return (TRUE);
1177 }
1178 
1179 /*
1180  * This tries to get the order number out of the local version of the map.
1181  * If the attempt fails for any version, the function will return "0"
1182  */
1183 unsigned
get_local_version(name)1184 get_local_version(name)
1185 	char *name;
1186 {
1187 	datum key;
1188 	datum val;
1189 	char number[11];
1190 	DBM *db;
1191 
1192 	if (!check_map_existence(name)) {
1193 		return (0);
1194 	}
1195 	if (debug) fprintf(stderr,
1196 		"ypxfr: Map does exist, checking version now.\n");
1197 
1198 	if ((db = dbm_open(name, 0, 0)) == 0) {
1199 		return (0);
1200 	}
1201 
1202 	key.dptr = yp_last_modified;
1203 	key.dsize = yp_last_modified_sz;
1204 	val = dbm_fetch(db, key);
1205 	if (!val.dptr) {	/* Check to see if dptr is NULL */
1206 		return (0);
1207 	}
1208 	if (val.dsize == 0 || val.dsize > 10) {
1209 		return (0);
1210 	}
1211 	/* Now save this value while we have it available */
1212 	(void) memmove(number, val.dptr, val.dsize);
1213 	number[val.dsize] = '\0';
1214 
1215 	/*
1216 	 * Now check to see if it is 'secure'. If we haven't already
1217 	 * determined that it is secure in get_private_recs() then we check
1218 	 * the local map here.
1219 	 */
1220 	if (!secure_map) {
1221 		key.dptr = yp_secure;
1222 		key.dsize = yp_secure_sz;
1223 		val = dbm_fetch(db, key);
1224 		secure_map = (val.dptr != NULL);
1225 	}
1226 
1227 	/*
1228 	 * Now check to see if interdomain requests are made of the local
1229 	 * map. Keep the value around if they are.
1230 	 */
1231 	if (!interdomain_map) {
1232 		key.dptr = yp_interdomain;
1233 		key.dsize = yp_interdomain_sz;
1234 		val = dbm_fetch(db, key);
1235 		if (interdomain_map = (val.dptr != NULL)) {
1236 			interdomain_value = (char *)malloc(val.dsize+1);
1237 			(void) memmove(interdomain_value, val.dptr, val.dsize);
1238 			*(interdomain_value+val.dsize) = '\0';
1239 			interdomain_sz = val.dsize;
1240 		}
1241 	}
1242 
1243 	/* finish up */
1244 	(void) dbm_close_status(db);
1245 
1246 	return ((unsigned)atoi(number));
1247 }
1248 
1249 /*
1250  * This constructs a file name for a map, minus its dbm_dir
1251  * or dbm_pag extensions
1252  */
1253 void
mkfilename(ppath)1254 mkfilename(ppath)
1255 	char *ppath;
1256 {
1257 	bool_t yptol_mode;
1258 	int len;
1259 
1260 	/* Work out if we are in yptol mode */
1261 	yptol_mode = is_yptol_mode();
1262 
1263 	len = strlen(domain) + strlen(map) + strlen(ypdbpath) + 3;
1264 	if (yptol_mode)
1265 		len += strlen(NTOL_PREFIX);
1266 
1267 	if (len > (MAXNAMLEN + 1)) {
1268 		logprintf("Map name string too long.\n");
1269 	}
1270 
1271 	(void) strcpy(ppath, ypdbpath);
1272 	(void) strcat(ppath, "/");
1273 	(void) strcat(ppath, domain);
1274 	(void) strcat(ppath, "/");
1275 	if (yptol_mode)
1276 		(void) strcat(ppath, NTOL_PREFIX);
1277 	(void) strcat(ppath, map);
1278 }
1279 
1280 /*
1281  * This returns a temporary name for a map transfer minus its dbm_dir or
1282  * dbm_pag extensions.
1283  */
1284 void
mk_tmpname(prefix,xfr_name)1285 mk_tmpname(prefix, xfr_name)
1286 	char *prefix;
1287 	char *xfr_name;
1288 {
1289 	char xfr_anumber[10];
1290 	long xfr_number;
1291 
1292 	if (!xfr_name) {
1293 		return;
1294 	}
1295 
1296 	xfr_number = getpid();
1297 	(void) sprintf(xfr_anumber, "%d", xfr_number);
1298 
1299 	(void) strcpy(xfr_name, ypdbpath);
1300 	(void) strcat(xfr_name, "/");
1301 	(void) strcat(xfr_name, domain);
1302 	(void) strcat(xfr_name, "/");
1303 	(void) strcat(xfr_name, prefix);
1304 	(void) strcat(xfr_name, map);
1305 	(void) strcat(xfr_name, ".");
1306 	(void) strcat(xfr_name, xfr_anumber);
1307 }
1308 
1309 /*
1310  * This deletes the .pag and .dir files which implement a map.
1311  *
1312  * Note:  No error checking is done here for a garbage input file name or for
1313  * failed unlink operations.
1314  */
1315 void
del_mapfiles(basename)1316 del_mapfiles(basename)
1317 	char *basename;
1318 {
1319 	char dbfilename[MAXNAMLEN + 1];
1320 
1321 	if (!basename) {
1322 		return;
1323 	}
1324 
1325 	strcpy(dbfilename, basename);
1326 	strcat(dbfilename, dbm_pag);
1327 	unlink(dbfilename);
1328 	strcpy(dbfilename, basename);
1329 	strcat(dbfilename, dbm_dir);
1330 	unlink(dbfilename);
1331 }
1332 
1333 /*
1334  * This creates <pname>.dir and <pname>.pag
1335  */
1336 bool
new_mapfiles(pname)1337 new_mapfiles(pname)
1338 	char *pname;
1339 {
1340 	char dbfile[MAXNAMLEN + 1];
1341 	int f;
1342 	int len;
1343 
1344 	if (!pname || ((len = strlen(pname)) == 0) ||
1345 	    (len + 5) > (MAXNAMLEN + 1)) {
1346 		return (FALSE);
1347 	}
1348 
1349 	errno = 0;
1350 	(void) strcpy(dbfile, pname);
1351 	(void) strcat(dbfile, dbm_dir);
1352 
1353 	if ((f = open(dbfile, (O_WRONLY | O_CREAT | O_TRUNC), 0600)) >= 0) {
1354 		(void) close(f);
1355 		(void) strcpy(dbfile, pname);
1356 		(void) strcat(dbfile, dbm_pag);
1357 
1358 		if ((f = open(dbfile, (O_WRONLY | O_CREAT | O_TRUNC),
1359 		    0600)) >= 0) {
1360 			(void) close(f);
1361 			return (TRUE);
1362 		} else {
1363 			return (FALSE);
1364 		}
1365 
1366 	} else {
1367 		return (FALSE);
1368 	}
1369 }
1370 
1371 int
count_callback(status)1372 count_callback(status)
1373 	int status;
1374 {
1375 	if (status != YP_TRUE) {
1376 
1377 		if (status != YP_NOMORE) {
1378 			logprintf(
1379 			    "Error from ypserv on %s (ypall_callback) = %s.\n",
1380 			    master, yperr_string(ypprot_err(status)));
1381 		}
1382 
1383 		return (TRUE);
1384 	}
1385 
1386 	entry_count++;
1387 	return (FALSE);
1388 }
1389 
1390 /*
1391  * This counts the entries in the dbm file after the transfer to
1392  * make sure that the dbm file was built correctly.
1393  * Returns TRUE if everything is OK, FALSE if they mismatch.
1394  */
1395 int
count_mismatch(pname,oldcount)1396 count_mismatch(pname, oldcount)
1397 	char *pname;
1398 	int oldcount;
1399 {
1400 	datum key;
1401 	DBM *db;
1402 #ifdef REALLY_PARANOID
1403 	struct ypall_callback cbinfo;
1404 	struct ypreq_nokey allreq;
1405 	enum clnt_stat s;
1406 	struct dom_binding domb;
1407 	datum value;
1408 #endif /* REALLY_PARANOID */
1409 
1410 	entry_count = 0;
1411 	db = dbm_open(pname, 0, 0);
1412 	if (db) {
1413 	    for (key = dbm_firstkey(db);
1414 				key.dptr != NULL; key = dbm_nextkey(db))
1415 		entry_count++;
1416 	    dbm_close_status(db);
1417 	}
1418 
1419 	if (oldcount != entry_count) {
1420 	logprintf(
1421 		    "*** Count mismatch in dbm file %s: old=%d, new=%d ***\n",
1422 		    map, oldcount, entry_count);
1423 	return (FALSE);
1424 	}
1425 
1426 #ifdef REALLY_PARANOID
1427 
1428 	if ((domb.dom_client = __yp_clnt_create_rsvdport(master, YPPROG,
1429 						    master_prog_vers,
1430 						    "tcp6", 0, 0)) == 0 &&
1431 		(domb.dom_client = __yp_clnt_create_rsvdport(master, YPPROG,
1432 						    master_prog_vers,
1433 						    "tcp", 0, 0)) == 0) {
1434 		clnt_pcreateerror("ypxfr (mismatch) - TCP channel "
1435 					"create failure");
1436 		return (FALSE);
1437 	}
1438 
1439 	if (master_prog_vers == YPVERS) {
1440 		int tmpstat;
1441 
1442 		allreq.domain = source;
1443 		allreq.map = map;
1444 		cbinfo.foreach = count_callback;
1445 		tmpstat = 0;
1446 		cbinfo.data = (char *)&tmpstat;
1447 
1448 		entry_count = 0;
1449 		s = clnt_call(domb.dom_client, YPPROC_ALL, xdr_ypreq_nokey,
1450 		    &allreq, xdr_ypall, &cbinfo, tcp_timeout);
1451 
1452 		if (tmpstat == 0) {
1453 			if (s == RPC_SUCCESS) {
1454 			} else {
1455 				clnt_perror(domb.dom_client,
1456 		"ypxfr (get_map/all) - RPC clnt_call (TCP) failure");
1457 		    return (FALSE);
1458 			}
1459 
1460 		} else {
1461 		    return (FALSE);
1462 		}
1463 
1464 	} else {
1465 	    logprintf("Wrong version number!\n");
1466 	    return (FALSE);
1467 	}
1468 	clnt_destroy(domb.dom_client);
1469 	close(domb.dom_socket);
1470 	entry_count += 2;			/* add in YP_entries */
1471 	if (oldcount != entry_count) {
1472 		logprintf(
1473 	"*** Count mismatch after enumerate %s: old=%d, new=%d ***\n",
1474 		    map, oldcount, entry_count);
1475 		return (FALSE);
1476 	}
1477 #endif /* REALLY_PARANOID */
1478 
1479 	return (TRUE);
1480 }
1481 
1482 /*
1483  * This sets up a TCP connection to the master server, and either gets
1484  * ypall_callback to do all the work of writing it to the local dbm file
1485  * (if the ypserv is current version), or does it itself for an old ypserv.
1486  */
1487 bool
get_map(pname,pushstat)1488 get_map(pname, pushstat)
1489 	char *pname;
1490 	int *pushstat;
1491 {
1492 	struct dom_binding domb;
1493 	enum clnt_stat s;
1494 	struct ypreq_nokey allreq;
1495 	struct ypall_callback cbinfo;
1496 	bool retval = FALSE;
1497 	int tmpstat;
1498 	int	recvsiz = 24 * 1024;
1499 	struct netconfig *nconf;
1500 	int fd;
1501 	struct netbuf *svcaddr;
1502 	char *netid[] = { "tcp6", "tcp" };
1503 	int i, lastnetid = (sizeof (netid)/sizeof (netid[0])) - 1;
1504 
1505 	svcaddr = (struct netbuf *)calloc(1, sizeof (struct netbuf));
1506 	if (! svcaddr)
1507 		return (FALSE);
1508 	svcaddr->maxlen = 32;
1509 	svcaddr->len = 32;
1510 	svcaddr->buf = (char *)malloc(32);
1511 	if (! svcaddr->buf) {
1512 		free(svcaddr);
1513 		return (FALSE);
1514 	}
1515 
1516 	for (i = 0; i <= lastnetid; i++) {
1517 		fd = RPC_ANYFD;
1518 		if ((nconf = getnetconfigent(netid[i])) == NULL) {
1519 			if (i != lastnetid)
1520 				continue;
1521 			logprintf("ypxfr: tcp transport not supported\n");
1522 			free(svcaddr->buf);
1523 			free(svcaddr);
1524 			return (FALSE);
1525 		}
1526 		if (rpcb_getaddr(YPPROG, master_prog_vers, nconf, svcaddr,
1527 				master) == FALSE) {
1528 			freenetconfigent(nconf);
1529 			if (i != lastnetid)
1530 				continue;
1531 			logprintf("ypxfr: could not get %s address\n", master);
1532 			free(svcaddr->buf);
1533 			free(svcaddr);
1534 			return (FALSE);
1535 		}
1536 		if ((domb.dom_client = __nis_clnt_create(fd, nconf, 0, svcaddr,
1537 			0, YPPROG, master_prog_vers, recvsiz, 0)) == 0) {
1538 			freenetconfigent(nconf);
1539 			if (i != lastnetid)
1540 				continue;
1541 			clnt_pcreateerror(
1542 				"ypxfr (get_map) - TCP channel create failure");
1543 			*pushstat = YPPUSH_RPC;
1544 			free(svcaddr->buf);
1545 			free(svcaddr);
1546 			return (FALSE);
1547 		}
1548 		break;
1549 	}
1550 
1551 	entry_count = 0;
1552 	if (master_prog_vers == YPVERS) {
1553 		allreq.domain = source;
1554 		allreq.map = map;
1555 		cbinfo.foreach = ypall_callback;
1556 		tmpstat = 0;
1557 		cbinfo.data = (char *)&tmpstat;
1558 
1559 		s = clnt_call(domb.dom_client, YPPROC_ALL,
1560 			(xdrproc_t)xdr_ypreq_nokey,
1561 			(char *)&allreq, (xdrproc_t)xdr_ypall, (char *)&cbinfo,
1562 			tcp_timeout);
1563 
1564 		if (tmpstat == 0) {
1565 
1566 			if (s == RPC_SUCCESS) {
1567 				retval = TRUE;
1568 			} else {
1569 				clnt_perror(domb.dom_client,
1570 			"ypxfr (get_map/all) - RPC clnt_call (TCP) failure");
1571 				*pushstat = YPPUSH_RPC;
1572 			}
1573 
1574 		} else {
1575 			*pushstat = tmpstat;
1576 		}
1577 
1578 	} else
1579 		retval = FALSE; /* barf again at YPOLDVERS */
1580 cleanup:
1581 	clnt_destroy(domb.dom_client);
1582 	return (retval);
1583 }
1584 
1585 /*
1586  * This sticks each key-value pair into the current map.  It returns FALSE as
1587  * long as it wants to keep getting called back, and TRUE on error conditions
1588  * and "No more k-v pairs".
1589  */
1590 int
ypall_callback(status,key,kl,val,vl,pushstat)1591 ypall_callback(status, key, kl, val, vl, pushstat)
1592 	int status;
1593 	char *key;
1594 	int kl;
1595 	char *val;
1596 	int vl;
1597 	int *pushstat;
1598 {
1599 	datum keydat;
1600 	datum valdat;
1601 	datum test;
1602 
1603 	if (status != YP_TRUE) {
1604 
1605 		if (status != YP_NOMORE) {
1606 			logprintf(
1607 			    "Error from ypserv on %s (ypall_callback) = %s.\n",
1608 			    master, yperr_string(ypprot_err(status)));
1609 			*pushstat = map_yperr_to_pusherr(status);
1610 		}
1611 
1612 		return (TRUE);
1613 	}
1614 
1615 	keydat.dptr = key;
1616 	keydat.dsize = kl;
1617 	valdat.dptr = val;
1618 	valdat.dsize = vl;
1619 	entry_count++;
1620 /* way too many fetches */
1621 
1622 #ifdef PARANOID
1623 	test = dbm_fetch(db, keydat);
1624 	if (test.dptr != NULL) {
1625 		logprintf("Duplicate key %s in map %s\n", key, map);
1626 		*pushstat  = YPPUSH_DBM;
1627 		return (TRUE);
1628 	}
1629 #endif /* PARANOID */
1630 	if (dbm_store(db, keydat, valdat, 0) < 0) {
1631 		logprintf(
1632 		    "Can't do dbm store into temp map %s.\n", map);
1633 		*pushstat  = YPPUSH_DBM;
1634 		return (TRUE);
1635 	}
1636 #ifdef PARANOID
1637 	test = dbm_fetch(db, keydat);
1638 	if (test.dptr == NULL) {
1639 		logprintf("Key %s was not inserted into dbm file %s\n",
1640 			key, map);
1641 		*pushstat  = YPPUSH_DBM;
1642 		return (TRUE);
1643 	}
1644 #endif /* PARANOID */
1645 
1646 	if (dbm_error(db)) {
1647 		logprintf("Key %s dbm_error raised in file %s\n",
1648 			key, map);
1649 		*pushstat  = YPPUSH_DBM;
1650 		return (TRUE);
1651 	}
1652 	return (FALSE);
1653 }
1654 
1655 /*
1656  * This maps a YP_xxxx error code into a YPPUSH_xxxx error code
1657  */
1658 int
map_yperr_to_pusherr(yperr)1659 map_yperr_to_pusherr(yperr)
1660 	int yperr;
1661 {
1662 	int reason;
1663 
1664 	switch (yperr) {
1665 
1666 	case YP_NOMORE:
1667 		reason = YPPUSH_SUCC;
1668 		break;
1669 
1670 	case YP_NOMAP:
1671 		reason = YPPUSH_NOMAP;
1672 		break;
1673 
1674 	case YP_NODOM:
1675 		reason = YPPUSH_NODOM;
1676 		break;
1677 
1678 	case YP_NOKEY:
1679 		reason = YPPUSH_YPERR;
1680 		break;
1681 
1682 	case YP_BADARGS:
1683 		reason = YPPUSH_BADARGS;
1684 		break;
1685 
1686 	case YP_BADDB:
1687 		reason = YPPUSH_YPERR;
1688 		break;
1689 
1690 	default:
1691 		reason = YPPUSH_XFRERR;
1692 		break;
1693 	}
1694 
1695 	return (reason);
1696 }
1697 
1698 /*
1699  * This writes the last-modified and master entries into the new dbm file
1700  */
1701 bool
add_private_entries(pname)1702 add_private_entries(pname)
1703 	char *pname;
1704 {
1705 	datum key;
1706 	datum val;
1707 
1708 	if (!fake_master_version) {
1709 		key.dptr = yp_last_modified;
1710 		key.dsize = yp_last_modified_sz;
1711 		val.dptr = master_ascii_version;
1712 		val.dsize = strlen(master_ascii_version);
1713 
1714 		if (dbm_store(db, key, val, 1) < 0) {
1715 			logprintf(
1716 			    "Can't do dbm store into temp map %s.\n",
1717 			    pname);
1718 			return (FALSE);
1719 		}
1720 		entry_count++;
1721 	}
1722 
1723 	if (master_name) {
1724 		key.dptr = yp_master_name;
1725 		key.dsize = yp_master_name_sz;
1726 		val.dptr = master_name;
1727 		val.dsize = strlen(master_name);
1728 		if (dbm_store(db, key, val, 1) < 0) {
1729 			logprintf(
1730 			    "Can't do dbm store into temp map %s.\n",
1731 			    pname);
1732 			return (FALSE);
1733 		}
1734 		entry_count++;
1735 	}
1736 
1737 	if (interdomain_map) {
1738 		key.dptr = yp_interdomain;
1739 		key.dsize = yp_interdomain_sz;
1740 		val.dptr = interdomain_value;
1741 		val.dsize = interdomain_sz;
1742 		if (dbm_store(db, key, val, 1) < 0) {
1743 			logprintf(
1744 			    "Can't do dbm store into temp map %s.\n",
1745 			    pname);
1746 			return (FALSE);
1747 		}
1748 		entry_count++;
1749 	}
1750 
1751 	if (secure_map) {
1752 		key.dptr = yp_secure;
1753 		key.dsize = yp_secure_sz;
1754 		val.dptr = yp_secure;
1755 		val.dsize = yp_secure_sz;
1756 		if (dbm_store(db, key, val, 1) < 0) {
1757 			logprintf(
1758 			    "Can't do dbm store into temp map %s.\n",
1759 			    pname);
1760 			return (FALSE);
1761 		}
1762 		entry_count++;
1763 	}
1764 
1765 	return (TRUE);
1766 }
1767 
1768 
1769 /*
1770  * This sends a YPPROC_CLEAR message to the local ypserv process.
1771  */
1772 bool
send_ypclear(pushstat)1773 send_ypclear(pushstat)
1774 	int *pushstat;
1775 {
1776 	struct dom_binding domb;
1777 	char local_host_name[256];
1778 	unsigned int progvers;
1779 	int status;
1780 
1781 	if (gethostname(local_host_name, 256)) {
1782 		logprintf("Can't get local machine name.\n");
1783 		*pushstat = YPPUSH_RSRC;
1784 		return (FALSE);
1785 	}
1786 
1787 	if (!bind_to_server(local_host_name, &domb,
1788 	    &progvers, &status)) {
1789 		*pushstat = YPPUSH_CLEAR;
1790 		return (FALSE);
1791 	}
1792 
1793 	if ((enum clnt_stat) clnt_call(domb.dom_client,
1794 	    YPPROC_CLEAR, xdr_void, 0, xdr_void, 0,
1795 	    udp_timeout) != RPC_SUCCESS) {
1796 		logprintf(
1797 		"Can't send ypclear message to ypserv on the local machine.\n");
1798 		xfr_exit(YPPUSH_CLEAR);
1799 	}
1800 
1801 	return (TRUE);
1802 }
1803 
1804 /*
1805  * This decides if send_callback has to get called, and does the process exit.
1806  */
1807 void
xfr_exit(status)1808 xfr_exit(status)
1809 	int status;
1810 {
1811 	if (callback) {
1812 		send_callback(&status);
1813 	}
1814 
1815 	if (status == YPPUSH_SUCC) {
1816 #ifdef TREEPUSH
1817 		if (treepush) {
1818 		if (debug)
1819 		execlp("./yppush", "yppush", "-T", map, 0);
1820 		execlp("/usr/etc/yp/yppush", "yppush", "-T", map, 0);
1821 		perror("yppush");
1822 		}
1823 #endif
1824 		exit(0);
1825 	} else {
1826 		exit(1);
1827 	}
1828 }
1829 
1830 /*
1831  * This sets up a UDP connection to the yppush process which contacted our
1832  * parent ypserv, and sends it a status on the requested transfer.
1833  */
1834 void
send_callback(status)1835 send_callback(status)
1836 	int *status;
1837 {
1838 	struct yppushresp_xfr resp;
1839 	struct dom_binding domb;
1840 
1841 	resp.transid = (unsigned long) atoi(tid);
1842 	resp.status = (unsigned long) *status;
1843 
1844 	udp_timeout.tv_sec = CALLTIMEOUT;
1845 
1846 	if ((domb.dom_client = __yp_clnt_create_rsvdport(pushhost,
1847 						    (ulong_t)atoi(proto),
1848 						    YPPUSHVERS,
1849 						    0, 0, 0)) == NULL) {
1850 		*status = YPPUSH_RPC;
1851 		return;
1852 	}
1853 
1854 	if ((enum clnt_stat) clnt_call(domb.dom_client,
1855 	    YPPUSHPROC_XFRRESP, (xdrproc_t)xdr_yppushresp_xfr,
1856 	    (char *)&resp, xdr_void, 0,
1857 	    udp_timeout) != RPC_SUCCESS) {
1858 		*status = YPPUSH_RPC;
1859 		return;
1860 	}
1861 }
1862 
1863 /*
1864  * FUNCTION:    is_yptol_mode();
1865  *
1866  * DESCRIPTION: Determines if we should run in N2L or traditional mode based
1867  *              on the presence of the N2L mapping file.
1868  *
1869  *		This is a copy of a function from libnisdb. If more than this
1870  *		one function become required it may be worth linking the
1871  *		entire lib.
1872  *
1873  * INPUTS:      Nothing
1874  *
1875  * OUTPUTS:     TRUE = Run in N2L mode
1876  *              FALSE = Run in traditional mode.
1877  */
1878 bool_t
is_yptol_mode()1879 is_yptol_mode()
1880 {
1881 	struct stat filestat;
1882 
1883 	if (stat(NTOL_MAP_FILE, &filestat) != -1)
1884 		return (TRUE);
1885 
1886 	return (FALSE);
1887 }
1888