1/*-
2 * SPDX-License-Identifier: BSD-4-Clause
3 *
4 * Copyright (c) 1995
5 *	Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *	This product includes software developed by Bill Paul.
18 * 4. Neither the name of the author nor the names of any co-contributors
19 *    may be used to endorse or promote products derived from this software
20 *    without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35#include <sys/cdefs.h>
36#include <errno.h>
37#include <signal.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include <strings.h>
42#include <time.h>
43#include <unistd.h>
44#include <sys/socket.h>
45#include <sys/fcntl.h>
46#include <sys/wait.h>
47#include <sys/param.h>
48#include <rpc/rpc.h>
49#include <rpc/clnt.h>
50#include <rpc/pmap_clnt.h>
51#include <rpcsvc/yp.h>
52#include <rpcsvc/ypclnt.h>
53#include "ypxfr_extern.h"
54#include "yppush_extern.h"
55
56char *progname = "yppush";
57int debug = 1;
58int _rpcpmstart = 0;
59char *yp_dir = _PATH_YP;
60
61static char *yppush_mapname = NULL;	/* Map to transfer. */
62static char *yppush_domain = NULL;	/* Domain in which map resides. */
63static char *yppush_master = NULL;	/* Master NIS server for said domain. */
64static int skip_master = 0;		/* Do not attempt to push map to master. */
65static int verbose = 0;		/* Toggle verbose mode. */
66static unsigned long yppush_transid = 0;
67static int yppush_timeout = 80;	/* Default timeout. */
68static int yppush_jobs = 1;		/* Number of allowed concurrent jobs. */
69static int yppush_running_jobs = 0;	/* Number of currently running jobs. */
70
71/* Structure for holding information about a running job. */
72struct jobs {
73	unsigned long tid;
74	int port;
75	ypxfrstat stat;
76	unsigned long prognum;
77	char *server;
78	char *map;
79	int polled;
80	struct jobs *next;
81};
82
83static struct jobs *yppush_joblist;	/* Linked list of running jobs. */
84static int yppush_svc_run(int);
85
86/*
87 * Local error messages.
88 */
89static const char *
90yppusherr_string(int err)
91{
92	switch (err) {
93	case YPPUSH_TIMEDOUT:
94		return("transfer or callback timed out");
95	case YPPUSH_YPSERV:
96		return("failed to contact ypserv");
97	case YPPUSH_NOHOST:
98		return("no such host");
99	case YPPUSH_PMAP:
100		return("portmapper failure");
101	default:
102		return("unknown error code");
103	}
104}
105
106/*
107 * Report state of a job.
108 */
109static int
110yppush_show_status(ypxfrstat status, unsigned long tid)
111{
112	struct jobs *job;
113
114	job = yppush_joblist;
115
116	while (job != NULL) {
117		if (job->tid == tid)
118			break;
119		job = job->next;
120	}
121
122	if (job == NULL) {
123		yp_error("warning: received callback with invalid transaction ID: %lu",
124			 tid);
125		return (0);
126	}
127
128	if (job->polled) {
129		yp_error("warning: received callback with duplicate transaction ID: %lu",
130			 tid);
131		return (0);
132	}
133
134	if (verbose > 1) {
135		yp_error("checking return status: transaction ID: %lu",
136								job->tid);
137	}
138
139	if (status != YPXFR_SUCC || verbose) {
140		yp_error("transfer of map %s to server %s %s",
141		 	job->map, job->server, status == YPXFR_SUCC ?
142		 	"succeeded" : "failed");
143		yp_error("status returned by ypxfr: %s", status > YPXFR_AGE ?
144			yppusherr_string(status) :
145			ypxfrerr_string(status));
146	}
147
148	job->polled = 1;
149
150	svc_unregister(job->prognum, 1);
151
152	yppush_running_jobs--;
153	return(0);
154}
155
156/* Exit routine. */
157static void
158yppush_exit(int now)
159{
160	struct jobs *jptr;
161	int still_pending = 1;
162
163	/* Let all the information trickle in. */
164	while (!now && still_pending) {
165		jptr = yppush_joblist;
166		still_pending = 0;
167		while (jptr) {
168			if (jptr->polled == 0) {
169				still_pending++;
170				if (verbose > 1)
171					yp_error("%s has not responded",
172						  jptr->server);
173			} else {
174				if (verbose > 1)
175					yp_error("%s has responded",
176						  jptr->server);
177			}
178			jptr = jptr->next;
179		}
180		if (still_pending) {
181			if (verbose > 1)
182				yp_error("%d transfer%sstill pending",
183					still_pending,
184					still_pending > 1 ? "s " : " ");
185			if (yppush_svc_run (YPPUSH_RESPONSE_TIMEOUT) == 0) {
186				yp_error("timed out");
187				now = 1;
188			}
189		} else {
190			if (verbose)
191				yp_error("all transfers complete");
192			break;
193		}
194	}
195
196
197	/* All stats collected and reported -- kill all the stragglers. */
198	jptr = yppush_joblist;
199	while (jptr) {
200		if (!jptr->polled)
201			yp_error("warning: exiting with transfer \
202to %s (transid = %lu) still pending", jptr->server, jptr->tid);
203		svc_unregister(jptr->prognum, 1);
204		jptr = jptr->next;
205	}
206
207	exit(0);
208}
209
210/*
211 * Handler for 'normal' signals.
212 */
213
214static void
215handler(int sig)
216{
217	yppush_exit (1);
218}
219
220/*
221 * Dispatch loop for callback RPC services.
222 * Return value:
223 *   -1 error
224 *    0 timeout
225 *   >0 request serviced
226 */
227static int
228yppush_svc_run(int timeout_secs)
229{
230	int rc;
231	fd_set readfds;
232	struct timeval timeout;
233
234	timeout.tv_usec = 0;
235	timeout.tv_sec = timeout_secs;
236
237retry:
238	readfds = svc_fdset;
239	rc = select(svc_maxfd + 1, &readfds, NULL, NULL, &timeout);
240	switch (rc) {
241	case -1:
242		if (errno == EINTR)
243			goto retry;
244		yp_error("select failed: %s", strerror(errno));
245		break;
246	case 0:
247		yp_error("select() timed out");
248		break;
249	default:
250		svc_getreqset(&readfds);
251		break;
252	}
253	return rc;
254}
255
256/*
257 * RPC service routines for callbacks.
258 */
259void *
260yppushproc_null_1_svc(void *argp, struct svc_req *rqstp)
261{
262	static char * result;
263	/* Do nothing -- RPC conventions call for all a null proc. */
264	return((void *) &result);
265}
266
267void *
268yppushproc_xfrresp_1_svc(yppushresp_xfr *argp, struct svc_req *rqstp)
269{
270	static char * result;
271	yppush_show_status(argp->status, argp->transid);
272	return((void *) &result);
273}
274
275/*
276 * Transmit a YPPROC_XFR request to ypserv.
277 */
278static int
279yppush_send_xfr(struct jobs *job)
280{
281	ypreq_xfr req;
282/*	ypresp_xfr *resp; */
283	DBT key, data;
284	CLIENT *clnt;
285	struct rpc_err err;
286	struct timeval timeout;
287
288	timeout.tv_usec = 0;
289	timeout.tv_sec = 0;
290
291	/*
292	 * The ypreq_xfr structure has a member of type map_parms,
293	 * which seems to require the order number of the map.
294	 * It isn't actually used at the other end (at least the
295	 * FreeBSD ypserv doesn't use it) but we fill it in here
296	 * for the sake of completeness.
297	 */
298	key.data = "YP_LAST_MODIFIED";
299	key.size = sizeof ("YP_LAST_MODIFIED") - 1;
300
301	if (yp_get_record(yppush_domain, yppush_mapname, &key, &data,
302			  1) != YP_TRUE) {
303		yp_error("failed to read order number from %s: %s: %s",
304			  yppush_mapname, yperr_string(yp_errno),
305			  strerror(errno));
306		return(1);
307	}
308
309	/* Fill in the request arguments */
310	req.map_parms.ordernum = atoi(data.data);
311	req.map_parms.domain = yppush_domain;
312	req.map_parms.peer = yppush_master;
313	req.map_parms.map = job->map;
314	req.transid = job->tid;
315	req.prog = job->prognum;
316	req.port = job->port;
317
318	/* Get a handle to the remote ypserv. */
319	if ((clnt = clnt_create(job->server, YPPROG, YPVERS, "udp")) == NULL) {
320		yp_error("%s: %s",job->server,clnt_spcreateerror("couldn't \
321create udp handle to NIS server"));
322		switch (rpc_createerr.cf_stat) {
323			case RPC_UNKNOWNHOST:
324				job->stat = YPPUSH_NOHOST;
325				break;
326			case RPC_PMAPFAILURE:
327				job->stat = YPPUSH_PMAP;
328				break;
329			default:
330				job->stat = YPPUSH_RPC;
331				break;
332			}
333		return(1);
334	}
335
336	/*
337	 * Reduce timeout to nothing since we may not
338	 * get a response from ypserv and we don't want to block.
339	 */
340	if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE)
341		yp_error("failed to set timeout on ypproc_xfr call");
342
343	/* Invoke the ypproc_xfr service. */
344	if (ypproc_xfr_2(&req, clnt) == NULL) {
345		clnt_geterr(clnt, &err);
346		if (err.re_status != RPC_SUCCESS &&
347		    err.re_status != RPC_TIMEDOUT) {
348			yp_error("%s: %s", job->server, clnt_sperror(clnt,
349							"yp_xfr failed"));
350			job->stat = YPPUSH_YPSERV;
351			clnt_destroy(clnt);
352			return(1);
353		}
354	}
355
356	clnt_destroy(clnt);
357
358	return(0);
359}
360
361/*
362 * Main driver function. Register the callback service, add the transfer
363 * request to the internal list, send the YPPROC_XFR request to ypserv
364 * do other magic things.
365 */
366static int
367yp_push(char *server, char *map, unsigned long tid)
368{
369	unsigned long prognum;
370	int sock = RPC_ANYSOCK;
371	SVCXPRT *xprt;
372	struct jobs *job;
373
374	/* Register the job in our linked list of jobs. */
375
376	/* First allocate job structure */
377	if ((job = (struct jobs *)malloc(sizeof (struct jobs))) == NULL) {
378		yp_error("malloc failed");
379		yppush_exit (1);
380	}
381
382	/*
383	 * Register the callback service on the first free transient
384	 * program number.
385	 */
386	xprt = svcudp_create(sock);
387	for (prognum = 0x40000000; prognum < 0x5FFFFFFF; prognum++) {
388		if (svc_register(xprt, prognum, 1,
389		    yppush_xfrrespprog_1, IPPROTO_UDP) == TRUE)
390			break;
391	}
392	if (prognum == 0x5FFFFFFF) {
393		yp_error ("can't register yppush_xfrrespprog_1");
394		yppush_exit (1);
395	}
396
397	/* Initialize the info for this job. */
398	job->stat = 0;
399	job->tid = tid;
400	job->port = xprt->xp_port;
401	job->server = strdup(server);
402	job->map = strdup(map);
403	job->prognum = prognum;
404	job->polled = 0;
405	job->next = yppush_joblist;
406	yppush_joblist = job;
407
408	if (verbose) {
409		yp_error("initiating transfer: %s -> %s (transid = %lu)",
410			yppush_mapname, server, tid);
411	}
412
413	/*
414	 * Send the XFR request to ypserv. We don't have to wait for
415	 * a response here since we handle them asynchronously.
416	 */
417
418	if (yppush_send_xfr(job)){
419		/* Transfer request blew up. */
420		yppush_show_status(job->stat ? job->stat :
421			YPPUSH_YPSERV,job->tid);
422	} else {
423		if (verbose > 1)
424			yp_error("%s has been called", server);
425	}
426
427	return(0);
428}
429
430/*
431 * Called for each entry in the ypservers map from yp_get_map(), which
432 * is our private yp_all() routine.
433 */
434static int
435yppush_foreach(int status, char *key, int keylen, char *val, int vallen,
436    char *data)
437{
438	char *server;
439
440	if (status != YP_TRUE)
441		return (status);
442
443	asprintf(&server, "%.*s", vallen, val);
444
445	/*
446	 * Do not stop the iteration on the allocation failure.  We
447	 * cannot usefully react on low memory condition anyway, and
448	 * the failure is more likely due to insane val.
449	 */
450	if (server == NULL)
451		return (0);
452
453	if (skip_master && strcasecmp(server, yppush_master) == 0) {
454		free(server);
455		return (0);
456	}
457
458	/*
459	 * Restrict the number of concurrent jobs: if yppush_jobs number
460	 * of jobs have already been dispatched and are still pending,
461	 * wait for one of them to finish so we can reuse its slot.
462	 */
463	while (yppush_running_jobs >= yppush_jobs && (yppush_svc_run (yppush_timeout) > 0))
464		;
465
466	/* Cleared for takeoff: set everything in motion. */
467	if (yp_push(server, yppush_mapname, yppush_transid)) {
468		free(server);
469		return(yp_errno);
470	}
471
472	/* Bump the job counter and transaction ID. */
473	yppush_running_jobs++;
474	yppush_transid++;
475	free(server);
476	return (0);
477}
478
479static void
480usage()
481{
482	fprintf (stderr, "%s\n%s\n",
483	"usage: yppush [-d domain] [-t timeout] [-j #parallel jobs] [-h host]",
484	"              [-p path] mapname");
485	exit(1);
486}
487
488/*
489 * Entry point. (About time!)
490 */
491int
492main(int argc, char *argv[])
493{
494	int ch;
495	DBT key, data;
496	char myname[MAXHOSTNAMELEN];
497	struct hostlist {
498		char *name;
499		struct hostlist *next;
500	};
501	struct hostlist *yppush_hostlist = NULL;
502	struct hostlist *tmp;
503
504	while ((ch = getopt(argc, argv, "d:j:p:h:t:v")) != -1) {
505		switch (ch) {
506		case 'd':
507			yppush_domain = optarg;
508			break;
509		case 'j':
510			yppush_jobs = atoi(optarg);
511			if (yppush_jobs <= 0)
512				yppush_jobs = 1;
513			break;
514		case 'p':
515			yp_dir = optarg;
516			break;
517		case 'h': /* we can handle multiple hosts */
518			if ((tmp = (struct hostlist *)malloc(sizeof(struct hostlist))) == NULL) {
519				yp_error("malloc failed");
520				yppush_exit(1);
521			}
522			tmp->name = strdup(optarg);
523			tmp->next = yppush_hostlist;
524			yppush_hostlist = tmp;
525			break;
526		case 't':
527			yppush_timeout = atoi(optarg);
528			break;
529		case 'v':
530			verbose++;
531			break;
532		default:
533			usage();
534			break;
535		}
536	}
537
538	argc -= optind;
539	argv += optind;
540
541	yppush_mapname = argv[0];
542
543	if (yppush_mapname == NULL) {
544	/* "No guts, no glory." */
545		usage();
546	}
547
548	/*
549	 * If no domain was specified, try to find the default
550	 * domain. If we can't find that, we're doomed and must bail.
551	 */
552	if (yppush_domain == NULL) {
553		char *yppush_check_domain;
554		if (!yp_get_default_domain(&yppush_check_domain) &&
555			!_yp_check(&yppush_check_domain)) {
556			yp_error("no domain specified and NIS not running");
557			usage();
558		} else
559			yp_get_default_domain(&yppush_domain);
560	}
561
562	/* Check to see that we are the master for this map. */
563
564	if (gethostname ((char *)&myname, sizeof(myname))) {
565		yp_error("failed to get name of local host: %s",
566			strerror(errno));
567		yppush_exit(1);
568	}
569
570	key.data = "YP_MASTER_NAME";
571	key.size = sizeof("YP_MASTER_NAME") - 1;
572
573	if (yp_get_record(yppush_domain, yppush_mapname,
574			  &key, &data, 1) != YP_TRUE) {
575		yp_error("couldn't open %s map: %s", yppush_mapname,
576			 strerror(errno));
577		yppush_exit(1);
578	}
579
580	if (strncasecmp(myname, data.data, data.size) == 0) {
581		/* I am master server, and no explicit host list was
582		   specified: do not push map to myself -- this will
583		   fail with YPPUSH_AGE anyway. */
584		if (yppush_hostlist == NULL)
585			skip_master = 1;
586	} else {
587		yp_error("warning: this host is not the master for %s",
588							yppush_mapname);
589#ifdef NITPICKY
590		yppush_exit(1);
591#endif
592	}
593
594	yppush_master = malloc(data.size + 1);
595	strncpy(yppush_master, data.data, data.size);
596	yppush_master[data.size] = '\0';
597
598	/* Install some handy handlers. */
599	signal(SIGTERM, handler);
600	signal(SIGINT, handler);
601
602	/* set initial transaction ID */
603	yppush_transid = time((time_t *)NULL);
604
605	if (yppush_hostlist) {
606	/*
607	 * Host list was specified on the command line:
608	 * kick off the transfers by hand.
609	 */
610		tmp = yppush_hostlist;
611		while (tmp) {
612			yppush_foreach(YP_TRUE, NULL, 0, tmp->name,
613			    strlen(tmp->name), NULL);
614			tmp = tmp->next;
615		}
616	} else {
617	/*
618	 * Do a yp_all() on the ypservers map and initiate a ypxfr
619	 * for each one.
620	 */
621		ypxfr_get_map("ypservers", yppush_domain,
622			      "localhost", yppush_foreach);
623	}
624
625	if (verbose > 1)
626		yp_error("all jobs dispatched");
627
628	/* All done -- normal exit. */
629	yppush_exit(0);
630
631	/* Just in case. */
632	exit(0);
633}
634