3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. 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.
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
32 * $FreeBSD: src/usr.sbin/yppush/yppush_main.c,v 1.11.2.2 2002/02/15 00:46:59 des Exp $
33 * $DragonFly: src/usr.sbin/yppush/yppush_main.c,v 1.2 2003/06/17 04:30:04 dillon Exp $
43 #include <sys/socket.h>
44 #include <sys/fcntl.h>
46 #include <sys/param.h>
49 #include <rpc/pmap_clnt.h>
50 #include <rpcsvc/yp.h>
51 struct dom_binding {};
52 #include <rpcsvc/ypclnt.h>
53 #include "ypxfr_extern.h"
54 #include "yppush_extern.h"
56 char *progname = "yppush";
59 char *yp_dir = _PATH_YP;
61 char *yppush_mapname = NULL; /* Map to transfer. */
62 char *yppush_domain = NULL; /* Domain in which map resides. */
63 char *yppush_master = NULL; /* Master NIS server for said domain. */
64 int verbose = 0; /* Toggle verbose mode. */
65 unsigned long yppush_transid = 0;
66 int yppush_timeout = 80; /* Default timeout. */
67 int yppush_jobs = 0; /* Number of allowed concurrent jobs. */
68 int yppush_running_jobs = 0; /* Number of currently running jobs. */
69 int yppush_alarm_tripped = 0;
71 /* Structure for holding information about a running job. */
77 unsigned long prognum;
84 struct jobs *yppush_joblist; /* Linked list of running jobs. */
87 * Local error messages.
89 static char *yppusherr_string(err)
93 case YPPUSH_TIMEDOUT: return("transfer or callback timed out");
94 case YPPUSH_YPSERV: return("failed to contact ypserv");
95 case YPPUSH_NOHOST: return("no such host");
96 case YPPUSH_PMAP: return("portmapper failure");
97 default: return("unknown error code");
102 * Report state of a job.
104 static int yppush_show_status(status, tid)
110 job = yppush_joblist;
123 yp_error("checking return status: transaction ID: %lu",
125 if (status != YPPUSH_SUCC || verbose) {
126 yp_error("transfer of map %s to server %s %s",
127 job->map, job->server, status == YPPUSH_SUCC ?
128 "succeeded" : "failed");
129 yp_error("status returned by ypxfr: %s", status > YPPUSH_AGE ?
130 yppusherr_string(status) :
131 ypxfrerr_string(status));
136 svc_unregister(job->prognum, 1);
138 yppush_running_jobs--;
143 static void yppush_exit(now)
147 int still_pending = 1;
149 /* Let all the information trickle in. */
150 while (!now && still_pending) {
151 jptr = yppush_joblist;
154 if (jptr->polled == 0) {
157 yp_error("%s has not responded",
161 yp_error("%s has responded",
168 yp_error("%d transfer%sstill pending",
170 still_pending > 1 ? "s " : " ");
171 yppush_alarm_tripped = 0;
172 alarm(YPPUSH_RESPONSE_TIMEOUT);
175 if (yppush_alarm_tripped == 1) {
176 yp_error("timed out");
181 yp_error("all transfers complete");
187 /* All stats collected and reported -- kill all the stragglers. */
188 jptr = yppush_joblist;
191 yp_error("warning: exiting with transfer \
192 to %s (transid = %lu) still pending", jptr->server, jptr->tid);
193 svc_unregister(jptr->prognum, 1);
201 * Handler for 'normal' signals.
204 static void handler(sig)
207 if (sig == SIGTERM || sig == SIGINT || sig == SIGABRT) {
212 if (sig == SIGALRM) {
214 yppush_alarm_tripped++;
221 * Dispatch loop for callback RPC services.
223 static void yppush_svc_run()
229 #endif /* def FD_SETSIZE */
230 struct timeval timeout;
240 #endif /* def FD_SETSIZE */
241 switch (select(_rpc_dtablesize(), &readfds, NULL, NULL, &timeout)) {
245 yp_error("select failed: %s", strerror(errno));
248 yp_error("select() timed out");
251 svc_getreqset(&readfds);
258 * Special handler for asynchronous socket I/O. We mark the
259 * sockets of the callback handlers as O_ASYNC and handle SIGIO
260 * events here, which will occur when the callback handler has
261 * something interesting to tell us.
263 static void async_handler(sig)
268 /* reset any pending alarms. */
270 yppush_alarm_tripped++;
271 kill(getpid(), SIGALRM);
276 * RPC service routines for callbacks.
279 yppushproc_null_1_svc(void *argp, struct svc_req *rqstp)
281 static char * result;
282 /* Do nothing -- RPC conventions call for all a null proc. */
283 return((void *) &result);
287 yppushproc_xfrresp_1_svc(yppushresp_xfr *argp, struct svc_req *rqstp)
289 static char * result;
290 yppush_show_status(argp->status, argp->transid);
291 return((void *) &result);
295 * Transmit a YPPROC_XFR request to ypserv.
297 static int yppush_send_xfr(job)
301 /* ypresp_xfr *resp; */
305 struct timeval timeout;
311 * The ypreq_xfr structure has a member of type map_parms,
312 * which seems to require the order number of the map.
313 * It isn't actually used at the other end (at least the
314 * FreeBSD ypserv doesn't use it) but we fill it in here
315 * for the sake of completeness.
317 key.data = "YP_LAST_MODIFIED";
318 key.size = sizeof ("YP_LAST_MODIFIED") - 1;
320 if (yp_get_record(yppush_domain, yppush_mapname, &key, &data,
322 yp_error("failed to read order number from %s: %s: %s",
323 yppush_mapname, yperr_string(yp_errno),
328 /* Fill in the request arguments */
329 req.map_parms.ordernum = atoi(data.data);
330 req.map_parms.domain = yppush_domain;
331 req.map_parms.peer = yppush_master;
332 req.map_parms.map = job->map;
333 req.transid = job->tid;
334 req.prog = job->prognum;
335 req.port = job->port;
337 /* Get a handle to the remote ypserv. */
338 if ((clnt = clnt_create(job->server, YPPROG, YPVERS, "udp")) == NULL) {
339 yp_error("%s: %s",job->server,clnt_spcreateerror("couldn't \
340 create udp handle to NIS server"));
341 switch (rpc_createerr.cf_stat) {
342 case RPC_UNKNOWNHOST:
343 job->stat = YPPUSH_NOHOST;
345 case RPC_PMAPFAILURE:
346 job->stat = YPPUSH_PMAP;
349 job->stat = YPPUSH_RPC;
356 * Reduce timeout to nothing since we may not
357 * get a response from ypserv and we don't want to block.
359 if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE)
360 yp_error("failed to set timeout on ypproc_xfr call");
362 /* Invoke the ypproc_xfr service. */
363 if (ypproc_xfr_2(&req, clnt) == NULL) {
364 clnt_geterr(clnt, &err);
365 if (err.re_status != RPC_SUCCESS &&
366 err.re_status != RPC_TIMEDOUT) {
367 yp_error("%s: %s", job->server, clnt_sperror(clnt,
369 job->stat = YPPUSH_YPSERV;
381 * Main driver function. Register the callback service, add the transfer
382 * request to the internal list, send the YPPROC_XFR request to ypserv
383 * do other magic things.
385 int yp_push(server, map, tid)
390 unsigned long prognum;
391 int sock = RPC_ANYSOCK;
396 * Register the callback service on the first free
397 * transient program number.
399 xprt = svcudp_create(sock);
400 for (prognum = 0x40000000; prognum < 0x5FFFFFFF; prognum++) {
401 if (svc_register(xprt, prognum, 1,
402 yppush_xfrrespprog_1, IPPROTO_UDP) == TRUE)
406 /* Register the job in our linked list of jobs. */
407 if ((job = (struct jobs *)malloc(sizeof (struct jobs))) == NULL) {
408 yp_error("malloc failed");
412 /* Initialize the info for this job. */
415 job->port = xprt->xp_port;
416 job->sock = xprt->xp_sock; /*XXX: Evil!! EEEEEEEVIL!!! */
417 job->server = strdup(server);
418 job->map = strdup(map);
419 job->prognum = prognum;
421 job->next = yppush_joblist;
422 yppush_joblist = job;
425 * Set the RPC sockets to asynchronous mode. This will
426 * cause the system to smack us with a SIGIO when an RPC
427 * callback is delivered. This in turn allows us to handle
428 * the callback even though we may be in the middle of doing
429 * something else at the time.
431 * XXX This is a horrible thing to do for two reasons,
432 * both of which have to do with portability:
433 * 1) We really ought not to be sticking our grubby mits
434 * into the RPC service transport handle like this.
435 * 2) Even in this day and age, there are still some *NIXes
436 * that don't support async socket I/O.
438 if (fcntl(xprt->xp_sock, F_SETOWN, getpid()) == -1 ||
439 fcntl(xprt->xp_sock, F_SETFL, O_ASYNC) == -1) {
440 yp_error("failed to set async I/O mode: %s",
446 yp_error("initiating transfer: %s -> %s (transid = %lu)",
447 yppush_mapname, server, tid);
451 * Send the XFR request to ypserv. We don't have to wait for
452 * a response here since we can handle them asynchronously.
455 if (yppush_send_xfr(job)){
456 /* Transfer request blew up. */
457 yppush_show_status(job->stat ? job->stat :
458 YPPUSH_YPSERV,job->tid);
461 yp_error("%s has been called", server);
468 * Called for each entry in the ypservers map from yp_get_map(), which
469 * is our private yp_all() routine.
471 int yppush_foreach(status, key, keylen, val, vallen, data)
479 char server[YPMAXRECORD + 2];
481 if (status != YP_TRUE)
484 snprintf(server, sizeof(server), "%.*s", vallen, val);
487 * Restrict the number of concurrent jobs. If yppush_jobs number
488 * of jobs have already been dispatched and are still pending,
489 * wait for one of them to finish so we can reuse its slot.
491 if (yppush_jobs <= 1) {
492 yppush_alarm_tripped = 0;
493 while (!yppush_alarm_tripped && yppush_running_jobs) {
494 alarm(yppush_timeout);
495 yppush_alarm_tripped = 0;
500 yppush_alarm_tripped = 0;
501 while (!yppush_alarm_tripped && yppush_running_jobs >= yppush_jobs) {
502 alarm(yppush_timeout);
503 yppush_alarm_tripped = 0;
509 /* Cleared for takeoff: set everything in motion. */
510 if (yp_push(&server, yppush_mapname, yppush_transid))
513 /* Bump the job counter and transaction ID. */
514 yppush_running_jobs++;
521 fprintf (stderr, "%s\n%s\n",
522 "usage: yppush [-d domain] [-t timeout] [-j #parallel jobs] [-h host]",
523 " [-p path] mapname");
528 * Entry point. (About time!)
537 char myname[MAXHOSTNAMELEN];
540 struct hostlist *next;
542 struct hostlist *yppush_hostlist = NULL;
543 struct hostlist *tmp;
546 while ((ch = getopt(argc, argv, "d:j:p:h:t:v")) != -1) {
549 yppush_domain = optarg;
552 yppush_jobs = atoi(optarg);
553 if (yppush_jobs <= 0)
559 case 'h': /* we can handle multiple hosts */
560 if ((tmp = (struct hostlist *)malloc(sizeof(struct hostlist))) == NULL) {
561 yp_error("malloc failed");
564 tmp->name = strdup(optarg);
565 tmp->next = yppush_hostlist;
566 yppush_hostlist = tmp;
569 yppush_timeout = atoi(optarg);
583 yppush_mapname = argv[0];
585 if (yppush_mapname == NULL) {
586 /* "No guts, no glory." */
591 * If no domain was specified, try to find the default
592 * domain. If we can't find that, we're doomed and must bail.
594 if (yppush_domain == NULL) {
595 char *yppush_check_domain;
596 if (!yp_get_default_domain(&yppush_check_domain) &&
597 !_yp_check(&yppush_check_domain)) {
598 yp_error("no domain specified and NIS not running");
601 yp_get_default_domain(&yppush_domain);
604 /* Check to see that we are the master for this map. */
606 if (gethostname ((char *)&myname, sizeof(myname))) {
607 yp_error("failed to get name of local host: %s",
612 key.data = "YP_MASTER_NAME";
613 key.size = sizeof("YP_MASTER_NAME") - 1;
615 if (yp_get_record(yppush_domain, yppush_mapname,
616 &key, &data, 1) != YP_TRUE) {
617 yp_error("couldn't open %s map: %s", yppush_mapname,
622 if (strncmp(myname, data.data, data.size)) {
623 yp_error("warning: this host is not the master for %s",
630 yppush_master = malloc(data.size + 1);
631 strncpy(yppush_master, data.data, data.size);
632 yppush_master[data.size] = '\0';
634 /* Install some handy handlers. */
635 signal(SIGALRM, handler);
636 signal(SIGTERM, handler);
637 signal(SIGINT, handler);
638 signal(SIGABRT, handler);
641 * Set up the SIGIO handler. Make sure that some of the
642 * other signals are blocked while the handler is running so
643 * select() doesn't get interrupted.
645 sigemptyset(&sa.sa_mask);
646 sigaddset(&sa.sa_mask, SIGIO); /* Goes without saying. */
647 sigaddset(&sa.sa_mask, SIGPIPE);
648 sigaddset(&sa.sa_mask, SIGCHLD);
649 sigaddset(&sa.sa_mask, SIGALRM);
650 sigaddset(&sa.sa_mask, SIGINT);
651 sa.sa_handler = async_handler;
654 sigaction(SIGIO, &sa, NULL);
656 /* set initial transaction ID */
657 yppush_transid = time((time_t *)NULL);
659 if (yppush_hostlist) {
661 * Host list was specified on the command line:
662 * kick off the transfers by hand.
664 tmp = yppush_hostlist;
666 yppush_foreach(YP_TRUE, NULL, 0, tmp->name,
672 * Do a yp_all() on the ypservers map and initiate a ypxfr
675 ypxfr_get_map("ypservers", yppush_domain,
676 "localhost", yppush_foreach);
680 yp_error("all jobs dispatched");
682 /* All done -- normal exit. */