Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / amd / amd / conf.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: conf.c,v 1.5 1999/09/30 21:01:30 ezk Exp $
42  *
43  */
44
45 /*
46  * Functions to handle the configuration file.
47  */
48
49 #ifdef HAVE_CONFIG_H
50 # include <config.h>
51 #endif /* HAVE_CONFIG_H */
52 #include <am_defs.h>
53 #include <amd.h>
54
55
56 /*
57  * MACROS:
58  */
59 /* Turn on to show some info about maps being configured */
60 /* #define DEBUG_CONF */
61
62 /*
63  * TYPEDEFS:
64  */
65 typedef int (*OptFuncPtr)(const char *);
66
67 /*
68  * STRUCTURES:
69  */
70 struct _func_map {
71   char *name;
72   OptFuncPtr func;
73 };
74
75 /*
76  * FORWARD DECLARATIONS:
77  */
78 static int gopt_arch(const char *val);
79 static int gopt_auto_dir(const char *val);
80 static int gopt_browsable_dirs(const char *val);
81 static int gopt_cache_duration(const char *val);
82 static int gopt_cluster(const char *val);
83 static int gopt_debug_options(const char *val);
84 static int gopt_dismount_interval(const char *val);
85 static int gopt_full_os(const char *val);
86 static int gopt_fully_qualified_hosts(const char *val);
87 static int gopt_hesiod_base(const char *val);
88 static int gopt_karch(const char *val);
89 static int gopt_ldap_base(const char *val);
90 static int gopt_ldap_cache_maxmem(const char *val);
91 static int gopt_ldap_cache_seconds(const char *val);
92 static int gopt_ldap_hostports(const char *val);
93 static int gopt_local_domain(const char *val);
94 static int gopt_log_file(const char *val);
95 static int gopt_log_options(const char *val);
96 static int gopt_map_options(const char *val);
97 static int gopt_map_type(const char *val);
98 static int gopt_mount_type(const char *val);
99 static int gopt_pid_file(const char *val);
100 static int gopt_portmap_program(const char *val);
101 static int gopt_nfs_retransmit_counter(const char *val);
102 static int gopt_nfs_retry_interval(const char *val);
103 static int gopt_nis_domain(const char *val);
104 static int gopt_normalize_hostnames(const char *val);
105 static int gopt_os(const char *val);
106 static int gopt_osver(const char *val);
107 static int gopt_plock(const char *val);
108 static int gopt_print_pid(const char *val);
109 static int gopt_print_version(const char *val);
110 static int gopt_restart_mounts(const char *val);
111 static int gopt_search_path(const char *val);
112 static int gopt_selectors_on_default(const char *val);
113 static int gopt_show_statfs_entries(const char *val);
114 static int gopt_unmount_on_exit(const char *val);
115 static int gopt_vendor(const char *val);
116 static int process_global_option(const char *key, const char *val);
117 static int process_regular_map(cf_map_t *cfm);
118 static int process_regular_option(const char *section, const char *key, const char *val, cf_map_t *cfm);
119 static int ropt_browsable_dirs(const char *val, cf_map_t *cfm);
120 static int ropt_map_name(const char *val, cf_map_t *cfm);
121 static int ropt_map_options(const char *val, cf_map_t *cfm);
122 static int ropt_map_type(const char *val, cf_map_t *cfm);
123 static int ropt_mount_type(const char *val, cf_map_t *cfm);
124 static int ropt_search_path(const char *val, cf_map_t *cfm);
125 static int ropt_tag(const char *val, cf_map_t *cfm);
126 static void reset_cf_map(cf_map_t *cfm);
127
128
129 /*
130  * STATIC VARIABLES:
131  */
132 static cf_map_t cur_map;
133 static struct _func_map glob_functable[] = {
134   {"arch",                      gopt_arch},
135   {"auto_dir",                  gopt_auto_dir},
136   {"browsable_dirs",            gopt_browsable_dirs},
137   {"cache_duration",            gopt_cache_duration},
138   {"cluster",                   gopt_cluster},
139   {"debug_options",             gopt_debug_options},
140   {"dismount_interval",         gopt_dismount_interval},
141   {"fully_qualified_hosts",     gopt_fully_qualified_hosts},
142   {"full_os",                   gopt_full_os},
143   {"hesiod_base",               gopt_hesiod_base},
144   {"karch",                     gopt_karch},
145   {"ldap_base",                 gopt_ldap_base},
146   {"ldap_cache_maxmem",         gopt_ldap_cache_maxmem},
147   {"ldap_cache_seconds",        gopt_ldap_cache_seconds},
148   {"ldap_hostports",            gopt_ldap_hostports},
149   {"local_domain",              gopt_local_domain},
150   {"log_file",                  gopt_log_file},
151   {"log_options",               gopt_log_options},
152   {"map_options",               gopt_map_options},
153   {"map_type",                  gopt_map_type},
154   {"mount_type",                gopt_mount_type},
155   {"pid_file",                  gopt_pid_file},
156   {"portmap_program",           gopt_portmap_program},
157   {"nfs_retransmit_counter",    gopt_nfs_retransmit_counter},
158   {"nfs_retry_interval",        gopt_nfs_retry_interval},
159   {"nis_domain",                gopt_nis_domain},
160   {"normalize_hostnames",       gopt_normalize_hostnames},
161   {"os",                        gopt_os},
162   {"osver",                     gopt_osver},
163   {"plock",                     gopt_plock},
164   {"print_pid",                 gopt_print_pid},
165   {"print_version",             gopt_print_version},
166   {"restart_mounts",            gopt_restart_mounts},
167   {"search_path",               gopt_search_path},
168   {"selectors_on_default",      gopt_selectors_on_default},
169   {"show_statfs_entries",       gopt_show_statfs_entries},
170   {"unmount_on_exit",           gopt_unmount_on_exit},
171   {"vendor",                    gopt_vendor},
172   {NULL, NULL}
173 };
174
175
176 /*
177  * Reset a map.
178  */
179 static void
180 reset_cf_map(cf_map_t *cfm)
181 {
182   if (!cfm)
183     return;
184
185   if (cfm->cfm_dir) {
186     XFREE(cfm->cfm_dir);
187     cfm->cfm_dir = NULL;
188   }
189
190   if (cfm->cfm_name) {
191     XFREE(cfm->cfm_name);
192     cfm->cfm_name = NULL;
193   }
194
195   if (cfm->cfm_tag) {
196     XFREE(cfm->cfm_tag);
197     cfm->cfm_tag = NULL;
198   }
199
200   /*
201    * reset/initialize a regular map's flags and other variables from the
202    * global ones, so that they are applied to all maps.  Of course, each map
203    * can then override the flags individually.
204    *
205    * NOTES:
206    * (1): Will only work for maps that appear after [global].
207    * (2): Also be careful not to free() a global option.
208    * (3): I'm doing direct char* pointer comparison, and not strcmp().  This
209    *      is correct!
210    */
211
212   /* initialize map_type from [global] */
213   if (cfm->cfm_type && cfm->cfm_type != gopt.map_type)
214     XFREE(cfm->cfm_type);
215   cfm->cfm_type = gopt.map_type;
216
217   /* initialize map_opts from [global] */
218   if (cfm->cfm_opts && cfm->cfm_opts != gopt.map_options)
219     XFREE(cfm->cfm_opts);
220   cfm->cfm_opts = gopt.map_options;
221
222   /* initialize search_path from [global] */
223   if (cfm->cfm_search_path && cfm->cfm_search_path != gopt.search_path)
224     XFREE(cfm->cfm_search_path);
225   cfm->cfm_search_path = gopt.search_path;
226
227   /*
228    * Initialize flags that are common both to [global] and a local map.
229    */
230   cfm->cfm_flags = gopt.flags & (CFM_BROWSABLE_DIRS |
231                                  CFM_BROWSABLE_DIRS_FULL |
232                                  CFM_MOUNT_TYPE_AUTOFS |
233                                  CFM_ENABLE_DEFAULT_SELECTORS);
234 }
235
236
237 /*
238  * Process configuration file options.
239  * Return 0 if OK, 1 otherwise.
240  */
241 int
242 set_conf_kv(const char *section, const char *key, const char *val)
243 {
244   int ret;
245
246 #ifdef DEBUG_CONF
247   fprintf(stderr,"set_conf_kv: section=%s, key=%s, val=%s\n",
248           section, key, val);
249 #endif /* DEBUG_CONF */
250
251   /*
252    * If global section, process them one at a time.
253    */
254   if (STREQ(section, "global")) {
255     /*
256      * Check if a regular map was configured before "global",
257      * and process it as needed.
258      */
259     if (cur_map.cfm_dir) {
260       fprintf(stderr,"processing regular map \"%s\" before global one.\n",
261               section);
262       ret = process_regular_map(&cur_map); /* will reset map */
263       if (ret != 0)
264         return ret;
265     }
266
267     /* process the global option first */
268     ret = process_global_option(key, val);
269
270     /* reset default options for regular maps from just updated globals */
271     if (ret == 0)
272       reset_cf_map(&cur_map);
273
274     /* return status from the processing of the global option */
275     return ret;
276   }
277
278   /*
279    * otherwise save options and process a single map all at once.
280    */
281
282   /* check if we found a new map, so process one already collected */
283   if (cur_map.cfm_dir && !STREQ(cur_map.cfm_dir, section)) {
284     ret = process_regular_map(&cur_map); /* will reset map */
285     if (ret != 0)
286       return ret;
287   }
288
289   /* now process a single entry of a regular map */
290   return process_regular_option(section, key, val, &cur_map);
291 }
292
293
294 /*
295  * Process global section of configuration file options.
296  * Return 0 upon success, 1 otherwise.
297  */
298 static int
299 process_global_option(const char *key, const char *val)
300 {
301   struct _func_map *gfp;
302
303   /* ensure that val is valid */
304   if (!val || val[0] == '\0')
305     return 1;
306
307   /*
308    * search for global function.
309    */
310   for (gfp = glob_functable; gfp->name; gfp++)
311     if (FSTREQ(gfp->name, key))
312       return (gfp->func)(val);
313
314   fprintf(stderr, "conf: unknown global key: \"%s\"\n", key);
315   return 1;                     /* failed to match any command */
316 }
317
318
319 static int
320 gopt_arch(const char *val)
321 {
322   gopt.arch = strdup((char *)val);
323   return 0;
324 }
325
326
327 static int
328 gopt_auto_dir(const char *val)
329 {
330   gopt.auto_dir = strdup((char *)val);
331   return 0;
332 }
333
334
335 static int
336 gopt_browsable_dirs(const char *val)
337 {
338   if (STREQ(val, "full")) {
339     gopt.flags |= CFM_BROWSABLE_DIRS_FULL;
340     return 0;
341   } else if (STREQ(val, "yes")) {
342     gopt.flags |= CFM_BROWSABLE_DIRS;
343     return 0;
344   } else if (STREQ(val, "no")) {
345     gopt.flags &= ~CFM_BROWSABLE_DIRS;
346     return 0;
347   }
348
349   fprintf(stderr, "conf: unknown value to browsable_dirs \"%s\"\n", val);
350   return 1;                     /* unknown value */
351 }
352
353
354 static int
355 gopt_cache_duration(const char *val)
356 {
357   gopt.am_timeo = atoi(val);
358   if (gopt.am_timeo <= 0)
359     gopt.am_timeo = AM_TTL;
360   return 0;
361 }
362
363
364 static int
365 gopt_cluster(const char *val)
366 {
367   gopt.cluster = strdup((char *)val);
368   return 0;
369 }
370
371
372 static int
373 gopt_debug_options(const char *val)
374 {
375 #ifdef DEBUG
376   usage += debug_option(strdup((char *)val));
377   return 0;
378 #else /* not DEBUG */
379   fprintf(stderr, "%s: not compiled with DEBUG option -- sorry.\n",
380           am_get_progname());
381   return 1;
382 #endif /* not DEBUG */
383 }
384
385
386 static int
387 gopt_dismount_interval(const char *val)
388 {
389   gopt.am_timeo_w = atoi(val);
390   if (gopt.am_timeo_w <= 0)
391     gopt.am_timeo_w = AM_TTL_W;
392   return 0;
393 }
394
395
396 static int
397 gopt_full_os(const char *val)
398 {
399   gopt.op_sys_full = strdup((char *)val);
400   return 0;
401 }
402
403
404 static int
405 gopt_fully_qualified_hosts(const char *val)
406 {
407   if (STREQ(val, "yes")) {
408     gopt.flags |= CFM_FULLY_QUALIFIED_HOSTS;
409     return 0;
410   } else if (STREQ(val, "no")) {
411     gopt.flags &= ~CFM_FULLY_QUALIFIED_HOSTS;
412     return 0;
413   }
414
415   fprintf(stderr, "conf: unknown value to fully_qualified_hosts \"%s\"\n", val);
416   return 1;                     /* unknown value */
417 }
418
419
420 static int
421 gopt_hesiod_base(const char *val)
422 {
423 #ifdef HAVE_MAP_HESIOD
424   gopt.hesiod_base = strdup((char *)val);
425   return 0;
426 #else /* not HAVE_MAP_HESIOD */
427   fprintf(stderr, "conf: hesiod_base option ignored.  No Hesiod support available.\n");
428   return 1;
429 #endif /* not HAVE_MAP_HESIOD */
430 }
431
432
433 static int
434 gopt_karch(const char *val)
435 {
436   gopt.karch = strdup((char *)val);
437   return 0;
438 }
439
440
441 static int
442 gopt_pid_file(const char *val)
443 {
444   gopt.pid_file = strdup((char *)val);
445   return 0;
446 }
447
448
449 static int
450 gopt_local_domain(const char *val)
451 {
452   gopt.sub_domain = strdup((char *)val);
453   return 0;
454 }
455
456
457 static int
458 gopt_ldap_base(const char *val)
459 {
460 #ifdef HAVE_MAP_LDAP
461   gopt.ldap_base = strdup((char *)val);
462   return 0;
463 #else /* not HAVE_MAP_LDAP */
464   fprintf(stderr, "conf: ldap_base option ignored.  No LDAP support available.\n");
465   return 1;
466 #endif /* not HAVE_MAP_LDAP */
467 }
468
469
470 static int
471 gopt_ldap_cache_seconds(const char *val)
472 {
473 #ifdef HAVE_MAP_LDAP
474   char *end;
475
476   gopt.ldap_cache_seconds = strtol((char *)val, &end, 10);
477   if (end == val) {
478     fprintf(stderr, "conf: bad LDAP cache (seconds) option: %s\n",val);
479     return 1;
480   }
481   return 0;
482 #else /* not HAVE_MAP_LDAP */
483   fprintf(stderr, "conf: ldap_cache option ignored.  No LDAP support available.\n");
484   return 1;
485 #endif /* not HAVE_MAP_LDAP */
486 }
487
488
489 static int
490 gopt_ldap_cache_maxmem(const char *val)
491 {
492 #ifdef HAVE_MAP_LDAP
493   char *end;
494
495   gopt.ldap_cache_maxmem = strtol((char *)val, &end, 10);
496   if (end == val) {
497     fprintf(stderr, "conf: bad LDAP cache (maxmem) option: %s\n",val);
498     return 1;
499   }
500   return 0;
501 #else /* not HAVE_MAP_LDAP */
502   fprintf(stderr, "conf: ldap_cache option ignored.  No LDAP support available.\n");
503   return 1;
504 #endif /* not HAVE_MAP_LDAP */
505 }
506
507
508 static int
509 gopt_ldap_hostports(const char *val)
510 {
511 #ifdef HAVE_MAP_LDAP
512   gopt.ldap_hostports = strdup((char *)val);
513   return 0;
514 #else /* not HAVE_MAP_LDAP */
515   fprintf(stderr, "conf: ldap_hostports option ignored.  No LDAP support available.\n");
516   return 1;
517 #endif /* not HAVE_MAP_LDAP */
518
519 }
520
521
522 static int
523 gopt_log_file(const char *val)
524 {
525   gopt.logfile = strdup((char *)val);
526   return 0;
527 }
528
529
530 static int
531 gopt_log_options(const char *val)
532 {
533   usage += switch_option(strdup((char *)val));
534   return 0;
535 }
536
537
538 static int
539 gopt_map_options(const char *val)
540 {
541   gopt.map_options = strdup((char *)val);
542   return 0;
543 }
544
545
546 static int
547 gopt_map_type(const char *val)
548 {
549   /* check if map type exist */
550   if (!mapc_type_exists(val)) {
551     fprintf(stderr, "conf: no such map type \"%s\"\n", val);
552     return 1;
553   }
554   gopt.map_type = strdup((char *)val);
555   return 0;
556 }
557
558
559 static int
560 gopt_mount_type(const char *val)
561 {
562   if (STREQ(val, "autofs")) {
563 #ifdef HAVE_FS_AUTOFS
564     gopt.flags |= CFM_MOUNT_TYPE_AUTOFS;
565     amd_use_autofs++;
566     return 0;
567 #else /* not HAVE_FS_AUTOFS */
568     fprintf(stderr, "conf: no autofs support available\n");
569     return 1;
570 #endif /* not HAVE_FS_AUTOFS */
571   } else if (STREQ(val, "nfs")) {
572     gopt.flags &= ~CFM_MOUNT_TYPE_AUTOFS;
573     return 0;
574   }
575
576   fprintf(stderr, "conf: unknown value to mount_type \"%s\"\n", val);
577   return 1;                     /* unknown value */
578 }
579
580
581 static int
582 gopt_portmap_program(const char *val)
583 {
584   gopt.portmap_program = atoi(val);
585   /*
586    * allow alternate program numbers to be no more than 10 offset from
587    * official amd program number (300019).
588    */
589   if (gopt.portmap_program < AMQ_PROGRAM ||
590       gopt.portmap_program > AMQ_PROGRAM + 10) {
591     gopt.portmap_program = AMQ_PROGRAM;
592     set_amd_program_number(gopt.portmap_program);
593     fprintf(stderr, "conf: illegal amd program numver \"%s\"\n", val);
594     return 1;
595   }
596
597   set_amd_program_number(gopt.portmap_program);
598   return 0;                     /* all is OK */
599 }
600
601
602 static int
603 gopt_nfs_retransmit_counter(const char *val)
604 {
605   gopt.amfs_auto_retrans = atoi(val);
606   return 0;
607 }
608
609
610 static int
611 gopt_nfs_retry_interval(const char *val)
612 {
613   gopt.amfs_auto_timeo = atoi(val);
614   return 0;
615 }
616
617
618 static int
619 gopt_nis_domain(const char *val)
620 {
621 #ifdef HAVE_MAP_NIS
622   gopt.nis_domain = strdup((char *)val);
623   return 0;
624 #else /* not HAVE_MAP_NIS */
625   fprintf(stderr, "conf: nis_domain option ignored.  No NIS support available.\n");
626   return 1;
627 #endif /* not HAVE_MAP_NIS */
628 }
629
630
631 static int
632 gopt_normalize_hostnames(const char *val)
633 {
634   if (STREQ(val, "yes")) {
635     gopt.flags |= CFM_NORMALIZE_HOSTNAMES;
636     return 0;
637   } else if (STREQ(val, "no")) {
638     gopt.flags &= ~CFM_NORMALIZE_HOSTNAMES;
639     return 0;
640   }
641
642   fprintf(stderr, "conf: unknown value to normalize_hostnames \"%s\"\n", val);
643   return 1;                     /* unknown value */
644 }
645
646
647 static int
648 gopt_os(const char *val)
649 {
650   gopt.op_sys = strdup((char *)val);
651   return 0;
652 }
653
654
655 static int
656 gopt_osver(const char *val)
657 {
658   gopt.op_sys_ver = strdup((char *)val);
659   return 0;
660 }
661
662
663 static int
664 gopt_plock(const char *val)
665 {
666   if (STREQ(val, "yes")) {
667     gopt.flags |= CFM_PROCESS_LOCK;
668     return 0;
669   } else if (STREQ(val, "no")) {
670     gopt.flags &= ~CFM_PROCESS_LOCK;
671     return 0;
672   }
673
674   fprintf(stderr, "conf: unknown value to plock \"%s\"\n", val);
675   return 1;                     /* unknown value */
676 }
677
678
679 static int
680 gopt_print_pid(const char *val)
681 {
682   if (STREQ(val, "yes")) {
683     gopt.flags |= CFM_PRINT_PID;
684     return 0;
685   } else if (STREQ(val, "no")) {
686     gopt.flags &= ~CFM_PRINT_PID;
687     return 0;
688   }
689
690   fprintf(stderr, "conf: unknown value to print_pid \"%s\"\n", val);
691   return 1;                     /* unknown value */
692 }
693
694
695 static int
696 gopt_print_version(const char *val)
697 {
698   if (STREQ(val, "yes")) {
699     fputs(get_version_string(), stderr);
700     return 0;
701   } else if (STREQ(val, "no")) {
702     return 0;
703   }
704
705   fprintf(stderr, "conf: unknown value to print_version \"%s\"\n", val);
706   return 1;                     /* unknown value */
707 }
708
709
710 static int
711 gopt_restart_mounts(const char *val)
712 {
713   if (STREQ(val, "yes")) {
714     gopt.flags |= CFM_RESTART_EXISTING_MOUNTS;
715     return 0;
716   } else if (STREQ(val, "no")) {
717     gopt.flags &= ~CFM_RESTART_EXISTING_MOUNTS;
718     return 0;
719   }
720
721   fprintf(stderr, "conf: unknown value to restart_mounts \"%s\"\n", val);
722   return 1;                     /* unknown value */
723 }
724
725
726 static int
727 gopt_search_path(const char *val)
728 {
729   gopt.search_path = strdup((char *)val);
730   return 0;
731 }
732
733
734 static int
735 gopt_selectors_on_default(const char *val)
736 {
737   if (STREQ(val, "yes")) {
738     gopt.flags |= CFM_ENABLE_DEFAULT_SELECTORS;
739     return 0;
740   } else if (STREQ(val, "no")) {
741     gopt.flags &= ~CFM_ENABLE_DEFAULT_SELECTORS;
742     return 0;
743   }
744
745   fprintf(stderr, "conf: unknown value to enable_default_selectors \"%s\"\n", val);
746   return 1;                     /* unknown value */
747 }
748
749
750 static int
751 gopt_show_statfs_entries(const char *val)
752 {
753   if (STREQ(val, "yes")) {
754     gopt.flags |= CFM_SHOW_STATFS_ENTRIES;
755     return 0;
756   } else if (STREQ(val, "no")) {
757     gopt.flags &= ~CFM_SHOW_STATFS_ENTRIES;
758     return 0;
759   }
760
761   fprintf(stderr, "conf: unknown value to show_statfs_entries \"%s\"\n", val);
762   return 1;                     /* unknown value */
763 }
764
765
766 static int
767 gopt_unmount_on_exit(const char *val)
768 {
769   if (STREQ(val, "yes")) {
770     gopt.flags |= CFM_UNMOUNT_ON_EXIT;
771     return 0;
772   } else if (STREQ(val, "no")) {
773     gopt.flags &= ~CFM_UNMOUNT_ON_EXIT;
774     return 0;
775   }
776
777   fprintf(stderr, "conf: unknown value to unmount_on_exit \"%s\"\n", val);
778   return 1;                     /* unknown value */
779 }
780
781
782 static int
783 gopt_vendor(const char *val)
784 {
785   gopt.op_sys_vendor = strdup((char *)val);
786   return 0;
787 }
788
789
790 /*
791  * Collect one entry for a regular map
792  */
793 static int
794 process_regular_option(const char *section, const char *key, const char *val, cf_map_t *cfm)
795 {
796   /* ensure that val is valid */
797   if (!section || section[0] == '\0' ||
798       !key || key[0] == '\0' ||
799       !val || val[0] == '\0' ||
800       !cfm) {
801     fprintf(stderr, "conf: process_regular_option: null entries\n");
802     return 1;
803   }
804
805   /* check if initializing a new map */
806   if (!cfm->cfm_dir)
807     cfm->cfm_dir = strdup((char *)section);
808
809   /* check for each possible field */
810   if (STREQ(key, "browsable_dirs"))
811     return ropt_browsable_dirs(val, cfm);
812
813   if (STREQ(key, "map_name"))
814     return ropt_map_name(val, cfm);
815
816   if (STREQ(key, "map_options"))
817     return ropt_map_options(val, cfm);
818
819   if (STREQ(key, "map_type"))
820     return ropt_map_type(val, cfm);
821
822   if (STREQ(key, "mount_type"))
823     return ropt_mount_type(val, cfm);
824
825   if (STREQ(key, "search_path"))
826     return ropt_search_path(val, cfm);
827
828   if (STREQ(key, "tag"))
829     return ropt_tag(val, cfm);
830
831   fprintf(stderr, "conf: unknown regular key \"%s\" for section \"%s\"\n",
832           key, section);
833   return 1;                     /* failed to match any command */
834 }
835
836
837 static int
838 ropt_browsable_dirs(const char *val, cf_map_t *cfm)
839 {
840   if (STREQ(val, "full")) {
841     cfm->cfm_flags |= CFM_BROWSABLE_DIRS_FULL;
842     return 0;
843   } else if (STREQ(val, "yes")) {
844     cfm->cfm_flags |= CFM_BROWSABLE_DIRS;
845     return 0;
846   } else if (STREQ(val, "no")) {
847     cfm->cfm_flags &= ~CFM_BROWSABLE_DIRS;
848     return 0;
849   }
850
851   fprintf(stderr, "conf: unknown value to browsable_dirs \"%s\"\n", val);
852   return 1;                     /* unknown value */
853 }
854
855
856 static int
857 ropt_map_name(const char *val, cf_map_t *cfm)
858 {
859   cfm->cfm_name = strdup((char *)val);
860   return 0;
861 }
862
863
864 static int
865 ropt_map_options(const char *val, cf_map_t *cfm)
866 {
867   cfm->cfm_opts = strdup((char *)val);
868   return 0;
869 }
870
871
872 static int
873 ropt_map_type(const char *val, cf_map_t *cfm)
874 {
875   /* check if map type exist */
876   if (!mapc_type_exists(val)) {
877     fprintf(stderr, "conf: no such map type \"%s\"\n", val);
878     return 1;
879   }
880   cfm->cfm_type = strdup((char *)val);
881   return 0;
882 }
883
884
885 static int
886 ropt_mount_type(const char *val, cf_map_t *cfm)
887 {
888   if (STREQ(val, "autofs")) {
889 #ifdef HAVE_FS_AUTOFS
890     cfm->cfm_flags |= CFM_MOUNT_TYPE_AUTOFS;
891     amd_use_autofs++;
892     return 0;
893 #else /* not HAVE_FS_AUTOFS */
894     fprintf(stderr, "conf: no autofs support available\n");
895     return 1;
896 #endif /* not HAVE_FS_AUTOFS */
897   } else if (STREQ(val, "nfs")) {
898     cfm->cfm_flags &= ~CFM_MOUNT_TYPE_AUTOFS;
899     return 0;
900   }
901
902   fprintf(stderr, "conf: unknown value to mount_type \"%s\"\n", val);
903   return 1;                     /* unknown value */
904 }
905
906
907 static int
908 ropt_search_path(const char *val, cf_map_t *cfm)
909 {
910   cfm->cfm_search_path = strdup((char *)val);
911   return 0;
912 }
913
914
915 static int
916 ropt_tag(const char *val, cf_map_t *cfm)
917 {
918   cfm->cfm_tag = strdup((char *)val);
919   return 0;
920 }
921
922
923 /*
924  * Process one collected map.
925  */
926 static int
927 process_regular_map(cf_map_t *cfm)
928 {
929
930   if (!cfm->cfm_name) {
931     fprintf(stderr, "conf: map_name must be defined for map \"%s\"\n", cfm->cfm_dir);
932     return 1;
933   }
934   /*
935    * If map has no tag defined, process the map.
936    * If no conf_tag was set in amd -T, process all untagged entries.
937    * If a tag is defined, then process it only if it matches the map tag.
938    */
939   if (!cfm->cfm_tag ||
940       (conf_tag && STREQ(cfm->cfm_tag, conf_tag))) {
941 #ifdef DEBUG_CONF
942     fprintf(stderr, "processing map %s (flags=0x%x)...\n",
943             cfm->cfm_dir, cfm->cfm_flags);
944 #endif /* DEBUG_CONF */
945     root_newmap(cfm->cfm_dir,
946                 cfm->cfm_opts ? cfm->cfm_opts : "",
947                 cfm->cfm_name,
948                 cfm);
949   } else {
950     fprintf(stderr, "skipping map %s...\n", cfm->cfm_dir);
951   }
952
953   reset_cf_map(cfm);
954   return 0;
955 }
956
957
958 /*
959  * Process last map in conf file (if any)
960  */
961 int
962 process_last_regular_map(void)
963 {
964   /*
965    * If the amd.conf file only has a [global] section (pretty useless
966    * IMHO), do not try to process a map that does not exist.
967    */
968   if (!cur_map.cfm_dir)
969     return 0;
970   return process_regular_map(&cur_map);
971 }