]> git.pld-linux.org Git - packages/autofs.git/blame - autofs-5.0.2-dynamic-logging.patch
projects / packages / autofs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- rel.1, lets try
[packages/autofs.git] / autofs-5.0.2-dynamic-logging.patch
CommitLineData
3d551623
PG		 1diff --git a/CHANGELOG b/CHANGELOG
2index ca171a4..a7ac9fb 100644
3--- a/CHANGELOG
4+++ b/CHANGELOG
5@@ -35,6 +35,7 @@
6 - fix typo in autofs(5) man page.
7 - fix map entry expansion when undefined macro is present.
8 - remove unused export validation code.
9+- add dynamic logging (adapted from v4 patch from Jeff Moyer).
10
11 18/06/2007 autofs-5.0.2
12 -----------------------
13diff --git a/daemon/automount.c b/daemon/automount.c
14index 70a3b9d..9ec6923 100644
15--- a/daemon/automount.c
16+++ b/daemon/automount.c
17@@ -173,7 +173,7 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev)
18 */
19 memset(&st, 0, sizeof(st));
20 if (lstat(buf, &st) != 0) {
21- crit(ap->logopt, "lstat of %s failed.", buf);
22+ crit(ap->logopt, "lstat of %s failed", buf);
23 return -1;
24 }
25
26@@ -234,14 +234,15 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev)
27 /* Like ftw, except fn gets called twice: before a directory is
28 entered, and after. If the before call returns 0, the directory
29 isn't entered. */
30-static int walk_tree(const char *base, int (*fn) (const char *file,
31+static int walk_tree(const char *base, int (*fn) (unsigned logopt,
32+ const char *file,
33 const struct stat * st,
34- int, void *), int incl, void *arg)
35+ int, void *), int incl, unsigned logopt, void *arg)
36 {
37 char buf[PATH_MAX + 1];
38 struct stat st;
39
40- if (lstat(base, &st) != -1 && (fn) (base, &st, 0, arg)) {
41+ if (lstat(base, &st) != -1 && (fn) (logopt, base, &st, 0, arg)) {
42 if (S_ISDIR(st.st_mode)) {
43 struct dirent **de;
44 int n;
45@@ -269,18 +270,18 @@ static int walk_tree(const char *base, int (*fn) (const char *file,
46 return -1;
47 }
48
49- walk_tree(buf, fn, 1, arg);
50+ walk_tree(buf, fn, 1, logopt, arg);
51 free(de[n]);
52 }
53 free(de);
54 }
55 if (incl)
56- (fn) (base, &st, 1, arg);
57+ (fn) (logopt, base, &st, 1, arg);
58 }
59 return 0;
60 }
61
62-static int rm_unwanted_fn(const char *file, const struct stat *st, int when, void *arg)
63+static int rm_unwanted_fn(unsigned logopt, const char *file, const struct stat *st, int when, void *arg)
64 {
65 dev_t dev = *(dev_t *) arg;
66 char buf[MAX_ERR_BUF];
67@@ -293,41 +294,38 @@ static int rm_unwanted_fn(const char *file, const struct stat *st, int when, voi
68 }
69
70 if (lstat(file, &newst)) {
71- crit(LOGOPT_ANY,
72- "unable to stat file, possible race condition");
73+ crit(logopt, "unable to stat file, possible race condition");
74 return 0;
75 }
76
77 if (newst.st_dev != dev) {
78- crit(LOGOPT_ANY,
79- "file %s has the wrong device, possible race condition",
80+ crit(logopt, "file %s has the wrong device, possible race condition",
81 file);
82 return 0;
83 }
84
85 if (S_ISDIR(newst.st_mode)) {
86- debug(LOGOPT_ANY, "removing directory %s", file);
87+ debug(logopt, "removing directory %s", file);
88 if (rmdir(file)) {
89 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
90- warn(LOGOPT_ANY,
91+ warn(logopt,
92 "unable to remove directory %s: %s", file, estr);
93 return 0;
94 }
95 } else if (S_ISREG(newst.st_mode)) {
96- crit(LOGOPT_ANY,
97- "attempting to remove files from a mounted "
98+ crit(logopt, "attempting to remove files from a mounted "
99 "directory. file %s", file);
100 return 0;
101 } else if (S_ISLNK(newst.st_mode)) {
102- debug(LOGOPT_ANY, "removing symlink %s", file);
103+ debug(logopt, "removing symlink %s", file);
104 unlink(file);
105 }
106 return 1;
107 }
108
109-void rm_unwanted(const char *path, int incl, dev_t dev)
110+void rm_unwanted(unsigned logopt, const char *path, int incl, dev_t dev)
111 {
112- walk_tree(path, rm_unwanted_fn, incl, &dev);
113+ walk_tree(path, rm_unwanted_fn, incl, logopt, &dev);
114 }
115
116 struct counter_args {
117@@ -335,7 +333,7 @@ struct counter_args {
118 dev_t dev;
119 };
120
121-static int counter_fn(const char *file, const struct stat *st, int when, void *arg)
122+static int counter_fn(unsigned logopt, const char *file, const struct stat *st, int when, void *arg)
123 {
124 struct counter_args *counter = (struct counter_args *) arg;
125
126@@ -349,14 +347,14 @@ static int counter_fn(const char *file, const struct stat *st, int when, void *a
127 }
128
129 /* Count mounted filesystems and symlinks */
130-int count_mounts(const char *path, dev_t dev)
131+int count_mounts(unsigned logopt, const char *path, dev_t dev)
132 {
133 struct counter_args counter;
134
135 counter.count = 0;
136 counter.dev = dev;
137
138- if (walk_tree(path, counter_fn, 0, &counter) == -1)
139+ if (walk_tree(path, counter_fn, 0, logopt, &counter) == -1)
140 return -1;
141
142 return counter.count;
143@@ -368,9 +366,9 @@ static void check_rm_dirs(struct autofs_point *ap, const char *path, int incl)
144 (ap->state == ST_SHUTDOWN_PENDING ||
145 ap->state == ST_SHUTDOWN_FORCE ||
146 ap->state == ST_SHUTDOWN))
147- rm_unwanted(path, incl, ap->dev);
148+ rm_unwanted(ap->logopt, path, incl, ap->dev);
149 else if (ap->ghost && (ap->type == LKP_INDIRECT))
150- rm_unwanted(path, 0, ap->dev);
151+ rm_unwanted(ap->logopt, path, 0, ap->dev);
152 }
153
154 /* Try to purge cache entries kept around due to existing mounts */
155@@ -466,7 +464,7 @@ static int umount_subtree_mounts(struct autofs_point *ap, const char *path, unsi
156 cache_multi_lock(me->parent);
157 if (umount_multi_triggers(ap, root, me, base)) {
158 warn(ap->logopt,
159- "could not umount some offsets under %s", path);
160+ "some offset mounts still present under %s", path);
161 left++;
162 }
163 cache_multi_unlock(me->parent);
164@@ -483,7 +481,7 @@ static int umount_subtree_mounts(struct autofs_point *ap, const char *path, unsi
165 * it already to ensure it's ok to remove any offset triggers.
166 */
167 if (!is_mm_root && is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
168- msg("unmounting dir = %s", path);
169+ info(ap->logopt, "unmounting dir = %s", path);
170 if (umount_ent(ap, path)) {
171 warn(ap->logopt, "could not umount dir %s", path);
172 left++;
173@@ -576,35 +574,35 @@ int umount_autofs(struct autofs_point *ap, int force)
174 return ret;
175 }
176
177-int send_ready(int ioctlfd, unsigned int wait_queue_token)
178+int send_ready(unsigned logopt, int ioctlfd, unsigned int wait_queue_token)
179 {
180 char buf[MAX_ERR_BUF];
181
182 if (wait_queue_token == 0)
183 return 0;
184
185- debug(LOGOPT_NONE, "token = %d", wait_queue_token);
186+ debug(logopt, "token = %d", wait_queue_token);
187
188 if (ioctl(ioctlfd, AUTOFS_IOC_READY, wait_queue_token) < 0) {
189 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
190- error(LOGOPT_ANY, "AUTOFS_IOC_READY: error %s", estr);
191+ logerr("AUTOFS_IOC_READY: error %s", estr);
192 return 1;
193 }
194 return 0;
195 }
196
197-int send_fail(int ioctlfd, unsigned int wait_queue_token)
198+int send_fail(unsigned logopt, int ioctlfd, unsigned int wait_queue_token)
199 {
200 char buf[MAX_ERR_BUF];
201
202 if (wait_queue_token == 0)
203 return 0;
204
205- debug(LOGOPT_NONE, "token = %d", wait_queue_token);
206+ debug(logopt, "token = %d", wait_queue_token);
207
208 if (ioctl(ioctlfd, AUTOFS_IOC_FAIL, wait_queue_token) < 0) {
209 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
210- error(LOGOPT_ANY, "AUTOFS_IOC_FAIL: error %s", estr);
211+ logerr("AUTOFS_IOC_FAIL: error %s", estr);
212 return 1;
213 }
214 return 0;
215@@ -649,23 +647,245 @@ static int fullread(int fd, void *ptr, size_t len)
216 return len;
217 }
218
219+static char *automount_path_to_fifo(unsigned logopt, const char *path)
220+{
221+ char *fifo_name, *p;
222+ int name_len = strlen(path) + strlen(AUTOFS_LOGPRI_FIFO) + 1;
223+ int ret;
224+
225+ fifo_name = malloc(name_len);
226+ if (!fifo_name)
227+ return NULL;
228+ ret = snprintf(fifo_name, name_len, "%s%s",
229+ AUTOFS_LOGPRI_FIFO, path);
230+ if (ret >= name_len) {
231+ info(logopt,
232+ "fifo path for \"%s\" truncated to \"%s\". This may "
233+ "lead to --set-log-priority commands being sent to the "
234+ "wrong automount daemon.", path, fifo_name);
235+ }
236+
237+ /*
238+ * An automount path can be made up of subdirectories. So, to
239+ * create the fifo name, we will just replace instances of '/' with
240+ * '-'.
241+ */
242+ p = fifo_name + strlen(AUTOFS_LOGPRI_FIFO);
243+ while (*p != '\0') {
244+ if (*p == '/')
245+ *p = '-';
246+ p++;
247+ }
248+
249+ debug(logopt, "fifo name %s",fifo_name);
250+
251+ return fifo_name;
252+}
253+
254+static int create_logpri_fifo(struct autofs_point *ap)
255+{
256+ int ret = -1;
257+ int fd;
258+ char *fifo_name;
259+
260+ fifo_name = automount_path_to_fifo(ap->logopt, ap->path);
261+ if (!fifo_name) {
262+ crit(ap->logopt, "Failed to allocate memory!");
263+ goto out_free; /* free(NULL) is okay */
264+ }
265+
266+ ret = unlink(fifo_name);
267+ if (ret != 0 && errno != ENOENT) {
268+ crit(ap->logopt,
269+ "Failed to unlink FIFO. Is the automount daemon "
270+ "already running?");
271+ goto out_free;
272+ }
273+
274+ ret = mkfifo(fifo_name, S_IRUSR|S_IWUSR);
275+ if (ret != 0) {
276+ crit(ap->logopt,
277+ "mkfifo for %s returned %d", fifo_name, errno);
278+ goto out_free;
279+ }
280+
281+ fd = open(fifo_name, O_RDWR|O_NONBLOCK);
282+ if (fd < 0) {
283+ crit(ap->logopt,
284+ "Failed to open %s, errno %d", fifo_name, errno);
285+ goto out_free;
286+ }
287+
288+ ap->logpri_fifo = fd;
289+
290+out_free:
291+ free(fifo_name);
292+ return ret;
293+}
294+
295+static int destroy_logpri_fifo(struct autofs_point *ap)
296+{
297+ int ret = -1;
298+ int fd = ap->logpri_fifo;
299+ char *fifo_name;
300+
301+ fifo_name = automount_path_to_fifo(ap->logopt, ap->path);
302+ if (!fifo_name) {
303+ crit(ap->logopt, "Failed to allocate memory!");
304+ goto out_free; /* free(NULL) is okay */
305+ }
306+
307+ ap->logpri_fifo = -1;
308+
309+ ret = close(fd);
310+ if (ret != 0) {
311+ warn(ap->logopt,
312+ "close for fifo %s returned %d", fifo_name, errno);
313+ }
314+
315+ ret = unlink(fifo_name);
316+ if (ret != 0) {
317+ warn(ap->logopt,
318+ "Failed to unlink FIFO. Was the fifo created OK?");
319+ }
320+
321+out_free:
322+ free(fifo_name);
323+ return ret;
324+}
325+
326+static void handle_fifo_message(struct autofs_point *ap, int fd)
327+{
328+ int ret;
329+ char buffer[PIPE_BUF];
330+ char *end;
331+ long pri;
332+
333+ memset(buffer, 0, sizeof(buffer));
334+ ret = read(fd, &buffer, sizeof(buffer));
335+ if (ret < 0) {
336+ warn(ap->logopt, "read on fifo returned error %d", errno);
337+ return;
338+ }
339+
340+ if (ret != 2) {
341+ debug(ap->logopt, "expected 2 bytes, received %d.", ret);
342+ return;
343+ }
344+
345+ errno = 0;
346+ pri = strtol(buffer, &end, 10);
347+ if ((pri == LONG_MIN || pri == LONG_MAX) && errno == ERANGE) {
348+ debug(ap->logopt, "strtol reported an %s. Failed to set "
349+ "log priority.", pri == LONG_MIN ? "underflow" : "overflow");
350+ return;
351+ }
352+ if ((pri == 0 && errno == EINVAL) || end == buffer) {
353+ debug(ap->logopt, "priority is expected to be an integer "
354+ "in the range 0-7 inclusive.");
355+ return;
356+ }
357+
358+ if (pri > LOG_DEBUG || pri < LOG_EMERG) {
359+ debug(ap->logopt, "invalid log priority (%ld) received "
360+ "on fifo", pri);
361+ return;
362+ }
363+
364+ /*
365+ * OK, the message passed all of the sanity checks. The
366+ * automounter actually only supports three log priorities.
367+ * Everything is logged at log level debug, deamon messages
368+ * and everything except debug messages are logged with the
369+ * verbose setting and only error and critical messages are
370+ * logged when debugging isn't enabled.
371+ */
372+ if (pri >= LOG_WARNING) {
373+ if (pri == LOG_DEBUG) {
374+ set_log_debug_ap(ap);
375+ info(ap->logopt, "Debug logging set for %s", ap->path);
376+ } else {
377+ set_log_verbose_ap(ap);
378+ info(ap->logopt, "Verbose logging set for %s", ap->path);
379+ }
380+ } else {
381+ if (ap->logopt & LOGOPT_ANY)
382+ info(ap->logopt, "Basic logging set for %s", ap->path);
383+ set_log_norm_ap(ap);
384+ }
385+}
386+
387+static int set_log_priority(const char *path, int priority)
388+{
389+ int fd;
390+ char *fifo_name;
391+ char buf[2];
392+
393+ if (priority > LOG_DEBUG || priority < LOG_EMERG) {
394+ fprintf(stderr, "Log priority %d is invalid.\n", priority);
395+ fprintf(stderr, "Please spcify a number in the range 0-7.\n");
396+ return -1;
397+ }
398+
399+ /*
400+ * This is an ascii based protocol, so we want the string
401+ * representation of the integer log priority.
402+ */
403+ snprintf(buf, sizeof(buf), "%d", priority);
404+
405+ fifo_name = automount_path_to_fifo(LOGOPT_NONE, path);
406+ if (!fifo_name) {
407+ fprintf(stderr, "%s: Failed to allocate memory!\n",
408+ __FUNCTION__);
409+ return -1;
410+ }
411+
412+ /*
413+ * Specify O_NONBLOCK so that the open will fail if there is no
414+ * daemon reading from the other side of the FIFO.
415+ */
416+ fd = open(fifo_name, O_WRONLY|O_NONBLOCK);
417+ if (fd < 0) {
418+ fprintf(stderr, "%s: open of %s failed with %d\n",
419+ __FUNCTION__, fifo_name, errno);
420+ free(fifo_name);
421+ return -1;
422+ }
423+
424+ if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
425+ fprintf(stderr, "Failed to change logging priority. ");
426+ fprintf(stderr, "write to fifo failed with errno %d.\n",
427+ errno);
428+ close(fd);
429+ free(fifo_name);
430+ return -1;
431+ }
432+ close(fd);
433+ free(fifo_name);
434+ fprintf(stdout, "Successfully set log priority for %s.\n", path);
435+
436+ return 0;
437+}
438+
439 static int get_pkt(struct autofs_point *ap, union autofs_packet_union *pkt)
440 {
441- struct pollfd fds[2];
442+ struct pollfd fds[3];
443 char buf[MAX_ERR_BUF];
444
445 fds[0].fd = ap->pipefd;
446 fds[0].events = POLLIN;
447 fds[1].fd = ap->state_pipe[0];
448 fds[1].events = POLLIN;
449+ fds[2].fd = ap->logpri_fifo;
450+ fds[2].events = POLLIN;
451
452 for (;;) {
453- if (poll(fds, 2, -1) == -1) {
454+ if (poll(fds, 3, -1) == -1) {
455 char *estr;
456 if (errno == EINTR)
457 continue;
458 estr = strerror_r(errno, buf, MAX_ERR_BUF);
459- error(ap->logopt, "poll failed: %s", estr);
460+ logerr("poll failed: %s", estr);
461 return -1;
462 }
463
464@@ -709,6 +929,11 @@ static int get_pkt(struct autofs_point *ap, union autofs_packet_union *pkt)
465
466 if (fds[0].revents & POLLIN)
467 return fullread(ap->pipefd, pkt, kpkt_len);
468+
469+ if (fds[2].revents & POLLIN) {
470+ debug(ap->logopt, "message pending on control fifo.");
471+ handle_fifo_message(ap, fds[2].fd);
472+ }
473 }
474 }
475
476@@ -730,21 +955,93 @@ int do_expire(struct autofs_point *ap, const char *name, int namelen)
477 return 1;
478 }
479
480- msg("expiring path %s", buf);
481+ info(ap->logopt, "expiring path %s", buf);
482
483 ret = umount_multi(ap, buf, 1);
484 if (ret == 0)
485- msg("expired %s", buf);
486+ info(ap->logopt, "expired %s", buf);
487 else
488 warn(ap->logopt, "couldn't complete expire of %s", buf);
489
490 return ret;
491 }
492
493+static int autofs_init_ap(struct autofs_point *ap)
494+{
495+ int pipefd[2], cl_flags;
496+
497+ if ((ap->state != ST_INIT)) {
498+ /* This can happen if an autofs process is already running*/
499+ error(ap->logopt, "bad state %d", ap->state);
500+ return -1;
501+ }
502+
503+ ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
504+
505+ /* Pipe for kernel communications */
506+ if (pipe(pipefd) < 0) {
507+ crit(ap->logopt,
508+ "failed to create commumication pipe for autofs path %s",
509+ ap->path);
510+ free(ap->path);
511+ return -1;
512+ }
513+
514+ ap->pipefd = pipefd[0];
515+ ap->kpipefd = pipefd[1];
516+
517+ if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
518+ cl_flags |= FD_CLOEXEC;
519+ fcntl(ap->pipefd, F_SETFD, cl_flags);
520+ }
521+
522+ if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
523+ cl_flags |= FD_CLOEXEC;
524+ fcntl(ap->kpipefd, F_SETFD, cl_flags);
525+ }
526+
527+ /* Pipe state changes from signal handler to main loop */
528+ if (pipe(ap->state_pipe) < 0) {
529+ crit(ap->logopt,
530+ "failed create state pipe for autofs path %s", ap->path);
531+ close(ap->pipefd);
532+ close(ap->kpipefd); /* Close kernel pipe end */
533+ free(ap->path);
534+ return -1;
535+ }
536+
537+ if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
538+ cl_flags |= FD_CLOEXEC;
539+ fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
540+ }
541+
542+ if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
543+ cl_flags |= FD_CLOEXEC;
544+ fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
545+ }
546+
547+ if (create_logpri_fifo(ap) < 0) {
548+ crit(ap->logopt,
549+ "failed to create FIFO for path %s\n", ap->path);
550+ destroy_logpri_fifo(ap);
551+ close(ap->pipefd);
552+ close(ap->kpipefd);
553+ free(ap->path);
554+ close(ap->state_pipe[0]);
555+ close(ap->state_pipe[1]);
556+ return -1;
557+ }
558+
559+ return 0;
560+}
561+
562 static int mount_autofs(struct autofs_point *ap)
563 {
564 int status = 0;
565
566+ if (autofs_init_ap(ap) != 0)
567+ return -1;
568+
569 if (ap->type == LKP_DIRECT)
570 status = mount_autofs_direct(ap);
571 else
572@@ -841,9 +1138,8 @@ static void become_daemon(unsigned foreground)
573 fclose(pidfp);
574 } else {
575 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
576- warn(LOGOPT_ANY,
577- "failed to write pid file %s: %s",
578- pid_file, estr);
579+ logerr("failed to write pid file %s: %s",
580+ pid_file, estr);
581 pid_file = NULL;
582 }
583 }
584@@ -889,12 +1185,12 @@ static void *do_notify_state(void *arg)
585
586 master = mrc.master;
587
588- debug(master->default_logging, "signal %d", sig);
589+ debug(master->logopt, "signal %d", sig);
590
591 mrc.signaled = 1;
592 status = pthread_cond_signal(&mrc.cond);
593 if (status) {
594- error(master->default_logging,
595+ error(master->logopt,
596 "failed to signal state notify condition");
597 status = pthread_mutex_unlock(&mrc.mutex);
598 if (status)
599@@ -923,7 +1219,7 @@ static pthread_t do_signals(struct master *master, int sig)
600
601 status = pthread_create(&thid, &thread_attr, do_notify_state, &r_sig);
602 if (status) {
603- error(master->default_logging,
604+ error(master->logopt,
605 "mount state notify thread create failed");
606 status = pthread_mutex_unlock(&mrc.mutex);
607 if (status)
608@@ -951,6 +1247,7 @@ static pthread_t do_signals(struct master *master, int sig)
609 static void *do_read_master(void *arg)
610 {
611 struct master *master;
612+ unsigned int logopt;
613 time_t age;
614 int readall = 1;
615 int status;
616@@ -961,11 +1258,12 @@ static void *do_read_master(void *arg)
617
618 master = mrc.master;
619 age = mrc.age;
620+ logopt = master->logopt;
621
622 mrc.signaled = 1;
623 status = pthread_cond_signal(&mrc.cond);
624 if (status) {
625- error(master->default_logging,
626+ error(logopt,
627 "failed to signal master read map condition");
628 master->reading = 0;
629 status = pthread_mutex_unlock(&mrc.mutex);
630@@ -989,6 +1287,7 @@ static void *do_read_master(void *arg)
631
632 static int do_hup_signal(struct master *master, time_t age)
633 {
634+ unsigned int logopt = master->logopt;
635 pthread_t thid;
636 int status;
637
638@@ -1007,7 +1306,7 @@ static int do_hup_signal(struct master *master, time_t age)
639
640 status = pthread_create(&thid, &thread_attr, do_read_master, NULL);
641 if (status) {
642- error(master->default_logging,
643+ error(logopt,
644 "master read map thread create failed");
645 master->reading = 0;
646 status = pthread_mutex_unlock(&mrc.mutex);
647@@ -1062,8 +1361,7 @@ static void *statemachine(void *arg)
648 break;
649
650 default:
651- error(master_list->default_logging,
652- "got unexpected signal %d!", sig);
653+ logerr("got unexpected signal %d!", sig);
654 continue;
655 }
656 }
657@@ -1134,10 +1432,11 @@ static void handle_mounts_cleanup(void *arg)
658 struct autofs_point *ap;
659 char path[PATH_MAX + 1];
660 char buf[MAX_ERR_BUF];
661- unsigned int clean = 0, submount;
662+ unsigned int clean = 0, submount, logopt;
663
664 ap = (struct autofs_point *) arg;
665
666+ logopt = ap->logopt;
667 submount = ap->submount;
668
669 strcpy(path, ap->path);
670@@ -1152,6 +1451,7 @@ static void handle_mounts_cleanup(void *arg)
671
672 umount_autofs(ap, 1);
673
674+ destroy_logpri_fifo(ap);
675 master_signal_submount(ap, MASTER_SUBMNT_JOIN);
676 master_remove_mapent(ap->entry);
677 master_free_mapent_sources(ap->entry, 1);
678@@ -1162,12 +1462,12 @@ static void handle_mounts_cleanup(void *arg)
679 if (clean) {
680 if (rmdir(path) == -1) {
681 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
682- warn(LOGOPT_NONE, "failed to remove dir %s: %s",
683+ warn(logopt, "failed to remove dir %s: %s",
684 path, estr);
685 }
686 }
687
688- msg("shut down path %s", path);
689+ info(logopt, "shut down path %s", path);
690
691 /* If we are the last tell the state machine to shutdown */
692 if (!submount && master_list_empty(master_list))
693@@ -1190,7 +1490,7 @@ void *handle_mounts(void *arg)
694
695 status = pthread_mutex_lock(&suc.mutex);
696 if (status) {
697- crit(ap->logopt, "failed to lock startup condition mutex!");
698+ logerr("failed to lock startup condition mutex!");
699 fatal(status);
700 }
701
702@@ -1204,7 +1504,7 @@ void *handle_mounts(void *arg)
703 }
704
705 if (ap->ghost && ap->type != LKP_DIRECT)
706- msg("ghosting enabled");
707+ info(ap->logopt, "ghosting enabled");
708
709 suc.status = 0;
710 pthread_cleanup_pop(1);
711@@ -1356,6 +1656,8 @@ static void usage(void)
712 " use ramdom replicated server selection\n"
713 " -O --global-options\n"
714 " specify global mount options\n"
715+ " -l --set-log-priority priority path [path,...]\n"
716+ " set daemon log verbosity\n"
717 " -V --version print version, build config and exit\n"
718 , program);
719 }
720@@ -1437,9 +1739,45 @@ static void show_build_info(void)
721 return;
722 }
723
724+typedef struct _code {
725+ char *c_name;
726+ int c_val;
727+} CODE;
728+
729+CODE prioritynames[] = {
730+ { "alert", LOG_ALERT },
731+ { "crit", LOG_CRIT },
732+ { "debug", LOG_DEBUG },
733+ { "emerg", LOG_EMERG },
734+ { "err", LOG_ERR },
735+ { "error", LOG_ERR }, /* DEPRECATED */
736+ { "info", LOG_INFO },
737+ { "notice", LOG_NOTICE },
738+ { "panic", LOG_EMERG }, /* DEPRECATED */
739+ { "warn", LOG_WARNING }, /* DEPRECATED */
740+ { "warning", LOG_WARNING },
741+ { NULL, -1 },
742+};
743+
744+static int convert_log_priority(char *priority_name)
745+{
746+ CODE *priority_mapping;
747+
748+ for (priority_mapping = prioritynames;
749+ priority_mapping->c_name != NULL;
750+ priority_mapping++) {
751+
752+ if (!strcasecmp(priority_name, priority_mapping->c_name))
753+ return priority_mapping->c_val;
754+ }
755+
756+ return -1;
757+}
758+
759 int main(int argc, char *argv[])
760 {
761 int res, opt, status;
762+ int logpri = -1;
763 unsigned ghost, logging;
764 unsigned foreground, have_global_options;
765 time_t timeout;
766@@ -1457,6 +1795,7 @@ int main(int argc, char *argv[])
767 {"random-multimount-selection", 0, 0, 'r'},
768 {"global-options", 1, 0, 'O'},
769 {"version", 0, 0, 'V'},
770+ {"set-log-priority", 1, 0, 'l'},
771 {0, 0, 0, 0}
772 };
773
774@@ -1477,7 +1816,7 @@ int main(int argc, char *argv[])
775 foreground = 0;
776
777 opterr = 0;
778- while ((opt = getopt_long(argc, argv, "+hp:t:vdD:fVrO:", long_options, NULL)) != EOF) {
779+ while ((opt = getopt_long(argc, argv, "+hp:t:vdD:fVrO:l:", long_options, NULL)) != EOF) {
780 switch (opt) {
781 case 'h':
782 usage();
783@@ -1525,6 +1864,23 @@ int main(int argc, char *argv[])
784 program);
785 break;
786
787+ case 'l':
788+ if (isalpha(*optarg)) {
789+ logpri = convert_log_priority(optarg);
790+ if (logpri < 0) {
791+ fprintf(stderr, "Invalid log priority:"
792+ " %s\n", optarg);
793+ exit(1);
794+ }
795+ } else if (isdigit(*optarg)) {
796+ logpri = getnumopt(optarg, opt);
797+ } else {
798+ fprintf(stderr, "non-alphanumeric character "
799+ "found in log priority. Aborting.\n");
800+ exit(1);
801+ }
802+ break;
803+
804 case '?':
805 case ':':
806 printf("%s: Ambiguous or unknown options\n", program);
807@@ -1548,6 +1904,26 @@ int main(int argc, char *argv[])
808 argv += optind;
809 argc -= optind;
810
811+ if (logpri >= 0) {
812+ int exit_code = 0;
813+ int i;
814+
815+ /*
816+ * The remaining argv elements are the paths for which
817+ * log priorities must be changed.
818+ */
819+ for (i = 0; i < argc; i++) {
820+ if (set_log_priority(argv[i], logpri) < 0)
821+ exit_code = 1;
822+ }
823+ if (argc < 1) {
824+ fprintf(stderr,
825+ "--set-log-priority requires a path.\n");
826+ exit_code = 1;
827+ }
828+ exit(exit_code);
829+ }
830+
831 if (is_automount_running() > 0) {
832 fprintf(stderr, "%s: program is already running.\n",
833 program);
834@@ -1572,7 +1948,7 @@ int main(int argc, char *argv[])
835 rlim.rlim_max = MAX_OPEN_FILES;
836 res = setrlimit(RLIMIT_NOFILE, &rlim);
837 if (res)
838- warn(LOGOPT_NONE,
839+ warn(logging,
840 "can't increase open file limit - continuing");
841
842 #if ENABLE_CORES
843@@ -1580,7 +1956,7 @@ int main(int argc, char *argv[])
844 rlim.rlim_max = RLIM_INFINITY;
845 res = setrlimit(RLIMIT_CORE, &rlim);
846 if (res)
847- warn(LOGOPT_NONE,
848+ warn(logging,
849 "can't increase core file limit - continuing");
850 #endif
851
852@@ -1592,15 +1968,14 @@ int main(int argc, char *argv[])
853 master_list = master_new(argv[0], timeout, ghost);
854
855 if (!master_list) {
856- crit(LOGOPT_ANY, "%s: can't create master map %s",
857+ logerr("%s: can't create master map %s",
858 program, argv[0]);
859 close(start_pipefd[1]);
860 exit(1);
861 }
862
863 if (pthread_attr_init(&thread_attr)) {
864- crit(LOGOPT_ANY,
865- "%s: failed to init thread attribute struct!",
866+ logerr("%s: failed to init thread attribute struct!",
867 program);
868 close(start_pipefd[1]);
869 exit(1);
870@@ -1608,8 +1983,7 @@ int main(int argc, char *argv[])
871
872 if (pthread_attr_setdetachstate(
873 &thread_attr, PTHREAD_CREATE_DETACHED)) {
874- crit(LOGOPT_ANY,
875- "%s: failed to set detached thread attribute!",
876+ logerr("%s: failed to set detached thread attribute!",
877 program);
878 close(start_pipefd[1]);
879 exit(1);
880@@ -1618,38 +1992,37 @@ int main(int argc, char *argv[])
881 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
882 if (pthread_attr_setstacksize(
883 &thread_attr, PTHREAD_STACK_MIN*64)) {
884- crit(LOGOPT_ANY,
885- "%s: failed to set stack size thread attribute!",
886- program);
887+ logerr("%s: failed to set stack size thread attribute!",
888+ program);
889 close(start_pipefd[1]);
890 exit(1);
891 }
892 #endif
893
894- msg("Starting automounter version %s, master map %s",
895+ info(logging, "Starting automounter version %s, master map %s",
896 version, master_list->name);
897- msg("using kernel protocol version %d.%02d",
898+ info(logging, "using kernel protocol version %d.%02d",
899 get_kver_major(), get_kver_minor());
900
901 status = pthread_key_create(&key_thread_stdenv_vars,
902 key_thread_stdenv_vars_destroy);
903 if (status) {
904- crit(LOGOPT_ANY,
905- "failed to create thread data key for std env vars!");
906+ logerr("%s: failed to create thread data key for std env vars!",
907+ program);
908 master_kill(master_list);
909 close(start_pipefd[1]);
910 exit(1);
911 }
912
913 if (!alarm_start_handler()) {
914- crit(LOGOPT_ANY, "failed to create alarm handler thread!");
915+ logerr("%s: failed to create alarm handler thread!", program);
916 master_kill(master_list);
917 close(start_pipefd[1]);
918 exit(1);
919 }
920
921 if (!st_start_handler()) {
922- crit(LOGOPT_ANY, "failed to create FSM handler thread!");
923+ logerr("%s: failed to create FSM handler thread!", program);
924 master_kill(master_list);
925 close(start_pipefd[1]);
926 exit(1);
927@@ -1685,5 +2058,7 @@ int main(int argc, char *argv[])
928 if (dh)
929 dlclose(dh);
930 #endif
931+ info(logging, "autofs stopped");
932+
933 exit(0);
934 }
935diff --git a/daemon/direct.c b/daemon/direct.c
936index 9a39a6f..4ab4204 100644
937--- a/daemon/direct.c
938+++ b/daemon/direct.c
939@@ -86,61 +86,6 @@ static void mnts_cleanup(void *arg)
940 return;
941 }
942
943-static int autofs_init_direct(struct autofs_point *ap)
944-{
945- int pipefd[2], cl_flags;
946-
947- if ((ap->state != ST_INIT)) {
948- /* This can happen if an autofs process is already running*/
949- error(ap->logopt, "bad state %d", ap->state);
950- return -1;
951- }
952-
953- ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
954-
955- /* Pipe for kernel communications */
956- if (pipe(pipefd) < 0) {
957- crit(ap->logopt,
958- "failed to create commumication pipe for autofs path %s",
959- ap->path);
960- return -1;
961- }
962-
963- ap->pipefd = pipefd[0];
964- ap->kpipefd = pipefd[1];
965-
966- if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
967- cl_flags |= FD_CLOEXEC;
968- fcntl(ap->pipefd, F_SETFD, cl_flags);
969- }
970-
971- if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
972- cl_flags |= FD_CLOEXEC;
973- fcntl(ap->kpipefd, F_SETFD, cl_flags);
974- }
975-
976- /* Pipe state changes from signal handler to main loop */
977- if (pipe(ap->state_pipe) < 0) {
978- crit(ap->logopt, "failed create state pipe for autofs path %s",
979- ap->path);
980- close(ap->pipefd);
981- close(ap->kpipefd);
982- return -1;
983- }
984-
985- if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
986- cl_flags |= FD_CLOEXEC;
987- fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
988- }
989-
990- if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
991- cl_flags |= FD_CLOEXEC;
992- fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
993- }
994-
995- return 0;
996-}
997-
998 int do_umount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, struct mapent *me)
999 {
1000 char buf[MAX_ERR_BUF];
1001@@ -241,10 +186,10 @@ int do_umount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, stru
1002
1003 force_umount:
1004 if (rv != 0) {
1005- msg("forcing umount of direct mount %s", me->key);
1006+ info(ap->logopt, "forcing umount of direct mount %s", me->key);
1007 rv = umount2(me->key, MNT_DETACH);
1008 } else
1009- msg("umounted direct mount %s", me->key);
1010+ info(ap->logopt, "umounted direct mount %s", me->key);
1011
1012 if (!rv && me->dir_created) {
1013 if (rmdir(me->key) == -1) {
1014@@ -326,7 +271,7 @@ static int unlink_mount_tree(struct autofs_point *ap, struct list_head *list)
1015 continue;
1016
1017 if (strcmp(mnt->fs_type, "autofs"))
1018- rv = spawn_umount(log_debug, "-l", mnt->path, NULL);
1019+ rv = spawn_umount(ap->logopt, "-l", mnt->path, NULL);
1020 else
1021 rv = umount2(mnt->path, MNT_DETACH);
1022 if (rv == -1) {
1023@@ -475,13 +420,15 @@ int do_mount_autofs_direct(struct autofs_point *ap, struct mnt_list *mnts, struc
1024 ioctl(ioctlfd, AUTOFS_IOC_SETTIMEOUT, &timeout);
1025
1026 if (ap->exp_timeout)
1027- msg("mounted direct mount on %s "
1028+ info(ap->logopt,
1029+ "mounted direct mount on %s "
1030 "with timeout %u, freq %u seconds", me->key,
1031 (unsigned int) ap->exp_timeout,
1032 (unsigned int) ap->exp_runfreq);
1033 else
1034- msg("mounted direct mount on %s with timeouts disabled",
1035- me->key);
1036+ info(ap->logopt,
1037+ "mounted direct mount on %s with timeouts disabled",
1038+ me->key);
1039
1040 ret = fstat(ioctlfd, &st);
1041 if (ret == -1) {
1042@@ -522,9 +469,6 @@ int mount_autofs_direct(struct autofs_point *ap)
1043 return -1;
1044 }
1045
1046- if (autofs_init_direct(ap))
1047- return -1;
1048-
1049 /* TODO: check map type */
1050 if (lookup_nss_read_map(ap, NULL, now))
1051 lookup_prune_cache(ap, now);
1052@@ -607,7 +551,7 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1053 /* offset isn't mounted, return success and try to recover */
1054 if (!is_mounted(_PROC_MOUNTS, me->key, MNTS_AUTOFS)) {
1055 debug(ap->logopt,
1056- "offset %s unexpectedly not mounted",
1057+ "offset %s not mounted",
1058 me->key);
1059 return 0;
1060 }
1061@@ -627,7 +571,7 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1062 rv = ioctl(ioctlfd, AUTOFS_IOC_ASKUMOUNT, &status);
1063 if (rv) {
1064 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1065- error(ap->logopt, "ioctl failed: %s", estr);
1066+ logerr("ioctl failed: %s", estr);
1067 return 1;
1068 } else if (!status) {
1069 if (ap->state != ST_SHUTDOWN_FORCE) {
1070@@ -692,10 +636,10 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)
1071
1072 force_umount:
1073 if (rv != 0) {
1074- msg("forcing umount of offset mount %s", me->key);
1075+ info(ap->logopt, "forcing umount of offset mount %s", me->key);
1076 rv = umount2(me->key, MNT_DETACH);
1077 } else
1078- msg("umounted offset mount %s", me->key);
1079+ info(ap->logopt, "umounted offset mount %s", me->key);
1080
1081 if (!rv && me->dir_created) {
1082 if (rmdir(me->key) == -1) {
1083@@ -868,7 +812,7 @@ static int expire_direct(int ioctlfd, const char *path, unsigned int when, unsig
1084 return 0;
1085 }
1086
1087- retries = (count_mounts(path, st.st_dev) + 1) * EXPIRE_RETRIES;
1088+ retries = (count_mounts(logopt, path, st.st_dev) + 1) * EXPIRE_RETRIES;
1089
1090 while (retries--) {
1091 struct timespec tm = {0, 100000000};
1092@@ -1018,7 +962,7 @@ void *expire_proc_direct(void *arg)
1093
1094 if (me->ioctlfd != -1 &&
1095 fstat(ioctlfd, &st) != -1 &&
1096- !count_mounts(next->path, st.st_dev)) {
1097+ !count_mounts(ap->logopt, next->path, st.st_dev)) {
1098 close(ioctlfd);
1099 me->ioctlfd = -1;
1100 }
1101@@ -1049,6 +993,9 @@ void *expire_proc_direct(void *arg)
1102 }
1103 pthread_cleanup_pop(1);
1104
1105+ if (left)
1106+ info(ap->logopt, "%d remaining in %s", left, ap->path);
1107+
1108 ec.status = left;
1109
1110 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
1111@@ -1072,7 +1019,7 @@ static void pending_cond_destroy(void *arg)
1112 static void expire_send_fail(void *arg)
1113 {
1114 struct pending_args *mt = arg;
1115- send_fail(mt->ioctlfd, mt->wait_queue_token);
1116+ send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1117 }
1118
1119 static void free_pending_args(void *arg)
1120@@ -1124,14 +1071,14 @@ static void *do_expire_direct(void *arg)
1121 status = do_expire(ap, mt->name, len);
1122 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1123 if (status)
1124- send_fail(mt->ioctlfd, mt->wait_queue_token);
1125+ send_fail(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1126 else {
1127 struct mapent *me;
1128 cache_readlock(mt->mc);
1129 me = cache_lookup_distinct(mt->mc, mt->name);
1130 me->ioctlfd = -1;
1131 cache_unlock(mt->mc);
1132- send_ready(mt->ioctlfd, mt->wait_queue_token);
1133+ send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1134 close(mt->ioctlfd);
1135 }
1136 pthread_setcancelstate(state, NULL);
1137@@ -1194,7 +1141,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1138 if (!mt) {
1139 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1140 error(ap->logopt, "malloc: %s", estr);
1141- send_fail(me->ioctlfd, pkt->wait_queue_token);
1142+ send_fail(ap->logopt, me->ioctlfd, pkt->wait_queue_token);
1143 cache_unlock(mc);
1144 pthread_setcancelstate(state, NULL);
1145 return 1;
1146@@ -1223,7 +1170,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1147 status = pthread_create(&thid, &thread_attr, do_expire_direct, mt);
1148 if (status) {
1149 error(ap->logopt, "expire thread create failed");
1150- send_fail(mt->ioctlfd, pkt->wait_queue_token);
1151+ send_fail(ap->logopt, mt->ioctlfd, pkt->wait_queue_token);
1152 cache_unlock(mc);
1153 expire_mutex_unlock(NULL);
1154 pending_cond_destroy(mt);
1155@@ -1252,7 +1199,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di
1156 static void mount_send_fail(void *arg)
1157 {
1158 struct pending_args *mt = arg;
1159- send_fail(mt->ioctlfd, mt->wait_queue_token);
1160+ send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1161 close(mt->ioctlfd);
1162 }
1163
1164@@ -1319,7 +1266,7 @@ static void *do_mount_direct(void *arg)
1165
1166 pthread_setcancelstate(state, NULL);
1167
1168- msg("attempting to mount entry %s", mt->name);
1169+ info(ap->logopt, "attempting to mount entry %s", mt->name);
1170
1171 /*
1172 * Setup thread specific data values for macro
1173@@ -1445,16 +1392,16 @@ cont:
1174 cache_unlock(mt->mc);
1175 if (set_fd) {
1176 me->ioctlfd = mt->ioctlfd;
1177- send_ready(mt->ioctlfd, mt->wait_queue_token);
1178+ send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1179 } else {
1180- send_ready(mt->ioctlfd, mt->wait_queue_token);
1181+ send_ready(ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1182 close(mt->ioctlfd);
1183 }
1184- msg("mounted %s", mt->name);
1185+ info(ap->logopt, "mounted %s", mt->name);
1186 } else {
1187- send_fail(mt->ioctlfd, mt->wait_queue_token);
1188+ send_fail(mt->ap->logopt, mt->ioctlfd, mt->wait_queue_token);
1189 close(mt->ioctlfd);
1190- msg("failed to mount %s", mt->name);
1191+ info(ap->logopt, "failed to mount %s", mt->name);
1192 }
1193 pthread_setcancelstate(state, NULL);
1194
1195@@ -1505,7 +1452,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1196 * Shouldn't happen as the kernel is telling us
1197 * someone has walked on our mount point.
1198 */
1199- crit(ap->logopt, "can't find map entry for (%lu,%lu)",
1200+ logerr("can't find map entry for (%lu,%lu)",
1201 (unsigned long) pkt->dev, (unsigned long) pkt->ino);
1202 pthread_setcancelstate(state, NULL);
1203 return 1;
1204@@ -1538,7 +1485,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1205 if (ap->state == ST_SHUTDOWN_PENDING ||
1206 ap->state == ST_SHUTDOWN_FORCE ||
1207 ap->state == ST_SHUTDOWN) {
1208- send_fail(ioctlfd, pkt->wait_queue_token);
1209+ send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1210 close(ioctlfd);
1211 cache_unlock(mc);
1212 pthread_setcancelstate(state, NULL);
1213@@ -1549,7 +1496,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1214 if (!mt) {
1215 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1216 error(ap->logopt, "malloc: %s", estr);
1217- send_fail(ioctlfd, pkt->wait_queue_token);
1218+ send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1219 close(ioctlfd);
1220 cache_unlock(mc);
1221 pthread_setcancelstate(state, NULL);
1222@@ -1578,7 +1525,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_
1223 status = pthread_create(&thid, &thread_attr, do_mount_direct, mt);
1224 if (status) {
1225 error(ap->logopt, "missing mount thread create failed");
1226- send_fail(ioctlfd, pkt->wait_queue_token);
1227+ send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);
1228 close(ioctlfd);
1229 cache_unlock(mc);
1230 mount_mutex_unlock(NULL);
1231diff --git a/daemon/indirect.c b/daemon/indirect.c
1232index 02e7045..5c422c8 100644
1233--- a/daemon/indirect.c
1234+++ b/daemon/indirect.c
1235@@ -43,63 +43,6 @@ extern pthread_attr_t thread_attr;
1236 static pthread_mutex_t ma_mutex = PTHREAD_MUTEX_INITIALIZER;
1237 static pthread_mutex_t ea_mutex = PTHREAD_MUTEX_INITIALIZER;
1238
1239-static int autofs_init_indirect(struct autofs_point *ap)
1240-{
1241- int pipefd[2], cl_flags;
1242-
1243- if ((ap->state != ST_INIT)) {
1244- /* This can happen if an autofs process is already running*/
1245- error(ap->logopt, "bad state %d", ap->state);
1246- return -1;
1247- }
1248-
1249- ap->pipefd = ap->kpipefd = ap->ioctlfd = -1;
1250-
1251- /* Pipe for kernel communications */
1252- if (pipe(pipefd) < 0) {
1253- crit(ap->logopt,
1254- "failed to create commumication pipe for autofs path %s",
1255- ap->path);
1256- free(ap->path);
1257- return -1;
1258- }
1259-
1260- ap->pipefd = pipefd[0];
1261- ap->kpipefd = pipefd[1];
1262-
1263- if ((cl_flags = fcntl(ap->pipefd, F_GETFD, 0)) != -1) {
1264- cl_flags |= FD_CLOEXEC;
1265- fcntl(ap->pipefd, F_SETFD, cl_flags);
1266- }
1267-
1268- if ((cl_flags = fcntl(ap->kpipefd, F_GETFD, 0)) != -1) {
1269- cl_flags |= FD_CLOEXEC;
1270- fcntl(ap->kpipefd, F_SETFD, cl_flags);
1271- }
1272-
1273- /* Pipe state changes from signal handler to main loop */
1274- if (pipe(ap->state_pipe) < 0) {
1275- crit(ap->logopt,
1276- "failed create state pipe for autofs path %s", ap->path);
1277- close(ap->pipefd);
1278- close(ap->kpipefd); /* Close kernel pipe end */
1279- free(ap->path);
1280- return -1;
1281- }
1282-
1283- if ((cl_flags = fcntl(ap->state_pipe[0], F_GETFD, 0)) != -1) {
1284- cl_flags |= FD_CLOEXEC;
1285- fcntl(ap->state_pipe[0], F_SETFD, cl_flags);
1286- }
1287-
1288- if ((cl_flags = fcntl(ap->state_pipe[1], F_GETFD, 0)) != -1) {
1289- cl_flags |= FD_CLOEXEC;
1290- fcntl(ap->state_pipe[1], F_SETFD, cl_flags);
1291- }
1292-
1293- return 0;
1294-}
1295-
1296 static int unlink_mount_tree(struct autofs_point *ap, struct mnt_list *mnts)
1297 {
1298 struct mnt_list *this;
1299@@ -118,7 +61,7 @@ static int unlink_mount_tree(struct autofs_point *ap, struct mnt_list *mnts)
1300 }
1301
1302 if (strcmp(this->fs_type, "autofs"))
1303- rv = spawn_umount(log_debug, "-l", this->path, NULL);
1304+ rv = spawn_umount(ap->logopt, "-l", this->path, NULL);
1305 else
1306 rv = umount2(this->path, MNT_DETACH);
1307 if (rv == -1) {
1308@@ -222,12 +165,14 @@ static int do_mount_autofs_indirect(struct autofs_point *ap)
1309 ioctl(ap->ioctlfd, AUTOFS_IOC_SETTIMEOUT, &timeout);
1310
1311 if (ap->exp_timeout)
1312- msg("mounted indirect mount on %s "
1313+ info(ap->logopt,
1314+ "mounted indirect mount on %s "
1315 "with timeout %u, freq %u seconds", ap->path,
1316- (unsigned int) ap->exp_timeout,
1317- (unsigned int) ap->exp_runfreq);
1318+ (unsigned int) ap->exp_timeout,
1319+ (unsigned int) ap->exp_runfreq);
1320 else
1321- msg("mounted indirect mount on %s with timeouts disabled",
1322+ info(ap->logopt,
1323+ "mounted indirect mount on %s with timeouts disabled",
1324 ap->path);
1325
1326 fstat(ap->ioctlfd, &st);
1327@@ -257,9 +202,6 @@ int mount_autofs_indirect(struct autofs_point *ap)
1328 int status;
1329 int map;
1330
1331- if (autofs_init_indirect(ap))
1332- return -1;
1333-
1334 /* TODO: read map, determine map type is OK */
1335 if (lookup_nss_read_map(ap, NULL, now))
1336 lookup_prune_cache(ap, now);
1337@@ -309,7 +251,7 @@ int umount_autofs_indirect(struct autofs_point *ap)
1338 rv = ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &ret);
1339 if (rv == -1) {
1340 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1341- error(ap->logopt, "ioctl failed: %s", estr);
1342+ logerr("ioctl failed: %s", estr);
1343 return 1;
1344 } else if (!ret) {
1345 error(ap->logopt, "ask umount returned busy %s", ap->path);
1346@@ -370,9 +312,9 @@ force_umount:
1347 "forcing umount of indirect mount %s", ap->path);
1348 rv = umount2(ap->path, MNT_DETACH);
1349 } else {
1350- msg("umounted indirect mount %s", ap->path);
1351+ info(ap->logopt, "umounted indirect mount %s", ap->path);
1352 if (ap->submount)
1353- rm_unwanted(ap->path, 1, ap->dev);
1354+ rm_unwanted(ap->logopt, ap->path, 1, ap->dev);
1355 }
1356
1357 return rv;
1358@@ -390,7 +332,7 @@ static int expire_indirect(struct autofs_point *ap, int ioctlfd, const char *pat
1359 return 0;
1360 }
1361
1362- retries = (count_mounts(path, st.st_dev) + 1) * EXPIRE_RETRIES;
1363+ retries = (count_mounts(ap->logopt, path, st.st_dev) + 1) * EXPIRE_RETRIES;
1364
1365 while (retries--) {
1366 struct timespec tm = {0, 100000000};
1367@@ -559,13 +501,7 @@ void *expire_proc_indirect(void *arg)
1368 * words) the umounts are done by the time we reach here
1369 */
1370 if (count)
1371- debug(ap->logopt, "%d remaining in %s", count, ap->path);
1372-
1373- /* If we are trying to shutdown make sure we can umount */
1374- if (!ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &ret)) {
1375- if (!ret)
1376- msg("mount still busy %s", ap->path);
1377- }
1378+ info(ap->logopt, "%d remaining in %s", count, ap->path);
1379
1380 ec.status = left;
1381
1382@@ -590,7 +526,7 @@ static void pending_cond_destroy(void *arg)
1383 static void expire_send_fail(void *arg)
1384 {
1385 struct pending_args *mt = arg;
1386- send_fail(mt->ap->ioctlfd, mt->wait_queue_token);
1387+ send_fail(mt->ap->logopt, mt->ap->ioctlfd, mt->wait_queue_token);
1388 }
1389
1390 static void free_pending_args(void *arg)
1391@@ -634,9 +570,9 @@ static void *do_expire_indirect(void *arg)
1392 status = do_expire(mt->ap, mt->name, mt->len);
1393 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1394 if (status)
1395- send_fail(ap->ioctlfd, mt->wait_queue_token);
1396+ send_fail(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1397 else
1398- send_ready(ap->ioctlfd, mt->wait_queue_token);
1399+ send_ready(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1400 pthread_setcancelstate(state, NULL);
1401
1402 pthread_cleanup_pop(0);
1403@@ -661,8 +597,8 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1404 mt = malloc(sizeof(struct pending_args));
1405 if (!mt) {
1406 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1407- error(ap->logopt, "malloc: %s", estr);
1408- send_fail(ap->ioctlfd, pkt->wait_queue_token);
1409+ logerr("malloc: %s", estr);
1410+ send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1411 pthread_setcancelstate(state, NULL);
1412 return 1;
1413 }
1414@@ -684,7 +620,7 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1415 status = pthread_create(&thid, &thread_attr, do_expire_indirect, mt);
1416 if (status) {
1417 error(ap->logopt, "expire thread create failed");
1418- send_fail(ap->ioctlfd, pkt->wait_queue_token);
1419+ send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1420 expire_mutex_unlock(NULL);
1421 pending_cond_destroy(mt);
1422 free_pending_args(mt);
1423@@ -710,7 +646,7 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
1424 static void mount_send_fail(void *arg)
1425 {
1426 struct pending_args *mt = arg;
1427- send_fail(mt->ap->ioctlfd, mt->wait_queue_token);
1428+ send_fail(mt->ap->logopt, mt->ap->ioctlfd, mt->wait_queue_token);
1429 }
1430
1431 static void mount_mutex_unlock(void *arg)
1432@@ -775,7 +711,7 @@ static void *do_mount_indirect(void *arg)
1433
1434 pthread_setcancelstate(state, NULL);
1435
1436- msg("attempting to mount entry %s", buf);
1437+ info(ap->logopt, "attempting to mount entry %s", buf);
1438
1439 /*
1440 * Setup thread specific data values for macro
1441@@ -887,11 +823,11 @@ cont:
1442 status = lookup_nss_mount(ap, NULL, mt->name, mt->len);
1443 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
1444 if (status) {
1445- send_ready(ap->ioctlfd, mt->wait_queue_token);
1446- msg("mounted %s", buf);
1447+ send_ready(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1448+ info(ap->logopt, "mounted %s", buf);
1449 } else {
1450- send_fail(ap->ioctlfd, mt->wait_queue_token);
1451- msg("failed to mount %s", buf);
1452+ send_fail(ap->logopt, ap->ioctlfd, mt->wait_queue_token);
1453+ info(ap->logopt, "failed to mount %s", buf);
1454 }
1455 pthread_setcancelstate(state, NULL);
1456
1457@@ -918,7 +854,7 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1458 if (ap->state == ST_SHUTDOWN_PENDING ||
1459 ap->state == ST_SHUTDOWN_FORCE ||
1460 ap->state == ST_SHUTDOWN) {
1461- send_fail(ap->ioctlfd, pkt->wait_queue_token);
1462+ send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1463 pthread_setcancelstate(state, NULL);
1464 return 0;
1465 }
1466@@ -926,8 +862,8 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1467 mt = malloc(sizeof(struct pending_args));
1468 if (!mt) {
1469 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1470- error(ap->logopt, "malloc: %s", estr);
1471- send_fail(ap->ioctlfd, pkt->wait_queue_token);
1472+ logerr("malloc: %s", estr);
1473+ send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1474 pthread_setcancelstate(state, NULL);
1475 return 1;
1476 }
1477@@ -953,7 +889,7 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin
1478 status = pthread_create(&thid, &thread_attr, do_mount_indirect, mt);
1479 if (status) {
1480 error(ap->logopt, "expire thread create failed");
1481- send_fail(ap->ioctlfd, pkt->wait_queue_token);
1482+ send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);
1483 mount_mutex_unlock(NULL);
1484 pending_cond_destroy(mt);
1485 free_pending_args(mt);
1486diff --git a/daemon/lookup.c b/daemon/lookup.c
1487index 4f2b318..fd99cf2 100644
1488--- a/daemon/lookup.c
1489+++ b/daemon/lookup.c
1490@@ -103,6 +103,7 @@ static int do_read_master(struct master *master, char *type, time_t age)
1491
1492 static int read_master_map(struct master *master, char *type, time_t age)
1493 {
1494+ unsigned int logopt = master->logopt;
1495 char *path, *save_name;
1496 int result;
1497
1498@@ -117,7 +118,7 @@ static int read_master_map(struct master *master, char *type, time_t age)
1499 */
1500
1501 if (strchr(master->name, '/')) {
1502- error(LOGOPT_ANY, "relative path invalid in files map name");
1503+ error(logopt, "relative path invalid in files map name");
1504 return NSS_STATUS_NOTFOUND;
1505 }
1506
1507@@ -142,6 +143,7 @@ static int read_master_map(struct master *master, char *type, time_t age)
1508
1509 int lookup_nss_read_master(struct master *master, time_t age)
1510 {
1511+ unsigned int logopt = master->logopt;
1512 struct list_head nsslist;
1513 struct list_head *head, *p;
1514 int result = NSS_STATUS_UNKNOWN;
1515@@ -149,12 +151,10 @@ int lookup_nss_read_master(struct master *master, time_t age)
1516 /* If it starts with a '/' it has to be a file or LDAP map */
1517 if (*master->name == '/') {
1518 if (*(master->name + 1) == '/') {
1519- debug(LOGOPT_NONE,
1520- "reading master ldap %s", master->name);
1521+ debug(logopt, "reading master ldap %s", master->name);
1522 result = do_read_master(master, "ldap", age);
1523 } else {
1524- debug(LOGOPT_NONE,
1525- "reading master file %s", master->name);
1526+ debug(logopt, "reading master file %s", master->name);
1527 result = do_read_master(master, "file", age);
1528 }
1529
1530@@ -184,13 +184,11 @@ int lookup_nss_read_master(struct master *master, time_t age)
1531 */
1532 if (strncmp(name, "ldap", 4)) {
1533 master->name = tmp + 1;
1534- debug(LOGOPT_NONE,
1535- "reading master %s %s",
1536+ debug(logopt, "reading master %s %s",
1537 source, master->name);
1538 } else {
1539 master->name = name;
1540- debug(LOGOPT_NONE,
1541- "reading master %s %s",
1542+ debug(logopt, "reading master %s %s",
1543 source, tmp + 1);
1544 }
1545
1546@@ -208,7 +206,7 @@ int lookup_nss_read_master(struct master *master, time_t age)
1547 if (result) {
1548 if (!list_empty(&nsslist))
1549 free_sources(&nsslist);
1550- error(LOGOPT_ANY, "can't to read name service switch config.");
1551+ error(logopt, "can't to read name service switch config.");
1552 return 0;
1553 }
1554
1555@@ -220,13 +218,12 @@ int lookup_nss_read_master(struct master *master, time_t age)
1556
1557 this = list_entry(p, struct nss_source, list);
1558
1559- debug(LOGOPT_NONE,
1560+ debug(logopt,
1561 "reading master %s %s", this->source, master->name);
1562
1563 result = read_master_map(master, this->source, age);
1564 if (result == NSS_STATUS_UNKNOWN) {
1565- debug(LOGOPT_NONE,
1566- "no map - continuing to next source");
1567+ debug(logopt, "no map - continuing to next source");
1568 continue;
1569 }
1570
1571@@ -1008,9 +1005,10 @@ int lookup_prune_cache(struct autofs_point *ap, time_t age)
1572 if (this->ioctlfd == -1)
1573 status = cache_delete(mc, key);
1574 if (status != CHE_FAIL) {
1575- if (ap->type == LKP_INDIRECT)
1576- rmdir_path(ap, path, ap->dev);
1577- else
1578+ if (ap->type == LKP_INDIRECT) {
1579+ if (ap->ghost)
1580+ rmdir_path(ap, path, ap->dev);
1581+ } else
1582 rmdir_path(ap, path, this->dev);
1583 }
1584 }
1585diff --git a/daemon/module.c b/daemon/module.c
1586index e83c929..36eca00 100644
1587--- a/daemon/module.c
1588+++ b/daemon/module.c
1589@@ -33,7 +33,7 @@ int load_autofs4_module(void)
1590 */
1591 fp = fopen("/proc/filesystems", "r");
1592 if (!fp) {
1593- error(LOGOPT_ANY, "cannot open /proc/filesystems\n");
1594+ logerr("cannot open /proc/filesystems\n");
1595 return 0;
1596 }
1597
1598@@ -45,7 +45,7 @@ int load_autofs4_module(void)
1599 }
1600 fclose(fp);
1601
1602- ret = spawnl(log_debug, PATH_MODPROBE, PATH_MODPROBE,
1603+ ret = spawnl(LOGOPT_NONE, PATH_MODPROBE, PATH_MODPROBE,
1604 "-q", FS_MODULE_NAME, NULL);
1605 if (ret)
1606 return 0;
1607@@ -72,7 +72,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1608 if (!mod) {
1609 if (err_prefix) {
1610 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1611- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1612+ logerr("%s%s", err_prefix, estr);
1613 }
1614 return NULL;
1615 }
1616@@ -83,7 +83,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1617 free(mod);
1618 if (err_prefix) {
1619 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1620- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1621+ logerr("%s%s", err_prefix, estr);
1622 }
1623 return NULL;
1624 }
1625@@ -91,7 +91,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1626
1627 if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1628 if (err_prefix)
1629- crit(LOGOPT_ANY, "%scannot open lookup module %s (%s)",
1630+ logerr("%scannot open lookup module %s (%s)",
1631 err_prefix, name, dlerror());
1632 free(mod);
1633 return NULL;
1634@@ -100,8 +100,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1635 if (!(ver = (int *) dlsym(dh, "lookup_version"))
1636 || *ver != AUTOFS_LOOKUP_VERSION) {
1637 if (err_prefix)
1638- crit(LOGOPT_ANY,
1639- "%slookup module %s version mismatch",
1640+ logerr("%slookup module %s version mismatch",
1641 err_prefix, name);
1642 dlclose(dh);
1643 free(mod);
1644@@ -114,7 +113,7 @@ struct lookup_mod *open_lookup(const char *name, const char *err_prefix,
1645 !(mod->lookup_mount = (lookup_mount_t) dlsym(dh, "lookup_mount")) ||
1646 !(mod->lookup_done = (lookup_done_t) dlsym(dh, "lookup_done"))) {
1647 if (err_prefix)
1648- crit(LOGOPT_ANY, "%slookup module %s corrupt", err_prefix, name);
1649+ logerr("%slookup module %s corrupt", err_prefix, name);
1650 dlclose(dh);
1651 free(mod);
1652 return NULL;
1653@@ -156,7 +155,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1654 if (!mod) {
1655 if (err_prefix) {
1656 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1657- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1658+ logerr("%s%s", err_prefix, estr);
1659 }
1660 return NULL;
1661 }
1662@@ -167,7 +166,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1663 free(mod);
1664 if (err_prefix) {
1665 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1666- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1667+ logerr("%s%s", err_prefix, estr);
1668 }
1669 return NULL;
1670 }
1671@@ -175,8 +174,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1672
1673 if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1674 if (err_prefix)
1675- crit(LOGOPT_ANY,
1676- "%scannot open parse module %s (%s)",
1677+ logerr("%scannot open parse module %s (%s)",
1678 err_prefix, name, dlerror());
1679 free(mod);
1680 return NULL;
1681@@ -185,8 +183,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1682 if (!(ver = (int *) dlsym(dh, "parse_version"))
1683 || *ver != AUTOFS_PARSE_VERSION) {
1684 if (err_prefix)
1685- crit(LOGOPT_ANY,
1686- "%sparse module %s version mismatch",
1687+ logerr("%sparse module %s version mismatch",
1688 err_prefix, name);
1689 dlclose(dh);
1690 free(mod);
1691@@ -197,8 +194,7 @@ struct parse_mod *open_parse(const char *name, const char *err_prefix,
1692 !(mod->parse_mount = (parse_mount_t) dlsym(dh, "parse_mount")) ||
1693 !(mod->parse_done = (parse_done_t) dlsym(dh, "parse_done"))) {
1694 if (err_prefix)
1695- crit(LOGOPT_ANY,
1696- "%sparse module %s corrupt",
1697+ logerr("%sparse module %s corrupt",
1698 err_prefix, name);
1699 dlclose(dh);
1700 free(mod);
1701@@ -240,7 +236,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1702 if (!mod) {
1703 if (err_prefix) {
1704 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1705- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1706+ logerr("%s%s", err_prefix, estr);
1707 }
1708 return NULL;
1709 }
1710@@ -251,7 +247,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1711 free(mod);
1712 if (err_prefix) {
1713 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1714- crit(LOGOPT_ANY, "%s%s", err_prefix, estr);
1715+ logerr("%s%s", err_prefix, estr);
1716 }
1717 return NULL;
1718 }
1719@@ -259,8 +255,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1720
1721 if (!(dh = dlopen(fnbuf, RTLD_NOW))) {
1722 if (err_prefix)
1723- crit(LOGOPT_ANY,
1724- "%scannot open mount module %s (%s)",
1725+ logerr("%scannot open mount module %s (%s)",
1726 err_prefix, name, dlerror());
1727 free(mod);
1728 return NULL;
1729@@ -269,8 +264,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1730 if (!(ver = (int *) dlsym(dh, "mount_version"))
1731 || *ver != AUTOFS_MOUNT_VERSION) {
1732 if (err_prefix)
1733- crit(LOGOPT_ANY,
1734- "%smount module %s version mismatch",
1735+ logerr("%smount module %s version mismatch",
1736 err_prefix, name);
1737 dlclose(dh);
1738 free(mod);
1739@@ -281,8 +275,7 @@ struct mount_mod *open_mount(const char *name, const char *err_prefix)
1740 !(mod->mount_mount = (mount_mount_t) dlsym(dh, "mount_mount")) ||
1741 !(mod->mount_done = (mount_done_t) dlsym(dh, "mount_done"))) {
1742 if (err_prefix)
1743- crit(LOGOPT_ANY,
1744- "%smount module %s corrupt",
1745+ logerr("%smount module %s corrupt",
1746 err_prefix, name);
1747 dlclose(dh);
1748 free(mod);
1749diff --git a/daemon/spawn.c b/daemon/spawn.c
1750index 271d37e..3d5ea56 100644
1751--- a/daemon/spawn.c
1752+++ b/daemon/spawn.c
1753@@ -88,7 +88,7 @@ void reset_signals(void)
1754
1755 #define ERRBUFSIZ 2047 /* Max length of error string excl \0 */
1756
1757-static int do_spawn(logger *log, unsigned int options, const char *prog, const char *const *argv)
1758+static int do_spawn(unsigned logopt, unsigned int options, const char *prog, const char *const *argv)
1759 {
1760 pid_t f;
1761 int ret, status, pipefd[2];
1762@@ -195,7 +195,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1763 while (errp && (p = memchr(sp, '\n', errp))) {
1764 *p++ = '\0';
1765 if (sp[0]) /* Don't output empty lines */
1766- log(LOGOPT_ANY, ">> %s", sp);
1767+ warn(logopt, ">> %s", sp);
1768 errp -= (p - sp);
1769 sp = p;
1770 }
1771@@ -206,7 +206,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1772 if (errp >= ERRBUFSIZ) {
1773 /* Line too long, split */
1774 errbuf[errp] = '\0';
1775- log(LOGOPT_ANY, ">> %s", errbuf);
1776+ warn(logopt, ">> %s", errbuf);
1777 errp = 0;
1778 }
1779 }
1780@@ -217,7 +217,7 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1781 if (errp > 0) {
1782 /* End of file without \n */
1783 errbuf[errp] = '\0';
1784- log(LOGOPT_ANY, ">> %s", errbuf);
1785+ warn(logopt, ">> %s", errbuf);
1786 }
1787
1788 if (waitpid(f, &ret, 0) != f)
1789@@ -235,12 +235,12 @@ static int do_spawn(logger *log, unsigned int options, const char *prog, const c
1790 }
1791 }
1792
1793-int spawnv(logger *log, const char *prog, const char *const *argv)
1794+int spawnv(unsigned logopt, const char *prog, const char *const *argv)
1795 {
1796- return do_spawn(log, SPAWN_OPT_NONE, prog, argv);
1797+ return do_spawn(logopt, SPAWN_OPT_NONE, prog, argv);
1798 }
1799
1800-int spawnl(logger *log, const char *prog, ...)
1801+int spawnl(unsigned logopt, const char *prog, ...)
1802 {
1803 va_list arg;
1804 int argc;
1805@@ -258,10 +258,10 @@ int spawnl(logger *log, const char *prog, ...)
1806 while ((*p++ = va_arg(arg, char *)));
1807 va_end(arg);
1808
1809- return do_spawn(log, SPAWN_OPT_NONE, prog, (const char **) argv);
1810+ return do_spawn(logopt, SPAWN_OPT_NONE, prog, (const char **) argv);
1811 }
1812
1813-int spawn_mount(logger *log, ...)
1814+int spawn_mount(unsigned logopt, ...)
1815 {
1816 va_list arg;
1817 int argc;
1818@@ -279,7 +279,7 @@ int spawn_mount(logger *log, ...)
1819 options = SPAWN_OPT_NONE;
1820 #endif
1821
1822- va_start(arg, log);
1823+ va_start(arg, logopt);
1824 for (argc = 1; va_arg(arg, char *); argc++);
1825 va_end(arg);
1826
1827@@ -288,13 +288,13 @@ int spawn_mount(logger *log, ...)
1828
1829 argv[0] = arg0;
1830
1831- va_start(arg, log);
1832+ va_start(arg, logopt);
1833 p = argv + 1;
1834 while ((*p++ = va_arg(arg, char *)));
1835 va_end(arg);
1836
1837 while (retries--) {
1838- ret = do_spawn(log, options, prog, (const char **) argv);
1839+ ret = do_spawn(logopt, options, prog, (const char **) argv);
1840 if (ret & MTAB_NOTUPDATED)
1841 continue;
1842 break;
1843@@ -311,7 +311,7 @@ int spawn_mount(logger *log, ...)
1844 * NOTE: If mount locking is enabled this type of recursive mount cannot
1845 * work.
1846 */
1847-int spawn_bind_mount(logger *log, ...)
1848+int spawn_bind_mount(unsigned logopt, ...)
1849 {
1850 va_list arg;
1851 int argc;
1852@@ -330,7 +330,7 @@ int spawn_bind_mount(logger *log, ...)
1853 options = SPAWN_OPT_ACCESS;
1854 #endif
1855
1856- va_start(arg, log);
1857+ va_start(arg, logopt);
1858 for (argc = 1; va_arg(arg, char *); argc++);
1859 va_end(arg);
1860
1861@@ -340,13 +340,13 @@ int spawn_bind_mount(logger *log, ...)
1862 argv[0] = arg0;
1863 argv[1] = bind;
1864
1865- va_start(arg, log);
1866+ va_start(arg, logopt);
1867 p = argv + 2;
1868 while ((*p++ = va_arg(arg, char *)));
1869 va_end(arg);
1870
1871 while (retries--) {
1872- ret = do_spawn(log, options, prog, (const char **) argv);
1873+ ret = do_spawn(logopt, options, prog, (const char **) argv);
1874 if (ret & MTAB_NOTUPDATED)
1875 continue;
1876 break;
1877@@ -355,7 +355,7 @@ int spawn_bind_mount(logger *log, ...)
1878 return ret;
1879 }
1880
1881-int spawn_umount(logger *log, ...)
1882+int spawn_umount(unsigned logopt, ...)
1883 {
1884 va_list arg;
1885 int argc;
1886@@ -372,7 +372,7 @@ int spawn_umount(logger *log, ...)
1887 options = SPAWN_OPT_NONE;
1888 #endif
1889
1890- va_start(arg, log);
1891+ va_start(arg, logopt);
1892 for (argc = 1; va_arg(arg, char *); argc++);
1893 va_end(arg);
1894
1895@@ -381,13 +381,13 @@ int spawn_umount(logger *log, ...)
1896
1897 argv[0] = arg0;
1898
1899- va_start(arg, log);
1900+ va_start(arg, logopt);
1901 p = argv + 1;
1902 while ((*p++ = va_arg(arg, char *)));
1903 va_end(arg);
1904
1905 while (retries--) {
1906- ret = do_spawn(log, options, prog, (const char **) argv);
1907+ ret = do_spawn(logopt, options, prog, (const char **) argv);
1908 if (ret & MTAB_NOTUPDATED)
1909 continue;
1910 break;
1911diff --git a/daemon/state.c b/daemon/state.c
1912index 39f4497..a2da762 100644
1913--- a/daemon/state.c
1914+++ b/daemon/state.c
1915@@ -58,22 +58,20 @@ void dump_state_queue(void)
1916 struct list_head *head = &state_queue;
1917 struct list_head *p, *q;
1918
1919- debug(LOGOPT_ANY, "dumping queue");
1920+ logmsg("dumping queue");
1921
1922 list_for_each(p, head) {
1923 struct state_queue *entry;
1924
1925 entry = list_entry(p, struct state_queue, list);
1926- debug(LOGOPT_ANY,
1927- "queue list head path %s state %d busy %d",
1928+ logmsg("queue list head path %s state %d busy %d",
1929 entry->ap->path, entry->state, entry->busy);
1930
1931 list_for_each(q, &entry->pending) {
1932 struct state_queue *this;
1933
1934 this = list_entry(q, struct state_queue, pending);
1935- debug(LOGOPT_ANY,
1936- "queue list entry path %s state %d busy %d",
1937+ logmsg("queue list entry path %s state %d busy %d",
1938 this->ap->path, this->state, this->busy);
1939 }
1940 }
1941@@ -85,7 +83,7 @@ void nextstate(int statefd, enum states next)
1942
1943 if (write(statefd, &next, sizeof(next)) != sizeof(next)) {
1944 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
1945- error(LOGOPT_ANY, "write failed %s", estr);
1946+ logerr("write failed %s", estr);
1947 }
1948 }
1949
1950diff --git a/include/automount.h b/include/automount.h
1951index d55ba5c..37a3c0a 100644
1952--- a/include/automount.h
1953+++ b/include/automount.h
1954@@ -131,6 +131,7 @@ struct mapent_cache {
1955 unsigned int size;
1956 pthread_mutex_t ino_index_mutex;
1957 struct list_head *ino_index;
1958+ struct autofs_point *ap;
1959 struct map_source *map;
1960 struct mapent **hash;
1961 };
1962@@ -164,7 +165,7 @@ void cache_readlock(struct mapent_cache *mc);
1963 void cache_writelock(struct mapent_cache *mc);
1964 int cache_try_writelock(struct mapent_cache *mc);
1965 void cache_unlock(struct mapent_cache *mc);
1966-struct mapent_cache *cache_init(struct map_source *map);
1967+struct mapent_cache *cache_init(struct autofs_point *ap, struct map_source *map);
1968 struct mapent_cache *cache_init_null_cache(struct master *master);
1969 int cache_set_ino_index(struct mapent_cache *mc, const char *key, dev_t dev, ino_t ino);
1970 /* void cache_set_ino(struct mapent *me, dev_t dev, ino_t ino); */
1971@@ -200,11 +201,11 @@ int free_argv(int argc, const char **argv);
1972 inline void dump_core(void);
1973 int aquire_lock(void);
1974 void release_lock(void);
1975-int spawnl(logger *log, const char *prog, ...);
1976-int spawnv(logger *log, const char *prog, const char *const *argv);
1977-int spawn_mount(logger *log, ...);
1978-int spawn_bind_mount(logger *log, ...);
1979-int spawn_umount(logger *log, ...);
1980+int spawnl(unsigned logopt, const char *prog, ...);
1981+int spawnv(unsigned logopt, const char *prog, const char *const *argv);
1982+int spawn_mount(unsigned logopt, ...);
1983+int spawn_bind_mount(unsigned logopt, ...);
1984+int spawn_umount(unsigned logopt, ...);
1985 void reset_signals(void);
1986 int do_mount(struct autofs_point *ap, const char *root, const char *name,
1987 int name_len, const char *what, const char *fstype,
1988@@ -222,6 +223,8 @@ int rmdir_path(struct autofs_point *ap, const char *path, dev_t dev);
1989 #define MAPENT_MAX_LEN 4095
1990 #define PARSE_MAX_BUF KEY_MAX_LEN + MAPENT_MAX_LEN + 2
1991
1992+#define AUTOFS_LOGPRI_FIFO "/tmp/autofs.fifo"
1993+
1994 int lookup_nss_read_master(struct master *master, time_t age);
1995 int lookup_nss_read_map(struct autofs_point *ap, struct map_source *source, time_t age);
1996 int lookup_enumerate(struct autofs_point *ap,
1997@@ -435,6 +438,7 @@ struct autofs_point {
1998 int pipefd; /* File descriptor for pipe */
1999 int kpipefd; /* Kernel end descriptor for pipe */
2000 int ioctlfd; /* File descriptor for ioctls */
2001+ int logpri_fifo; /* FIFO used for changing log levels */
2002 dev_t dev; /* "Device" number assigned by kernel */
2003 struct master_mapent *entry; /* Master map entry for this mount */
2004 unsigned int type; /* Type of map direct or indirect */
2005@@ -464,8 +468,8 @@ struct autofs_point {
2006
2007 void *handle_mounts(void *arg);
2008 int umount_multi(struct autofs_point *ap, const char *path, int incl);
2009-int send_ready(int ioctlfd, unsigned int wait_queue_token);
2010-int send_fail(int ioctlfd, unsigned int wait_queue_token);
2011+int send_ready(unsigned logopt, int ioctlfd, unsigned int wait_queue_token);
2012+int send_fail(unsigned logopt, int ioctlfd, unsigned int wait_queue_token);
2013 int do_expire(struct autofs_point *ap, const char *name, int namelen);
2014 void *expire_proc_indirect(void *);
2015 void *expire_proc_direct(void *);
2016@@ -483,8 +487,8 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_
2017 int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_direct_t *pkt);
2018 int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missing_indirect_t *pkt);
2019 int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_direct_t *pkt);
2020-void rm_unwanted(const char *path, int incl, dev_t dev);
2021-int count_mounts(const char *path, dev_t dev);
2022+void rm_unwanted(unsigned logopt, const char *path, int incl, dev_t dev);
2023+int count_mounts(unsigned logopt, const char *path, dev_t dev);
2024
2025 #define state_mutex_lock(ap) \
2026 do { \
2027diff --git a/include/log.h b/include/log.h
2028index 3276cca..6a4a942 100644
2029--- a/include/log.h
2030+++ b/include/log.h
2031@@ -20,6 +20,7 @@
2032 /* Define logging functions */
2033
2034 #define LOGOPT_NONE 0x0000
2035+#define LOGOPT_ERROR 0x0000
2036 #define LOGOPT_DEBUG 0x0001
2037 #define LOGOPT_VERBOSE 0x0002
2038 #define LOGOPT_ANY (LOGOPT_DEBUG | LOGOPT_VERBOSE)
2039@@ -29,34 +30,33 @@ struct autofs_point;
2040 extern void set_log_norm(void);
2041 extern void set_log_verbose(void);
2042 extern void set_log_debug(void);
2043-extern void set_mnt_logging(struct autofs_point *);
2044+extern void set_log_norm_ap(struct autofs_point *ap);
2045+extern void set_log_verbose_ap(struct autofs_point *ap);
2046+extern void set_log_debug_ap(struct autofs_point *ap);
2047+extern void set_mnt_logging(unsigned global_logopt);
2048
2049 extern void log_to_syslog(void);
2050 extern void log_to_stderr(void);
2051
2052-typedef void logger(unsigned int logopt, const char* msg, ...);
2053-
2054-extern void (*log_info)(unsigned int, const char* msg, ...);
2055-extern void (*log_notice)(unsigned int, const char* msg, ...);
2056-extern void (*log_warn)(unsigned int, const char* msg, ...);
2057-extern void (*log_error)(unsigned int, const char* msg, ...);
2058-extern void (*log_crit)(unsigned int, const char* msg, ...);
2059-extern void (*log_debug)(unsigned int, const char* msg, ...);
2060-
2061-#define msg(msg, args...) \
2062- do { log_info(LOGOPT_NONE, msg, ##args); } while (0)
2063+extern void log_info(unsigned int, const char* msg, ...);
2064+extern void log_notice(unsigned int, const char* msg, ...);
2065+extern void log_warn(unsigned int, const char* msg, ...);
2066+extern void log_error(unsigned, const char* msg, ...);
2067+extern void log_crit(unsigned, const char* msg, ...);
2068+extern void log_debug(unsigned int, const char* msg, ...);
2069+extern void logmsg(const char* msg, ...);
2070
2071 #define debug(opt, msg, args...) \
2072 do { log_debug(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2073
2074-#define info(opt, msg, args...) \
2075- do { log_info(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2076+#define info(opt, msg, args...) \
2077+ do { log_info(opt, msg, ##args); } while (0)
2078
2079 #define notice(opt, msg, args...) \
2080- do { log_notice(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2081+ do { log_notice(opt, msg, ##args); } while (0)
2082
2083-#define warn(opt, msg, args...) \
2084- do { log_warn(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2085+#define warn(opt, msg, args...) \
2086+ do { log_warn(opt, msg, ##args); } while (0)
2087
2088 #define error(opt, msg, args...) \
2089 do { log_error(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2090@@ -64,17 +64,18 @@ extern void (*log_debug)(unsigned int, const char* msg, ...);
2091 #define crit(opt, msg, args...) \
2092 do { log_crit(opt, "%s: " msg, __FUNCTION__, ##args); } while (0)
2093
2094+#define logerr(msg, args...) \
2095+ do { logmsg("%s:%d: " msg, __FUNCTION__, __LINE__, ##args); } while (0)
2096+
2097 #define fatal(status) \
2098 do { \
2099 if (status == EDEADLK) { \
2100- log_crit(LOGOPT_ANY, \
2101- "%s: deadlock detected " \
2102+ logmsg("deadlock detected " \
2103 "at line %d in %s, dumping core.", \
2104- __FUNCTION__, __LINE__, __FILE__); \
2105+ __LINE__, __FILE__); \
2106 dump_core(); \
2107 } \
2108- log_crit(LOGOPT_ANY, \
2109- "unexpected pthreads error: %d at %d " \
2110+ logmsg("unexpected pthreads error: %d at %d " \
2111 "in %s", status, __LINE__, __FILE__); \
2112 abort(); \
2113 } while(0)
2114@@ -83,7 +84,7 @@ extern void (*log_debug)(unsigned int, const char* msg, ...);
2115 #define assert(x) \
2116 do { \
2117 if (!(x)) { \
2118- log_crit(LOGOPT_ANY, __FILE__ \
2119+ logmsg(__FILE__ \
2120 ":%d: assertion failed: " #x, __LINE__); \
2121 } \
2122 } while(0)
2123diff --git a/include/lookup_ldap.h b/include/lookup_ldap.h
2124index ca8d658..5b5c475 100644
2125--- a/include/lookup_ldap.h
2126+++ b/include/lookup_ldap.h
2127@@ -94,13 +94,13 @@ struct lookup_context {
2128 #define LDAP_AUTH_AUTODETECT 0x0004
2129
2130 /* lookup_ldap.c */
2131-LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt);
2132-int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt);
2133+LDAP *init_ldap_connection(unsigned logopt, const char *uri, struct lookup_context *ctxt);
2134+int unbind_ldap_connection(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2135 int authtype_requires_creds(const char *authtype);
2136
2137 /* cyrus-sasl.c */
2138-int autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt);
2139-int autofs_sasl_bind(LDAP *ldap, struct lookup_context *ctxt);
2140+int autofs_sasl_init(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2141+int autofs_sasl_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt);
2142 void autofs_sasl_unbind(struct lookup_context *ctxt);
2143 void autofs_sasl_done(struct lookup_context *ctxt);
2144 #endif
2145diff --git a/include/master.h b/include/master.h
2146index 8470bb1..5f10d1f 100644
2147--- a/include/master.h
2148+++ b/include/master.h
2149@@ -62,6 +62,7 @@ struct master {
2150 unsigned int default_ghost;
2151 unsigned int default_logging;
2152 unsigned int default_timeout;
2153+ unsigned int logopt;
2154 struct mapent_cache *nc;
2155 struct list_head mounts;
2156 };
2157@@ -106,6 +107,7 @@ int master_notify_submount(struct autofs_point *, const char *path, enum states)
2158 void master_signal_submount(struct autofs_point *, unsigned int);
2159 void master_notify_state_change(struct master *, int);
2160 int master_mount_mounts(struct master *, time_t, int);
2161+extern inline unsigned int master_get_logopt(void);
2162 int master_list_empty(struct master *);
2163 int master_kill(struct master *);
2164
2165diff --git a/include/replicated.h b/include/replicated.h
2166index 3afe9f7..672f853 100644
2167--- a/include/replicated.h
2168+++ b/include/replicated.h
2169@@ -62,8 +62,8 @@ struct host {
2170
2171 void seed_random(void);
2172 void free_host_list(struct host **);
2173-int parse_location(struct host **, const char *);
2174-int prune_host_list(struct host **, unsigned int, const char *, unsigned int);
2175+int parse_location(unsigned, struct host **, const char *);
2176+int prune_host_list(unsigned, struct host **, unsigned int, const char *, unsigned int);
2177 void dump_host_list(struct host *);
2178
2179 #endif
2180diff --git a/lib/alarm.c b/lib/alarm.c
2181index 90bf7aa..6a70ed1 100755
2182--- a/lib/alarm.c
2183+++ b/lib/alarm.c
2184@@ -51,7 +51,7 @@ void dump_alarms(void)
2185 struct alarm *this;
2186
2187 this = list_entry(p, struct alarm, list);
2188- msg("alarm time = %d", this->time);
2189+ logmsg("alarm time = %d", this->time);
2190 }
2191 pthread_mutex_unlock(&mutex);
2192 }
2193diff --git a/lib/args.c b/lib/args.c
2194index fbfb004..9616598 100644
2195--- a/lib/args.c
2196+++ b/lib/args.c
2197@@ -37,7 +37,7 @@ char **add_argv(int argc, char **argv, char *str)
2198 if (argv[i]) {
2199 vector[i] = strdup(argv[i]);
2200 if (!vector[i]) {
2201- error(LOGOPT_ANY, "failed to strdup arg");
2202+ logerr("failed to strdup arg");
2203 break;
2204 }
2205 } else
2206@@ -81,7 +81,7 @@ char **append_argv(int argc1, char **argv1, int argc2, char **argv2)
2207 if (argv2[j]) {
2208 vector[i] = strdup(argv2[j]);
2209 if (!vector[i]) {
2210- error(LOGOPT_ANY, "failed to strdup arg");
2211+ logerr("failed to strdup arg");
2212 break;
2213 }
2214 } else
2215@@ -116,7 +116,7 @@ const char **copy_argv(int argc, const char **argv)
2216 if (argv[i]) {
2217 vector[i] = strdup(argv[i]);
2218 if (!vector[i]) {
2219- error(LOGOPT_ANY, "failed to strdup arg");
2220+ logerr("failed to strdup arg");
2221 break;
2222 }
2223 } else
2224diff --git a/lib/cache.c b/lib/cache.c
2225index 06bb461..55586a3 100644
2226--- a/lib/cache.c
2227+++ b/lib/cache.c
2228@@ -34,7 +34,7 @@ void cache_dump_multi(struct list_head *list)
2229
2230 list_for_each(p, list) {
2231 me = list_entry(p, struct mapent, multi_list);
2232- msg("key=%s", me->key);
2233+ logmsg("key=%s", me->key);
2234 }
2235 }
2236
2237@@ -48,7 +48,7 @@ void cache_dump_cache(struct mapent_cache *mc)
2238 if (me == NULL)
2239 continue;
2240 while (me) {
2241- msg("me->key=%s me->multi=%p dev=%ld ino=%ld",
2242+ logmsg("me->key=%s me->multi=%p dev=%ld ino=%ld",
2243 me->key, me->multi, me->dev, me->ino);
2244 me = me->next;
2245 }
2246@@ -61,7 +61,7 @@ void cache_readlock(struct mapent_cache *mc)
2247
2248 status = pthread_rwlock_rdlock(&mc->rwlock);
2249 if (status) {
2250- error(LOGOPT_ANY, "mapent cache rwlock lock failed");
2251+ logmsg("mapent cache rwlock lock failed");
2252 fatal(status);
2253 }
2254 return;
2255@@ -73,7 +73,7 @@ void cache_writelock(struct mapent_cache *mc)
2256
2257 status = pthread_rwlock_wrlock(&mc->rwlock);
2258 if (status) {
2259- error(LOGOPT_ANY, "mapent cache rwlock lock failed");
2260+ logmsg("mapent cache rwlock lock failed");
2261 fatal(status);
2262 }
2263 return;
2264@@ -85,7 +85,7 @@ int cache_try_writelock(struct mapent_cache *mc)
2265
2266 status = pthread_rwlock_trywrlock(&mc->rwlock);
2267 if (status) {
2268- debug(LOGOPT_ANY, "mapent cache rwlock busy");
2269+ logmsg("mapent cache rwlock busy");
2270 return 0;
2271 }
2272 return 1;
2273@@ -97,7 +97,7 @@ void cache_unlock(struct mapent_cache *mc)
2274
2275 status = pthread_rwlock_unlock(&mc->rwlock);
2276 if (status) {
2277- error(LOGOPT_ANY, "mapent cache rwlock unlock failed");
2278+ logmsg("mapent cache rwlock unlock failed");
2279 fatal(status);
2280 }
2281 return;
2282@@ -120,7 +120,7 @@ void cache_multi_lock(struct mapent *me)
2283
2284 status = pthread_mutex_lock(&me->multi_mutex);
2285 if (status) {
2286- error(LOGOPT_ANY, "mapent cache multi mutex lock failed");
2287+ logmsg("mapent cache multi mutex lock failed");
2288 fatal(status);
2289 }
2290 return;
2291@@ -135,7 +135,7 @@ void cache_multi_unlock(struct mapent *me)
2292
2293 status = pthread_mutex_unlock(&me->multi_mutex);
2294 if (status) {
2295- error(LOGOPT_ANY, "mapent cache multi mutex unlock failed");
2296+ logmsg("mapent cache multi mutex unlock failed");
2297 fatal(status);
2298 }
2299 return;
2300@@ -164,7 +164,7 @@ static inline void ino_index_unlock(struct mapent_cache *mc)
2301 return;
2302 }
2303
2304-struct mapent_cache *cache_init(struct map_source *map)
2305+struct mapent_cache *cache_init(struct autofs_point *ap, struct map_source *map)
2306 {
2307 struct mapent_cache *mc;
2308 unsigned int i;
2309@@ -207,6 +207,7 @@ struct mapent_cache *cache_init(struct map_source *map)
2310 INIT_LIST_HEAD(&mc->ino_index[i]);
2311 }
2312
2313+ mc->ap = ap;
2314 mc->map = map;
2315
2316 cache_unlock(mc);
2317@@ -257,6 +258,9 @@ struct mapent_cache *cache_init_null_cache(struct master *master)
2318 INIT_LIST_HEAD(&mc->ino_index[i]);
2319 }
2320
2321+ mc->ap = NULL;
2322+ mc->map = NULL;
2323+
2324 cache_unlock(mc);
2325
2326 return mc;
2327@@ -608,6 +612,7 @@ static void cache_add_ordered_offset(struct mapent *me, struct list_head *head)
2328 /* cache must be write locked by caller */
2329 int cache_add_offset(struct mapent_cache *mc, const char *mkey, const char *key, const char *mapent, time_t age)
2330 {
2331+ unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2332 struct mapent *me, *owner;
2333 int ret = CHE_OK;
2334
2335@@ -621,7 +626,7 @@ int cache_add_offset(struct mapent_cache *mc, const char *mkey, const char *key,
2336
2337 ret = cache_add(mc, owner->source, key, mapent, age);
2338 if (ret == CHE_FAIL) {
2339- warn(LOGOPT_ANY, "failed to add key %s to cache", key);
2340+ warn(logopt, "failed to add key %s to cache", key);
2341 return CHE_FAIL;
2342 }
2343
2344@@ -689,6 +694,7 @@ int cache_set_parents(struct mapent *mm)
2345 /* cache must be write locked by caller */
2346 int cache_update(struct mapent_cache *mc, struct map_source *ms, const char *key, const char *mapent, time_t age)
2347 {
2348+ unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2349 struct mapent *me = NULL;
2350 char *pent;
2351 int ret = CHE_OK;
2352@@ -697,7 +703,7 @@ int cache_update(struct mapent_cache *mc, struct map_source *ms, const char *key
2353 if (!me || (*me->key == '*' && *key != '*')) {
2354 ret = cache_add(mc, ms, key, mapent, age);
2355 if (!ret) {
2356- debug(LOGOPT_NONE, "failed for %s", key);
2357+ debug(logopt, "failed for %s", key);
2358 return CHE_FAIL;
2359 }
2360 ret = CHE_UPDATED;
2361@@ -796,6 +802,7 @@ done:
2362 /* cache must be write locked by caller */
2363 int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2364 {
2365+ unsigned logopt = mc->ap ? mc->ap->logopt : master_get_logopt();
2366 struct mapent *me;
2367 struct mapent *this;
2368 struct list_head *head, *next;
2369@@ -816,7 +823,7 @@ int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2370 this = list_entry(next, struct mapent, multi_list);
2371 next = next->next;
2372 if (this->ioctlfd != -1) {
2373- error(LOGOPT_ANY,
2374+ error(logopt,
2375 "active offset mount key %s", this->key);
2376 return CHE_FAIL;
2377 }
2378@@ -829,10 +836,10 @@ int cache_delete_offset_list(struct mapent_cache *mc, const char *key)
2379 next = next->next;
2380 list_del_init(&this->multi_list);
2381 this->multi = NULL;
2382- debug(LOGOPT_NONE, "deleting offset key %s", this->key);
2383+ debug(logopt, "deleting offset key %s", this->key);
2384 status = cache_delete(mc, this->key);
2385 if (status == CHE_FAIL) {
2386- warn(LOGOPT_ANY,
2387+ warn(logopt,
2388 "failed to delete offset %s", this->key);
2389 this->multi = me;
2390 /* TODO: add list back in */
2391diff --git a/lib/defaults.c b/lib/defaults.c
2392index 2cccf20..94885e8 100644
2393--- a/lib/defaults.c
2394+++ b/lib/defaults.c
2395@@ -105,17 +105,22 @@ static int get_env_yesno(const char *name)
2396 * We've changed the key names so we need to check for the
2397 * config key and it's old name for backward conpatibility.
2398 */
2399-static int check_set_config_value(const char *res, const char *name, const char *value)
2400+static int check_set_config_value(const char *res, const char *name, const char *value, unsigned to_syslog)
2401 {
2402 char *old_name;
2403 int ret;
2404
2405 if (!strcasecmp(res, name)) {
2406 ret = setenv(name, value, 0);
2407- if (ret)
2408- fprintf(stderr,
2409- "can't set config value for %s, "
2410- "error %d", name, ret);
2411+ if (ret) {
2412+ if (!to_syslog)
2413+ fprintf(stderr,
2414+ "can't set config value for %s, "
2415+ "error %d\n", name, ret);
2416+ else
2417+ logmsg("can't set config value for %s, "
2418+ "error %d", name, ret);
2419+ }
2420 return 1;
2421 }
2422
2423@@ -125,10 +130,15 @@ static int check_set_config_value(const char *res, const char *name, const char
2424
2425 if (!strcasecmp(res, old_name)) {
2426 ret = setenv(name, value, 0);
2427- if (ret)
2428- fprintf(stderr,
2429- "can't set config value for %s, "
2430- "error %d", name, ret);
2431+ if (ret) {
2432+ if (!to_syslog)
2433+ fprintf(stderr,
2434+ "can't set config value for %s, "
2435+ "error %d\n", name, ret);
2436+ else
2437+ logmsg("can't set config value for %s, "
2438+ "error %d\n", name, ret);
2439+ }
2440 return 1;
2441 }
2442 return 0;
2443@@ -296,19 +306,19 @@ unsigned int defaults_read_config(unsigned int to_syslog)
2444 if (!parse_line(res, &key, &value))
2445 continue;
2446
2447- if (check_set_config_value(key, ENV_NAME_MASTER_MAP, value) ||
2448- check_set_config_value(key, ENV_NAME_TIMEOUT, value) ||
2449- check_set_config_value(key, ENV_NAME_BROWSE_MODE, value) ||
2450- check_set_config_value(key, ENV_NAME_LOGGING, value) ||
2451- check_set_config_value(key, ENV_LDAP_TIMEOUT, value) ||
2452- check_set_config_value(key, ENV_LDAP_NETWORK_TIMEOUT, value) ||
2453- check_set_config_value(key, ENV_NAME_MAP_OBJ_CLASS, value) ||
2454- check_set_config_value(key, ENV_NAME_ENTRY_OBJ_CLASS, value) ||
2455- check_set_config_value(key, ENV_NAME_MAP_ATTR, value) ||
2456- check_set_config_value(key, ENV_NAME_ENTRY_ATTR, value) ||
2457- check_set_config_value(key, ENV_NAME_VALUE_ATTR, value) ||
2458- check_set_config_value(key, ENV_APPEND_OPTIONS, value) ||
2459- check_set_config_value(key, ENV_AUTH_CONF_FILE, value))
2460+ if (check_set_config_value(key, ENV_NAME_MASTER_MAP, value, to_syslog) ||
2461+ check_set_config_value(key, ENV_NAME_TIMEOUT, value, to_syslog) ||
2462+ check_set_config_value(key, ENV_NAME_BROWSE_MODE, value, to_syslog) ||
2463+ check_set_config_value(key, ENV_NAME_LOGGING, value, to_syslog) ||
2464+ check_set_config_value(key, ENV_LDAP_TIMEOUT, value, to_syslog) ||
2465+ check_set_config_value(key, ENV_LDAP_NETWORK_TIMEOUT, value, to_syslog) ||
2466+ check_set_config_value(key, ENV_NAME_MAP_OBJ_CLASS, value, to_syslog) ||
2467+ check_set_config_value(key, ENV_NAME_ENTRY_OBJ_CLASS, value, to_syslog) ||
2468+ check_set_config_value(key, ENV_NAME_MAP_ATTR, value, to_syslog) ||
2469+ check_set_config_value(key, ENV_NAME_ENTRY_ATTR, value, to_syslog) ||
2470+ check_set_config_value(key, ENV_NAME_VALUE_ATTR, value, to_syslog) ||
2471+ check_set_config_value(key, ENV_APPEND_OPTIONS, value, to_syslog) ||
2472+ check_set_config_value(key, ENV_AUTH_CONF_FILE, value, to_syslog))
2473 ;
2474 }
2475
2476@@ -318,8 +328,7 @@ unsigned int defaults_read_config(unsigned int to_syslog)
2477 "fgets returned error %d while reading %s\n",
2478 ferror(f), DEFAULTS_CONFIG_FILE);
2479 } else {
2480- error(LOGOPT_ANY,
2481- "fgets returned error %d while reading %s",
2482+ logmsg("fgets returned error %d while reading %s",
2483 ferror(f), DEFAULTS_CONFIG_FILE);
2484 }
2485 fclose(f);
2486diff --git a/lib/log.c b/lib/log.c
2487index b747e12..65e8ad2 100644
2488--- a/lib/log.c
2489+++ b/lib/log.c
2490@@ -27,11 +27,6 @@
2491
2492 #include "automount.h"
2493
2494-/*
2495-struct syslog_data syslog_context = AUTOFS_SYSLOG_CONTEXT;
2496-struct syslog_data *slc = &syslog_context;
2497-*/
2498-
2499 static unsigned int syslog_open = 0;
2500 static unsigned int logging_to_syslog = 0;
2501
2502@@ -39,32 +34,44 @@ static unsigned int logging_to_syslog = 0;
2503 static unsigned int do_verbose = 0; /* Verbose feedback option */
2504 static unsigned int do_debug = 0; /* Full debug output */
2505
2506-static void null(unsigned int logopt, const char *msg, ...) { }
2507-
2508-void (*log_info)(unsigned int logopt, const char* msg, ...) = null;
2509-void (*log_notice)(unsigned int logopt, const char* msg, ...) = null;
2510-void (*log_warn)(unsigned int logopt, const char* msg, ...) = null;
2511-void (*log_error)(unsigned int logopt, const char* msg, ...) = null;
2512-void (*log_crit)(unsigned int logopt, const char* msg, ...) = null;
2513-void (*log_debug)(unsigned int logopt, const char* msg, ...) = null;
2514-
2515 void set_log_norm(void)
2516 {
2517 do_verbose = 0;
2518 do_debug = 0;
2519+ return;
2520 }
2521
2522 void set_log_verbose(void)
2523 {
2524 do_verbose = 1;
2525+ return;
2526 }
2527
2528 void set_log_debug(void)
2529 {
2530 do_debug = 1;
2531+ return;
2532+}
2533+
2534+void set_log_norm_ap(struct autofs_point *ap)
2535+{
2536+ ap->logopt = LOGOPT_ERROR;
2537+ return;
2538+}
2539+
2540+void set_log_verbose_ap(struct autofs_point *ap)
2541+{
2542+ ap->logopt = LOGOPT_VERBOSE;
2543+ return;
2544+}
2545+
2546+void set_log_debug_ap(struct autofs_point *ap)
2547+{
2548+ ap->logopt = LOGOPT_DEBUG;
2549+ return;
2550 }
2551
2552-static void syslog_info(unsigned int logopt, const char *msg, ...)
2553+void log_info(unsigned int logopt, const char *msg, ...)
2554 {
2555 unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2556 va_list ap;
2557@@ -73,11 +80,18 @@ static void syslog_info(unsigned int logopt, const char *msg, ...)
2558 return;
2559
2560 va_start(ap, msg);
2561- vsyslog(LOG_INFO, msg, ap);
2562+ if (logging_to_syslog)
2563+ vsyslog(LOG_INFO, msg, ap);
2564+ else {
2565+ vfprintf(stderr, msg, ap);
2566+ fputc('\n', stderr);
2567+ }
2568 va_end(ap);
2569+
2570+ return;
2571 }
2572
2573-static void syslog_notice(unsigned int logopt, const char *msg, ...)
2574+void log_notice(unsigned int logopt, const char *msg, ...)
2575 {
2576 unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2577 va_list ap;
2578@@ -86,11 +100,18 @@ static void syslog_notice(unsigned int logopt, const char *msg, ...)
2579 return;
2580
2581 va_start(ap, msg);
2582- vsyslog(LOG_NOTICE, msg, ap);
2583+ if (logging_to_syslog)
2584+ vsyslog(LOG_NOTICE, msg, ap);
2585+ else {
2586+ vfprintf(stderr, msg, ap);
2587+ fputc('\n', stderr);
2588+ }
2589 va_end(ap);
2590+
2591+ return;
2592 }
2593
2594-static void syslog_warn(unsigned int logopt, const char *msg, ...)
2595+void log_warn(unsigned int logopt, const char *msg, ...)
2596 {
2597 unsigned int opt_log = logopt & (LOGOPT_DEBUG | LOGOPT_VERBOSE);
2598 va_list ap;
2599@@ -99,70 +120,79 @@ static void syslog_warn(unsigned int logopt, const char *msg, ...)
2600 return;
2601
2602 va_start(ap, msg);
2603- vsyslog(LOG_WARNING, msg, ap);
2604+ if (logging_to_syslog)
2605+ vsyslog(LOG_WARNING, msg, ap);
2606+ else {
2607+ vfprintf(stderr, msg, ap);
2608+ fputc('\n', stderr);
2609+ }
2610 va_end(ap);
2611+
2612+ return;
2613 }
2614
2615-static void syslog_err(unsigned int logopt, const char *msg, ...)
2616+void log_error(unsigned logopt, const char *msg, ...)
2617 {
2618 va_list ap;
2619+
2620 va_start(ap, msg);
2621- vsyslog(LOG_ERR, msg, ap);
2622+ if (logging_to_syslog)
2623+ vsyslog(LOG_ERR, msg, ap);
2624+ else {
2625+ vfprintf(stderr, msg, ap);
2626+ fputc('\n', stderr);
2627+ }
2628 va_end(ap);
2629+ return;
2630 }
2631
2632-static void syslog_crit(unsigned int logopt, const char *msg, ...)
2633+void log_crit(unsigned logopt, const char *msg, ...)
2634 {
2635 va_list ap;
2636+
2637 va_start(ap, msg);
2638- vsyslog(LOG_CRIT, msg, ap);
2639+ if (logging_to_syslog)
2640+ vsyslog(LOG_CRIT, msg, ap);
2641+ else {
2642+ vfprintf(stderr, msg, ap);
2643+ fputc('\n', stderr);
2644+ }
2645 va_end(ap);
2646+ return;
2647 }
2648
2649-static void syslog_debug(unsigned int logopt, const char *msg, ...)
2650+void log_debug(unsigned int logopt, const char *msg, ...)
2651 {
2652+ unsigned int opt_log = logopt & LOGOPT_DEBUG;
2653 va_list ap;
2654
2655- if (!do_debug && !(logopt & LOGOPT_DEBUG))
2656+ if (!do_debug && !opt_log)
2657 return;
2658
2659 va_start(ap, msg);
2660- vsyslog(LOG_DEBUG, msg, ap);
2661+ if (logging_to_syslog)
2662+ vsyslog(LOG_WARNING, msg, ap);
2663+ else {
2664+ vfprintf(stderr, msg, ap);
2665+ fputc('\n', stderr);
2666+ }
2667 va_end(ap);
2668+
2669+ return;
2670 }
2671
2672-static void to_stderr(unsigned int logopt, const char *msg, ...)
2673+void logmsg(const char *msg, ...)
2674 {
2675 va_list ap;
2676 va_start(ap, msg);
2677- vfprintf(stderr, msg, ap);
2678- fputc('\n',stderr);
2679- va_end(ap);
2680-}
2681-
2682-void set_mnt_logging(struct autofs_point *ap)
2683-{
2684- unsigned int opt_verbose = ap->logopt & LOGOPT_VERBOSE;
2685- unsigned int opt_debug = ap->logopt & LOGOPT_DEBUG;
2686-
2687- if (opt_debug) {
2688- if (logging_to_syslog)
2689- log_debug = syslog_debug;
2690- else
2691- log_debug = to_stderr;
2692- }
2693-
2694- if (opt_verbose || opt_debug) {
2695- if (logging_to_syslog) {
2696- log_info = syslog_info;
2697- log_notice = syslog_notice;
2698- log_warn = syslog_warn;
2699- } else {
2700- log_info = to_stderr;
2701- log_notice = to_stderr;
2702- log_warn = to_stderr;
2703- }
2704+ if (logging_to_syslog)
2705+ vsyslog(LOG_CRIT, msg, ap);
2706+ else {
2707+ vfprintf(stderr, msg, ap);
2708+ fputc('\n', stderr);
2709 }
2710+ va_end(ap);
2711+ return;
2712 }
2713
2714 void log_to_syslog(void)
2715@@ -175,31 +205,13 @@ void log_to_syslog(void)
2716 openlog("automount", LOG_PID, LOG_DAEMON);
2717 }
2718
2719- if (do_debug)
2720- log_debug = syslog_debug;
2721- else
2722- log_debug = null;
2723-
2724- if (do_verbose || do_debug) {
2725- log_info = syslog_info;
2726- log_notice = syslog_notice;
2727- log_warn = syslog_warn;
2728- } else {
2729- log_info = null;
2730- log_notice = null;
2731- log_warn = null;
2732- }
2733-
2734- log_error = syslog_err;
2735- log_crit = syslog_crit;
2736-
2737 logging_to_syslog = 1;
2738
2739 /* Redirect all our file descriptors to /dev/null */
2740 nullfd = open("/dev/null", O_RDWR);
2741 if (nullfd < 0) {
2742 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
2743- syslog_crit(LOGOPT_ANY, "cannot open /dev/null: %s", estr);
2744+ fprintf(stderr, "cannot open /dev/null: %s", estr);
2745 exit(1);
2746 }
2747
2748@@ -207,13 +219,15 @@ void log_to_syslog(void)
2749 dup2(nullfd, STDOUT_FILENO) < 0 ||
2750 dup2(nullfd, STDERR_FILENO) < 0) {
2751 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
2752- syslog_crit(LOGOPT_ANY,
2753- "redirecting file descriptors failed: %s", estr);
2754+ fprintf(stderr,
2755+ "redirecting file descriptors failed: %s", estr);
2756 exit(1);
2757 }
2758
2759 if (nullfd > 2)
2760 close(nullfd);
2761+
2762+ return;
2763 }
2764
2765 void log_to_stderr(void)
2766@@ -223,23 +237,7 @@ void log_to_stderr(void)
2767 closelog();
2768 }
2769
2770- if (do_debug)
2771- log_debug = to_stderr;
2772- else
2773- log_debug = null;
2774-
2775- if (do_verbose || do_debug) {
2776- log_info = to_stderr;
2777- log_notice = to_stderr;
2778- log_warn = to_stderr;
2779- } else {
2780- log_info = null;
2781- log_notice = null;
2782- log_warn = null;
2783- }
2784-
2785- log_error = to_stderr;
2786- log_crit = to_stderr;
2787-
2788 logging_to_syslog = 0;
2789+
2790+ return;
2791 }
2792diff --git a/lib/macros.c b/lib/macros.c
2793index 936ae06..fa6db8e 100644
2794--- a/lib/macros.c
2795+++ b/lib/macros.c
2796@@ -50,8 +50,7 @@ void dump_table(struct substvar *table)
2797 fatal(status);
2798
2799 while (lv) {
2800- debug(LOGOPT_NONE,
2801- "lv->def %s lv->val %s lv->next %p",
2802+ logmsg("lv->def %s lv->val %s lv->next %p",
2803 lv->def, lv->val, lv->next);
2804 lv = lv->next;
2805 }
2806diff --git a/lib/master.c b/lib/master.c
2807index abc3bc2..2e24ad0 100644
2808--- a/lib/master.c
2809+++ b/lib/master.c
2810@@ -524,8 +524,7 @@ void master_source_writelock(struct master_mapent *entry)
2811
2812 status = pthread_rwlock_wrlock(&entry->source_lock);
2813 if (status) {
2814- error(LOGOPT_ANY,
2815- "master_mapent source write lock failed");
2816+ logmsg("master_mapent source write lock failed");
2817 fatal(status);
2818 }
2819 return;
2820@@ -537,8 +536,7 @@ void master_source_readlock(struct master_mapent *entry)
2821
2822 status = pthread_rwlock_rdlock(&entry->source_lock);
2823 if (status) {
2824- error(LOGOPT_ANY,
2825- "master_mapent source read lock failed");
2826+ logmsg("master_mapent source read lock failed");
2827 fatal(status);
2828 }
2829 return;
2830@@ -550,8 +548,7 @@ void master_source_unlock(struct master_mapent *entry)
2831
2832 status = pthread_rwlock_unlock(&entry->source_lock);
2833 if (status) {
2834- error(LOGOPT_ANY,
2835- "master_mapent source unlock failed");
2836+ logmsg("master_mapent source unlock failed");
2837 fatal(status);
2838 }
2839 return;
2840@@ -572,7 +569,7 @@ void master_source_current_wait(struct master_mapent *entry)
2841
2842 status = pthread_mutex_lock(&entry->current_mutex);
2843 if (status) {
2844- error(LOGOPT_ANY, "entry current source lock failed");
2845+ logmsg("entry current source lock failed");
2846 fatal(status);
2847 }
2848
2849@@ -580,8 +577,7 @@ void master_source_current_wait(struct master_mapent *entry)
2850 status = pthread_cond_wait(
2851 &entry->current_cond, &entry->current_mutex);
2852 if (status) {
2853- error(LOGOPT_ANY,
2854- "entry current source condition wait failed");
2855+ logmsg("entry current source condition wait failed");
2856 fatal(status);
2857 }
2858 }
2859@@ -595,14 +591,13 @@ void master_source_current_signal(struct master_mapent *entry)
2860
2861 status = pthread_cond_signal(&entry->current_cond);
2862 if (status) {
2863- error(LOGOPT_ANY,
2864- "entry current source condition signal failed");
2865+ logmsg("entry current source condition signal failed");
2866 fatal(status);
2867 }
2868
2869 status = pthread_mutex_unlock(&entry->current_mutex);
2870 if (status) {
2871- error(LOGOPT_ANY, "entry current source unlock failed");
2872+ logmsg("entry current source unlock failed");
2873 fatal(status);
2874 }
2875
2876@@ -770,6 +765,7 @@ struct master *master_new(const char *name, unsigned int timeout, unsigned int g
2877 master->default_ghost = ghost;
2878 master->default_timeout = timeout;
2879 master->default_logging = defaults_get_logging();
2880+ master->logopt = master->default_logging;
2881
2882 INIT_LIST_HEAD(&master->mounts);
2883
2884@@ -778,11 +774,12 @@ struct master *master_new(const char *name, unsigned int timeout, unsigned int g
2885
2886 int master_read_master(struct master *master, time_t age, int readall)
2887 {
2888+ unsigned int logopt = master->logopt;
2889 struct mapent_cache *nc;
2890
2891 nc = cache_init_null_cache(master);
2892 if (!nc) {
2893- error(LOGOPT_ANY,
2894+ error(logopt,
2895 "failed to init null map cache for %s", master->name);
2896 return 0;
2897 }
2898@@ -791,7 +788,7 @@ int master_read_master(struct master *master, time_t age, int readall)
2899 master_init_scan();
2900
2901 if (!lookup_nss_read_master(master, age)) {
2902- error(LOGOPT_ANY,
2903+ error(logopt,
2904 "can't read master map %s", master->name);
2905 return 0;
2906 }
2907@@ -802,7 +799,7 @@ int master_read_master(struct master *master, time_t age, int readall)
2908
2909 if (list_empty(&master->mounts)) {
2910 master_mutex_unlock();
2911- warn(LOGOPT_ANY, "no mounts in table");
2912+ warn(logopt, "no mounts in table");
2913 return 1;
2914 }
2915
2916@@ -934,6 +931,7 @@ void master_notify_state_change(struct master *master, int sig)
2917 struct autofs_point *ap;
2918 struct list_head *p;
2919 int state_pipe, cur_state;
2920+ unsigned int logopt;
2921
2922 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
2923 master_mutex_lock();
2924@@ -944,6 +942,7 @@ void master_notify_state_change(struct master *master, int sig)
2925 entry = list_entry(p, struct master_mapent, list);
2926
2927 ap = entry->ap;
2928+ logopt = ap->logopt;
2929
2930 state_mutex_lock(ap);
2931
2932@@ -978,7 +977,7 @@ void master_notify_state_change(struct master *master, int sig)
2933 }
2934 next:
2935 if (next != ST_INVAL)
2936- debug(ap->logopt,
2937+ debug(logopt,
2938 "sig %d switching %s from %d to %d",
2939 sig, ap->path, ap->state, next);
2940
2941@@ -1230,6 +1229,11 @@ int master_list_empty(struct master *master)
2942 return res;
2943 }
2944
2945+inline unsigned int master_get_logopt(void)
2946+{
2947+ return master_list ? master_list->logopt : LOGOPT_NONE;
2948+}
2949+
2950 int master_kill(struct master *master)
2951 {
2952 if (!list_empty(&master->mounts))
2953@@ -1251,6 +1255,6 @@ void dump_master(struct master *master)
2954 head = &master->mounts;
2955 list_for_each(p, head) {
2956 struct master_mapent *this = list_entry(p, struct master_mapent, list);
2957- debug(LOGOPT_ANY, "path %s", this->path);
2958+ logmsg("path %s", this->path);
2959 }
2960 }
2961diff --git a/lib/master_parse.y b/lib/master_parse.y
2962index 70b48be..a767f9e 100644
2963--- a/lib/master_parse.y
2964+++ b/lib/master_parse.y
2965@@ -585,13 +585,13 @@ static char *master_strdup(char *str)
2966
2967 static int master_error(const char *s)
2968 {
2969- error(LOGOPT_ANY, "%s while parsing map.", s);
2970+ logmsg("%s while parsing map.", s);
2971 return 0;
2972 }
2973
2974 static int master_notify(const char *s)
2975 {
2976- warn(LOGOPT_ANY, "syntax error in map near [ %s ]", s);
2977+ logmsg("syntax error in map near [ %s ]", s);
2978 return(0);
2979 }
2980
2981@@ -704,6 +704,7 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
2982 struct master_mapent *entry, *new;
2983 struct map_source *source;
2984 unsigned int logopt = logging;
2985+ unsigned int m_logopt = master->logopt;
2986 int ret;
2987
2988 local_init_vars();
2989@@ -758,8 +759,8 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
2990 } else {
2991 if (entry->age && entry->age == age) {
2992 if (strcmp(path, "/-")) {
2993- warn(LOGOPT_VERBOSE,
2994- "ignoring duplicate indirect mount %s",
2995+ info(m_logopt,
2996+ "ignoring duplicate indirect mount %s",
2997 path);
2998 local_free_vars();
2999 return 0;
3000@@ -770,13 +771,12 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3001 if (!entry->ap) {
3002 ret = master_add_autofs_point(entry, timeout, logopt, ghost, 0);
3003 if (!ret) {
3004- error(LOGOPT_ANY, "failed to add autofs_point");
3005+ error(m_logopt, "failed to add autofs_point");
3006 if (new)
3007 master_free_mapent(new);
3008 local_free_vars();
3009 return 0;
3010 }
3011- set_mnt_logging(entry->ap);
3012 } else {
3013 struct autofs_point *ap = entry->ap;
3014 time_t tout = timeout;
3015@@ -786,14 +786,11 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3016 * use the ghost, log and timeout of the first
3017 */
3018 if (entry->age < age) {
3019- ap->ghost = ghost;
3020- ap->logopt = logopt;
3021 ap->exp_timeout = timeout;
3022 ap->exp_runfreq = (ap->exp_timeout + CHECK_RATIO - 1) / CHECK_RATIO;
3023 if (ap->ioctlfd != -1 && ap->type == LKP_INDIRECT)
3024 ioctl(ap->ioctlfd, AUTOFS_IOC_SETTIMEOUT, &tout);
3025 }
3026- set_mnt_logging(ap);
3027 }
3028 entry->ap->random_selection = random_selection;
3029
3030@@ -809,7 +806,7 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3031 source = master_add_map_source(entry, type, format, age,
3032 local_argc, (const char **) local_argv);
3033 if (!source) {
3034- error(LOGOPT_ANY, "failed to add source");
3035+ error(m_logopt, "failed to add source");
3036 if (new)
3037 master_free_mapent(new);
3038 local_free_vars();
3039@@ -817,9 +814,9 @@ int master_parse_entry(const char *buffer, unsigned int default_timeout, unsigne
3040 }
3041
3042 if (!source->mc) {
3043- source->mc = cache_init(source);
3044+ source->mc = cache_init(entry->ap, source);
3045 if (!source->mc) {
3046- error(LOGOPT_ANY, "failed to init source cache");
3047+ error(m_logopt, "failed to init source cache");
3048 if (new)
3049 master_free_mapent(new);
3050 local_free_vars();
3051diff --git a/lib/master_tok.l b/lib/master_tok.l
3052index 2735223..00cd223 100644
3053--- a/lib/master_tok.l
3054+++ b/lib/master_tok.l
3055@@ -368,7 +368,7 @@ int master_wrap(void)
3056
3057 static void master_echo(void)
3058 {
3059- debug(LOGOPT_NONE, "%s", master_text);
3060+ logmsg("%s", master_text);
3061 return;
3062 }
3063
3064diff --git a/lib/mounts.c b/lib/mounts.c
3065index 0e428e8..425a65a 100644
3066--- a/lib/mounts.c
3067+++ b/lib/mounts.c
3068@@ -126,7 +126,7 @@ char *make_options_string(char *path, int pipefd, char *extra)
3069
3070 options = malloc(MAX_OPTIONS_LEN + 1);
3071 if (!options) {
3072- crit(LOGOPT_ANY, "can't malloc options string");
3073+ logerr("can't malloc options string");
3074 return NULL;
3075 }
3076
3077@@ -141,13 +141,12 @@ char *make_options_string(char *path, int pipefd, char *extra)
3078 AUTOFS_MAX_PROTO_VERSION);
3079
3080 if (len >= MAX_OPTIONS_LEN) {
3081- crit(LOGOPT_ANY, "buffer to small for options - truncated");
3082+ logerr("buffer to small for options - truncated");
3083 len = MAX_OPTIONS_LEN - 1;
3084 }
3085
3086 if (len < 0) {
3087- crit(LOGOPT_ANY,
3088- "failed to malloc autofs mount options for %s", path);
3089+ logerr("failed to malloc autofs mount options for %s", path);
3090 free(options);
3091 return NULL;
3092 }
3093@@ -163,7 +162,7 @@ char *make_mnt_name_string(char *path)
3094
3095 mnt_name = malloc(MAX_MNT_NAME_LEN + 1);
3096 if (!mnt_name) {
3097- crit(LOGOPT_ANY, "can't malloc mnt_name string");
3098+ logerr("can't malloc mnt_name string");
3099 return NULL;
3100 }
3101
3102@@ -171,13 +170,12 @@ char *make_mnt_name_string(char *path)
3103 mnt_name_template, (unsigned) getpid());
3104
3105 if (len >= MAX_MNT_NAME_LEN) {
3106- crit(LOGOPT_ANY, "buffer to small for mnt_name - truncated");
3107+ logerr("buffer to small for mnt_name - truncated");
3108 len = MAX_MNT_NAME_LEN - 1;
3109 }
3110
3111 if (len < 0) {
3112- crit(LOGOPT_ANY,
3113- "failed setting up mnt_name for autofs path %s", path);
3114+ logerr("failed setting up mnt_name for autofs path %s", path);
3115 free(mnt_name);
3116 return NULL;
3117 }
3118@@ -207,7 +205,7 @@ struct mnt_list *get_mnt_list(const char *table, const char *path, int include)
3119 tab = setmntent(table, "r");
3120 if (!tab) {
3121 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3122- error(LOGOPT_ANY, "setmntent: %s", estr);
3123+ logerr("setmntent: %s", estr);
3124 return NULL;
3125 }
3126
3127@@ -398,7 +396,7 @@ int is_mounted(const char *table, const char *path, unsigned int type)
3128 tab = setmntent(table, "r");
3129 if (!tab) {
3130 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3131- error(LOGOPT_ANY, "setmntent: %s", estr);
3132+ logerr("setmntent: %s", estr);
3133 return 0;
3134 }
3135
3136@@ -443,7 +441,7 @@ int has_fstab_option(const char *opt)
3137 tab = setmntent(_PATH_MNTTAB, "r");
3138 if (!tab) {
3139 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3140- error(LOGOPT_ANY, "setmntent: %s", estr);
3141+ logerr("setmntent: %s", estr);
3142 return 0;
3143 }
3144
3145@@ -471,7 +469,7 @@ char *find_mnt_ino(const char *table, dev_t dev, ino_t ino)
3146 tab = setmntent(table, "r");
3147 if (!tab) {
3148 char *estr = strerror_r(errno, buf, (size_t) PATH_MAX - 1);
3149- error(LOGOPT_ANY, "setmntent: %s", estr);
3150+ logerr("setmntent: %s", estr);
3151 return 0;
3152 }
3153
3154@@ -667,7 +665,7 @@ struct mnt_list *tree_make_mnt_tree(const char *table, const char *path)
3155 tab = setmntent(table, "r");
3156 if (!tab) {
3157 char *estr = strerror_r(errno, buf, PATH_MAX - 1);
3158- error(LOGOPT_ANY, "setmntent: %s", estr);
3159+ logerr("setmntent: %s", estr);
3160 return NULL;
3161 }
3162
3163diff --git a/lib/nss_parse.y b/lib/nss_parse.y
3164index e559696..90b7d25 100644
3165--- a/lib/nss_parse.y
3166+++ b/lib/nss_parse.y
3167@@ -127,13 +127,13 @@ status_exp: STATUS EQUAL ACTION
3168
3169 static int nss_ignore(const char *s)
3170 {
3171- msg("ignored invalid nsswitch config near [ %s ]", s);
3172+ logmsg("ignored invalid nsswitch config near [ %s ]", s);
3173 return(0);
3174 }
3175
3176 static int nss_error(const char *s)
3177 {
3178- msg("syntax error in nsswitch config near [ %s ]\n", s);
3179+ logmsg("syntax error in nsswitch config near [ %s ]\n", s);
3180 return(0);
3181 }
3182
3183@@ -167,7 +167,7 @@ int nsswitch_parse(struct list_head *list)
3184
3185 nsswitch = fopen(NSSWITCH_FILE, "r");
3186 if (!nsswitch) {
3187- error(LOGOPT_ANY, "couldn't open %s\n", NSSWITCH_FILE);
3188+ logerr("couldn't open %s\n", NSSWITCH_FILE);
3189 return 1;
3190 }
3191
3192diff --git a/lib/nss_tok.l b/lib/nss_tok.l
3193index f96b47f..c435b63 100644
3194--- a/lib/nss_tok.l
3195+++ b/lib/nss_tok.l
3196@@ -135,6 +135,6 @@ int nss_wrap(void)
3197
3198 static void nss_echo(void)
3199 {
3200- msg("%s", nss_text);
3201+ logmsg("%s", nss_text);
3202 return;
3203 }
3204diff --git a/lib/parse_subs.c b/lib/parse_subs.c
3205index 3627f44..5422fef 100644
3206--- a/lib/parse_subs.c
3207+++ b/lib/parse_subs.c
3208@@ -337,9 +337,9 @@ int umount_ent(struct autofs_point *ap, const char *path)
3209 * and EBADSLT relates to CD changer not responding.
3210 */
3211 if (!status && (S_ISDIR(st.st_mode) && st.st_dev != ap->dev)) {
3212- rv = spawn_umount(log_debug, path, NULL);
3213+ rv = spawn_umount(ap->logopt, path, NULL);
3214 } else if (is_smbfs && (sav_errno == EIO || sav_errno == EBADSLT)) {
3215- rv = spawn_umount(log_debug, path, NULL);
3216+ rv = spawn_umount(ap->logopt, path, NULL);
3217 }
3218
3219 /* We are doing a forced shutcwdown down so unlink busy mounts */
3220@@ -356,8 +356,8 @@ int umount_ent(struct autofs_point *ap, const char *path)
3221 }
3222
3223 if (ap->state == ST_SHUTDOWN_FORCE) {
3224- msg("forcing umount of %s", path);
3225- rv = spawn_umount(log_debug, "-l", path, NULL);
3226+ info(ap->logopt, "forcing umount of %s", path);
3227+ rv = spawn_umount(ap->logopt, "-l", path, NULL);
3228 }
3229
3230 /*
3231@@ -503,7 +503,7 @@ int umount_multi_triggers(struct autofs_point *ap, char *root, struct mapent *me
3232 * the offset triggers back.
3233 */
3234 if (is_mounted(_PATH_MOUNTED, root, MNTS_REAL)) {
3235- msg("unmounting dir = %s", root);
3236+ info(ap->logopt, "unmounting dir = %s", root);
3237 if (umount_ent(ap, root)) {
3238 if (!mount_multi_triggers(ap, root, me, "/"))
3239 warn(ap->logopt,
3240diff --git a/lib/rpc_subs.c b/lib/rpc_subs.c
3241index d79a94f..5797639 100644
3242--- a/lib/rpc_subs.c
3243+++ b/lib/rpc_subs.c
3244@@ -96,7 +96,7 @@ static CLIENT *create_udp_client(struct conn_info *info)
3245 if (ret || !result) {
3246 int err = ghn_errno == -1 ? errno : ghn_errno;
3247 char *estr = strerror_r(err, buf, HOST_ENT_BUF_SIZE);
3248- error(LOGOPT_ANY, "hostname lookup failed: %s", estr);
3249+ logerr("hostname lookup failed: %s", estr);
3250 goto out_close;
3251 }
3252 memcpy(&raddr.sin_addr.s_addr, php->h_addr, php->h_length);
3253@@ -305,7 +305,7 @@ static CLIENT *create_tcp_client(struct conn_info *info)
3254 if (ret || !result) {
3255 int err = ghn_errno == -1 ? errno : ghn_errno;
3256 char *estr = strerror_r(err, buf, HOST_ENT_BUF_SIZE);
3257- error(LOGOPT_ANY, "hostname lookup failed: %s", estr);
3258+ logerr("hostname lookup failed: %s", estr);
3259 goto out_close;
3260 }
3261 memcpy(&addr.sin_addr.s_addr, php->h_addr, php->h_length);
3262diff --git a/man/automount.8 b/man/automount.8
3263index e203a3e..5cd63c7 100644
3264--- a/man/automount.8
3265+++ b/man/automount.8
3266@@ -62,6 +62,22 @@ setting.
3267 .TP
3268 .I "\-V, \-\-version"
3269 Display the version number, then exit.
3270+.TP
3271+.I "\-l, \-\-set-log-priority priority path [path,...]"
3272+Set the daemon log priority to the specified value. Valid values include
3273+the numbers 0-7, or the strings emerg, alert, crit, err, warning, notice,
3274+info, or debug. Log level debug will log everything, log levels info, warn
3275+(or warning), or notice with enable the daemon verbose logging. Any other
3276+level will set basic logging. Note that enabling debug or verbose
3277+logging in the autofs global configuration will override dynamic log level
3278+changes. For example, if verbose logging is set in the configuration then
3279+attempting to set logging to basic logging, by using alert, crit, err
3280+or emerg won't stop the verbose logging. However, setting logging to debug
3281+will lead to everything (debug logging) being logged witch can then also
3282+be disabled, returning the daemon to verbose logging.
3283+.P
3284+The \fIpath\fP argument corresponds to the automounted
3285+path name as specified in the master map.
3286 .SH ARGUMENTS
3287 \fBautomount\fP takes one optional argument, the name of the master map to
3288 use.
3289diff --git a/modules/cyrus-sasl.c b/modules/cyrus-sasl.c
3290index 68e5dd7..18733f3 100644
3291--- a/modules/cyrus-sasl.c
3292+++ b/modules/cyrus-sasl.c
3293@@ -96,18 +96,18 @@ sasl_log_func(void *context, int level, const char *message)
3294 switch (level) {
3295 case SASL_LOG_ERR:
3296 case SASL_LOG_FAIL:
3297- error(LOGOPT_ANY, "%s", message);
3298+ logerr("%s", message);
3299 break;
3300 case SASL_LOG_WARN:
3301- warn(LOGOPT_ANY, "%s", message);
3302+ logmsg("%s", message);
3303 break;
3304 case SASL_LOG_NOTE:
3305- info(LOGOPT_ANY, "%s", message);
3306+ logmsg("%s", message);
3307 break;
3308 case SASL_LOG_DEBUG:
3309 case SASL_LOG_TRACE:
3310 case SASL_LOG_PASS:
3311- debug(LOGOPT_NONE, "%s", message);
3312+ debug(LOGOPT_DEBUG, "%s", message);
3313 break;
3314 default:
3315 break;
3316@@ -129,7 +129,7 @@ getuser_func(void *context, int id, const char **result, unsigned *len)
3317 *len = strlen(sasl_auth_id);
3318 break;
3319 default:
3320- error(LOGOPT_ANY, "unknown id in request: %d", id);
3321+ error(LOGOPT_VERBOSE, "unknown id in request: %d", id);
3322 return SASL_FAIL;
3323 }
3324
3325@@ -166,7 +166,7 @@ getpass_func(sasl_conn_t *conn, void *context, int id, sasl_secret_t **psecret)
3326 * the returned data.
3327 */
3328 char **
3329-get_server_SASL_mechanisms(LDAP *ld)
3330+get_server_SASL_mechanisms(unsigned logopt, LDAP *ld)
3331 {
3332 int ret;
3333 const char *saslattrlist[] = {"supportedSASLmechanisms", NULL};
3334@@ -178,7 +178,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3335 NULL, NULL,
3336 NULL, LDAP_NO_LIMIT, &results);
3337 if (ret != LDAP_SUCCESS) {
3338- error(LOGOPT_ANY, "%s", ldap_err2string(ret));
3339+ error(logopt, "%s", ldap_err2string(ret));
3340 return NULL;
3341 }
3342
3343@@ -186,7 +186,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3344 if (entry == NULL) {
3345 /* No root DSE. (!) */
3346 ldap_msgfree(results);
3347- debug(LOGOPT_NONE,
3348+ debug(logopt,
3349 "a lookup of \"supportedSASLmechanisms\" returned "
3350 "no results.");
3351 return NULL;
3352@@ -196,7 +196,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3353 ldap_msgfree(results);
3354 if (mechanisms == NULL) {
3355 /* Well, that was a waste of time. */
3356- msg("No SASL authentication mechanisms are supported"
3357+ info(logopt, "No SASL authentication mechanisms are supported"
3358 " by the LDAP server.");
3359 return NULL;
3360 }
3361@@ -208,7 +208,7 @@ get_server_SASL_mechanisms(LDAP *ld)
3362 * Returns 0 upon successful connect, -1 on failure.
3363 */
3364 int
3365-do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3366+do_sasl_bind(unsigned logopt, LDAP *ld, sasl_conn_t *conn, const char **clientout,
3367 unsigned int *clientoutlen, const char *auth_mech, int sasl_result)
3368 {
3369 int ret, msgid, bind_result;
3370@@ -226,7 +226,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3371 &client_cred : NULL,
3372 NULL, NULL, &msgid);
3373 if (ret != LDAP_SUCCESS) {
3374- crit(LOGOPT_ANY,
3375+ crit(logopt,
3376 "Error sending sasl_bind request to "
3377 "the server: %s", ldap_err2string(ret));
3378 return -1;
3379@@ -236,7 +236,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3380 results = NULL;
3381 ret = ldap_result(ld, msgid, LDAP_MSG_ALL, NULL, &results);
3382 if (ret != LDAP_RES_BIND) {
3383- crit(LOGOPT_ANY,
3384+ crit(logopt,
3385 "Error while waiting for response to "
3386 "sasl_bind request: %s", ldap_err2string(ret));
3387 return -1;
3388@@ -264,7 +264,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3389 ret = ldap_get_option(ld, LDAP_OPT_RESULT_CODE,
3390 &bind_result);
3391 if (ret != LDAP_SUCCESS) {
3392- crit(LOGOPT_ANY,
3393+ crit(logopt,
3394 "Error retrieving response to sasl_bind "
3395 "request: %s", ldap_err2string(ret));
3396 ret = -1;
3397@@ -277,7 +277,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3398 bind_result = ret;
3399 break;
3400 default:
3401- warn(LOGOPT_ANY,
3402+ warn(logopt,
3403 "Error parsing response to sasl_bind "
3404 "request: %s.", ldap_err2string(ret));
3405 break;
3406@@ -299,7 +299,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3407 expected_data = sasl_result == SASL_CONTINUE;
3408
3409 if (have_data && !expected_data) {
3410- warn(LOGOPT_ANY,
3411+ warn(logopt,
3412 "The LDAP server sent data in response to our "
3413 "bind request, but indicated that the bind was "
3414 "complete. LDAP SASL bind with mechansim %s "
3415@@ -308,7 +308,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3416 break;
3417 }
3418 if (expected_data && !have_data) {
3419- warn(LOGOPT_ANY,
3420+ warn(logopt,
3421 "The LDAP server indicated that the LDAP SASL "
3422 "bind was incomplete, but did not provide the "
3423 "required data to proceed. LDAP SASL bind with "
3424@@ -340,7 +340,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3425 */
3426 if ((*clientoutlen > 0) &&
3427 (bind_result != LDAP_SASL_BIND_IN_PROGRESS)) {
3428- warn(LOGOPT_ANY,
3429+ warn(logopt,
3430 "We have data for the server, "
3431 "but it thinks we are done!");
3432 /* XXX should print out debug data here */
3433@@ -372,7 +372,7 @@ do_sasl_bind(LDAP *ld, sasl_conn_t *conn, const char **clientout,
3434 * Upon failure, -1 is returned.
3435 */
3436 int
3437-sasl_do_kinit(struct lookup_context *ctxt)
3438+sasl_do_kinit(unsigned logopt, struct lookup_context *ctxt)
3439 {
3440 krb5_error_code ret;
3441 krb5_principal tgs_princ, krb5_client_princ = ctxt->krb5_client_princ;
3442@@ -384,33 +384,33 @@ sasl_do_kinit(struct lookup_context *ctxt)
3443 return 0;
3444 ctxt->kinit_done = 1;
3445
3446- debug(LOGOPT_NONE,
3447+ debug(logopt,
3448 "initializing kerberos ticket: client principal %s ",
3449 ctxt->client_princ ? "" : "autofsclient");
3450
3451 ret = krb5_init_context(&ctxt->krb5ctxt);
3452 if (ret) {
3453- error(LOGOPT_ANY, "krb5_init_context failed with %d", ret);
3454+ error(logopt, "krb5_init_context failed with %d", ret);
3455 return -1;
3456 }
3457
3458 ret = krb5_cc_resolve(ctxt->krb5ctxt, krb5ccval, &ctxt->krb5_ccache);
3459 if (ret) {
3460- error(LOGOPT_ANY, "krb5_cc_resolve failed with error %d",
3461+ error(logopt, "krb5_cc_resolve failed with error %d",
3462 ret);
3463 krb5_free_context(ctxt->krb5ctxt);
3464 return -1;
3465 }
3466
3467 if (ctxt->client_princ) {
3468- debug(LOGOPT_NONE,
3469+ debug(logopt,
3470 "calling krb5_parse_name on client principal %s",
3471 ctxt->client_princ);
3472
3473 ret = krb5_parse_name(ctxt->krb5ctxt, ctxt->client_princ,
3474 &krb5_client_princ);
3475 if (ret) {
3476- error(LOGOPT_ANY,
3477+ error(logopt,
3478 "krb5_parse_name failed for "
3479 "specified client principal %s",
3480 ctxt->client_princ);
3481@@ -419,14 +419,14 @@ sasl_do_kinit(struct lookup_context *ctxt)
3482 } else {
3483 char *tmp_name = NULL;
3484
3485- debug(LOGOPT_NONE,
3486+ debug(logopt,
3487 "calling krb5_sname_to_principal using defaults");
3488
3489 ret = krb5_sname_to_principal(ctxt->krb5ctxt, NULL,
3490 "autofsclient", KRB5_NT_SRV_HST,
3491 &krb5_client_princ);
3492 if (ret) {
3493- error(LOGOPT_ANY,
3494+ error(logopt,
3495 "krb5_sname_to_principal failed for "
3496 "%s with error %d",
3497 ctxt->client_princ ? "" : "autofsclient", ret);
3498@@ -437,13 +437,13 @@ sasl_do_kinit(struct lookup_context *ctxt)
3499 ret = krb5_unparse_name(ctxt->krb5ctxt,
3500 krb5_client_princ, &tmp_name);
3501 if (ret) {
3502- debug(LOGOPT_NONE,
3503+ debug(logopt,
3504 "krb5_unparse_name failed with error %d",
3505 ret);
3506 goto out_cleanup_cc;
3507 }
3508
3509- debug(LOGOPT_NONE,
3510+ debug(logopt,
3511 "principal used for authentication: \"%s\"", tmp_name);
3512
3513 krb5_free_unparsed_name(ctxt->krb5ctxt, tmp_name);
3514@@ -458,19 +458,19 @@ sasl_do_kinit(struct lookup_context *ctxt)
3515 krb5_princ_realm(ctxt->krb5ctxt, krb5_client_princ)->data,
3516 0);
3517 if (ret) {
3518- error(LOGOPT_ANY,
3519+ error(logopt,
3520 "krb5_build_principal failed with error %d", ret);
3521 goto out_cleanup_cc;
3522 }
3523
3524 ret = krb5_unparse_name(ctxt->krb5ctxt, tgs_princ, &tgs_name);
3525 if (ret) {
3526- error(LOGOPT_ANY, "krb5_unparse_name failed with error %d",
3527+ error(logopt, "krb5_unparse_name failed with error %d",
3528 ret);
3529 goto out_cleanup_cc;
3530 }
3531
3532- debug(LOGOPT_NONE, "Using tgs name %s", tgs_name);
3533+ debug(logopt, "Using tgs name %s", tgs_name);
3534
3535 memset(&my_creds, 0, sizeof(my_creds));
3536 ret = krb5_get_init_creds_keytab(ctxt->krb5ctxt, &my_creds,
3537@@ -479,7 +479,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3538 0 /* relative start time */,
3539 tgs_name, NULL);
3540 if (ret) {
3541- error(LOGOPT_ANY,
3542+ error(logopt,
3543 "krb5_get_init_creds_keytab failed with error %d",
3544 ret);
3545 goto out_cleanup_unparse;
3546@@ -500,7 +500,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3547 fatal(status);
3548
3549 if (ret) {
3550- error(LOGOPT_ANY,
3551+ error(logopt,
3552 "krb5_cc_initialize failed with error %d", ret);
3553 goto out_cleanup_unparse;
3554 }
3555@@ -508,7 +508,7 @@ sasl_do_kinit(struct lookup_context *ctxt)
3556 /* and store credentials for that principal */
3557 ret = krb5_cc_store_cred(ctxt->krb5ctxt, ctxt->krb5_ccache, &my_creds);
3558 if (ret) {
3559- error(LOGOPT_ANY,
3560+ error(logopt,
3561 "krb5_cc_store_cred failed with error %d", ret);
3562 goto out_cleanup_unparse;
3563 }
3564@@ -516,12 +516,12 @@ sasl_do_kinit(struct lookup_context *ctxt)
3565 /* finally, set the environment variable to point to our
3566 * credentials cache */
3567 if (setenv(krb5ccenv, krb5ccval, 1) != 0) {
3568- error(LOGOPT_ANY, "setenv failed with %d", errno);
3569+ error(logopt, "setenv failed with %d", errno);
3570 goto out_cleanup_unparse;
3571 }
3572 ctxt->kinit_successful = 1;
3573
3574- debug(LOGOPT_NONE, "Kerberos authentication was successful!");
3575+ debug(logopt, "Kerberos authentication was successful!");
3576
3577 krb5_free_unparsed_name(ctxt->krb5ctxt, tgs_name);
3578
3579@@ -540,7 +540,7 @@ out_cleanup_cc:
3580 else
3581 ret = krb5_cc_destroy(ctxt->krb5ctxt, ctxt->krb5_ccache);
3582 if (ret)
3583- warn(LOGOPT_ANY,
3584+ warn(logopt,
3585 "krb5_cc_destroy failed with non-fatal error %d", ret);
3586
3587 status = pthread_mutex_unlock(&krb5cc_mutex);
3588@@ -559,7 +559,7 @@ out_cleanup_cc:
3589 * Returns a valid sasl_conn_t pointer upon success, NULL on failure.
3590 */
3591 sasl_conn_t *
3592-sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3593+sasl_bind_mech(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3594 {
3595 sasl_conn_t *conn;
3596 char *tmp, *host = NULL;
3597@@ -569,15 +569,15 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3598 int result;
3599
3600 if (!strncmp(mech, "GSSAPI", 6)) {
3601- if (sasl_do_kinit(ctxt) != 0)
3602+ if (sasl_do_kinit(logopt, ctxt) != 0)
3603 return NULL;
3604 }
3605
3606- debug(LOGOPT_NONE, "Attempting sasl bind with mechanism %s", mech);
3607+ debug(logopt, "Attempting sasl bind with mechanism %s", mech);
3608
3609 result = ldap_get_option(ldap, LDAP_OPT_HOST_NAME, &host);
3610 if (result != LDAP_SUCCESS || !host) {
3611- debug(LOGOPT_NONE, "failed to get hostname for connection");
3612+ debug(logopt, "failed to get hostname for connection");
3613 return NULL;
3614 }
3615
3616@@ -587,7 +587,7 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3617 /* Create a new authentication context for the service. */
3618 result = sasl_client_new("ldap", host, NULL, NULL, NULL, 0, &conn);
3619 if (result != SASL_OK) {
3620- error(LOGOPT_ANY, "sasl_client_new failed with error %d",
3621+ error(logopt, "sasl_client_new failed with error %d",
3622 result);
3623 ldap_memfree(host);
3624 return NULL;
3625@@ -599,23 +599,23 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3626
3627 /* OK and CONTINUE are the only non-fatal return codes here. */
3628 if ((result != SASL_OK) && (result != SASL_CONTINUE)) {
3629- error(LOGOPT_ANY, "sasl_client start failed with error: %s",
3630+ error(logopt, "sasl_client start failed with error: %s",
3631 sasl_errdetail(conn));
3632 ldap_memfree(host);
3633 sasl_dispose(&conn);
3634 return NULL;
3635 }
3636
3637- result = do_sasl_bind(ldap, conn,
3638+ result = do_sasl_bind(logopt, ldap, conn,
3639 &clientout, &clientoutlen, chosen_mech, result);
3640 if (result == 0) {
3641 ldap_memfree(host);
3642- debug(LOGOPT_NONE, "sasl bind with mechanism %s succeeded",
3643+ debug(logopt, "sasl bind with mechanism %s succeeded",
3644 chosen_mech);
3645 return conn;
3646 }
3647
3648- info(LOGOPT_ANY, "sasl bind with mechanism %s failed", mech);
3649+ info(logopt, "sasl bind with mechanism %s failed", mech);
3650
3651 /* sasl bind failed */
3652 ldap_memfree(host);
3653@@ -629,14 +629,14 @@ sasl_bind_mech(LDAP *ldap, struct lookup_context *ctxt, const char *mech)
3654 * -1 on error or if no mechanism is supported by both client and server.
3655 */
3656 sasl_conn_t *
3657-sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3658+sasl_choose_mech(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3659 {
3660 sasl_conn_t *conn;
3661 int authenticated;
3662 int i;
3663 char **mechanisms;
3664
3665- mechanisms = get_server_SASL_mechanisms(ldap);
3666+ mechanisms = get_server_SASL_mechanisms(logopt, ldap);
3667 if (!mechanisms)
3668 return NULL;
3669
3670@@ -652,12 +652,11 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3671 if (authtype_requires_creds(mechanisms[i]))
3672 continue;
3673
3674- conn = sasl_bind_mech(ldap, ctxt, mechanisms[i]);
3675+ conn = sasl_bind_mech(logopt, ldap, ctxt, mechanisms[i]);
3676 if (conn) {
3677 ctxt->sasl_mech = strdup(mechanisms[i]);
3678 if (!ctxt->sasl_mech) {
3679- crit(LOGOPT_ANY,
3680- "Successfully authenticated with "
3681+ crit(logopt, "Successfully authenticated with "
3682 "mechanism %s, but failed to allocate "
3683 "memory to hold the mechanism type.",
3684 mechanisms[i]);
3685@@ -668,11 +667,11 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3686 authenticated = 1;
3687 break;
3688 }
3689- debug(LOGOPT_NONE, "Failed to authenticate with mech %s",
3690+ debug(logopt, "Failed to authenticate with mech %s",
3691 mechanisms[i]);
3692 }
3693
3694- debug(LOGOPT_NONE, "authenticated: %d, sasl_mech: %s",
3695+ debug(logopt, "authenticated: %d, sasl_mech: %s",
3696 authenticated, ctxt->sasl_mech);
3697
3698 ldap_value_free(mechanisms);
3699@@ -680,14 +679,14 @@ sasl_choose_mech(LDAP *ldap, struct lookup_context *ctxt)
3700 }
3701
3702 int
3703-autofs_sasl_bind(LDAP *ldap, struct lookup_context *ctxt)
3704+autofs_sasl_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3705 {
3706 sasl_conn_t *conn;
3707
3708 if (!ctxt->sasl_mech)
3709 return -1;
3710
3711- conn = sasl_bind_mech(ldap, ctxt, ctxt->sasl_mech);
3712+ conn = sasl_bind_mech(logopt, ldap, ctxt, ctxt->sasl_mech);
3713 if (!conn)
3714 return -1;
3715
3716@@ -717,13 +716,13 @@ autofs_sasl_unbind(struct lookup_context *ctxt)
3717 * -1 - Failure
3718 */
3719 int
3720-autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt)
3721+autofs_sasl_init(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
3722 {
3723 sasl_conn_t *conn;
3724
3725 /* Start up Cyrus SASL--only needs to be done once. */
3726 if (sasl_client_init(callbacks) != SASL_OK) {
3727- error(LOGOPT_ANY, "sasl_client_init failed");
3728+ error(logopt, "sasl_client_init failed");
3729 return -1;
3730 }
3731
3732@@ -736,9 +735,9 @@ autofs_sasl_init(LDAP *ldap, struct lookup_context *ctxt)
3733 * select one.
3734 */
3735 if (ctxt->sasl_mech)
3736- conn = sasl_bind_mech(ldap, ctxt, ctxt->sasl_mech);
3737+ conn = sasl_bind_mech(logopt, ldap, ctxt, ctxt->sasl_mech);
3738 else
3739- conn = sasl_choose_mech(ldap, ctxt);
3740+ conn = sasl_choose_mech(logopt, ldap, ctxt);
3741
3742 if (conn) {
3743 sasl_dispose(&conn);
3744@@ -772,8 +771,7 @@ autofs_sasl_done(struct lookup_context *ctxt)
3745 else
3746 ret = krb5_cc_destroy(ctxt->krb5ctxt, ctxt->krb5_ccache);
3747 if (ret)
3748- warn(LOGOPT_ANY,
3749- "krb5_cc_destroy failed with non-fatal error %d",
3750+ logmsg("krb5_cc_destroy failed with non-fatal error %d",
3751 ret);
3752
3753 status = pthread_mutex_unlock(&krb5cc_mutex);
3754@@ -782,8 +780,7 @@ autofs_sasl_done(struct lookup_context *ctxt)
3755
3756 krb5_free_context(ctxt->krb5ctxt);
3757 if (unsetenv(krb5ccenv) != 0)
3758- warn(LOGOPT_ANY,
3759- "unsetenv failed with error %d", errno);
3760+ logerr("unsetenv failed with error %d", errno);
3761
3762 ctxt->krb5ctxt = NULL;
3763 ctxt->krb5_ccache = NULL;
3764diff --git a/modules/lookup_file.c b/modules/lookup_file.c
3765index 31ee0fb..921b32b 100644
3766--- a/modules/lookup_file.c
3767+++ b/modules/lookup_file.c
3768@@ -63,13 +63,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3769 ctxt = malloc(sizeof(struct lookup_context));
3770 if (!ctxt) {
3771 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
3772- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
3773+ logerr(MODPREFIX "malloc: %s", estr);
3774 return 1;
3775 }
3776
3777 if (argc < 1) {
3778 free(ctxt);
3779- crit(LOGOPT_ANY, MODPREFIX "No map name");
3780+ logerr(MODPREFIX "No map name");
3781 return 1;
3782 }
3783
3784@@ -77,21 +77,21 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3785
3786 if (ctxt->mapname[0] != '/') {
3787 free(ctxt);
3788- msg(MODPREFIX "file map %s is not an absolute pathname",
3789- argv[0]);
3790+ logmsg(MODPREFIX
3791+ "file map %s is not an absolute pathname", argv[0]);
3792 return 1;
3793 }
3794
3795 if (access(ctxt->mapname, R_OK)) {
3796 free(ctxt);
3797- msg(MODPREFIX "file map %s missing or not readable",
3798- argv[0]);
3799+ warn(LOGOPT_NONE, MODPREFIX
3800+ "file map %s missing or not readable", argv[0]);
3801 return 1;
3802 }
3803
3804 if (stat(ctxt->mapname, &st)) {
3805 free(ctxt);
3806- crit(LOGOPT_ANY, MODPREFIX "file map %s, could not stat",
3807+ logmsg(MODPREFIX "file map %s, could not stat",
3808 argv[0]);
3809 return 1;
3810 }
3811@@ -104,7 +104,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3812 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
3813 if (!ctxt->parse) {
3814 free(ctxt);
3815- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
3816+ logmsg(MODPREFIX "failed to open parse context");
3817 return 1;
3818 }
3819 *context = ctxt;
3820@@ -112,7 +112,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
3821 return 0;
3822 }
3823
3824-static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsigned int *m_len)
3825+static int read_one(unsigned logopt, FILE *f, char *key, unsigned int *k_len, char *mapent, unsigned int *m_len)
3826 {
3827 char *kptr, *p;
3828 int mapent_len, key_len;
3829@@ -193,7 +193,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3830 if (gotten == got_plus)
3831 goto got_it;
3832 else if (escape == esc_all) {
3833- warn(LOGOPT_ANY, MODPREFIX
3834+ warn(logopt, MODPREFIX
3835 "unmatched \" in map key %s", key);
3836 goto next;
3837 } else if (escape != esc_val)
3838@@ -208,7 +208,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3839 if (key_len == KEY_MAX_LEN) {
3840 state = st_badent;
3841 gotten = got_nothing;
3842- warn(LOGOPT_ANY,
3843+ warn(logopt,
3844 MODPREFIX "map key \"%s...\" "
3845 "is too long. The maximum key "
3846 "length is %d", key,
3847@@ -245,7 +245,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3848 state = st_begin;
3849 if (gotten == got_real || gotten == getting)
3850 goto got_it;
3851- warn(LOGOPT_ANY, MODPREFIX
3852+ warn(logopt, MODPREFIX
3853 "bad map entry \"%s...\" for key "
3854 "\"%s\"", mapent, key);
3855 goto next;
3856@@ -286,7 +286,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3857 if (ch == '\n') {
3858 if (escape == esc_all) {
3859 state = st_begin;
3860- warn(LOGOPT_ANY, MODPREFIX
3861+ warn(logopt, MODPREFIX
3862 "unmatched \" in %s for key %s",
3863 mapent, key);
3864 goto next;
3865@@ -310,7 +310,7 @@ static int read_one(FILE *f, char *key, unsigned int *k_len, char *mapent, unsig
3866 goto got_it;
3867 ungetc(nch, f);
3868 } else {
3869- warn(LOGOPT_ANY,
3870+ warn(logopt,
3871 MODPREFIX "map entry \"%s...\" for key "
3872 "\"%s\" is too long. The maximum entry"
3873 " size is %d", mapent, key,
3874@@ -388,6 +388,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3875 struct lookup_context *ctxt = (struct lookup_context *) context;
3876 unsigned int timeout = master->default_timeout;
3877 unsigned int logging = master->default_logging;
3878+ unsigned int logopt = master->logopt;
3879 char *buffer;
3880 int blen;
3881 char *path;
3882@@ -402,29 +403,28 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3883 return NSS_STATUS_UNAVAIL;
3884
3885 if (master->depth > MAX_INCLUDE_DEPTH) {
3886- error(LOGOPT_ANY,
3887- MODPREFIX
3888+ error(logopt, MODPREFIX
3889 "maximum include depth exceeded %s", master->name);
3890 return NSS_STATUS_UNAVAIL;
3891 }
3892
3893 path = alloca(KEY_MAX_LEN + 1);
3894 if (!path) {
3895- error(LOGOPT_ANY,
3896+ error(logopt,
3897 MODPREFIX "could not malloc storage for path");
3898 return NSS_STATUS_UNAVAIL;
3899 }
3900
3901 ent = alloca(MAPENT_MAX_LEN + 1);
3902 if (!ent) {
3903- error(LOGOPT_ANY,
3904+ error(logopt,
3905 MODPREFIX "could not malloc storage for mapent");
3906 return NSS_STATUS_UNAVAIL;
3907 }
3908
3909 f = fopen(ctxt->mapname, "r");
3910 if (!f) {
3911- error(LOGOPT_ANY,
3912+ error(logopt,
3913 MODPREFIX "could not open master map file %s",
3914 ctxt->mapname);
3915 return NSS_STATUS_UNAVAIL;
3916@@ -438,19 +438,19 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3917 }
3918
3919 while(1) {
3920- entry = read_one(f, path, &path_len, ent, &ent_len);
3921+ entry = read_one(logopt, f, path, &path_len, ent, &ent_len);
3922 if (!entry) {
3923 if (feof(f))
3924 break;
3925 if (ferror(f)) {
3926- warn(LOGOPT_ANY, MODPREFIX
3927+ warn(logopt, MODPREFIX
3928 "error reading map %s", ctxt->mapname);
3929 break;
3930 }
3931 continue;
3932 }
3933
3934- debug(LOGOPT_NONE, MODPREFIX "read entry %s", path);
3935+ debug(logopt, MODPREFIX "read entry %s", path);
3936
3937 /*
3938 * If key starts with '+' it has to be an
3939@@ -470,7 +470,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3940 master->depth++;
3941 status = lookup_nss_read_master(master, age);
3942 if (!status)
3943- warn(LOGOPT_ANY,
3944+ warn(logopt,
3945 MODPREFIX
3946 "failed to read included master map %s",
3947 master->name);
3948@@ -482,7 +482,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3949 blen = path_len + 1 + ent_len + 1;
3950 buffer = malloc(blen);
3951 if (!buffer) {
3952- error(LOGOPT_ANY,
3953+ error(logopt,
3954 MODPREFIX "could not malloc parse buffer");
3955 return NSS_STATUS_UNAVAIL;
3956 }
3957@@ -503,7 +503,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
3958 }
3959
3960 if (fstat(fd, &st)) {
3961- crit(LOGOPT_ANY, MODPREFIX "file map %s, could not stat",
3962+ crit(logopt, MODPREFIX "file map %s, could not stat",
3963 ctxt->mapname);
3964 return NSS_STATUS_UNAVAIL;
3965 }
3966@@ -684,12 +684,12 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
3967 }
3968
3969 while(1) {
3970- entry = read_one(f, key, &k_len, mapent, &m_len);
3971+ entry = read_one(ap->logopt, f, key, &k_len, mapent, &m_len);
3972 if (!entry) {
3973 if (feof(f))
3974 break;
3975 if (ferror(f)) {
3976- warn(LOGOPT_ANY, MODPREFIX
3977+ warn(ap->logopt, MODPREFIX
3978 "error reading map %s", ctxt->mapname);
3979 break;
3980 }
3981@@ -791,7 +791,7 @@ static int lookup_one(struct autofs_point *ap,
3982 }
3983
3984 while(1) {
3985- entry = read_one(f, mkey, &k_len, mapent, &m_len);
3986+ entry = read_one(ap->logopt, f, mkey, &k_len, mapent, &m_len);
3987 if (entry) {
3988 /*
3989 * If key starts with '+' it has to be an
3990@@ -860,7 +860,7 @@ static int lookup_one(struct autofs_point *ap,
3991 break;
3992
3993 if (ferror(f)) {
3994- warn(LOGOPT_ANY, MODPREFIX
3995+ warn(ap->logopt, MODPREFIX
3996 "error reading map %s", ctxt->mapname);
3997 break;
3998 }
3999@@ -904,7 +904,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
4000 }
4001
4002 while(1) {
4003- entry = read_one(f, mkey, &k_len, mapent, &m_len);
4004+ entry = read_one(ap->logopt, f, mkey, &k_len, mapent, &m_len);
4005 if (entry) {
4006 int eq;
4007
4008@@ -925,7 +925,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
4009 break;
4010
4011 if (ferror(f)) {
4012- warn(LOGOPT_ANY, MODPREFIX
4013+ warn(ap->logopt, MODPREFIX
4014 "error reading map %s", ctxt->mapname);
4015 break;
4016 }
4017diff --git a/modules/lookup_hesiod.c b/modules/lookup_hesiod.c
4018index f30e9b2..649e24c 100644
4019--- a/modules/lookup_hesiod.c
4020+++ b/modules/lookup_hesiod.c
4021@@ -48,7 +48,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4022 ctxt = malloc(sizeof(struct lookup_context));
4023 if (!ctxt) {
4024 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4025- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4026+ logerr(MODPREFIX "malloc: %s", estr);
4027 return 1;
4028 }
4029
4030@@ -58,7 +58,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4031 /* Initialize the hesiod context. */
4032 if (hesiod_init(&(ctxt->hesiod_context)) != 0) {
4033 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4034- crit(LOGOPT_ANY, MODPREFIX "hesiod_init(): %s", estr);
4035+ logerr(MODPREFIX "hesiod_init(): %s", estr);
4036 free(ctxt);
4037 return 1;
4038 }
4039@@ -70,7 +70,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4040 /* Open the parser, if we can. */
4041 ctxt->parser = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
4042 if (!ctxt->parser) {
4043- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4044+ logerr(MODPREFIX "failed to open parse context");
4045 free(ctxt);
4046 return 1;
4047 }
4048diff --git a/modules/lookup_hosts.c b/modules/lookup_hosts.c
4049index d711611..d746e42 100644
4050--- a/modules/lookup_hosts.c
4051+++ b/modules/lookup_hosts.c
4052@@ -57,7 +57,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4053 ctxt = malloc(sizeof(struct lookup_context));
4054 if (!ctxt) {
4055 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4056- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4057+ logerr(MODPREFIX "malloc: %s", estr);
4058 return 1;
4059 }
4060
4061@@ -65,7 +65,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4062
4063 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc, argv);
4064 if (!ctxt->parse) {
4065- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4066+ logerr(MODPREFIX "failed to open parse context");
4067 free(ctxt);
4068 return 1;
4069 }
4070@@ -94,7 +94,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
4071
4072 status = pthread_mutex_lock(&hostent_mutex);
4073 if (status) {
4074- error(LOGOPT_ANY, MODPREFIX "failed to lock hostent mutex");
4075+ error(ap->logopt, MODPREFIX "failed to lock hostent mutex");
4076 return NSS_STATUS_UNAVAIL;
4077 }
4078
4079@@ -110,7 +110,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
4080
4081 status = pthread_mutex_unlock(&hostent_mutex);
4082 if (status)
4083- error(LOGOPT_ANY, MODPREFIX "failed to unlock hostent mutex");
4084+ error(ap->logopt, MODPREFIX "failed to unlock hostent mutex");
4085
4086 source->age = age;
4087
4088@@ -157,10 +157,10 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
4089 }
4090
4091 if (*name == '/')
4092- msg(MODPREFIX
4093+ info(ap->logopt, MODPREFIX
4094 "can't find path in hosts map %s", name);
4095 else
4096- msg(MODPREFIX
4097+ info(ap->logopt, MODPREFIX
4098 "can't find path in hosts map %s/%s",
4099 ap->path, name);
4100
4101@@ -216,7 +216,7 @@ done:
4102 if (!mapent) {
4103 char *estr;
4104 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4105- crit(ap->logopt, MODPREFIX "malloc: %s", estr);
4106+ logerr(MODPREFIX "malloc: %s", estr);
4107 rpc_exports_free(exp);
4108 return NSS_STATUS_UNAVAIL;
4109 }
4110@@ -230,7 +230,7 @@ done:
4111 if (!mapent) {
4112 char *estr;
4113 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4114- crit(ap->logopt, MODPREFIX "malloc: %s", estr);
4115+ logerr(MODPREFIX "malloc: %s", estr);
4116 rpc_exports_free(exp);
4117 return NSS_STATUS_UNAVAIL;
4118 }
4119diff --git a/modules/lookup_ldap.c b/modules/lookup_ldap.c
4120index c0f228b..00215af 100644
4121--- a/modules/lookup_ldap.c
4122+++ b/modules/lookup_ldap.c
4123@@ -49,9 +49,9 @@ static struct ldap_schema common_schema[] = {
4124 };
4125 static unsigned int common_schema_count = sizeof(common_schema)/sizeof(struct ldap_schema);
4126
4127-static LDAP *auth_init(const char *, struct lookup_context *);
4128+static LDAP *auth_init(unsigned logopt, const char *, struct lookup_context *);
4129
4130-int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4131+int bind_ldap_anonymous(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4132 {
4133 int rv;
4134
4135@@ -62,15 +62,14 @@ int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4136
4137 if (rv != LDAP_SUCCESS) {
4138 if (!ctxt->uri) {
4139- crit(LOGOPT_ANY,
4140- MODPREFIX "Unable to bind to the LDAP server: "
4141+ crit(logopt, MODPREFIX
4142+ "Unable to bind to the LDAP server: "
4143 "%s, error %s", ctxt->server ? "" : "(default)",
4144 ldap_err2string(rv));
4145 } else {
4146 struct ldap_uri *uri;
4147 uri = list_entry(ctxt->uri->next, struct ldap_uri, list);
4148- warn(LOGOPT_ANY,
4149- MODPREFIX "Unable to bind to the LDAP server: "
4150+ info(logopt, MODPREFIX "Unable to bind to the LDAP server: "
4151 "%s, error %s", uri->uri, ldap_err2string(rv));
4152 }
4153 return -1;
4154@@ -79,12 +78,11 @@ int bind_ldap_anonymous(LDAP *ldap, struct lookup_context *ctxt)
4155 return 0;
4156 }
4157
4158-int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt)
4159+int unbind_ldap_connection(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4160 {
4161 int rv;
4162
4163 #ifdef WITH_SASL
4164- debug(LOGOPT_NONE, "use_tls: %d", ctxt->use_tls);
4165 /*
4166 * The OpenSSL library can't handle having its message and error
4167 * string database loaded multiple times and segfaults if the
4168@@ -102,13 +100,12 @@ int unbind_ldap_connection(LDAP *ldap, struct lookup_context *ctxt)
4169
4170 rv = ldap_unbind_ext(ldap, NULL, NULL);
4171 if (rv != LDAP_SUCCESS)
4172- error(LOGOPT_ANY,
4173- "unbind failed: %s", ldap_err2string(rv));
4174+ error(logopt, "unbind failed: %s", ldap_err2string(rv));
4175
4176 return rv;
4177 }
4178
4179-LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4180+LDAP *init_ldap_connection(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4181 {
4182 LDAP *ldap = NULL;
4183 struct timeval timeout = { ctxt->timeout, 0 };
4184@@ -120,9 +117,9 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4185 /* Initialize the LDAP context. */
4186 rv = ldap_initialize(&ldap, uri);
4187 if (rv != LDAP_OPT_SUCCESS) {
4188- crit(LOGOPT_ANY,
4189- MODPREFIX "couldn't initialize LDAP connection to %s",
4190- uri ? uri : "default server");
4191+ info(logopt, MODPREFIX
4192+ "couldn't initialize LDAP connection to %s",
4193+ uri ? uri : "default");
4194 return NULL;
4195 }
4196
4197@@ -133,7 +130,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4198 ldap_unbind_ext(ldap, NULL, NULL);
4199 rv = ldap_initialize(&ldap, uri);
4200 if (rv != LDAP_OPT_SUCCESS) {
4201- crit(LOGOPT_ANY, MODPREFIX "couldn't initialize LDAP");
4202+ crit(logopt, MODPREFIX "couldn't initialize LDAP");
4203 return NULL;
4204 }
4205 ctxt->version = 2;
4206@@ -144,7 +141,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4207 /* Set synchronous call timeout */
4208 rv = ldap_set_option(ldap, LDAP_OPT_TIMEOUT, &timeout);
4209 if (rv != LDAP_OPT_SUCCESS)
4210- info(LOGOPT_ANY, MODPREFIX
4211+ info(logopt, MODPREFIX
4212 "failed to set synchronous call timeout to %d",
4213 timeout.tv_sec);
4214 }
4215@@ -152,16 +149,14 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4216 /* Sane network timeout */
4217 rv = ldap_set_option(ldap, LDAP_OPT_NETWORK_TIMEOUT, &net_timeout);
4218 if (rv != LDAP_OPT_SUCCESS)
4219- info(LOGOPT_ANY,
4220- MODPREFIX "failed to set connection timeout to %d",
4221+ info(logopt, MODPREFIX "failed to set connection timeout to %d",
4222 net_timeout.tv_sec);
4223
4224 #ifdef WITH_SASL
4225 if (ctxt->use_tls) {
4226 if (ctxt->version == 2) {
4227 if (ctxt->tls_required) {
4228- error(LOGOPT_ANY,
4229- MODPREFIX
4230+ error(logopt, MODPREFIX
4231 "TLS required but connection is version 2");
4232 ldap_unbind_ext(ldap, NULL, NULL);
4233 return NULL;
4234@@ -171,16 +166,15 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4235
4236 rv = ldap_start_tls_s(ldap, NULL, NULL);
4237 if (rv != LDAP_SUCCESS) {
4238- unbind_ldap_connection(ldap, ctxt);
4239+ unbind_ldap_connection(logopt, ldap, ctxt);
4240 if (ctxt->tls_required) {
4241- error(LOGOPT_ANY,
4242- MODPREFIX
4243+ error(logopt, MODPREFIX
4244 "TLS required but START_TLS failed: %s",
4245 ldap_err2string(rv));
4246 return NULL;
4247 }
4248 ctxt->use_tls = LDAP_TLS_DONT_USE;
4249- ldap = init_ldap_connection(uri, ctxt);
4250+ ldap = init_ldap_connection(logopt, uri, ctxt);
4251 if (ldap)
4252 ctxt->use_tls = LDAP_TLS_INIT;
4253 return ldap;
4254@@ -192,7 +186,7 @@ LDAP *init_ldap_connection(const char *uri, struct lookup_context *ctxt)
4255 return ldap;
4256 }
4257
4258-static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *class, const char *key)
4259+static int get_query_dn(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt, const char *class, const char *key)
4260 {
4261 char buf[PARSE_MAX_BUF];
4262 char *query, *dn, *qdn;
4263@@ -206,7 +200,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4264 attrs[1] = NULL;
4265
4266 if (!ctxt->mapname && !ctxt->base) {
4267- error(LOGOPT_ANY, MODPREFIX "no master map to lookup");
4268+ error(logopt, MODPREFIX "no master map to lookup");
4269 return 0;
4270 }
4271
4272@@ -218,7 +212,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4273 query = alloca(l);
4274 if (query == NULL) {
4275 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4276- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
4277+ crit(logopt, MODPREFIX "alloca: %s", estr);
4278 return NSS_STATUS_UNAVAIL;
4279 }
4280
4281@@ -229,14 +223,14 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4282 if (ctxt->mapname) {
4283 if (sprintf(query, "(&(objectclass=%s)(%s=%.*s))", class,
4284 key, (int) strlen(ctxt->mapname), ctxt->mapname) >= l) {
4285- debug(LOGOPT_NONE,
4286+ debug(logopt,
4287 MODPREFIX "error forming query string");
4288 return 0;
4289 }
4290 scope = LDAP_SCOPE_SUBTREE;
4291 } else {
4292 if (sprintf(query, "(objectclass=%s)", class) >= l) {
4293- debug(LOGOPT_NONE,
4294+ debug(logopt,
4295 MODPREFIX "error forming query string");
4296 return 0;
4297 }
4298@@ -259,15 +253,14 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4299 else {
4300 struct ldap_searchdn *this = ctxt->sdns;
4301
4302- debug(LOGOPT_NONE, MODPREFIX
4303- "check search base list");
4304+ debug(logopt, MODPREFIX "check search base list");
4305
4306 while (this) {
4307 rv = ldap_search_s(ldap, this->basedn,
4308 scope, query, attrs, 0, &result);
4309
4310 if ((rv == LDAP_SUCCESS) && result) {
4311- debug(LOGOPT_NONE, MODPREFIX
4312+ debug(logopt, MODPREFIX
4313 "found search base under %s",
4314 this->basedn);
4315 break;
4316@@ -283,7 +276,7 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4317 }
4318
4319 if ((rv != LDAP_SUCCESS) || !result) {
4320- error(LOGOPT_NONE,
4321+ error(logopt,
4322 MODPREFIX "query failed for %s: %s",
4323 query, ldap_err2string(rv));
4324 return 0;
4325@@ -292,9 +285,9 @@ static int get_query_dn(LDAP *ldap, struct lookup_context *ctxt, const char *cla
4326 e = ldap_first_entry(ldap, result);
4327 if (e) {
4328 dn = ldap_get_dn(ldap, e);
4329- debug(LOGOPT_NONE, MODPREFIX "found query dn %s", dn);
4330+ debug(logopt, MODPREFIX "found query dn %s", dn);
4331 } else {
4332- debug(LOGOPT_NONE,
4333+ debug(logopt,
4334 MODPREFIX "query succeeded, no matches for %s",
4335 query);
4336 ldap_msgfree(result);
4337@@ -373,7 +366,7 @@ static struct ldap_schema *alloc_common_schema(struct ldap_schema *s)
4338 return schema;
4339 }
4340
4341-static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4342+static int find_query_dn(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4343 {
4344 struct ldap_schema *schema;
4345 unsigned int i;
4346@@ -384,11 +377,10 @@ static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4347 for (i = 0; i < common_schema_count; i++) {
4348 const char *class = common_schema[i].map_class;
4349 const char *key = common_schema[i].map_attr;
4350- if (get_query_dn(ldap, ctxt, class, key)) {
4351+ if (get_query_dn(logopt, ldap, ctxt, class, key)) {
4352 schema = alloc_common_schema(&common_schema[i]);
4353 if (!schema) {
4354- error(LOGOPT_ANY,
4355- MODPREFIX "failed to allocate schema");
4356+ error(logopt, MODPREFIX "failed to allocate schema");
4357 return 0;
4358 }
4359 ctxt->schema = schema;
4360@@ -399,28 +391,26 @@ static int find_query_dn(LDAP *ldap, struct lookup_context *ctxt)
4361 return 0;
4362 }
4363
4364-static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4365+static int do_bind(unsigned logopt, LDAP *ldap, struct lookup_context *ctxt)
4366 {
4367 char *host = NULL, *nhost;
4368 int rv, need_base = 1;
4369
4370 #ifdef WITH_SASL
4371- debug(LOGOPT_NONE, "auth_required: %d, sasl_mech %s",
4372+ debug(logopt, MODPREFIX "auth_required: %d, sasl_mech %s",
4373 ctxt->auth_required, ctxt->sasl_mech);
4374
4375 if (ctxt->sasl_mech ||
4376 (ctxt->auth_required & (LDAP_AUTH_REQUIRED|LDAP_AUTH_AUTODETECT))) {
4377- rv = autofs_sasl_bind(ldap, ctxt);
4378- debug(LOGOPT_NONE, MODPREFIX
4379- "autofs_sasl_bind returned %d", rv);
4380+ rv = autofs_sasl_bind(logopt, ldap, ctxt);
4381+ debug(logopt, MODPREFIX "autofs_sasl_bind returned %d", rv);
4382 } else {
4383- rv = bind_ldap_anonymous(ldap, ctxt);
4384- debug(LOGOPT_NONE,
4385- MODPREFIX "ldap anonymous bind returned %d", rv);
4386+ rv = bind_ldap_anonymous(logopt, ldap, ctxt);
4387+ debug(logopt, MODPREFIX "ldap anonymous bind returned %d", rv);
4388 }
4389 #else
4390- rv = bind_ldap_anonymous(ldap, ctxt);
4391- debug(LOGOPT_NONE, MODPREFIX "ldap anonymous bind returned %d", rv);
4392+ rv = bind_ldap_anonymous(logopt, ldap, ctxt);
4393+ debug(logopt, MODPREFIX "ldap anonymous bind returned %d", rv);
4394 #endif
4395
4396 if (rv != 0)
4397@@ -428,13 +418,13 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4398
4399 rv = ldap_get_option(ldap, LDAP_OPT_HOST_NAME, &host);
4400 if (rv != LDAP_SUCCESS || !host) {
4401- debug(LOGOPT_ANY, "failed to get hostname for connection");
4402+ debug(logopt, "failed to get hostname for connection");
4403 return 0;
4404 }
4405
4406 nhost = strdup(host);
4407 if (!nhost) {
4408- debug(LOGOPT_ANY, "failed to alloc context for hostname");
4409+ debug(logopt, "failed to alloc context for hostname");
4410 return 0;
4411 }
4412 ldap_memfree(host);
4413@@ -463,16 +453,16 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4414 * base dn for searches.
4415 */
4416 if (!ctxt->schema) {
4417- if (!find_query_dn(ldap, ctxt)) {
4418- error(LOGOPT_ANY,
4419- MODPREFIX "failed to find valid query dn");
4420+ if (!find_query_dn(logopt, ldap, ctxt)) {
4421+ warn(logopt,
4422+ MODPREFIX "failed to find valid query dn");
4423 return 0;
4424 }
4425 } else {
4426 const char *class = ctxt->schema->map_class;
4427 const char *key = ctxt->schema->map_attr;
4428- if (!get_query_dn(ldap, ctxt, class, key)) {
4429- error(LOGOPT_ANY, MODPREFIX "failed to get query dn");
4430+ if (!get_query_dn(logopt, ldap, ctxt, class, key)) {
4431+ error(logopt, MODPREFIX "failed to get query dn");
4432 return 0;
4433 }
4434 }
4435@@ -480,23 +470,23 @@ static int do_bind(LDAP *ldap, struct lookup_context *ctxt)
4436 return 1;
4437 }
4438
4439-static LDAP *do_connect(const char *uri, struct lookup_context *ctxt)
4440+static LDAP *do_connect(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4441 {
4442 LDAP *ldap;
4443
4444- ldap = init_ldap_connection(uri, ctxt);
4445+ ldap = init_ldap_connection(logopt, uri, ctxt);
4446 if (!ldap)
4447 return NULL;
4448
4449- if (!do_bind(ldap, ctxt)) {
4450- unbind_ldap_connection(ldap, ctxt);
4451+ if (!do_bind(logopt, ldap, ctxt)) {
4452+ unbind_ldap_connection(logopt, ldap, ctxt);
4453 return NULL;
4454 }
4455
4456 return ldap;
4457 }
4458
4459-static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4460+static LDAP *connect_to_server(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4461 {
4462 LDAP *ldap;
4463
4464@@ -506,19 +496,19 @@ static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4465 * authentication.
4466 */
4467 if (ctxt->auth_required & LDAP_AUTH_REQUIRED) {
4468- ldap = auth_init(uri, ctxt);
4469+ ldap = auth_init(logopt, uri, ctxt);
4470 if (!ldap && ctxt->auth_required & LDAP_AUTH_AUTODETECT)
4471- warn(LOGOPT_NONE,
4472+ info(logopt,
4473 "no authentication mechanisms auto detected.");
4474 if (!ldap) {
4475- error(LOGOPT_ANY, MODPREFIX
4476+ error(logopt, MODPREFIX
4477 "cannot initialize authentication setup");
4478 return NULL;
4479 }
4480
4481- if (!do_bind(ldap, ctxt)) {
4482- unbind_ldap_connection(ldap, ctxt);
4483- error(LOGOPT_ANY, MODPREFIX "cannot bind to server");
4484+ if (!do_bind(logopt, ldap, ctxt)) {
4485+ unbind_ldap_connection(logopt, ldap, ctxt);
4486+ error(logopt, MODPREFIX "cannot bind to server");
4487 return NULL;
4488 }
4489
4490@@ -526,16 +516,18 @@ static LDAP *connect_to_server(const char *uri, struct lookup_context *ctxt)
4491 }
4492 #endif
4493
4494- ldap = do_connect(uri, ctxt);
4495+ ldap = do_connect(logopt, uri, ctxt);
4496 if (!ldap) {
4497- error(LOGOPT_ANY, MODPREFIX "cannot connect to server");
4498+ warn(logopt,
4499+ MODPREFIX "couldn't connect to server %s",
4500+ uri ? uri : "default");
4501 return NULL;
4502 }
4503
4504 return ldap;
4505 }
4506
4507-static LDAP *find_server(struct lookup_context *ctxt)
4508+static LDAP *find_server(unsigned logopt, struct lookup_context *ctxt)
4509 {
4510 LDAP *ldap = NULL;
4511 struct ldap_uri *this;
4512@@ -547,10 +539,9 @@ static LDAP *find_server(struct lookup_context *ctxt)
4513 while(p != ctxt->uri) {
4514 this = list_entry(p, struct ldap_uri, list);
4515 p = p->next;
4516- debug(LOGOPT_ANY, "check uri %s", this->uri);
4517- ldap = connect_to_server(this->uri, ctxt);
4518+ ldap = connect_to_server(logopt, this->uri, ctxt);
4519 if (ldap) {
4520- debug(LOGOPT_ANY, "connexted to uri %s", this->uri);
4521+ info(logopt, "connected to uri %s", this->uri);
4522 break;
4523 }
4524 list_del_init(&this->list);
4525@@ -568,17 +559,17 @@ static LDAP *find_server(struct lookup_context *ctxt)
4526 return ldap;
4527 }
4528
4529-static LDAP *do_reconnect(struct lookup_context *ctxt)
4530+static LDAP *do_reconnect(unsigned logopt, struct lookup_context *ctxt)
4531 {
4532 LDAP *ldap;
4533
4534 if (ctxt->server || !ctxt->uri) {
4535- ldap = do_connect(ctxt->server, ctxt);
4536+ ldap = do_connect(logopt, ctxt->server, ctxt);
4537 return ldap;
4538 } else {
4539 struct ldap_uri *this;
4540 this = list_entry(ctxt->uri->next, struct ldap_uri, list);
4541- ldap = do_connect(this->uri, ctxt);
4542+ ldap = do_connect(logopt, this->uri, ctxt);
4543 if (ldap)
4544 return ldap;
4545 /* Failed to connect, put at end of list */
4546@@ -589,15 +580,15 @@ static LDAP *do_reconnect(struct lookup_context *ctxt)
4547 autofs_sasl_done(ctxt);
4548
4549 /* Current server failed connect, try the rest */
4550- ldap = find_server(ctxt);
4551+ ldap = find_server(logopt, ctxt);
4552 if (!ldap)
4553- error(LOGOPT_ANY, MODPREFIX "failed to find available server");
4554+ error(logopt, MODPREFIX "failed to find available server");
4555
4556 return ldap;
4557 }
4558
4559 #ifdef WITH_SASL
4560-int get_property(xmlNodePtr node, const char *prop, char **value)
4561+int get_property(unsigned logopt, xmlNodePtr node, const char *prop, char **value)
4562 {
4563 xmlChar *ret;
4564 xmlChar *property = (xmlChar *) prop;
4565@@ -608,8 +599,7 @@ int get_property(xmlNodePtr node, const char *prop, char **value)
4566 }
4567
4568 if (!(*value = strdup((char *) ret))) {
4569- error(LOGOPT_ANY,
4570- MODPREFIX "strdup failed with %d", errno);
4571+ logerr(MODPREFIX "strdup failed with %d", errno);
4572 xmlFree(ret);
4573 return -1;
4574 }
4575@@ -645,7 +635,7 @@ int authtype_requires_creds(const char *authtype)
4576 * then no further action is necessary. If it is not, the caller is free
4577 * to then use another method to determine how to connect to the server.
4578 */
4579-int parse_ldap_config(struct lookup_context *ctxt)
4580+int parse_ldap_config(unsigned logopt, struct lookup_context *ctxt)
4581 {
4582 int ret = 0, fallback = 0;
4583 unsigned int auth_required = LDAP_AUTH_NOTREQUIRED;
4584@@ -662,7 +652,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4585
4586 auth_conf = (char *) defaults_get_auth_conf_file();
4587 if (!auth_conf) {
4588- error(LOGOPT_ANY,
4589+ error(logopt,
4590 MODPREFIX "failed to get auth config file name.");
4591 return 0;
4592 }
4593@@ -687,7 +677,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4594 ctxt->client_princ = NULL;
4595 return 0;
4596 }
4597- error(LOGOPT_ANY,
4598+ error(logopt,
4599 MODPREFIX "stat(2) failed with error %s.",
4600 strerror(errno));
4601 return 0;
4602@@ -696,8 +686,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4603 if (!S_ISREG(st.st_mode) ||
4604 st.st_uid != 0 || st.st_gid != 0 ||
4605 (st.st_mode & 0x01ff) != 0600) {
4606- error(LOGOPT_ANY,
4607- MODPREFIX
4608+ error(logopt, MODPREFIX
4609 "Configuration file %s exists, but is not usable. "
4610 "Please make sure that it is owned by root, group "
4611 "is root, and the mode is 0600.",
4612@@ -708,30 +697,29 @@ int parse_ldap_config(struct lookup_context *ctxt)
4613 xmlInitParser();
4614 doc = xmlParseFile(auth_conf);
4615 if (!doc) {
4616- warn(LOGOPT_ANY,
4617- MODPREFIX "xmlParseFile failed for %s.", auth_conf);
4618+ error(logopt, MODPREFIX
4619+ "xmlParseFile failed for %s.", auth_conf);
4620 goto out;
4621 }
4622
4623 root = xmlDocGetRootElement(doc);
4624 if (!root) {
4625- debug(LOGOPT_ANY,
4626- MODPREFIX "empty xml document (%s).", auth_conf);
4627+ debug(logopt, MODPREFIX
4628+ "empty xml document (%s).", auth_conf);
4629 fallback = 1;
4630 goto out;
4631 }
4632
4633 if (xmlStrcmp(root->name, (const xmlChar *)"autofs_ldap_sasl_conf")) {
4634- error(LOGOPT_ANY,
4635- MODPREFIX
4636+ error(logopt, MODPREFIX
4637 "The root node of the XML document %s is not "
4638 "autofs_ldap_sasl_conf.", auth_conf);
4639 goto out;
4640 }
4641
4642- ret = get_property(root, "usetls", &usetls);
4643+ ret = get_property(logopt, root, "usetls", &usetls);
4644 if (ret != 0) {
4645- error(LOGOPT_ANY,
4646+ error(logopt,
4647 MODPREFIX
4648 "Failed read the usetls property from "
4649 "the configuration file %s.", auth_conf);
4650@@ -746,7 +734,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4651 else if (!strcasecmp(usetls, "no"))
4652 use_tls = LDAP_TLS_DONT_USE;
4653 else {
4654- error(LOGOPT_ANY,
4655+ error(logopt,
4656 MODPREFIX
4657 "The usetls property must have value "
4658 "\"yes\" or \"no\".");
4659@@ -756,9 +744,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4660 free(usetls);
4661 }
4662
4663- ret = get_property(root, "tlsrequired", &tlsrequired);
4664+ ret = get_property(logopt, root, "tlsrequired", &tlsrequired);
4665 if (ret != 0) {
4666- error(LOGOPT_ANY,
4667+ error(logopt,
4668 MODPREFIX
4669 "Failed read the tlsrequired property from "
4670 "the configuration file %s.", auth_conf);
4671@@ -773,7 +761,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4672 else if (!strcasecmp(tlsrequired, "no"))
4673 tls_required = LDAP_TLS_DONT_USE;
4674 else {
4675- error(LOGOPT_ANY,
4676+ error(logopt,
4677 MODPREFIX
4678 "The tlsrequired property must have value "
4679 "\"yes\" or \"no\".");
4680@@ -783,9 +771,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4681 free(tlsrequired);
4682 }
4683
4684- ret = get_property(root, "authrequired", &authrequired);
4685+ ret = get_property(logopt, root, "authrequired", &authrequired);
4686 if (ret != 0) {
4687- error(LOGOPT_ANY,
4688+ error(logopt,
4689 MODPREFIX
4690 "Failed read the authrequired property from "
4691 "the configuration file %s.", auth_conf);
4692@@ -802,7 +790,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4693 else if (!strcasecmp(authrequired, "autodetect"))
4694 auth_required = LDAP_AUTH_AUTODETECT;
4695 else {
4696- error(LOGOPT_ANY,
4697+ error(logopt,
4698 MODPREFIX
4699 "The authrequired property must have value "
4700 "\"yes\", \"no\" or \"autodetect\".");
4701@@ -812,9 +800,9 @@ int parse_ldap_config(struct lookup_context *ctxt)
4702 free(authrequired);
4703 }
4704
4705- ret = get_property(root, "authtype", &authtype);
4706+ ret = get_property(logopt, root, "authtype", &authtype);
4707 if (ret != 0) {
4708- error(LOGOPT_ANY,
4709+ error(logopt,
4710 MODPREFIX
4711 "Failed read the authtype property from the "
4712 "configuration file %s.", auth_conf);
4713@@ -822,10 +810,10 @@ int parse_ldap_config(struct lookup_context *ctxt)
4714 }
4715
4716 if (authtype && authtype_requires_creds(authtype)) {
4717- ret = get_property(root, "user", &user);
4718- ret |= get_property(root, "secret", &secret);
4719+ ret = get_property(logopt, root, "user", &user);
4720+ ret |= get_property(logopt, root, "secret", &secret);
4721 if (ret != 0 || (!user || !secret)) {
4722- error(LOGOPT_ANY,
4723+ error(logopt,
4724 MODPREFIX
4725 "%s authentication type requires a username "
4726 "and a secret. Please fix your configuration "
4727@@ -845,7 +833,7 @@ int parse_ldap_config(struct lookup_context *ctxt)
4728 * We allow the admin to specify the principal to use for the
4729 * client. The default is "autofsclient/hostname@REALM".
4730 */
4731- (void)get_property(root, "clientprinc", &client_princ);
4732+ (void)get_property(logopt, root, "clientprinc", &client_princ);
4733
4734 ctxt->auth_conf = auth_conf;
4735 ctxt->use_tls = use_tls;
4736@@ -856,15 +844,15 @@ int parse_ldap_config(struct lookup_context *ctxt)
4737 ctxt->secret = secret;
4738 ctxt->client_princ = client_princ;
4739
4740- debug(LOGOPT_NONE,
4741+ debug(logopt, MODPREFIX
4742 "ldap authentication configured with the following options:");
4743- debug(LOGOPT_NONE,
4744+ debug(logopt, MODPREFIX
4745 "use_tls: %u, "
4746 "tls_required: %u, "
4747 "auth_required: %u, "
4748 "sasl_mech: %s",
4749 use_tls, tls_required, auth_required, authtype);
4750- debug(LOGOPT_NONE,
4751+ debug(logopt, MODPREFIX
4752 "user: %s, "
4753 "secret: %s, "
4754 "client principal: %s",
4755@@ -889,7 +877,7 @@ out:
4756 * Returns ldap connection on success, with authtype, user and secret
4757 * filled in as appropriate. Returns NULL on failre.
4758 */
4759-static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4760+static LDAP *auth_init(unsigned logopt, const char *uri, struct lookup_context *ctxt)
4761 {
4762 int ret;
4763 LDAP *ldap;
4764@@ -900,11 +888,11 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4765 * if the permissions on the file were incorrect, or if the
4766 * specified authentication type is not valid.
4767 */
4768- ret = parse_ldap_config(ctxt);
4769+ ret = parse_ldap_config(logopt, ctxt);
4770 if (ret)
4771 return NULL;
4772
4773- ldap = init_ldap_connection(uri, ctxt);
4774+ ldap = init_ldap_connection(logopt, uri, ctxt);
4775 if (!ldap)
4776 return NULL;
4777
4778@@ -916,7 +904,7 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4779 * to use. If kerberos is used, it will also take care to initialize
4780 * the credential cache and the client and service principals.
4781 */
4782- ret = autofs_sasl_init(ldap, ctxt);
4783+ ret = autofs_sasl_init(logopt, ldap, ctxt);
4784 if (ret) {
4785 ctxt->sasl_mech = NULL;
4786 return NULL;
4787@@ -930,7 +918,7 @@ static LDAP *auth_init(const char *uri, struct lookup_context *ctxt)
4788 * Take an input string as specified in the master map, and break it
4789 * down into a server name and basedn.
4790 */
4791-static int parse_server_string(const char *url, struct lookup_context *ctxt)
4792+static int parse_server_string(unsigned logopt, const char *url, struct lookup_context *ctxt)
4793 {
4794 char buf[MAX_ERR_BUF], *tmp = NULL, proto[9];
4795 const char *ptr, *name;
4796@@ -939,8 +927,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4797 memset(proto, 0, 9);
4798 ptr = url;
4799
4800- debug(LOGOPT_NONE,
4801- MODPREFIX
4802+ debug(logopt, MODPREFIX
4803 "Attempting to parse LDAP information from string \"%s\".", ptr);
4804
4805 ctxt->port = LDAP_PORT;
4806@@ -974,7 +961,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4807 if (!tmp) {
4808 char *estr;
4809 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4810- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4811+ logerr(MODPREFIX "malloc: %s", estr);
4812 return 0;
4813 }
4814 ctxt->server = tmp;
4815@@ -987,7 +974,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4816 memcpy(ctxt->server, s, l);
4817 ptr = q + 1;
4818 } else {
4819- crit(LOGOPT_ANY,
4820+ crit(logopt,
4821 MODPREFIX "invalid LDAP map syntax %s", ptr);
4822 return 0;
4823 /* TODO: why did I put this here, the parser shouldn't let this by
4824@@ -996,7 +983,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4825 if (!tmp) {
4826 char *estr;
4827 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4828- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4829+ crit(logopt, MODPREFIX "malloc: %s", estr);
4830 return 0;
4831 }
4832 ctxt->server = tmp;
4833@@ -1014,7 +1001,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4834 q++;
4835
4836 if (*q != ':') {
4837- crit(LOGOPT_ANY,
4838+ crit(logopt,
4839 MODPREFIX "invalid LDAP map syntax %s", ptr);
4840 return 0;
4841 }
4842@@ -1031,7 +1018,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4843 if (!tmp) {
4844 char *estr;
4845 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4846- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4847+ logerr(MODPREFIX "malloc: %s", estr);
4848 return 0;
4849 }
4850 ctxt->server = tmp;
4851@@ -1072,7 +1059,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4852 else {
4853 char *estr;
4854 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4855- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4856+ logerr(MODPREFIX "malloc: %s", estr);
4857 if (ctxt->server)
4858 free(ctxt->server);
4859 return 0;
4860@@ -1083,7 +1070,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4861 if (!base) {
4862 char *estr;
4863 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4864- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4865+ logerr(MODPREFIX "malloc: %s", estr);
4866 if (ctxt->server)
4867 free(ctxt->server);
4868 return 0;
4869@@ -1097,7 +1084,7 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4870 if (!map) {
4871 char *estr;
4872 estr = strerror_r(errno, buf, MAX_ERR_BUF);
4873- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4874+ logerr(MODPREFIX "malloc: %s", estr);
4875 if (ctxt->server)
4876 free(ctxt->server);
4877 return 0;
4878@@ -1109,16 +1096,16 @@ static int parse_server_string(const char *url, struct lookup_context *ctxt)
4879
4880 if (!ctxt->server && *proto) {
4881 if (!strncmp(proto, "ldaps", 5)) {
4882- warn(LOGOPT_ANY, MODPREFIX
4883+ info(logopt, MODPREFIX
4884 "server must be given to force ldaps, connection "
4885 "will use LDAP client configured protocol");
4886 }
4887 }
4888 done:
4889 if (ctxt->mapname)
4890- debug(LOGOPT_NONE, MODPREFIX "mapname %s", ctxt->mapname);
4891+ debug(logopt, MODPREFIX "mapname %s", ctxt->mapname);
4892 else
4893- debug(LOGOPT_NONE, MODPREFIX "server \"%s\", base dn \"%s\"",
4894+ debug(logopt, MODPREFIX "server \"%s\", base dn \"%s\"",
4895 ctxt->server ? ctxt->server : "(default)",
4896 ctxt->base);
4897
4898@@ -1175,8 +1162,6 @@ static void validate_uris(struct list_head *list)
4899
4900 /* At least we get some basic validation */
4901 if (!ldap_is_ldap_url(this->uri)) {
4902- warn(LOGOPT_ANY,
4903- "removed invalid uri from list, %s", this->uri);
4904 list_del(&this->list);
4905 free(this->uri);
4906 free(this);
4907@@ -1202,7 +1187,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4908 ctxt = malloc(sizeof(struct lookup_context));
4909 if (!ctxt) {
4910 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4911- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
4912+ logerr(MODPREFIX "malloc: %s", estr);
4913 return 1;
4914 }
4915 memset(ctxt, 0, sizeof(struct lookup_context));
4916@@ -1215,7 +1200,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4917 * Parse out the server name and base dn, and fill them
4918 * into the proper places in the lookup context structure.
4919 */
4920- if (!parse_server_string(argv[0], ctxt)) {
4921+ if (!parse_server_string(LOGOPT_NONE, argv[0], ctxt)) {
4922 error(LOGOPT_ANY, MODPREFIX "cannot parse server string");
4923 free_context(ctxt);
4924 return 1;
4925@@ -1236,13 +1221,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4926 }
4927
4928 if (ctxt->server || !ctxt->uri) {
4929- ldap = connect_to_server(ctxt->server, ctxt);
4930+ ldap = connect_to_server(LOGOPT_NONE, ctxt->server, ctxt);
4931 if (!ldap) {
4932 free_context(ctxt);
4933 return 1;
4934 }
4935 } else {
4936- ldap = find_server(ctxt);
4937+ ldap = find_server(LOGOPT_NONE, ctxt);
4938 if (!ldap) {
4939 free_context(ctxt);
4940 error(LOGOPT_ANY, MODPREFIX
4941@@ -1250,13 +1235,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
4942 return 1;
4943 }
4944 }
4945- unbind_ldap_connection(ldap, ctxt);
4946+ unbind_ldap_connection(LOGOPT_ANY, ldap, ctxt);
4947
4948 /* Open the parser, if we can. */
4949 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
4950 if (!ctxt->parse) {
4951 free_context(ctxt);
4952- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
4953+ logerr(MODPREFIX "failed to open parse context");
4954 return 1;
4955 }
4956 *context = ctxt;
4957@@ -1269,6 +1254,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
4958 struct lookup_context *ctxt = (struct lookup_context *) context;
4959 unsigned int timeout = master->default_timeout;
4960 unsigned int logging = master->default_logging;
4961+ unsigned int logopt = master->logopt;
4962 int rv, l, count, blen;
4963 char buf[PARSE_MAX_BUF];
4964 char *query;
4965@@ -1293,45 +1279,44 @@ int lookup_read_master(struct master *master, time_t age, void *context)
4966 query = alloca(l);
4967 if (query == NULL) {
4968 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
4969- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
4970+ logerr(MODPREFIX "alloca: %s", estr);
4971 return NSS_STATUS_UNAVAIL;
4972 }
4973
4974 if (sprintf(query, "(objectclass=%s)", class) >= l) {
4975- debug(LOGOPT_NONE, MODPREFIX "error forming query string");
4976+ error(logopt, MODPREFIX "error forming query string");
4977 return NSS_STATUS_UNAVAIL;
4978 }
4979 query[l] = '\0';
4980
4981 /* Initialize the LDAP context. */
4982- ldap = do_reconnect(ctxt);
4983+ ldap = do_reconnect(logopt, ctxt);
4984 if (!ldap)
4985 return NSS_STATUS_UNAVAIL;
4986
4987 /* Look around. */
4988- debug(LOGOPT_NONE,
4989+ debug(logopt,
4990 MODPREFIX "searching for \"%s\" under \"%s\"", query, ctxt->qdn);
4991
4992 rv = ldap_search_s(ldap, ctxt->qdn, scope, query, attrs, 0, &result);
4993
4994 if ((rv != LDAP_SUCCESS) || !result) {
4995- error(LOGOPT_NONE,
4996- MODPREFIX "query failed for %s: %s",
4997+ error(logopt, MODPREFIX "query failed for %s: %s",
4998 query, ldap_err2string(rv));
4999- unbind_ldap_connection(ldap, ctxt);
5000+ unbind_ldap_connection(logging, ldap, ctxt);
5001 return NSS_STATUS_NOTFOUND;
5002 }
5003
5004 e = ldap_first_entry(ldap, result);
5005 if (!e) {
5006- debug(LOGOPT_NONE,
5007+ debug(logopt,
5008 MODPREFIX "query succeeded, no matches for %s",
5009 query);
5010 ldap_msgfree(result);
5011- unbind_ldap_connection(ldap, ctxt);
5012+ unbind_ldap_connection(logging, ldap, ctxt);
5013 return NSS_STATUS_NOTFOUND;
5014 } else
5015- debug(LOGOPT_NONE, MODPREFIX "examining entries");
5016+ debug(logopt, MODPREFIX "examining entries");
5017
5018 while (e) {
5019 keyValue = ldap_get_values(ldap, e, entry);
5020@@ -1346,7 +1331,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5021 * each map entry
5022 */
5023 if (ldap_count_values(keyValue) > 1) {
5024- error(LOGOPT_ANY,
5025+ error(logopt,
5026 MODPREFIX
5027 "key %s has duplicate entries - ignoring",
5028 *keyValue);
5029@@ -1358,7 +1343,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5030 * inclusion is only valid in file maps.
5031 */
5032 if (**keyValue == '+') {
5033- warn(LOGOPT_ANY,
5034+ warn(logopt,
5035 MODPREFIX
5036 "ignoreing '+' map entry - not in file map");
5037 goto next;
5038@@ -1366,7 +1351,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5039
5040 values = ldap_get_values(ldap, e, info);
5041 if (!values || !*values) {
5042- debug(LOGOPT_NONE,
5043+ debug(logopt,
5044 MODPREFIX "no %s defined for %s", info, query);
5045 goto next;
5046 }
5047@@ -1376,7 +1361,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5048 */
5049 count = ldap_count_values(values);
5050 if (count > 1) {
5051- error(LOGOPT_ANY,
5052+ error(logopt,
5053 MODPREFIX
5054 "one value per key allowed in master map");
5055 ldap_value_free(values);
5056@@ -1385,7 +1370,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5057
5058 blen = strlen(*keyValue) + 1 + strlen(*values) + 1;
5059 if (blen > PARSE_MAX_BUF) {
5060- error(LOGOPT_ANY, MODPREFIX "map entry too long");
5061+ error(logopt, MODPREFIX "map entry too long");
5062 ldap_value_free(values);
5063 goto next;
5064 }
5065@@ -1403,7 +1388,7 @@ next:
5066
5067 /* Clean up. */
5068 ldap_msgfree(result);
5069- unbind_ldap_connection(ldap, ctxt);
5070+ unbind_ldap_connection(logopt, ldap, ctxt);
5071
5072 return NSS_STATUS_SUCCESS;
5073 }
5074@@ -1445,7 +1430,7 @@ static int read_one_map(struct autofs_point *ap,
5075 query = alloca(l);
5076 if (query == NULL) {
5077 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5078- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5079+ logerr(MODPREFIX "malloc: %s", estr);
5080 return NSS_STATUS_UNAVAIL;
5081 }
5082
5083@@ -1456,7 +1441,7 @@ static int read_one_map(struct autofs_point *ap,
5084 query[l] = '\0';
5085
5086 /* Initialize the LDAP context. */
5087- ldap = do_reconnect(ctxt);
5088+ ldap = do_reconnect(ap->logopt, ctxt);
5089 if (!ldap)
5090 return NSS_STATUS_UNAVAIL;
5091
5092@@ -1470,7 +1455,7 @@ static int read_one_map(struct autofs_point *ap,
5093 debug(ap->logopt,
5094 MODPREFIX "query failed for %s: %s",
5095 query, ldap_err2string(rv));
5096- unbind_ldap_connection(ldap, ctxt);
5097+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5098 *result_ldap = rv;
5099 return NSS_STATUS_NOTFOUND;
5100 }
5101@@ -1480,7 +1465,7 @@ static int read_one_map(struct autofs_point *ap,
5102 debug(ap->logopt,
5103 MODPREFIX "query succeeded, no matches for %s", query);
5104 ldap_msgfree(result);
5105- unbind_ldap_connection(ldap, ctxt);
5106+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5107 return NSS_STATUS_NOTFOUND;
5108 } else
5109 debug(ap->logopt, MODPREFIX "examining entries");
5110@@ -1612,8 +1597,7 @@ static int read_one_map(struct autofs_point *ap,
5111 if (!mapent) {
5112 char *estr;
5113 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5114- error(ap->logopt,
5115- MODPREFIX "malloc: %s", estr);
5116+ logerr(MODPREFIX "malloc: %s", estr);
5117 ldap_value_free_len(bvValues);
5118 goto next;
5119 }
5120@@ -1633,8 +1617,7 @@ static int read_one_map(struct autofs_point *ap,
5121 } else {
5122 char *estr;
5123 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5124- error(ap->logopt,
5125- MODPREFIX "realloc: %s", estr);
5126+ logerr(MODPREFIX "realloc: %s", estr);
5127 }
5128 }
5129 }
5130@@ -1669,7 +1652,7 @@ next:
5131
5132 /* Clean up. */
5133 ldap_msgfree(result);
5134- unbind_ldap_connection(ldap, ctxt);
5135+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5136
5137 source->age = age;
5138
5139@@ -1766,7 +1749,7 @@ static int lookup_one(struct autofs_point *ap,
5140 query[ql] = '\0';
5141
5142 /* Initialize the LDAP context. */
5143- ldap = do_reconnect(ctxt);
5144+ ldap = do_reconnect(ap->logopt, ctxt);
5145 if (!ldap)
5146 return CHE_FAIL;
5147
5148@@ -1777,7 +1760,7 @@ static int lookup_one(struct autofs_point *ap,
5149
5150 if ((rv != LDAP_SUCCESS) || !result) {
5151 crit(ap->logopt, MODPREFIX "query failed for %s", query);
5152- unbind_ldap_connection(ldap, ctxt);
5153+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5154 return CHE_FAIL;
5155 }
5156
5157@@ -1789,7 +1772,7 @@ static int lookup_one(struct autofs_point *ap,
5158 debug(ap->logopt,
5159 MODPREFIX "got answer, but no entry for %s", query);
5160 ldap_msgfree(result);
5161- unbind_ldap_connection(ldap, ctxt);
5162+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5163 return CHE_MISSING;
5164 }
5165
5166@@ -1897,8 +1880,7 @@ static int lookup_one(struct autofs_point *ap,
5167 if (!mapent) {
5168 char *estr;
5169 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5170- error(ap->logopt,
5171- MODPREFIX "malloc: %s", estr);
5172+ logerr(MODPREFIX "malloc: %s", estr);
5173 ldap_value_free_len(bvValues);
5174 goto next;
5175 }
5176@@ -1918,8 +1900,7 @@ static int lookup_one(struct autofs_point *ap,
5177 } else {
5178 char *estr;
5179 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5180- error(ap->logopt,
5181- MODPREFIX "realloc: %s", estr);
5182+ logerr(MODPREFIX "realloc: %s", estr);
5183 }
5184 }
5185 }
5186@@ -1955,7 +1936,7 @@ next:
5187 }
5188
5189 ldap_msgfree(result);
5190- unbind_ldap_connection(ldap, ctxt);
5191+ unbind_ldap_connection(ap->logopt, ldap, ctxt);
5192
5193 /* Failed to find wild entry, update cache if needed */
5194 pthread_cleanup_push(cache_lock_cleanup, mc);
5195diff --git a/modules/lookup_multi.c b/modules/lookup_multi.c
5196index 8fa94ae..601d48e 100644
5197--- a/modules/lookup_multi.c
5198+++ b/modules/lookup_multi.c
5199@@ -73,7 +73,7 @@ static struct lookup_mod *nss_open_lookup(const char *format, int argc, const ch
5200 if (nsswitch_parse(&nsslist)) {
5201 if (!list_empty(&nsslist))
5202 free_sources(&nsslist);
5203- error(LOGOPT_ANY, "can't to read name service switch config.");
5204+ logerr("can't to read name service switch config.");
5205 return NULL;
5206 }
5207
5208@@ -92,7 +92,7 @@ static struct lookup_mod *nss_open_lookup(const char *format, int argc, const ch
5209 path = malloc(strlen(AUTOFS_MAP_DIR) + strlen(argv[0]) + 2);
5210 if (!path) {
5211 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5212- crit(LOGOPT_ANY, MODPREFIX "error: %s", estr);
5213+ logerr(MODPREFIX "error: %s", estr);
5214 free_sources(&nsslist);
5215 return NULL;
5216 }
5217@@ -150,7 +150,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5218 memset(ctxt, 0, sizeof(struct lookup_context));
5219
5220 if (argc < 1) {
5221- crit(LOGOPT_ANY, MODPREFIX "No map list");
5222+ logerr(MODPREFIX "No map list");
5223 goto error_out;
5224 }
5225
5226@@ -176,8 +176,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5227 if (!strcmp(ctxt->argl[an], "--")) {
5228 ctxt->argl[an] = NULL;
5229 if (!args) {
5230- crit(LOGOPT_ANY,
5231- MODPREFIX "error assigning map args");
5232+ logerr(MODPREFIX "error assigning map args");
5233 goto error_out;
5234 }
5235 ctxt->m[i].argv = copy_argv(ctxt->m[i].argc, (const char **) args);
5236@@ -201,7 +200,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5237 ctxt->m[i].mod = nss_open_lookup(my_mapfmt,
5238 ctxt->m[i].argc, ctxt->m[i].argv);
5239 if (!ctxt->m[i].mod) {
5240- error(LOGOPT_ANY, MODPREFIX "error opening module");
5241+ logerr(MODPREFIX "error opening module");
5242 goto error_out;
5243 }
5244 }
5245@@ -211,7 +210,7 @@ int lookup_init(const char *my_mapfmt, int argc, const char *const *argv, void *
5246
5247 nomem:
5248 estr = strerror_r(errno, buf, MAX_ERR_BUF);
5249- crit(LOGOPT_ANY, MODPREFIX "error: %s", estr);
5250+ logerr(MODPREFIX "error: %s", estr);
5251 error_out:
5252 if (ctxt) {
5253 for (i = 0; i < ctxt->n; i++) {
5254diff --git a/modules/lookup_nisplus.c b/modules/lookup_nisplus.c
5255index 83e99e0..ff8bd49 100644
5256--- a/modules/lookup_nisplus.c
5257+++ b/modules/lookup_nisplus.c
5258@@ -41,13 +41,13 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5259 ctxt = malloc(sizeof(struct lookup_context));
5260 if (!ctxt) {
5261 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5262- crit(LOGOPT_ANY, MODPREFIX "%s", estr);
5263+ logerr(MODPREFIX "%s", estr);
5264 return 1;
5265 }
5266
5267 if (argc < 1) {
5268 free(ctxt);
5269- crit(LOGOPT_ANY, MODPREFIX "No map name");
5270+ logmsg(MODPREFIX "No map name");
5271 return 1;
5272 }
5273 ctxt->mapname = argv[0];
5274@@ -59,7 +59,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5275 ctxt->domainname = nis_local_directory();
5276 if (!ctxt->domainname) {
5277 free(ctxt);
5278- crit(LOGOPT_ANY, MODPREFIX "NIS+ domain not set");
5279+ logmsg(MODPREFIX "NIS+ domain not set");
5280 return 1;
5281 }
5282
5283@@ -69,7 +69,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5284 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5285 if (!ctxt->parse) {
5286 free(ctxt);
5287- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5288+ logerr(MODPREFIX "failed to open parse context");
5289 return 1;
5290 }
5291 *context = ctxt;
5292@@ -81,7 +81,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5293 {
5294 struct lookup_context *ctxt = (struct lookup_context *) context;
5295 unsigned int timeout = master->default_timeout;
5296- unsigned int logging = master->default_logging;
5297+ unsigned int logging = master->default_logging;
5298+ unsigned int logopt = master->logopt;
5299 char *tablename;
5300 nis_result *result;
5301 nis_object *this;
5302@@ -95,7 +96,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5303 tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5304 if (!tablename) {
5305 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5306- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5307+ logerr(MODPREFIX "alloca: %s", estr);
5308 pthread_setcancelstate(cur_state, NULL);
5309 return NSS_STATUS_UNAVAIL;
5310 }
5311@@ -105,8 +106,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5312 result = nis_lookup(tablename, FOLLOW_PATH | FOLLOW_LINKS);
5313 if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5314 nis_freeresult(result);
5315- crit(LOGOPT_ANY,
5316- MODPREFIX "couldn't locat nis+ table %s", ctxt->mapname);
5317+ crit(logopt,
5318+ MODPREFIX "couldn't locate nis+ table %s", ctxt->mapname);
5319 pthread_setcancelstate(cur_state, NULL);
5320 return NSS_STATUS_NOTFOUND;
5321 }
5322@@ -116,7 +117,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5323 result = nis_list(tablename, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
5324 if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5325 nis_freeresult(result);
5326- crit(LOGOPT_ANY,
5327+ crit(logopt,
5328 MODPREFIX "couldn't enumrate nis+ map %s", ctxt->mapname);
5329 pthread_setcancelstate(cur_state, NULL);
5330 return NSS_STATUS_UNAVAIL;
5331@@ -139,8 +140,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5332
5333 buffer = malloc(ENTRY_LEN(this, 0) + 1 + ENTRY_LEN(this, 1) + 1);
5334 if (!buffer) {
5335- error(LOGOPT_ANY,
5336- MODPREFIX "could not malloc parse buffer");
5337+ logerr(MODPREFIX "could not malloc parse buffer");
5338 continue;
5339 }
5340
5341@@ -182,7 +182,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5342 tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5343 if (!tablename) {
5344 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5345- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5346+ logerr(MODPREFIX "alloca: %s", estr);
5347 pthread_setcancelstate(cur_state, NULL);
5348 return NSS_STATUS_UNAVAIL;
5349 }
5350@@ -193,7 +193,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5351 if (result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) {
5352 nis_freeresult(result);
5353 crit(ap->logopt,
5354- MODPREFIX "couldn't locat nis+ table %s", ctxt->mapname);
5355+ MODPREFIX "couldn't locate nis+ table %s", ctxt->mapname);
5356 pthread_setcancelstate(cur_state, NULL);
5357 return NSS_STATUS_NOTFOUND;
5358 }
5359@@ -274,7 +274,7 @@ static int lookup_one(struct autofs_point *ap,
5360 strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5361 if (!tablename) {
5362 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5363- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5364+ logerr(MODPREFIX "alloca: %s", estr);
5365 pthread_setcancelstate(cur_state, NULL);
5366 return -1;
5367 }
5368@@ -327,7 +327,7 @@ static int lookup_wild(struct autofs_point *ap, struct lookup_context *ctxt)
5369 tablename = alloca(strlen(ctxt->mapname) + strlen(ctxt->domainname) + 20);
5370 if (!tablename) {
5371 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5372- crit(LOGOPT_ANY, MODPREFIX "alloca: %s", estr);
5373+ logerr(MODPREFIX "alloca: %s", estr);
5374 pthread_setcancelstate(cur_state, NULL);
5375 return -1;
5376 }
5377diff --git a/modules/lookup_program.c b/modules/lookup_program.c
5378index 2fd521a..e28168e 100644
5379--- a/modules/lookup_program.c
5380+++ b/modules/lookup_program.c
5381@@ -51,28 +51,26 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5382 ctxt = malloc(sizeof(struct lookup_context));
5383 if (!ctxt) {
5384 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5385- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5386+ logerr(MODPREFIX "malloc: %s", estr);
5387 return 1;
5388 }
5389
5390 if (argc < 1) {
5391- crit(LOGOPT_ANY, MODPREFIX "No map name");
5392+ logmsg(MODPREFIX "No map name");
5393 free(ctxt);
5394 return 1;
5395 }
5396 ctxt->mapname = argv[0];
5397
5398 if (ctxt->mapname[0] != '/') {
5399- crit(LOGOPT_ANY,
5400- MODPREFIX "program map %s is not an absolute pathname",
5401+ logmsg(MODPREFIX "program map %s is not an absolute pathname",
5402 ctxt->mapname);
5403 free(ctxt);
5404 return 1;
5405 }
5406
5407 if (access(ctxt->mapname, X_OK)) {
5408- crit(LOGOPT_ANY,
5409- MODPREFIX "program map %s missing or not executable",
5410+ logmsg(MODPREFIX "program map %s missing or not executable",
5411 ctxt->mapname);
5412 free(ctxt);
5413 return 1;
5414@@ -83,7 +81,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5415
5416 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5417 if (!ctxt->parse) {
5418- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5419+ logmsg(MODPREFIX "failed to open parse context");
5420 free(ctxt);
5421 return 1;
5422 }
5423@@ -163,7 +161,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5424 mapent = (char *) malloc(MAPENT_MAX_LEN + 1);
5425 if (!mapent) {
5426 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5427- error(ap->logopt, MODPREFIX "malloc: %s", estr);
5428+ logerr(MODPREFIX "malloc: %s", estr);
5429 return NSS_STATUS_UNAVAIL;
5430 }
5431
5432@@ -176,7 +174,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5433 */
5434 if (pipe(pipefd)) {
5435 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5436- error(ap->logopt, MODPREFIX "pipe: %s", estr);
5437+ logerr(MODPREFIX "pipe: %s", estr);
5438 goto out_free;
5439 }
5440 if (pipe(epipefd)) {
5441@@ -188,7 +186,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5442 f = fork();
5443 if (f < 0) {
5444 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5445- error(ap->logopt, MODPREFIX "fork: %s", estr);
5446+ logerr(MODPREFIX "fork: %s", estr);
5447 close(pipefd[0]);
5448 close(pipefd[1]);
5449 close(epipefd[0]);
5450@@ -271,8 +269,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5451 ++alloci));
5452 if (!tmp) {
5453 alloci--;
5454- error(ap->logopt,
5455- MODPREFIX "realloc: %s",
5456+ logerr(MODPREFIX "realloc: %s",
5457 strerror(errno));
5458 break;
5459 }
5460@@ -308,12 +305,12 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5461 } else if (ch == '\n') {
5462 *errp = '\0';
5463 if (errbuf[0])
5464- error(ap->logopt, ">> %s", errbuf);
5465+ logmsg(">> %s", errbuf);
5466 errp = errbuf;
5467 } else {
5468 if (errp >= &errbuf[1023]) {
5469 *errp = '\0';
5470- error(ap->logopt, ">> %s", errbuf);
5471+ logmsg(">> %s", errbuf);
5472 errp = errbuf;
5473 }
5474 *(errp++) = ch;
5475@@ -325,7 +322,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5476 *mapp = '\0';
5477 if (errp > errbuf) {
5478 *errp = '\0';
5479- error(ap->logopt, ">> %s", errbuf);
5480+ logmsg(">> %s", errbuf);
5481 }
5482
5483 close(pipefd[0]);
5484@@ -333,12 +330,12 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5485
5486 if (waitpid(f, &status, 0) != f) {
5487 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5488- error(ap->logopt, MODPREFIX "waitpid: %s", estr);
5489+ logerr(MODPREFIX "waitpid: %s", estr);
5490 goto out_free;
5491 }
5492
5493 if (mapp == mapent || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
5494- msg(MODPREFIX "lookup for %s failed", name);
5495+ info(ap->logopt, MODPREFIX "lookup for %s failed", name);
5496 goto out_free;
5497 }
5498
5499diff --git a/modules/lookup_userhome.c b/modules/lookup_userhome.c
5500index efcab0b..680ddaf 100644
5501--- a/modules/lookup_userhome.c
5502+++ b/modules/lookup_userhome.c
5503@@ -73,7 +73,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5504 /* Create the appropriate symlink */
5505 if (chdir(ap->path)) {
5506 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5507- error(ap->logopt, MODPREFIX "chdir failed: %s", estr);
5508+ logerr(MODPREFIX "chdir failed: %s", estr);
5509 return NSS_STATUS_UNAVAIL;
5510 }
5511
5512@@ -88,7 +88,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
5513
5514 if (symlink(pw->pw_dir, name) && errno != EEXIST) {
5515 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5516- error(ap->logopt, MODPREFIX "symlink failed: %s", estr);
5517+ logerr(MODPREFIX "symlink failed: %s", estr);
5518 return NSS_STATUS_UNAVAIL;
5519 }
5520
5521diff --git a/modules/lookup_yp.c b/modules/lookup_yp.c
5522index da280cc..63fc8e3 100644
5523--- a/modules/lookup_yp.c
5524+++ b/modules/lookup_yp.c
5525@@ -45,12 +45,14 @@ struct lookup_context {
5526 struct callback_master_data {
5527 unsigned timeout;
5528 unsigned logging;
5529+ unsigned logopt;
5530 time_t age;
5531 };
5532
5533 struct callback_data {
5534 struct autofs_point *ap;
5535 struct map_source *source;
5536+ unsigned logopt;
5537 time_t age;
5538 };
5539
5540@@ -111,20 +113,18 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5541 ctxt = malloc(sizeof(struct lookup_context));
5542 if (!ctxt) {
5543 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5544- crit(LOGOPT_ANY, MODPREFIX "%s", estr);
5545+ logerr(MODPREFIX "%s", estr);
5546 return 1;
5547 }
5548 memset(ctxt, 0, sizeof(struct lookup_context));
5549
5550 if (argc < 1) {
5551 free(ctxt);
5552- crit(LOGOPT_ANY, MODPREFIX "no map name");
5553+ logerr(MODPREFIX "no map name");
5554 return 1;
5555 }
5556 ctxt->mapname = argv[0];
5557
5558- debug(LOGOPT_NONE, MODPREFIX "ctxt->mapname=%s", ctxt->mapname);
5559-
5560 /* This should, but doesn't, take a const char ** */
5561 err = yp_get_default_domain((char **) &ctxt->domainname);
5562 if (err) {
5563@@ -133,8 +133,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5564 memcpy(name, ctxt->mapname, len);
5565 name[len] = '\0';
5566 free(ctxt);
5567- debug(LOGOPT_NONE, MODPREFIX "map %s: %s", name,
5568- yperr_string(err));
5569+ logerr(MODPREFIX "map %s: %s", name, yperr_string(err));
5570 return 1;
5571 }
5572
5573@@ -146,7 +145,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
5574 ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
5575 if (!ctxt->parse) {
5576 free(ctxt);
5577- crit(LOGOPT_ANY, MODPREFIX "failed to open parse context");
5578+ logmsg(MODPREFIX "failed to open parse context");
5579 return 1;
5580 }
5581 *context = ctxt;
5582@@ -161,6 +160,7 @@ int yp_all_master_callback(int status, char *ypkey, int ypkeylen,
5583 (struct callback_master_data *) ypcb_data;
5584 unsigned int timeout = cbdata->timeout;
5585 unsigned int logging = cbdata->logging;
5586+ unsigned int logopt = cbdata->logopt;
5587 time_t age = cbdata->age;
5588 char *buffer;
5589 unsigned int len;
5590@@ -182,7 +182,7 @@ int yp_all_master_callback(int status, char *ypkey, int ypkeylen,
5591
5592 buffer = alloca(len);
5593 if (!buffer) {
5594- error(LOGOPT_ANY, MODPREFIX "could not malloc parse buffer");
5595+ error(logopt, MODPREFIX "could not malloc parse buffer");
5596 return 0;
5597 }
5598 memset(buffer, 0, len);
5599@@ -201,6 +201,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5600 struct lookup_context *ctxt = (struct lookup_context *) context;
5601 struct ypall_callback ypcb;
5602 struct callback_master_data ypcb_data;
5603+ unsigned int logging = master->default_logging;
5604+ unsigned int logopt = master->logopt;
5605 char *mapname;
5606 int err;
5607
5608@@ -211,7 +213,8 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5609 strcpy(mapname, ctxt->mapname);
5610
5611 ypcb_data.timeout = master->default_timeout;
5612- ypcb_data.logging = master->default_logging;
5613+ ypcb_data.logging = logging;
5614+ ypcb_data.logopt = logopt;
5615 ypcb_data.age = age;
5616
5617 ypcb.foreach = yp_all_master_callback;
5618@@ -232,7 +235,7 @@ int lookup_read_master(struct master *master, time_t age, void *context)
5619 if (err == YPERR_SUCCESS)
5620 return NSS_STATUS_SUCCESS;
5621
5622- warn(LOGOPT_ANY,
5623+ info(logopt,
5624 MODPREFIX "read of master map %s failed: %s",
5625 mapname, yperr_string(err));
5626
5627@@ -249,6 +252,7 @@ int yp_all_callback(int status, char *ypkey, int ypkeylen,
5628 struct autofs_point *ap = cbdata->ap;
5629 struct map_source *source = cbdata->source;
5630 struct mapent_cache *mc = source->mc;
5631+ unsigned int logopt = cbdata->logopt;
5632 time_t age = cbdata->age;
5633 char *key, *mapent;
5634 int ret;
5635@@ -264,8 +268,10 @@ int yp_all_callback(int status, char *ypkey, int ypkeylen,
5636 return 0;
5637
5638 key = sanitize_path(ypkey, ypkeylen, ap->type, ap->logopt);
5639- if (!key)
5640+ if (!key) {
5641+ error(logopt, MODPREFIX "invalid path %s", ypkey);
5642 return 0;
5643+ }
5644
5645 mapent = alloca(vallen + 1);
5646 strncpy(mapent, val, vallen);
5647@@ -288,6 +294,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5648 struct lookup_context *ctxt = (struct lookup_context *) context;
5649 struct ypall_callback ypcb;
5650 struct callback_data ypcb_data;
5651+ unsigned int logopt = ap->logopt;
5652 struct map_source *source;
5653 char *mapname;
5654 int err;
5655@@ -298,6 +305,7 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
5656
5657 ypcb_data.ap = ap;
5658 ypcb_data.source = source;
5659+ ypcb_data.logopt = logopt;
5660 ypcb_data.age = age;
5661
5662 ypcb.foreach = yp_all_callback;
5663diff --git a/modules/mount_autofs.c b/modules/mount_autofs.c
5664index c45b91b..356fb14 100644
5665--- a/modules/mount_autofs.c
5666+++ b/modules/mount_autofs.c
5667@@ -64,7 +64,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5668 fullpath = alloca(strlen(root) + name_len + 2);
5669 if (!fullpath) {
5670 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5671- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5672+ logerr(MODPREFIX "alloca: %s", estr);
5673 return 1;
5674 }
5675
5676@@ -156,7 +156,6 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5677 }
5678 nap = entry->ap;
5679 nap->parent = ap;
5680- set_mnt_logging(nap);
5681
5682 argc = 1;
5683
5684@@ -208,7 +207,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name,
5685 return 1;
5686 }
5687
5688- source->mc = cache_init(source);
5689+ source->mc = cache_init(entry->ap, source);
5690 if (!source->mc) {
5691 error(ap->logopt, MODPREFIX "failed to init source cache");
5692 master_free_mapent(entry);
5693diff --git a/modules/mount_bind.c b/modules/mount_bind.c
5694index cb17ce4..04284f5 100644
5695--- a/modules/mount_bind.c
5696+++ b/modules/mount_bind.c
5697@@ -52,16 +52,14 @@ int mount_init(void **context)
5698 if (lstat(t1_dir, &st1) == -1)
5699 goto out;
5700
5701- err = spawn_mount(log_debug, "-n", "--bind", t1_dir, t2_dir, NULL);
5702+ err = spawn_mount(LOGOPT_NONE, "-n", "--bind", t1_dir, t2_dir, NULL);
5703 if (err == 0 &&
5704 lstat(t2_dir, &st2) == 0 &&
5705 st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino) {
5706 bind_works = 1;
5707 }
5708
5709- debug(LOGOPT_NONE, MODPREFIX "bind_works = %d", bind_works);
5710-
5711- spawn_umount(log_debug, "-n", t2_dir, NULL);
5712+ spawn_umount(LOGOPT_NONE, "-n", t2_dir, NULL);
5713
5714 out:
5715 rmdir(t1_dir);
5716@@ -91,7 +89,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5717 fullpath = alloca(rlen + name_len + 2);
5718 if (!fullpath) {
5719 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5720- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5721+ logerr(MODPREFIX "alloca: %s", estr);
5722 return 1;
5723 }
5724
5725@@ -139,7 +137,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5726 "calling mount --bind " SLOPPY " -o %s %s %s",
5727 options, what, fullpath);
5728
5729- err = spawn_bind_mount(log_debug,
5730+ err = spawn_bind_mount(ap->logopt,
5731 SLOPPYOPT "-o", options, what, fullpath, NULL);
5732
5733 if (err) {
5734diff --git a/modules/mount_changer.c b/modules/mount_changer.c
5735index 6e04c7c..08d9147 100644
5736--- a/modules/mount_changer.c
5737+++ b/modules/mount_changer.c
5738@@ -66,7 +66,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5739 fullpath = alloca(rlen + name_len + 2);
5740 if (!fullpath) {
5741 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5742- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5743+ logerr(MODPREFIX "alloca: %s", estr);
5744 return 1;
5745 }
5746
5747@@ -80,7 +80,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5748
5749 debug(ap->logopt, MODPREFIX "calling umount %s", what);
5750
5751- err = spawn_umount(log_debug, what, NULL);
5752+ err = spawn_umount(ap->logopt, what, NULL);
5753 if (err) {
5754 error(ap->logopt,
5755 MODPREFIX
5756@@ -115,18 +115,18 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5757 MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5758 fstype, options, what, fullpath);
5759
5760- err = spawn_mount(log_debug, "-t", fstype,
5761+ err = spawn_mount(ap->logopt, "-t", fstype,
5762 SLOPPYOPT "-o", options, what, fullpath, NULL);
5763 } else {
5764 debug(ap->logopt,
5765 MODPREFIX "calling mount -t %s %s %s",
5766 fstype, what, fullpath);
5767
5768- err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5769+ err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5770 }
5771
5772 if (err) {
5773- msg(MODPREFIX "failed to mount %s (type %s) on %s",
5774+ info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5775 what, fstype, fullpath);
5776
5777 if (ap->type != LKP_INDIRECT)
5778@@ -137,7 +137,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5779
5780 return 1;
5781 } else {
5782- msg(MODPREFIX "mounted %s type %s on %s",
5783+ info(ap->logopt, MODPREFIX "mounted %s type %s on %s",
5784 what, fstype, fullpath);
5785 return 0;
5786 }
5787@@ -161,7 +161,7 @@ int swapCD(const char *device, const char *slotName)
5788 /* open device */
5789 fd = open(device, O_RDONLY | O_NONBLOCK);
5790 if (fd < 0) {
5791- error(LOGOPT_ANY, MODPREFIX "Opening device %s failed : %s",
5792+ logerr(MODPREFIX "Opening device %s failed : %s",
5793 device, strerror(errno));
5794 return 1;
5795 }
5796@@ -174,7 +174,7 @@ int swapCD(const char *device, const char *slotName)
5797 /* Check CD player status */
5798 total_slots_available = ioctl(fd, CDROM_CHANGER_NSLOTS);
5799 if (total_slots_available <= 1) {
5800- error(LOGOPT_ANY, MODPREFIX
5801+ logerr(MODPREFIX
5802 "Device %s is not an ATAPI compliant CD changer.",
5803 device);
5804 return 1;
5805@@ -183,14 +183,14 @@ int swapCD(const char *device, const char *slotName)
5806 /* load */
5807 slot = ioctl(fd, CDROM_SELECT_DISC, slot);
5808 if (slot < 0) {
5809- error(LOGOPT_ANY, MODPREFIX "CDROM_SELECT_DISC failed");
5810+ logerr(MODPREFIX "CDROM_SELECT_DISC failed");
5811 return 1;
5812 }
5813
5814 /* close device */
5815 status = close(fd);
5816 if (status != 0) {
5817- error(LOGOPT_ANY, MODPREFIX "close failed for `%s': %s",
5818+ logerr(MODPREFIX "close failed for `%s': %s",
5819 device, strerror(errno));
5820 return 1;
5821 }
5822diff --git a/modules/mount_ext2.c b/modules/mount_ext2.c
5823index 45f0615..8cf9937 100644
5824--- a/modules/mount_ext2.c
5825+++ b/modules/mount_ext2.c
5826@@ -58,7 +58,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5827 fullpath = alloca(rlen + name_len + 2);
5828 if (!fullpath) {
5829 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5830- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5831+ logerr(MODPREFIX "alloca: %s", estr);
5832 return 1;
5833 }
5834
5835@@ -108,11 +108,11 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5836 if (ro) {
5837 debug(ap->logopt,
5838 MODPREFIX "calling %s -n %s", fsck_prog, what);
5839- err = spawnl(log_debug, fsck_prog, fsck_prog, "-n", what, NULL);
5840+ err = spawnl(ap->logopt, fsck_prog, fsck_prog, "-n", what, NULL);
5841 } else {
5842 debug(ap->logopt,
5843 MODPREFIX "calling %s -p %s", fsck_prog, what);
5844- err = spawnl(log_debug, fsck_prog, fsck_prog, "-p", what, NULL);
5845+ err = spawnl(ap->logopt, fsck_prog, fsck_prog, "-p", what, NULL);
5846 }
5847
5848 /*
5849@@ -132,17 +132,17 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5850 debug(ap->logopt,
5851 MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5852 fstype, options, what, fullpath);
5853- err = spawn_mount(log_debug, "-t", fstype,
5854+ err = spawn_mount(ap->logopt, "-t", fstype,
5855 SLOPPYOPT "-o", options, what, fullpath, NULL);
5856 } else {
5857 debug(ap->logopt,
5858 MODPREFIX "calling mount -t %s %s %s",
5859 fstype, what, fullpath);
5860- err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5861+ err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5862 }
5863
5864 if (err) {
5865- msg(MODPREFIX "failed to mount %s (type %s) on %s",
5866+ info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5867 what, fstype, fullpath);
5868
5869 if (ap->type != LKP_INDIRECT)
5870@@ -153,7 +153,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5871
5872 return 1;
5873 } else {
5874- debug(ap->logopt,
5875+ info(ap->logopt,
5876 MODPREFIX "mounted %s type %s on %s",
5877 what, fstype, fullpath);
5878 return 0;
5879diff --git a/modules/mount_generic.c b/modules/mount_generic.c
5880index 1f43baa..85b4391 100644
5881--- a/modules/mount_generic.c
5882+++ b/modules/mount_generic.c
5883@@ -57,7 +57,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5884 fullpath = alloca(rlen + name_len + 2);
5885 if (!fullpath) {
5886 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5887- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5888+ logerr(MODPREFIX "alloca: %s", estr);
5889 return 1;
5890 }
5891
5892@@ -93,16 +93,16 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5893 MODPREFIX "calling mount -t %s " SLOPPY "-o %s %s %s",
5894 fstype, options, what, fullpath);
5895
5896- err = spawn_mount(log_debug, "-t", fstype,
5897+ err = spawn_mount(ap->logopt, "-t", fstype,
5898 SLOPPYOPT "-o", options, what, fullpath, NULL);
5899 } else {
5900 debug(ap->logopt, MODPREFIX "calling mount -t %s %s %s",
5901 fstype, what, fullpath);
5902- err = spawn_mount(log_debug, "-t", fstype, what, fullpath, NULL);
5903+ err = spawn_mount(ap->logopt, "-t", fstype, what, fullpath, NULL);
5904 }
5905
5906 if (err) {
5907- msg(MODPREFIX "failed to mount %s (type %s) on %s",
5908+ info(ap->logopt, MODPREFIX "failed to mount %s (type %s) on %s",
5909 what, fstype, fullpath);
5910
5911 if (ap->type != LKP_INDIRECT)
5912@@ -113,7 +113,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5913
5914 return 1;
5915 } else {
5916- msg(MODPREFIX "mounted %s type %s on %s",
5917+ info(ap->logopt, MODPREFIX "mounted %s type %s on %s",
5918 what, fstype, fullpath);
5919 return 0;
5920 }
5921diff --git a/modules/mount_nfs.c b/modules/mount_nfs.c
5922index e4480c5..bad21fc 100644
5923--- a/modules/mount_nfs.c
5924+++ b/modules/mount_nfs.c
5925@@ -133,14 +133,14 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5926 else
5927 vers = NFS_VERS_MASK | NFS_PROTO_MASK;
5928
5929- if (!parse_location(&hosts, what)) {
5930- warn(ap->logopt, MODPREFIX "no hosts available");
5931+ if (!parse_location(ap->logopt, &hosts, what)) {
5932+ info(ap->logopt, MODPREFIX "no hosts available");
5933 return 1;
5934 }
5935- prune_host_list(&hosts, vers, nfsoptions, ap->random_selection);
5936+ prune_host_list(ap->logopt, &hosts, vers, nfsoptions, ap->random_selection);
5937
5938 if (!hosts) {
5939- warn(ap->logopt, MODPREFIX "no hosts available");
5940+ info(ap->logopt, MODPREFIX "no hosts available");
5941 return 1;
5942 }
5943
5944@@ -159,7 +159,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5945 fullpath = alloca(rlen + name_len + 2);
5946 if (!fullpath) {
5947 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5948- error(ap->logopt, MODPREFIX "alloca: %s", estr);
5949+ logerr(MODPREFIX "alloca: %s", estr);
5950 free_host_list(&hosts);
5951 return 1;
5952 }
5953@@ -252,19 +252,19 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5954 MODPREFIX "calling mount -t %s " SLOPPY
5955 "-o %s %s %s", fstype, nfsoptions, loc, fullpath);
5956
5957- err = spawn_mount(log_debug,
5958+ err = spawn_mount(ap->logopt,
5959 "-t", fstype, SLOPPYOPT "-o",
5960 nfsoptions, loc, fullpath, NULL);
5961 } else {
5962 debug(ap->logopt,
5963 MODPREFIX "calling mount -t %s %s %s",
5964 fstype, loc, fullpath);
5965- err = spawn_mount(log_debug,
5966+ err = spawn_mount(ap->logopt,
5967 "-t", fstype, loc, fullpath, NULL);
5968 }
5969
5970 if (!err) {
5971- msg(MODPREFIX "mounted %s on %s", loc, fullpath);
5972+ info(ap->logopt, MODPREFIX "mounted %s on %s", loc, fullpath);
5973 free(loc);
5974 free_host_list(&hosts);
5975 ap->ghost = save_ghost;
5976@@ -280,7 +280,7 @@ int mount_mount(struct autofs_point *ap, const char *root, const char *name, int
5977
5978 /* If we get here we've failed to complete the mount */
5979
5980- msg(MODPREFIX "nfs: mount failure %s on %s", what, fullpath);
5981+ info(ap->logopt, MODPREFIX "nfs: mount failure %s on %s", what, fullpath);
5982
5983 if (ap->type != LKP_INDIRECT)
5984 return 1;
5985diff --git a/modules/parse_sun.c b/modules/parse_sun.c
5986index 079bda6..186e567 100644
5987--- a/modules/parse_sun.c
5988+++ b/modules/parse_sun.c
5989@@ -277,7 +277,7 @@ int parse_init(int argc, const char *const *argv, void **context)
5990
5991 if (!(ctxt = (struct parse_context *) malloc(sizeof(struct parse_context)))) {
5992 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
5993- crit(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
5994+ logerr(MODPREFIX "malloc: %s", estr);
5995 *context = NULL;
5996 return 1;
5997 }
5998@@ -302,7 +302,7 @@ int parse_init(int argc, const char *const *argv, void **context)
5999
6000 if (!def) {
6001 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6002- error(LOGOPT_ANY, MODPREFIX "strdup: %s", estr);
6003+ logerr(MODPREFIX "strdup: %s", estr);
6004 break;
6005 }
6006
6007@@ -387,7 +387,7 @@ int parse_init(int argc, const char *const *argv, void **context)
6008 if (!noptstr) {
6009 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6010 kill_context(ctxt);
6011- crit(LOGOPT_ANY, MODPREFIX "%s", estr);
6012+ logerr(MODPREFIX "%s", estr);
6013 *context = NULL;
6014 return 1;
6015 }
6016@@ -408,7 +408,7 @@ int parse_init(int argc, const char *const *argv, void **context)
6017 char *tmp = concat_options(gbl_options, ctxt->optstr);
6018 if (!tmp) {
6019 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6020- error(LOGOPT_ANY, MODPREFIX "concat_options: %s", estr);
6021+ logerr(MODPREFIX "concat_options: %s", estr);
6022 free(gbl_options);
6023 } else
6024 ctxt->optstr = tmp;
6025@@ -472,7 +472,7 @@ static char *concat_options(char *left, char *right)
6026
6027 if (ret == NULL) {
6028 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6029- error(LOGOPT_ANY, MODPREFIX "malloc: %s", estr);
6030+ logerr(MODPREFIX "malloc: %s", estr);
6031 return NULL;
6032 }
6033
6034@@ -637,8 +637,7 @@ static int check_is_multi(const char *mapent)
6035 int not_first_chunk = 0;
6036
6037 if (!p) {
6038- crit(LOGOPT_ANY,
6039- MODPREFIX "unexpected NULL map entry pointer");
6040+ logerr(MODPREFIX "unexpected NULL map entry pointer");
6041 return 0;
6042 }
6043
6044@@ -1021,7 +1020,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6045 pmapent = alloca(mapent_len + 1);
6046 if (!pmapent) {
6047 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6048- error(ap->logopt, MODPREFIX "alloca: %s", estr);
6049+ logerr(MODPREFIX "alloca: %s", estr);
6050 ctxt->subst = removestdenv(ctxt->subst);
6051 macro_unlock();
6052 pthread_setcancelstate(cur_state, NULL);
6053@@ -1041,7 +1040,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6054 options = strdup(ctxt->optstr ? ctxt->optstr : "");
6055 if (!options) {
6056 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6057- error(ap->logopt, MODPREFIX "strdup: %s", estr);
6058+ logerr(MODPREFIX "strdup: %s", estr);
6059 return 1;
6060 }
6061 optlen = strlen(options);
6062@@ -1119,7 +1118,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6063 if (!m_root) {
6064 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6065 free(options);
6066- error(ap->logopt, MODPREFIX "alloca: %s", estr);
6067+ logerr(MODPREFIX "alloca: %s", estr);
6068 return 1;
6069 }
6070 strcpy(m_root, name);
6071@@ -1129,7 +1128,7 @@ int parse_mount(struct autofs_point *ap, const char *name,
6072 if (!m_root) {
6073 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6074 free(options);
6075- error(ap->logopt, MODPREFIX "alloca: %s", estr);
6076+ logerr(MODPREFIX "alloca: %s", estr);
6077 return 1;
6078 }
6079 strcpy(m_root, ap->path);
6080diff --git a/modules/replicated.c b/modules/replicated.c
6081index e15587c..14b20a9 100644
6082--- a/modules/replicated.c
6083+++ b/modules/replicated.c
6084@@ -113,7 +113,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6085 sock = socket(AF_INET, SOCK_DGRAM, 0);
6086 if (sock < 0) {
6087 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6088- error(LOGOPT_ANY, "socket creation failed: %s", estr);
6089+ logerr("socket creation failed: %s", estr);
6090 return PROXIMITY_ERROR;
6091 }
6092
6093@@ -127,7 +127,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6094 ret = ioctl(sock, SIOCGIFCONF, &ifc);
6095 if (ret == -1) {
6096 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6097- error(LOGOPT_ANY, "ioctl: %s", estr);
6098+ logerr("ioctl: %s", estr);
6099 close(sock);
6100 return PROXIMITY_ERROR;
6101 }
6102@@ -176,7 +176,7 @@ static unsigned int get_proximity(const char *host_addr, int addr_len)
6103 ret = ioctl(sock, SIOCGIFNETMASK, &nmptr);
6104 if (ret == -1) {
6105 char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
6106- error(LOGOPT_ANY, "ioctl: %s", estr);
6107+ logerr("ioctl: %s", estr);
6108 close(sock);
6109 return PROXIMITY_ERROR;
6110 }
6111@@ -387,7 +387,7 @@ static unsigned short get_port_option(const char *options)
6112 return (unsigned short) port;
6113 }
6114
6115-static unsigned int get_nfs_info(struct host *host,
6116+static unsigned int get_nfs_info(unsigned logopt, struct host *host,
6117 struct conn_info *pm_info, struct conn_info *rpc_info,
6118 const char *proto, unsigned int version,
6119 const char *options, unsigned int random_selection)
6120@@ -533,7 +533,7 @@ done_ver:
6121 return supported;
6122 }
6123
6124-static int get_vers_and_cost(struct host *host,
6125+static int get_vers_and_cost(unsigned logopt, struct host *host,
6126 unsigned int version, const char *options,
6127 unsigned int random_selection)
6128 {
6129@@ -559,7 +559,7 @@ static int get_vers_and_cost(struct host *host,
6130 vers &= version;
6131
6132 if (version & UDP_REQUESTED) {
6133- supported = get_nfs_info(host,
6134+ supported = get_nfs_info(logopt, host,
6135 &pm_info, &rpc_info, "udp", vers,
6136 options, random_selection);
6137 if (supported) {
6138@@ -569,7 +569,7 @@ static int get_vers_and_cost(struct host *host,
6139 }
6140
6141 if (version & TCP_REQUESTED) {
6142- supported = get_nfs_info(host,
6143+ supported = get_nfs_info(logopt, host,
6144 &pm_info, &rpc_info, "tcp", vers,
6145 options, random_selection);
6146 if (supported) {
6147@@ -581,7 +581,7 @@ static int get_vers_and_cost(struct host *host,
6148 return ret;
6149 }
6150
6151-static int get_supported_ver_and_cost(struct host *host,
6152+static int get_supported_ver_and_cost(unsigned logopt, struct host *host,
6153 unsigned int version, const char *options,
6154 unsigned int random_selection)
6155 {
6156@@ -636,7 +636,7 @@ static int get_supported_ver_and_cost(struct host *host,
6157 vers = NFS4_VERSION;
6158 break;
6159 default:
6160- crit(LOGOPT_ANY, "called with invalid version: 0x%x\n", version);
6161+ crit(logopt, "called with invalid version: 0x%x\n", version);
6162 return 0;
6163 }
6164
6165@@ -701,7 +701,7 @@ done:
6166 return 0;
6167 }
6168
6169-int prune_host_list(struct host **list,
6170+int prune_host_list(unsigned logopt, struct host **list,
6171 unsigned int vers, const char *options,
6172 unsigned int random_selection)
6173 {
6174@@ -742,7 +742,7 @@ int prune_host_list(struct host **list,
6175 break;
6176
6177 if (this->name) {
6178- status = get_vers_and_cost(this, vers,
6179+ status = get_vers_and_cost(logopt, this, vers,
6180 options, random_selection);
6181 if (!status) {
6182 if (this == first) {
6183@@ -833,7 +833,7 @@ int prune_host_list(struct host **list,
6184 remove_host(list, this);
6185 add_host(&new, this);
6186 } else {
6187- status = get_supported_ver_and_cost(this,
6188+ status = get_supported_ver_and_cost(logopt, this,
6189 selected_version, options,
6190 random_selection);
6191 if (status) {
6192@@ -886,11 +886,9 @@ static int add_host_addrs(struct host **list, const char *host, unsigned int wei
6193 buf, MAX_IFC_BUF, &result, &ghn_errno);
6194 if (ret || !result) {
6195 if (ghn_errno == -1)
6196- error(LOGOPT_ANY,
6197- "host %s: lookup failure %d", host, errno);
6198+ logmsg("host %s: lookup failure %d", host, errno);
6199 else
6200- error(LOGOPT_ANY,
6201- "host %s: lookup failure %d", host, ghn_errno);
6202+ logmsg("host %s: lookup failure %d", host, ghn_errno);
6203 return 0;
6204 }
6205
6206@@ -965,7 +963,7 @@ static int add_local_path(struct host **hosts, const char *path)
6207 return 1;
6208 }
6209
6210-int parse_location(struct host **hosts, const char *list)
6211+int parse_location(unsigned logopt, struct host **hosts, const char *list)
6212 {
6213 char *str, *p, *delim;
6214 unsigned int empty = 1;
6215@@ -1072,8 +1070,7 @@ void dump_host_list(struct host *hosts)
6216
6217 this = hosts;
6218 while (this) {
6219- debug(LOGOPT_ANY,
6220- "name %s path %s version %x proximity %u weight %u cost %u",
6221+ logmsg("name %s path %s version %x proximity %u weight %u cost %u",
6222 this->name, this->path, this->version,
6223 this->proximity, this->weight, this->cost);
6224 this = this->next;
autofs daemon
This page took 1.024999 seconds and 4 git commands to generate.