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