2 * SPDX-License-Identifier: BSD-4-Clause
5 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
46 #include <sys/socket.h>
47 #include <sys/fcntl.h>
49 #include <sys/param.h>
52 #include <rpc/pmap_clnt.h>
53 #include <rpcsvc/yp.h>
54 #include <rpcsvc/ypclnt.h>
55 #include "ypxfr_extern.h"
56 #include "yppush_extern.h"
58 char *progname = "yppush";
61 char *yp_dir = _PATH_YP;
63 static char *yppush_mapname = NULL; /* Map to transfer. */
64 static char *yppush_domain = NULL; /* Domain in which map resides. */
65 static char *yppush_master = NULL; /* Master NIS server for said domain. */
66 static int skip_master = 0; /* Do not attempt to push map to master. */
67 static int verbose = 0; /* Toggle verbose mode. */
68 static unsigned long yppush_transid = 0;
69 static int yppush_timeout = 80; /* Default timeout. */
70 static int yppush_jobs = 1; /* Number of allowed concurrent jobs. */
71 static int yppush_running_jobs = 0; /* Number of currently running jobs. */
73 /* Structure for holding information about a running job. */
78 unsigned long prognum;
85 static struct jobs *yppush_joblist; /* Linked list of running jobs. */
86 static int yppush_svc_run(int);
89 * Local error messages.
92 yppusherr_string(int err)
96 return("transfer or callback timed out");
98 return("failed to contact ypserv");
100 return("no such host");
102 return("portmapper failure");
104 return("unknown error code");
109 * Report state of a job.
112 yppush_show_status(ypxfrstat status, unsigned long tid)
116 job = yppush_joblist;
118 while (job != NULL) {
125 yp_error("warning: received callback with invalid transaction ID: %lu",
131 yp_error("warning: received callback with duplicate transaction ID: %lu",
137 yp_error("checking return status: transaction ID: %lu",
141 if (status != YPXFR_SUCC || verbose) {
142 yp_error("transfer of map %s to server %s %s",
143 job->map, job->server, status == YPXFR_SUCC ?
144 "succeeded" : "failed");
145 yp_error("status returned by ypxfr: %s", status > YPXFR_AGE ?
146 yppusherr_string(status) :
147 ypxfrerr_string(status));
152 svc_unregister(job->prognum, 1);
154 yppush_running_jobs--;
163 int still_pending = 1;
165 /* Let all the information trickle in. */
166 while (!now && still_pending) {
167 jptr = yppush_joblist;
170 if (jptr->polled == 0) {
173 yp_error("%s has not responded",
177 yp_error("%s has responded",
184 yp_error("%d transfer%sstill pending",
186 still_pending > 1 ? "s " : " ");
187 if (yppush_svc_run (YPPUSH_RESPONSE_TIMEOUT) == 0) {
188 yp_error("timed out");
193 yp_error("all transfers complete");
199 /* All stats collected and reported -- kill all the stragglers. */
200 jptr = yppush_joblist;
203 yp_error("warning: exiting with transfer \
204 to %s (transid = %lu) still pending", jptr->server, jptr->tid);
205 svc_unregister(jptr->prognum, 1);
213 * Handler for 'normal' signals.
224 * Dispatch loop for callback RPC services.
228 * >0 request serviced
231 yppush_svc_run(int timeout_secs)
235 struct timeval timeout;
238 timeout.tv_sec = timeout_secs;
242 rc = select(svc_maxfd + 1, &readfds, NULL, NULL, &timeout);
247 yp_error("select failed: %s", strerror(errno));
250 yp_error("select() timed out");
253 svc_getreqset(&readfds);
260 * RPC service routines for callbacks.
263 yppushproc_null_1_svc(void *argp, struct svc_req *rqstp)
265 static char * result;
266 /* Do nothing -- RPC conventions call for all a null proc. */
267 return((void *) &result);
271 yppushproc_xfrresp_1_svc(yppushresp_xfr *argp, struct svc_req *rqstp)
273 static char * result;
274 yppush_show_status(argp->status, argp->transid);
275 return((void *) &result);
279 * Transmit a YPPROC_XFR request to ypserv.
282 yppush_send_xfr(struct jobs *job)
285 /* ypresp_xfr *resp; */
289 struct timeval timeout;
295 * The ypreq_xfr structure has a member of type map_parms,
296 * which seems to require the order number of the map.
297 * It isn't actually used at the other end (at least the
298 * FreeBSD ypserv doesn't use it) but we fill it in here
299 * for the sake of completeness.
301 key.data = "YP_LAST_MODIFIED";
302 key.size = sizeof ("YP_LAST_MODIFIED") - 1;
304 if (yp_get_record(yppush_domain, yppush_mapname, &key, &data,
306 yp_error("failed to read order number from %s: %s: %s",
307 yppush_mapname, yperr_string(yp_errno),
312 /* Fill in the request arguments */
313 req.map_parms.ordernum = atoi(data.data);
314 req.map_parms.domain = yppush_domain;
315 req.map_parms.peer = yppush_master;
316 req.map_parms.map = job->map;
317 req.transid = job->tid;
318 req.prog = job->prognum;
319 req.port = job->port;
321 /* Get a handle to the remote ypserv. */
322 if ((clnt = clnt_create(job->server, YPPROG, YPVERS, "udp")) == NULL) {
323 yp_error("%s: %s",job->server,clnt_spcreateerror("couldn't \
324 create udp handle to NIS server"));
325 switch (rpc_createerr.cf_stat) {
326 case RPC_UNKNOWNHOST:
327 job->stat = YPPUSH_NOHOST;
329 case RPC_PMAPFAILURE:
330 job->stat = YPPUSH_PMAP;
333 job->stat = YPPUSH_RPC;
340 * Reduce timeout to nothing since we may not
341 * get a response from ypserv and we don't want to block.
343 if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE)
344 yp_error("failed to set timeout on ypproc_xfr call");
346 /* Invoke the ypproc_xfr service. */
347 if (ypproc_xfr_2(&req, clnt) == NULL) {
348 clnt_geterr(clnt, &err);
349 if (err.re_status != RPC_SUCCESS &&
350 err.re_status != RPC_TIMEDOUT) {
351 yp_error("%s: %s", job->server, clnt_sperror(clnt,
353 job->stat = YPPUSH_YPSERV;
365 * Main driver function. Register the callback service, add the transfer
366 * request to the internal list, send the YPPROC_XFR request to ypserv
367 * do other magic things.
370 yp_push(char *server, char *map, unsigned long tid)
372 unsigned long prognum;
373 int sock = RPC_ANYSOCK;
377 /* Register the job in our linked list of jobs. */
379 /* First allocate job structure */
380 if ((job = (struct jobs *)malloc(sizeof (struct jobs))) == NULL) {
381 yp_error("malloc failed");
386 * Register the callback service on the first free transient
389 xprt = svcudp_create(sock);
390 for (prognum = 0x40000000; prognum < 0x5FFFFFFF; prognum++) {
391 if (svc_register(xprt, prognum, 1,
392 yppush_xfrrespprog_1, IPPROTO_UDP) == TRUE)
395 if (prognum == 0x5FFFFFFF) {
396 yp_error ("can't register yppush_xfrrespprog_1");
400 /* Initialize the info for this job. */
403 job->port = xprt->xp_port;
404 job->server = strdup(server);
405 job->map = strdup(map);
406 job->prognum = prognum;
408 job->next = yppush_joblist;
409 yppush_joblist = job;
412 yp_error("initiating transfer: %s -> %s (transid = %lu)",
413 yppush_mapname, server, tid);
417 * Send the XFR request to ypserv. We don't have to wait for
418 * a response here since we handle them asynchronously.
421 if (yppush_send_xfr(job)){
422 /* Transfer request blew up. */
423 yppush_show_status(job->stat ? job->stat :
424 YPPUSH_YPSERV,job->tid);
427 yp_error("%s has been called", server);
434 * Called for each entry in the ypservers map from yp_get_map(), which
435 * is our private yp_all() routine.
438 yppush_foreach(int status, char *key, int keylen, char *val, int vallen,
443 if (status != YP_TRUE)
446 asprintf(&server, "%.*s", vallen, val);
449 * Do not stop the iteration on the allocation failure. We
450 * cannot usefully react on low memory condition anyway, and
451 * the failure is more likely due to insane val.
456 if (skip_master && strcasecmp(server, yppush_master) == 0) {
462 * Restrict the number of concurrent jobs: if yppush_jobs number
463 * of jobs have already been dispatched and are still pending,
464 * wait for one of them to finish so we can reuse its slot.
466 while (yppush_running_jobs >= yppush_jobs && (yppush_svc_run (yppush_timeout) > 0))
469 /* Cleared for takeoff: set everything in motion. */
470 if (yp_push(server, yppush_mapname, yppush_transid)) {
475 /* Bump the job counter and transaction ID. */
476 yppush_running_jobs++;
485 fprintf (stderr, "%s\n%s\n",
486 "usage: yppush [-d domain] [-t timeout] [-j #parallel jobs] [-h host]",
487 " [-p path] mapname");
492 * Entry point. (About time!)
495 main(int argc, char *argv[])
499 char myname[MAXHOSTNAMELEN];
502 struct hostlist *next;
504 struct hostlist *yppush_hostlist = NULL;
505 struct hostlist *tmp;
507 while ((ch = getopt(argc, argv, "d:j:p:h:t:v")) != -1) {
510 yppush_domain = optarg;
513 yppush_jobs = atoi(optarg);
514 if (yppush_jobs <= 0)
520 case 'h': /* we can handle multiple hosts */
521 if ((tmp = (struct hostlist *)malloc(sizeof(struct hostlist))) == NULL) {
522 yp_error("malloc failed");
525 tmp->name = strdup(optarg);
526 tmp->next = yppush_hostlist;
527 yppush_hostlist = tmp;
530 yppush_timeout = atoi(optarg);
544 yppush_mapname = argv[0];
546 if (yppush_mapname == NULL) {
547 /* "No guts, no glory." */
552 * If no domain was specified, try to find the default
553 * domain. If we can't find that, we're doomed and must bail.
555 if (yppush_domain == NULL) {
556 char *yppush_check_domain;
557 if (!yp_get_default_domain(&yppush_check_domain) &&
558 !_yp_check(&yppush_check_domain)) {
559 yp_error("no domain specified and NIS not running");
562 yp_get_default_domain(&yppush_domain);
565 /* Check to see that we are the master for this map. */
567 if (gethostname ((char *)&myname, sizeof(myname))) {
568 yp_error("failed to get name of local host: %s",
573 key.data = "YP_MASTER_NAME";
574 key.size = sizeof("YP_MASTER_NAME") - 1;
576 if (yp_get_record(yppush_domain, yppush_mapname,
577 &key, &data, 1) != YP_TRUE) {
578 yp_error("couldn't open %s map: %s", yppush_mapname,
583 if (strncasecmp(myname, data.data, data.size) == 0) {
584 /* I am master server, and no explicit host list was
585 specified: do not push map to myself -- this will
586 fail with YPPUSH_AGE anyway. */
587 if (yppush_hostlist == NULL)
590 yp_error("warning: this host is not the master for %s",
597 yppush_master = malloc(data.size + 1);
598 strncpy(yppush_master, data.data, data.size);
599 yppush_master[data.size] = '\0';
601 /* Install some handy handlers. */
602 signal(SIGTERM, handler);
603 signal(SIGINT, handler);
605 /* set initial transaction ID */
606 yppush_transid = time((time_t *)NULL);
608 if (yppush_hostlist) {
610 * Host list was specified on the command line:
611 * kick off the transfers by hand.
613 tmp = yppush_hostlist;
615 yppush_foreach(YP_TRUE, NULL, 0, tmp->name,
616 strlen(tmp->name), NULL);
621 * Do a yp_all() on the ypservers map and initiate a ypxfr
624 ypxfr_get_map("ypservers", yppush_domain,
625 "localhost", yppush_foreach);
629 yp_error("all jobs dispatched");
631 /* All done -- normal exit. */