yp*: Staticise.
[dragonfly.git] / usr.sbin / yppush / yppush_main.c
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  * $FreeBSD: src/usr.sbin/yppush/yppush_main.c,v 1.22 2006/08/16 12:58:41 thomas Exp $
33  */
34
35 #include <errno.h>
36 #include <signal.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <strings.h>
41 #include <time.h>
42 #include <unistd.h>
43 #include <sys/socket.h>
44 #include <sys/fcntl.h>
45 #include <sys/wait.h>
46 #include <sys/param.h>
47 #include <rpc/rpc.h>
48 #include <rpc/clnt.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"
54
55 char *progname = "yppush";
56 int debug = 1;
57 int _rpcpmstart = 0;
58 const char *yp_dir = _PATH_YP;
59
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. */
69
70 /* Structure for holding information about a running job. */
71 struct jobs {
72         unsigned long tid;
73         int port;
74         ypxfrstat stat;
75         unsigned long prognum;
76         char *server;
77         char *map;
78         int polled;
79         struct jobs *next;
80 };
81
82 static struct jobs *yppush_joblist;     /* Linked list of running jobs. */
83 static int yppush_svc_run(int);
84
85 /*
86  * Local error messages.
87  */
88 static const char *
89 yppusherr_string(int err)
90 {
91         switch (err) {
92         case YPPUSH_TIMEDOUT:
93                 return("transfer or callback timed out");
94         case YPPUSH_YPSERV:
95                 return("failed to contact ypserv");
96         case YPPUSH_NOHOST:
97                 return("no such host");
98         case YPPUSH_PMAP:
99                 return("portmapper failure");
100         default:
101                 return("unknown error code");
102         }
103 }
104
105 /*
106  * Report state of a job.
107  */
108 static int
109 yppush_show_status(ypxfrstat status, unsigned long tid)
110 {
111         struct jobs *job;
112
113         job = yppush_joblist;
114
115         while (job != NULL) {
116                 if (job->tid == tid)
117                         break;
118                 job = job->next;
119         }
120
121         if (job == NULL) {
122                 yp_error("warning: received callback with invalid transaction ID: %lu",
123                          tid);
124                 return (0);
125         }
126
127         if (job->polled) {
128                 yp_error("warning: received callback with duplicate transaction ID: %lu",
129                          tid);
130                 return (0);
131         }
132
133         if (verbose > 1) {
134                 yp_error("checking return status: transaction ID: %lu",
135                                                                 job->tid);
136         }
137
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));
145         }
146
147         job->polled = 1;
148
149         svc_unregister(job->prognum, 1);
150
151         yppush_running_jobs--;
152         return(0);
153 }
154
155 /* Exit routine. */
156 static void
157 yppush_exit(int now)
158 {
159         struct jobs *jptr;
160         int still_pending = 1;
161
162         /* Let all the information trickle in. */
163         while (!now && still_pending) {
164                 jptr = yppush_joblist;
165                 still_pending = 0;
166                 while (jptr) {
167                         if (jptr->polled == 0) {
168                                 still_pending++;
169                                 if (verbose > 1)
170                                         yp_error("%s has not responded",
171                                                   jptr->server);
172                         } else {
173                                 if (verbose > 1)
174                                         yp_error("%s has responded",
175                                                   jptr->server);
176                         }
177                         jptr = jptr->next;
178                 }
179                 if (still_pending) {
180                         if (verbose > 1)
181                                 yp_error("%d transfer%sstill pending",
182                                         still_pending,
183                                         still_pending > 1 ? "s " : " ");
184                         if (yppush_svc_run (YPPUSH_RESPONSE_TIMEOUT) == 0) {
185                                 yp_error("timed out");
186                                 now = 1;
187                         }
188                 } else {
189                         if (verbose)
190                                 yp_error("all transfers complete");
191                         break;
192                 }
193         }
194
195
196         /* All stats collected and reported -- kill all the stragglers. */
197         jptr = yppush_joblist;
198         while (jptr) {
199                 if (!jptr->polled)
200                         yp_error("warning: exiting with transfer \
201 to %s (transid = %lu) still pending", jptr->server, jptr->tid);
202                 svc_unregister(jptr->prognum, 1);
203                 jptr = jptr->next;
204         }
205
206         exit(0);
207 }
208
209 /*
210  * Handler for 'normal' signals.
211  */
212
213 static void
214 handler(int sig)
215 {
216         yppush_exit (1);
217         return;
218 }
219
220 /*
221  * Dispatch loop for callback RPC services.
222  * Return value:
223  *   -1 error
224  *    0 timeout
225  *   >0 request serviced
226  */
227 static int
228 yppush_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
237 retry:
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  */
259 void *
260 yppushproc_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
267 void *
268 yppushproc_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  */
278 static int
279 yppush_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 \
321 create 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  */
366 static int
367 yp_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  */
434 static int
435 yppush_foreach(int status, char *key, int keylen, char *val, int vallen,
436                char *data)
437 {
438         char server[YPMAXRECORD + 2];
439
440         if (status != YP_TRUE)
441                 return (status);
442
443         snprintf(server, sizeof(server), "%.*s", vallen, val);
444         if (skip_master && strcasecmp(server, yppush_master) == 0)
445                 return (0);
446
447         /*
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.
451          */
452         while (yppush_running_jobs >= yppush_jobs && (yppush_svc_run (yppush_timeout) > 0))
453                 ;
454
455         /* Cleared for takeoff: set everything in motion. */
456         if (yp_push(server, yppush_mapname, yppush_transid))
457                 return(yp_errno);
458
459         /* Bump the job counter and transaction ID. */
460         yppush_running_jobs++;
461         yppush_transid++;
462         return (0);
463 }
464
465 static void
466 usage(void)
467 {
468         fprintf (stderr, "%s\n%s\n",
469         "usage: yppush [-d domain] [-t timeout] [-j #parallel jobs] [-h host]",
470         "              [-p path] mapname");
471         exit(1);
472 }
473
474 /*
475  * Entry point. (About time!)
476  */
477 int
478 main(int argc, char *argv[])
479 {
480         int ch;
481         DBT key, data;
482         char myname[MAXHOSTNAMELEN];
483         struct hostlist {
484                 char *name;
485                 struct hostlist *next;
486         };
487         struct hostlist *yppush_hostlist = NULL;
488         struct hostlist *tmp;
489
490         while ((ch = getopt(argc, argv, "d:j:p:h:t:v")) != -1) {
491                 switch (ch) {
492                 case 'd':
493                         yppush_domain = optarg;
494                         break;
495                 case 'j':
496                         yppush_jobs = atoi(optarg);
497                         if (yppush_jobs <= 0)
498                                 yppush_jobs = 1;
499                         break;
500                 case 'p':
501                         yp_dir = optarg;
502                         break;
503                 case 'h': /* we can handle multiple hosts */
504                         if ((tmp = (struct hostlist *)malloc(sizeof(struct hostlist))) == NULL) {
505                                 yp_error("malloc failed");
506                                 yppush_exit(1);
507                         }
508                         tmp->name = strdup(optarg);
509                         tmp->next = yppush_hostlist;
510                         yppush_hostlist = tmp;
511                         break;
512                 case 't':
513                         yppush_timeout = atoi(optarg);
514                         break;
515                 case 'v':
516                         verbose++;
517                         break;
518                 default:
519                         usage();
520                         break;
521                 }
522         }
523
524         argc -= optind;
525         argv += optind;
526
527         yppush_mapname = argv[0];
528
529         if (yppush_mapname == NULL) {
530         /* "No guts, no glory." */
531                 usage();
532         }
533
534         /*
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.
537          */
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");
543                         usage();
544                 } else
545                         yp_get_default_domain(&yppush_domain);
546         }
547
548         /* Check to see that we are the master for this map. */
549
550         if (gethostname ((char *)&myname, sizeof(myname))) {
551                 yp_error("failed to get name of local host: %s",
552                         strerror(errno));
553                 yppush_exit(1);
554         }
555
556         key.data = "YP_MASTER_NAME";
557         key.size = sizeof("YP_MASTER_NAME") - 1;
558
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,
562                          strerror(errno));
563                 yppush_exit(1);
564         }
565
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)
571                         skip_master = 1;
572         } else {
573                 yp_error("warning: this host is not the master for %s",
574                                                         yppush_mapname);
575 #ifdef NITPICKY
576                 yppush_exit(1);
577 #endif
578         }
579
580         yppush_master = malloc(data.size + 1);
581         strncpy(yppush_master, data.data, data.size);
582         yppush_master[data.size] = '\0';
583
584         /* Install some handy handlers. */
585         signal(SIGTERM, handler);
586         signal(SIGINT, handler);
587
588         /* set initial transaction ID */
589         yppush_transid = time(NULL);
590
591         if (yppush_hostlist) {
592         /*
593          * Host list was specified on the command line:
594          * kick off the transfers by hand.
595          */
596                 tmp = yppush_hostlist;
597                 while (tmp) {
598                         yppush_foreach(YP_TRUE, NULL, 0, tmp->name,
599                             strlen(tmp->name), NULL);
600                         tmp = tmp->next;
601                 }
602         } else {
603         /*
604          * Do a yp_all() on the ypservers map and initiate a ypxfr
605          * for each one.
606          */
607                 ypxfr_get_map("ypservers", yppush_domain,
608                               "localhost", yppush_foreach);
609         }
610
611         if (verbose > 1)
612                 yp_error("all jobs dispatched");
613
614         /* All done -- normal exit. */
615         yppush_exit(0);
616
617         /* Just in case. */
618         exit(0);
619 }