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