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.22 2006/08/16 12:58:41 thomas 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 #include <rpcsvc/ypclnt.h>
52 #include "ypxfr_extern.h"
53 #include "yppush_extern.h"
55 char *progname
= "yppush";
58 const char *yp_dir
= _PATH_YP
;
60 static char *yppush_mapname
= NULL
; /* Map to transfer. */
61 static char *yppush_domain
= NULL
; /* Domain in which map resides. */
62 static char *yppush_master
= NULL
; /* Master NIS server for said domain. */
63 static int skip_master
= 0; /* Do not attempt to push map to master. */
64 static int verbose
= 0; /* Toggle verbose mode. */
65 static unsigned long yppush_transid
= 0;
66 static int yppush_timeout
= 80; /* Default timeout. */
67 static int yppush_jobs
= 1; /* Number of allowed concurrent jobs. */
68 static int yppush_running_jobs
= 0; /* Number of currently running jobs. */
70 /* Structure for holding information about a running job. */
75 unsigned long prognum
;
82 static struct jobs
*yppush_joblist
; /* Linked list of running jobs. */
83 static int yppush_svc_run(int);
86 * Local error messages.
89 yppusherr_string(int err
)
93 return("transfer or callback timed out");
95 return("failed to contact ypserv");
97 return("no such host");
99 return("portmapper failure");
101 return("unknown error code");
106 * Report state of a job.
109 yppush_show_status(ypxfrstat status
, unsigned long tid
)
113 job
= yppush_joblist
;
115 while (job
!= NULL
) {
122 yp_error("warning: received callback with invalid transaction ID: %lu",
128 yp_error("warning: received callback with duplicate transaction ID: %lu",
134 yp_error("checking return status: transaction ID: %lu",
138 if (status
!= YPXFR_SUCC
|| verbose
) {
139 yp_error("transfer of map %s to server %s %s",
140 job
->map
, job
->server
, status
== YPXFR_SUCC
?
141 "succeeded" : "failed");
142 yp_error("status returned by ypxfr: %s", status
> YPXFR_AGE
?
143 yppusherr_string(status
) :
144 ypxfrerr_string(status
));
149 svc_unregister(job
->prognum
, 1);
151 yppush_running_jobs
--;
160 int still_pending
= 1;
162 /* Let all the information trickle in. */
163 while (!now
&& still_pending
) {
164 jptr
= yppush_joblist
;
167 if (jptr
->polled
== 0) {
170 yp_error("%s has not responded",
174 yp_error("%s has responded",
181 yp_error("%d transfer%sstill pending",
183 still_pending
> 1 ? "s " : " ");
184 if (yppush_svc_run (YPPUSH_RESPONSE_TIMEOUT
) == 0) {
185 yp_error("timed out");
190 yp_error("all transfers complete");
196 /* All stats collected and reported -- kill all the stragglers. */
197 jptr
= yppush_joblist
;
200 yp_error("warning: exiting with transfer \
201 to %s (transid = %lu) still pending", jptr
->server
, jptr
->tid
);
202 svc_unregister(jptr
->prognum
, 1);
210 * Handler for 'normal' signals.
221 * Dispatch loop for callback RPC services.
225 * >0 request serviced
228 yppush_svc_run(int timeout_secs
)
232 struct timeval timeout
;
235 timeout
.tv_sec
= timeout_secs
;
239 rc
= select(svc_maxfd
+ 1, &readfds
, NULL
, NULL
, &timeout
);
244 yp_error("select failed: %s", strerror(errno
));
247 yp_error("select() timed out");
250 svc_getreqset(&readfds
);
257 * RPC service routines for callbacks.
260 yppushproc_null_1_svc(void *argp
, struct svc_req
*rqstp
)
262 static char * result
;
263 /* Do nothing -- RPC conventions call for all a null proc. */
264 return((void *) &result
);
268 yppushproc_xfrresp_1_svc(yppushresp_xfr
*argp
, struct svc_req
*rqstp
)
270 static char * result
;
271 yppush_show_status(argp
->status
, argp
->transid
);
272 return((void *) &result
);
276 * Transmit a YPPROC_XFR request to ypserv.
279 yppush_send_xfr(struct jobs
*job
)
282 /* ypresp_xfr *resp; */
286 struct timeval timeout
;
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.
298 key
.data
= "YP_LAST_MODIFIED";
299 key
.size
= sizeof ("YP_LAST_MODIFIED") - 1;
301 if (yp_get_record(yppush_domain
, yppush_mapname
, &key
, &data
,
303 yp_error("failed to read order number from %s: %s: %s",
304 yppush_mapname
, yperr_string(yp_errno
),
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
;
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 \
321 create udp handle to NIS server"));
322 switch (rpc_createerr
.cf_stat
) {
323 case RPC_UNKNOWNHOST
:
324 job
->stat
= YPPUSH_NOHOST
;
326 case RPC_PMAPFAILURE
:
327 job
->stat
= YPPUSH_PMAP
;
330 job
->stat
= YPPUSH_RPC
;
337 * Reduce timeout to nothing since we may not
338 * get a response from ypserv and we don't want to block.
340 if (clnt_control(clnt
, CLSET_TIMEOUT
, (char *)&timeout
) == FALSE
)
341 yp_error("failed to set timeout on ypproc_xfr call");
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
,
350 job
->stat
= YPPUSH_YPSERV
;
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.
367 yp_push(char *server
, char *map
, unsigned long tid
)
369 unsigned long prognum
;
370 int sock
= RPC_ANYSOCK
;
374 /* Register the job in our linked list of jobs. */
376 /* First allocate job structure */
377 if ((job
= (struct jobs
*)malloc(sizeof (struct jobs
))) == NULL
) {
378 yp_error("malloc failed");
383 * Register the callback service on the first free transient
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
)
392 if (prognum
== 0x5FFFFFFF) {
393 yp_error ("can't register yppush_xfrrespprog_1");
397 /* Initialize the info for this job. */
400 job
->port
= xprt
->xp_port
;
401 job
->server
= strdup(server
);
402 job
->map
= strdup(map
);
403 job
->prognum
= prognum
;
405 job
->next
= yppush_joblist
;
406 yppush_joblist
= job
;
409 yp_error("initiating transfer: %s -> %s (transid = %lu)",
410 yppush_mapname
, server
, tid
);
414 * Send the XFR request to ypserv. We don't have to wait for
415 * a response here since we handle them asynchronously.
418 if (yppush_send_xfr(job
)){
419 /* Transfer request blew up. */
420 yppush_show_status(job
->stat
? job
->stat
:
421 YPPUSH_YPSERV
,job
->tid
);
424 yp_error("%s has been called", server
);
431 * Called for each entry in the ypservers map from yp_get_map(), which
432 * is our private yp_all() routine.
435 yppush_foreach(int status
, char *key
, int keylen
, char *val
, int vallen
,
438 char server
[YPMAXRECORD
+ 2];
440 if (status
!= YP_TRUE
)
443 snprintf(server
, sizeof(server
), "%.*s", vallen
, val
);
444 if (skip_master
&& strcasecmp(server
, yppush_master
) == 0)
448 * Restrict the number of concurrent jobs: if yppush_jobs number
449 * of jobs have already been dispatched and are still pending,
450 * wait for one of them to finish so we can reuse its slot.
452 while (yppush_running_jobs
>= yppush_jobs
&& (yppush_svc_run (yppush_timeout
) > 0))
455 /* Cleared for takeoff: set everything in motion. */
456 if (yp_push(server
, yppush_mapname
, yppush_transid
))
459 /* Bump the job counter and transaction ID. */
460 yppush_running_jobs
++;
468 fprintf (stderr
, "%s\n%s\n",
469 "usage: yppush [-d domain] [-t timeout] [-j #parallel jobs] [-h host]",
470 " [-p path] mapname");
475 * Entry point. (About time!)
478 main(int argc
, char *argv
[])
482 char myname
[MAXHOSTNAMELEN
];
485 struct hostlist
*next
;
487 struct hostlist
*yppush_hostlist
= NULL
;
488 struct hostlist
*tmp
;
490 while ((ch
= getopt(argc
, argv
, "d:j:p:h:t:v")) != -1) {
493 yppush_domain
= optarg
;
496 yppush_jobs
= atoi(optarg
);
497 if (yppush_jobs
<= 0)
503 case 'h': /* we can handle multiple hosts */
504 if ((tmp
= (struct hostlist
*)malloc(sizeof(struct hostlist
))) == NULL
) {
505 yp_error("malloc failed");
508 tmp
->name
= strdup(optarg
);
509 tmp
->next
= yppush_hostlist
;
510 yppush_hostlist
= tmp
;
513 yppush_timeout
= atoi(optarg
);
527 yppush_mapname
= argv
[0];
529 if (yppush_mapname
== NULL
) {
530 /* "No guts, no glory." */
535 * If no domain was specified, try to find the default
536 * domain. If we can't find that, we're doomed and must bail.
538 if (yppush_domain
== NULL
) {
539 char *yppush_check_domain
;
540 if (!yp_get_default_domain(&yppush_check_domain
) &&
541 !_yp_check(&yppush_check_domain
)) {
542 yp_error("no domain specified and NIS not running");
545 yp_get_default_domain(&yppush_domain
);
548 /* Check to see that we are the master for this map. */
550 if (gethostname ((char *)&myname
, sizeof(myname
))) {
551 yp_error("failed to get name of local host: %s",
556 key
.data
= "YP_MASTER_NAME";
557 key
.size
= sizeof("YP_MASTER_NAME") - 1;
559 if (yp_get_record(yppush_domain
, yppush_mapname
,
560 &key
, &data
, 1) != YP_TRUE
) {
561 yp_error("couldn't open %s map: %s", yppush_mapname
,
566 if (strncasecmp(myname
, data
.data
, data
.size
) == 0) {
567 /* I am master server, and no explicit host list was
568 specified: do not push map to myself -- this will
569 fail with YPPUSH_AGE anyway. */
570 if (yppush_hostlist
== NULL
)
573 yp_error("warning: this host is not the master for %s",
580 yppush_master
= malloc(data
.size
+ 1);
581 strncpy(yppush_master
, data
.data
, data
.size
);
582 yppush_master
[data
.size
] = '\0';
584 /* Install some handy handlers. */
585 signal(SIGTERM
, handler
);
586 signal(SIGINT
, handler
);
588 /* set initial transaction ID */
589 yppush_transid
= time(NULL
);
591 if (yppush_hostlist
) {
593 * Host list was specified on the command line:
594 * kick off the transfers by hand.
596 tmp
= yppush_hostlist
;
598 yppush_foreach(YP_TRUE
, NULL
, 0, tmp
->name
,
599 strlen(tmp
->name
), NULL
);
604 * Do a yp_all() on the ypservers map and initiate a ypxfr
607 ypxfr_get_map("ypservers", yppush_domain
,
608 "localhost", yppush_foreach
);
612 yp_error("all jobs dispatched");
614 /* All done -- normal exit. */