Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / contrib / amd / amq / amq.c
1 /*
2  * Copyright (c) 1997-1999 Erez Zadok
3  * Copyright (c) 1990 Jan-Simon Pendry
4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
5  * Copyright (c) 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Jan-Simon Pendry at Imperial College, London.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgment:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      %W% (Berkeley) %G%
40  *
41  * $Id: amq.c,v 1.6 1999/09/08 23:36:40 ezk Exp $
42  * $FreeBSD: src/contrib/amd/amq/amq.c,v 1.5 1999/09/15 05:45:14 obrien Exp $
43  * $DragonFly: src/contrib/amd/amq/amq.c,v 1.2 2003/06/17 04:23:57 dillon Exp $
44  *
45  */
46
47 /*
48  * Automounter query tool
49  */
50
51 #ifndef lint
52 char copyright[] = "\
53 @(#)Copyright (c) 1997-1999 Erez Zadok\n\
54 @(#)Copyright (c) 1990 Jan-Simon Pendry\n\
55 @(#)Copyright (c) 1990 Imperial College of Science, Technology & Medicine\n\
56 @(#)Copyright (c) 1990 The Regents of the University of California.\n\
57 @(#)All rights reserved.\n";
58 #if __GNUC__ < 2
59 static char rcsid[] = "$Id: amq.c,v 1.6 1999/09/08 23:36:40 ezk Exp $";
60 static char sccsid[] = "%W% (Berkeley) %G%";
61 #endif /* __GNUC__ < 2 */
62 #endif /* not lint */
63
64 #ifdef HAVE_CONFIG_H
65 # include <config.h>
66 #endif /* HAVE_CONFIG_H */
67 #include <am_defs.h>
68 #include <amq.h>
69
70 /* locals */
71 static int flush_flag;
72 static int minfo_flag;
73 static int getpid_flag;
74 static int unmount_flag;
75 static int stats_flag;
76 static int getvers_flag;
77 static int amd_program_number = AMQ_PROGRAM;
78 static int use_tcp_flag, use_udp_flag;
79 static char *debug_opts;
80 static char *amq_logfile;
81 static char *mount_map;
82 static char *xlog_optstr;
83 static char localhost[] = "localhost";
84 static char *def_server = localhost;
85
86 /* externals */
87 extern int optind;
88 extern char *optarg;
89
90 /* forward declarations */
91 #ifdef HAVE_TRANSPORT_TYPE_TLI
92 static CLIENT *get_secure_amd_client(char *host, struct timeval *tv, int *sock);
93 static int amq_bind_resv_port(int td, u_short *pp);
94 #else /* not HAVE_TRANSPORT_TYPE_TLI */
95 static int privsock(int ty);
96 #endif /* not HAVE_TRANSPORT_TYPE_TLI */
97
98 /* structures */
99 enum show_opt {
100   Full, Stats, Calc, Short, ShowDone
101 };
102
103
104 /*
105  * If (e) is Calc then just calculate the sizes
106  * Otherwise display the mount node on stdout
107  */
108 static void
109 show_mti(amq_mount_tree *mt, enum show_opt e, int *mwid, int *dwid, int *twid)
110 {
111   switch (e) {
112   case Calc:
113     {
114       int mw = strlen(mt->mt_mountinfo);
115       int dw = strlen(mt->mt_directory);
116       int tw = strlen(mt->mt_type);
117       if (mw > *mwid)
118         *mwid = mw;
119       if (dw > *dwid)
120         *dwid = dw;
121       if (tw > *twid)
122         *twid = tw;
123     }
124   break;
125
126   case Full:
127     {
128       struct tm *tp = localtime((time_t *) &mt->mt_mounttime);
129       printf("%-*.*s %-*.*s %-*.*s %s\n\t%-5d %-7d %-6d %-7d %-7d %-6d %02d/%02d/%02d %02d:%02d:%02d\n",
130              *dwid, *dwid,
131              *mt->mt_directory ? mt->mt_directory : "/",        /* XXX */
132              *twid, *twid,
133              mt->mt_type,
134              *mwid, *mwid,
135              mt->mt_mountinfo,
136              mt->mt_mountpoint,
137
138              mt->mt_mountuid,
139              mt->mt_getattr,
140              mt->mt_lookup,
141              mt->mt_readdir,
142              mt->mt_readlink,
143              mt->mt_statfs,
144
145              tp->tm_year > 99 ? tp->tm_year - 100 : tp->tm_year,
146              tp->tm_mon + 1, tp->tm_mday,
147              tp->tm_hour, tp->tm_min, tp->tm_sec);
148     }
149   break;
150
151   case Stats:
152     {
153       struct tm *tp = localtime((time_t *) &mt->mt_mounttime);
154       printf("%-*.*s %-5d %-7d %-6d %-7d %-7d %-6d %02d/%02d/%02d %02d:%02d:%02d\n",
155              *dwid, *dwid,
156              *mt->mt_directory ? mt->mt_directory : "/",        /* XXX */
157
158              mt->mt_mountuid,
159              mt->mt_getattr,
160              mt->mt_lookup,
161              mt->mt_readdir,
162              mt->mt_readlink,
163              mt->mt_statfs,
164
165              tp->tm_year > 99 ? tp->tm_year - 100 : tp->tm_year,
166              tp->tm_mon + 1, tp->tm_mday,
167              tp->tm_hour, tp->tm_min, tp->tm_sec);
168     }
169   break;
170
171   case Short:
172     {
173       printf("%-*.*s %-*.*s %-*.*s %s\n",
174              *dwid, *dwid,
175              *mt->mt_directory ? mt->mt_directory : "/",
176              *twid, *twid,
177              mt->mt_type,
178              *mwid, *mwid,
179              mt->mt_mountinfo,
180              mt->mt_mountpoint);
181     }
182   break;
183
184   default:
185     break;
186   }
187 }
188
189 /*
190  * Display a mount tree.
191  */
192 static void
193 show_mt(amq_mount_tree *mt, enum show_opt e, int *mwid, int *dwid, int *pwid)
194 {
195   while (mt) {
196     show_mti(mt, e, mwid, dwid, pwid);
197     show_mt(mt->mt_next, e, mwid, dwid, pwid);
198     mt = mt->mt_child;
199   }
200 }
201
202 static void
203 show_mi(amq_mount_info_list *ml, enum show_opt e, int *mwid, int *dwid, int *twid)
204 {
205   int i;
206
207   switch (e) {
208
209   case Calc:
210     {
211       for (i = 0; i < ml->amq_mount_info_list_len; i++) {
212         amq_mount_info *mi = &ml->amq_mount_info_list_val[i];
213         int mw = strlen(mi->mi_mountinfo);
214         int dw = strlen(mi->mi_mountpt);
215         int tw = strlen(mi->mi_type);
216         if (mw > *mwid)
217           *mwid = mw;
218         if (dw > *dwid)
219           *dwid = dw;
220         if (tw > *twid)
221           *twid = tw;
222       }
223     }
224   break;
225
226   case Full:
227     {
228       for (i = 0; i < ml->amq_mount_info_list_len; i++) {
229         amq_mount_info *mi = &ml->amq_mount_info_list_val[i];
230         printf("%-*.*s %-*.*s %-*.*s %-3d %s is %s",
231                *mwid, *mwid, mi->mi_mountinfo,
232                *dwid, *dwid, mi->mi_mountpt,
233                *twid, *twid, mi->mi_type,
234                mi->mi_refc, mi->mi_fserver,
235                mi->mi_up > 0 ? "up" :
236                mi->mi_up < 0 ? "starting" : "down");
237         if (mi->mi_error > 0) {
238           extern int sys_nerr;
239           if (mi->mi_error < sys_nerr)
240 #ifdef HAVE_STRERROR
241             printf(" (%s)", strerror(mi->mi_error));
242 #else /* not HAVE_STRERROR */
243             printf(" (%s)", sys_errlist[mi->mi_error]);
244 #endif /* not HAVE_STRERROR */
245           else
246             printf(" (Error %d)", mi->mi_error);
247         } else if (mi->mi_error < 0) {
248           fputs(" (in progress)", stdout);
249         }
250         fputc('\n', stdout);
251       }
252     }
253   break;
254
255   default:
256     break;
257   }
258 }
259
260
261 /*
262  * Display general mount statistics
263  */
264 static void
265 show_ms(amq_mount_stats *ms)
266 {
267   printf("\
268 requests  stale     mount     mount     unmount\n\
269 deferred  fhandles  ok        failed    failed\n\
270 %-9d %-9d %-9d %-9d %-9d\n",
271          ms->as_drops, ms->as_stale, ms->as_mok, ms->as_merr, ms->as_uerr);
272 }
273
274
275 #if defined(HAVE_CLUSTER_H) && defined(HAVE_CNODEID) && defined(HAVE_GETCCENT)
276 static char *
277 cluster_server(void)
278 {
279   struct cct_entry *cp;
280
281   if (cnodeid() == 0) {
282     /*
283      * Not clustered
284      */
285     return def_server;
286   }
287   while (cp = getccent())
288     if (cp->cnode_type == 'r')
289       return cp->cnode_name;
290
291   return def_server;
292 }
293 #endif /* defined(HAVE_CLUSTER_H) && defined(HAVE_CNODEID) && defined(HAVE_GETCCENT) */
294
295
296 /*
297  * MAIN
298  */
299 int
300 main(int argc, char *argv[])
301 {
302   int opt_ch;
303   int errs = 0;
304   char *server;
305   struct sockaddr_in server_addr;
306   int s;        /* to pass the Amd security check, we must use a priv port */
307   CLIENT *clnt = NULL;
308   struct hostent *hp;
309   int nodefault = 0;
310   struct timeval tv;
311   char *progname = NULL;
312 #ifndef HAVE_TRANSPORT_TYPE_TLI
313   enum clnt_stat cs;
314 #endif /* not HAVE_TRANSPORT_TYPE_TLI */
315
316
317   /*
318    * Compute program name
319    */
320   if (argv[0]) {
321     progname = strrchr(argv[0], '/');
322     if (progname && progname[1])
323       progname++;
324     else
325       progname = argv[0];
326   }
327   if (!progname)
328     progname = "amq";
329   am_set_progname(progname);
330
331   /*
332    * Parse arguments
333    */
334 #ifdef ENABLE_AMQ_MOUNT
335   while ((opt_ch = getopt(argc, argv, "fh:l:msuvx:D:M:pP:TU")) != -1)
336 #else /* not ENABLE_AMQ_MOUNT */
337   while ((opt_ch = getopt(argc, argv, "fh:l:msuvx:D:pP:TU")) != -1)
338 #endif /* not ENABLE_AMQ_MOUNT */
339     switch (opt_ch) {
340     case 'f':
341       flush_flag = 1;
342       nodefault = 1;
343       break;
344
345     case 'h':
346       def_server = optarg;
347       break;
348
349     case 'l':
350       amq_logfile = optarg;
351       nodefault = 1;
352       break;
353
354     case 'm':
355       minfo_flag = 1;
356       nodefault = 1;
357       break;
358
359     case 'p':
360       getpid_flag = 1;
361       nodefault = 1;
362       break;
363
364     case 's':
365       stats_flag = 1;
366       nodefault = 1;
367       break;
368
369     case 'u':
370       unmount_flag = 1;
371       nodefault = 1;
372       break;
373
374     case 'v':
375       getvers_flag = 1;
376       nodefault = 1;
377       break;
378
379     case 'x':
380       xlog_optstr = optarg;
381       nodefault = 1;
382       break;
383
384     case 'D':
385       debug_opts = optarg;
386       nodefault = 1;
387       break;
388
389 #ifdef ENABLE_AMQ_MOUNT
390     case 'M':
391       mount_map = optarg;
392       nodefault = 1;
393       break;
394 #endif /* ENABLE_AMQ_MOUNT */
395
396     case 'P':
397       amd_program_number = atoi(optarg);
398       break;
399
400     case 'T':
401       use_tcp_flag = 1;
402       break;
403
404     case 'U':
405       use_udp_flag = 1;
406       break;
407
408     default:
409       errs = 1;
410       break;
411     }
412
413   if (optind == argc) {
414     if (unmount_flag)
415       errs = 1;
416   }
417   if (errs) {
418   show_usage:
419     fprintf(stderr, "\
420 Usage: %s [-h host] [[-f] [-m] [-p] [-v] [-s]] | [[-u] directory ...]]\n\
421 \t[-l logfile|\"syslog\"] [-x log_flags] [-D dbg_opts]%s\n\
422 \t[-P prognum] [-T] [-U]\n",
423             am_get_progname(),
424 #ifdef ENABLE_AMQ_MOUNT
425             " [-M mapent]"
426 #else /* not ENABLE_AMQ_MOUNT */
427             ""
428 #endif /* not ENABLE_AMQ_MOUNT */
429     );
430     exit(1);
431   }
432
433
434
435   /* set use_udp and use_tcp flags both to on if none are defined */
436   if (!use_tcp_flag && !use_udp_flag)
437     use_tcp_flag = use_udp_flag = 1;
438
439 #if defined(HAVE_CLUSTER_H) && defined(HAVE_CNODEID) && defined(HAVE_GETCCENT)
440   /*
441    * Figure out root server of cluster
442    */
443   if (def_server == localhost)
444     server = cluster_server();
445   else
446 #endif /* defined(HAVE_CLUSTER_H) && defined(HAVE_CNODEID) && defined(HAVE_GETCCENT) */
447     server = def_server;
448
449   /*
450    * Get address of server
451    */
452   if ((hp = gethostbyname(server)) == 0 && !STREQ(server, localhost)) {
453     fprintf(stderr, "%s: Can't get address of %s\n",
454             am_get_progname(), server);
455     exit(1);
456   }
457   memset(&server_addr, 0, sizeof server_addr);
458   server_addr.sin_family = AF_INET;
459   if (hp) {
460     memmove((voidp) &server_addr.sin_addr, (voidp) hp->h_addr,
461             sizeof(server_addr.sin_addr));
462   } else {
463     /* fake "localhost" */
464     server_addr.sin_addr.s_addr = htonl(0x7f000001);
465   }
466
467   /*
468    * Create RPC endpoint
469    */
470   tv.tv_sec = 5;                /* 5 seconds for timeout or per retry */
471   tv.tv_usec = 0;
472
473 #ifdef HAVE_TRANSPORT_TYPE_TLI
474   clnt = get_secure_amd_client(server, &tv, &s);
475   if (!clnt && use_tcp_flag)    /* try tcp first */
476     clnt = clnt_create(server, amd_program_number, AMQ_VERSION, "tcp");
477   if (!clnt && use_udp_flag) {  /* try udp next */
478     clnt = clnt_create(server, amd_program_number, AMQ_VERSION, "udp");
479     /* if ok, set timeout (valid for connectionless transports only) */
480     if (clnt)
481       clnt_control(clnt, CLSET_RETRY_TIMEOUT, (char *) &tv);
482   }
483 #else /* not HAVE_TRANSPORT_TYPE_TLI */
484
485   /* first check if remote portmapper is up */
486   cs = pmap_ping(&server_addr);
487   if (cs == RPC_TIMEDOUT) {
488     fprintf(stderr, "%s: failed to contact portmapper on host \"%s\". %s\n",
489             am_get_progname(), server, clnt_sperrno(cs));
490     exit(1);
491   }
492
493   /* portmapper exists: get remote amd info from it */
494   if (!clnt && use_tcp_flag) {  /* try tcp first */
495     s = RPC_ANYSOCK;
496     clnt = clnttcp_create(&server_addr, amd_program_number,
497                           AMQ_VERSION, &s, 0, 0);
498   }
499   if (!clnt && use_udp_flag) {  /* try udp next */
500     /* XXX: do we need to close(s) ? */
501     s = privsock(SOCK_DGRAM);
502     clnt = clntudp_create(&server_addr, amd_program_number,
503                           AMQ_VERSION, tv, &s);
504   }
505 #endif /* not HAVE_TRANSPORT_TYPE_TLI */
506   if (!clnt) {
507     fprintf(stderr, "%s: ", am_get_progname());
508     clnt_pcreateerror(server);
509     exit(1);
510   }
511
512   /*
513    * Control debugging
514    */
515   if (debug_opts) {
516     int *rc;
517     amq_setopt opt;
518     opt.as_opt = AMOPT_DEBUG;
519     opt.as_str = debug_opts;
520     rc = amqproc_setopt_1(&opt, clnt);
521     if (rc && *rc < 0) {
522       fprintf(stderr, "%s: daemon not compiled for debug\n",
523               am_get_progname());
524       errs = 1;
525     } else if (!rc || *rc > 0) {
526       fprintf(stderr, "%s: debug setting for \"%s\" failed\n",
527               am_get_progname(), debug_opts);
528       errs = 1;
529     }
530   }
531
532   /*
533    * Control logging
534    */
535   if (xlog_optstr) {
536     int *rc;
537     amq_setopt opt;
538     opt.as_opt = AMOPT_XLOG;
539     opt.as_str = xlog_optstr;
540     rc = amqproc_setopt_1(&opt, clnt);
541     if (!rc || *rc) {
542       fprintf(stderr, "%s: setting log level to \"%s\" failed\n",
543               am_get_progname(), xlog_optstr);
544       errs = 1;
545     }
546   }
547
548   /*
549    * Control log file
550    */
551   if (amq_logfile) {
552     int *rc;
553     amq_setopt opt;
554     opt.as_opt = AMOPT_LOGFILE;
555     opt.as_str = amq_logfile;
556     rc = amqproc_setopt_1(&opt, clnt);
557     if (!rc || *rc) {
558       fprintf(stderr, "%s: setting logfile to \"%s\" failed\n",
559               am_get_progname(), amq_logfile);
560       errs = 1;
561     }
562   }
563
564   /*
565    * Flush map cache
566    */
567   if (flush_flag) {
568     int *rc;
569     amq_setopt opt;
570     opt.as_opt = AMOPT_FLUSHMAPC;
571     opt.as_str = "";
572     rc = amqproc_setopt_1(&opt, clnt);
573     if (!rc || *rc) {
574       fprintf(stderr, "%s: amd on %s cannot flush the map cache\n",
575               am_get_progname(), server);
576       errs = 1;
577     }
578   }
579
580   /*
581    * Mount info
582    */
583   if (minfo_flag) {
584     int dummy;
585     amq_mount_info_list *ml = amqproc_getmntfs_1(&dummy, clnt);
586     if (ml) {
587       int mwid = 0, dwid = 0, twid = 0;
588       show_mi(ml, Calc, &mwid, &dwid, &twid);
589       mwid++;
590       dwid++;
591       twid++;
592       show_mi(ml, Full, &mwid, &dwid, &twid);
593
594     } else {
595       fprintf(stderr, "%s: amd on %s cannot provide mount info\n",
596               am_get_progname(), server);
597     }
598   }
599
600   /*
601    * Mount map
602    */
603   if (mount_map) {
604     int *rc;
605     do {
606       rc = amqproc_mount_1(&mount_map, clnt);
607     } while (rc && *rc < 0);
608     if (!rc || *rc > 0) {
609       if (rc)
610         errno = *rc;
611       else
612         errno = ETIMEDOUT;
613       fprintf(stderr, "%s: could not start new ", am_get_progname());
614       perror("automount point");
615     }
616   }
617
618   /*
619    * Get Version
620    */
621   if (getvers_flag) {
622     amq_string *spp = amqproc_getvers_1((voidp) 0, clnt);
623     if (spp && *spp) {
624       fputs(*spp, stdout);
625       XFREE(*spp);
626     } else {
627       fprintf(stderr, "%s: failed to get version information\n",
628               am_get_progname());
629       errs = 1;
630     }
631   }
632
633   /*
634    * Get PID of amd
635    */
636   if (getpid_flag) {
637     int *ip = amqproc_getpid_1((voidp) 0, clnt);
638     if (ip && *ip) {
639       printf("%d\n", *ip);
640     } else {
641       fprintf(stderr, "%s: failed to get PID of amd\n", am_get_progname());
642       errs = 1;
643     }
644   }
645
646   /*
647    * Apply required operation to all remaining arguments
648    */
649   if (optind < argc) {
650     do {
651       char *fs = argv[optind++];
652       if (unmount_flag) {
653         /*
654          * Unmount request
655          */
656         amqproc_umnt_1(&fs, clnt);
657       } else {
658         /*
659          * Stats request
660          */
661         amq_mount_tree_p *mtp = amqproc_mnttree_1(&fs, clnt);
662         if (mtp) {
663           amq_mount_tree *mt = *mtp;
664           if (mt) {
665             int mwid = 0, dwid = 0, twid = 0;
666             show_mt(mt, Calc, &mwid, &dwid, &twid);
667             mwid++;
668             dwid++, twid++;
669             printf("%-*.*s Uid   Getattr Lookup RdDir   RdLnk   Statfs Mounted@\n",
670                    dwid, dwid, "What");
671             show_mt(mt, Stats, &mwid, &dwid, &twid);
672           } else {
673             fprintf(stderr, "%s: %s not automounted\n", am_get_progname(), fs);
674           }
675           xdr_pri_free((XDRPROC_T_TYPE) xdr_amq_mount_tree_p, (caddr_t) mtp);
676         } else {
677           fprintf(stderr, "%s: ", am_get_progname());
678           clnt_perror(clnt, server);
679           errs = 1;
680         }
681       }
682     } while (optind < argc);
683
684   } else if (unmount_flag) {
685     goto show_usage;
686
687   } else if (stats_flag) {
688     amq_mount_stats *ms = amqproc_stats_1((voidp) 0, clnt);
689     if (ms) {
690       show_ms(ms);
691     } else {
692       fprintf(stderr, "%s: ", am_get_progname());
693       clnt_perror(clnt, server);
694       errs = 1;
695     }
696
697   } else if (!nodefault) {
698     amq_mount_tree_list *mlp = amqproc_export_1((voidp) 0, clnt);
699     if (mlp) {
700       enum show_opt e = Calc;
701       int mwid = 0, dwid = 0, pwid = 0;
702       while (e != ShowDone) {
703         int i;
704         for (i = 0; i < mlp->amq_mount_tree_list_len; i++) {
705           show_mt(mlp->amq_mount_tree_list_val[i],
706                   e, &mwid, &dwid, &pwid);
707         }
708         mwid++;
709         dwid++, pwid++;
710         if (e == Calc)
711           e = Short;
712         else if (e == Short)
713           e = ShowDone;
714       }
715
716     } else {
717       fprintf(stderr, "%s: ", am_get_progname());
718       clnt_perror(clnt, server);
719       errs = 1;
720     }
721   }
722   exit(errs);
723   return errs; /* should never reach here */
724 }
725
726
727 #ifdef HAVE_TRANSPORT_TYPE_TLI
728
729 /*
730  * How to bind to reserved ports.
731  * TLI handle (socket) and port version.
732  */
733 /* defined here so that it does not have to resolve it with libamu.a */
734 static int
735 amq_bind_resv_port(int td, u_short *pp)
736 {
737   int rc = -1, port;
738   struct t_bind *treq, *tret;
739   struct sockaddr_in *sin;
740
741   treq = (struct t_bind *) t_alloc(td, T_BIND, T_ADDR);
742   if (!treq) {
743     plog(XLOG_ERROR, "t_alloc 1");
744     return -1;
745   }
746   tret = (struct t_bind *) t_alloc(td, T_BIND, T_ADDR);
747   if (!tret) {
748     t_free((char *) treq, T_BIND);
749     plog(XLOG_ERROR, "t_alloc 2");
750     return -1;
751   }
752   memset((char *) treq->addr.buf, 0, treq->addr.len);
753   sin = (struct sockaddr_in *) treq->addr.buf;
754   sin->sin_family = AF_INET;
755   treq->qlen = 0;
756   treq->addr.len = treq->addr.maxlen;
757   errno = EADDRINUSE;
758   port = IPPORT_RESERVED;
759
760   do {
761     --port;
762     sin->sin_port = htons(port);
763     rc = t_bind(td, treq, tret);
764     if (rc < 0) {
765     } else {
766       if (memcmp(treq->addr.buf, tret->addr.buf, tret->addr.len) == 0)
767         break;
768       else
769         t_unbind(td);
770     }
771   } while ((rc < 0 || errno == EADDRINUSE) && (int) port > IPPORT_RESERVED / 2);
772
773   if (pp) {
774     if (rc == 0)
775       *pp = port;
776     else
777       plog(XLOG_ERROR, "could not t_bind to any reserved port");
778   }
779   t_free((char *) tret, T_BIND);
780   t_free((char *) treq, T_BIND);
781   return rc;
782 }
783
784
785 /*
786  * Create a secure rpc client attached to the amd daemon.
787  */
788 static CLIENT *
789 get_secure_amd_client(char *host, struct timeval *tv, int *sock)
790 {
791   CLIENT *client;
792   struct netbuf nb;
793   struct netconfig *nc, *pm_nc;
794   struct sockaddr_in sin;
795
796
797   nb.maxlen = sizeof(sin);
798   nb.buf = (char *) &sin;
799
800   /*
801    * Ensure that remote portmapper is alive
802    * (must use connectionless netconfig).
803    */
804   if ((pm_nc = getnetconfigent(NC_UDP)) != NULL) {
805     enum clnt_stat cs;
806
807     cs = rpcb_rmtcall(pm_nc,
808                       host,
809                       amd_program_number,
810                       AMQ_VERSION,
811                       AMQPROC_NULL,
812                       (XDRPROC_T_TYPE) xdr_void,
813                       NULL,
814                       (XDRPROC_T_TYPE) xdr_void,
815                       NULL,
816                       *tv,
817                       NULL);
818     if (cs == RPC_TIMEDOUT) {
819       fprintf(stderr, "%s: failed to contact portmapper on host \"%s\". %s\n",
820               am_get_progname(), host, clnt_sperrno(cs));
821       exit(1);
822     }
823   }
824
825   /*
826    * First transport type to try: TCP
827    */
828   if (use_tcp_flag) {
829     /* Find amd address on TCP */
830     nc = getnetconfigent(NC_TCP);
831     if (!nc) {
832       fprintf(stderr, "getnetconfig for tcp failed: %s\n", nc_sperror());
833       goto tryudp;
834     }
835
836     if (!rpcb_getaddr(amd_program_number, AMQ_VERSION, nc, &nb, host)) {
837       /*
838        * don't print error messages here, since amd might legitimately
839        * serve udp only
840        */
841       goto tryudp;
842     }
843     /* Create privileged TCP socket */
844     *sock = t_open(nc->nc_device, O_RDWR, 0);
845
846     if (*sock < 0) {
847       fprintf(stderr, "t_open %s: %m\n", nc->nc_device);
848       goto tryudp;
849     }
850     if (amq_bind_resv_port(*sock, (u_short *) 0) < 0)
851       goto tryudp;
852
853     client = clnt_vc_create(*sock, &nb, amd_program_number, AMQ_VERSION, 0, 0);
854     if (!client) {
855       fprintf(stderr, "clnt_vc_create failed");
856       t_close(*sock);
857       goto tryudp;
858     }
859     /* tcp succeeded */
860     return client;
861   }
862
863 tryudp:
864   /*
865    * TCP failed so try UDP
866    */
867   if (use_udp_flag) {
868     /* find amd address on UDP */
869     nc = getnetconfigent(NC_UDP);
870     if (!nc) {
871       fprintf(stderr, "getnetconfig for udp failed: %s\n", nc_sperror());
872       return NULL;
873     }
874     if (!rpcb_getaddr(amd_program_number, AMQ_VERSION, nc, &nb, host)) {
875       fprintf(stderr, "%s\n",
876               clnt_spcreateerror("couldn't get amd address on udp"));
877       return NULL;
878     }
879     /* create privileged UDP socket */
880     *sock = t_open(nc->nc_device, O_RDWR, 0);
881
882     if (*sock < 0) {
883       fprintf(stderr, "t_open %s: %m\n", nc->nc_device);
884       return NULL;              /* neither tcp not udp succeeded */
885     }
886     if (amq_bind_resv_port(*sock, (u_short *) 0) < 0)
887       return NULL;
888
889     client = clnt_dg_create(*sock, &nb, amd_program_number, AMQ_VERSION, 0, 0);
890     if (!client) {
891       fprintf(stderr, "clnt_dg_create failed\n");
892       t_close(*sock);
893       return NULL;              /* neither tcp not udp succeeded */
894     }
895     if (clnt_control(client, CLSET_RETRY_TIMEOUT, (char *) tv) == FALSE) {
896       fprintf(stderr, "clnt_control CLSET_RETRY_TIMEOUT for udp failed\n");
897       clnt_destroy(client);
898       return NULL;              /* neither tcp not udp succeeded */
899     }
900     /* udp succeeded */
901     return client;
902   }
903
904   /* should never get here */
905   return NULL;
906 }
907
908 #else /* not HAVE_TRANSPORT_TYPE_TLI */
909
910 /*
911  * inetresport creates a datagram socket and attempts to bind it to a
912  * secure port.
913  * returns: The bound socket, or -1 to indicate an error.
914  */
915 static int
916 inetresport(int ty)
917 {
918   int alport;
919   struct sockaddr_in addr;
920   int fd;
921
922   /* Use internet address family */
923   addr.sin_family = AF_INET;
924   addr.sin_addr.s_addr = INADDR_ANY;
925   if ((fd = socket(AF_INET, ty, 0)) < 0)
926     return -1;
927
928   for (alport = IPPORT_RESERVED - 1; alport > IPPORT_RESERVED / 2 + 1; alport--) {
929     addr.sin_port = htons((u_short) alport);
930     if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) >= 0)
931       return fd;
932     if (errno != EADDRINUSE) {
933       close(fd);
934       return -1;
935     }
936   }
937   close(fd);
938   errno = EAGAIN;
939   return -1;
940 }
941
942
943 /*
944  * Privsock() calls inetresport() to attempt to bind a socket to a secure
945  * port.  If inetresport() fails, privsock returns a magic socket number which
946  * indicates to RPC that it should make its own socket.
947  * returns: A privileged socket # or RPC_ANYSOCK.
948  */
949 static int
950 privsock(int ty)
951 {
952   int sock = inetresport(ty);
953
954   if (sock < 0) {
955     errno = 0;
956     /* Couldn't get a secure port, let RPC make an insecure one */
957     sock = RPC_ANYSOCK;
958   }
959   return sock;
960 }
961
962 #endif /* not HAVE_TRANSPORT_TYPE_TLI */