File autofs-5.1.1-dbus-udisks-monitor.patch of Package autofs

Overview Repositories Revisions Requests Users Attributes Meta

File autofs-5.1.1-dbus-udisks-monitor.patch of Package autofs (Revision ec6db2d99f67b40173469626eefee043)

Currently displaying revision ec6db2d99f67b40173469626eefee043 , Show latest

--- a/Makefile.conf.in
+++ b/Makefile.conf.in
@@ -40,6 +40,9 @@ KRB5_FLAGS=@KRB5_FLAGS@
 # NIS+ support: yes (1) no (0)
 NISPLUS = @HAVE_NISPLUS@
 
+# Udisks support
+UDISKS = 1
+
 # SMBFS support: yes (1) no (0)
 SMBFS = @HAVE_SMBMOUNT@
 
--- a/daemon/lookup.c
+++ b/daemon/lookup.c
@@ -239,6 +239,10 @@ int lookup_nss_read_master(struct master
 				 (name[3] == ',' || name[3] == ':')) ||
 			    (!strncmp(name, "nisplus", 7) &&
 				 (name[7] == ',' || name[7] == ':')) ||
+			    (!strncmp(name, "udisks", 6) &&
+			     	 (name[6] == ',' || name[6] == ':')) ||
+			    (!strncmp(name, "udisks2", 7) &&
+			     	 (name[7] == ',' || name[7] == ':')) ||
 			    (!strncmp(name, "ldap", 4) &&
 				 (name[4] == ',' || name[4] == ':')) ||
 			    (!strncmp(name, "ldaps", 5) &&
--- /dev/null
+++ b/include/lookup_udisks.h
@@ -0,0 +1,381 @@
+/*
+ * loopup_udisks.h - Header file for lookup_udisks automount module
+ *
+ *   Copyright 2012 SuSE LINUX Products GmbH - All Rights Reserved
+ *   Copyright 2012 Werner Fink <werner@suse.de>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
+ *   USA; either version 2 of the License, or (at your option) any later
+ *   version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ */
+
+#ifndef LOOKUP_UDISKS_H
+#define LOOKUP_UDISKS_H
+
+#include "list.h"
+typedef struct list_head list_t;
+
+#ifndef list_for_each_safe
+#define list_for_each_safe(pos, safe, head)	\
+	for (pos = (head)->next, safe = pos->next; pos != (head); pos = safe, safe = pos->next)
+#endif
+#ifdef offsetof
+# undef list_entry
+# define list_entry(ptr, type, member)		(__extension__ ({	\
+	__const__ __typeof__( ((type*)0)->member ) *__mptr = (ptr);	\
+	((type *)( (char *)__mptr - offsetof(type,member) ));}))
+#endif
+
+#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)
+# ifndef  inline
+#  define inline		__inline__
+# endif
+# ifndef  restrict
+#  define restrict		__restrict__
+# endif
+# ifndef  volatile
+#  define volatile		__volatile__
+# endif
+# ifndef  extension
+#  define extension		__extension__
+# endif
+# ifndef  typeof
+#  define typeof		__typeof__
+# endif
+#endif
+#ifndef  attribute
+# define attribute(attr)	__attribute__(attr)
+#endif
+#define alignof(type)		((sizeof(type)+(sizeof(void*)-1)) & ~(sizeof(void*)-1))
+#define strsize(string)		((strlen(string)+1)*sizeof(char))
+#define MODPREFIX "lookup(udisks): "
+
+typedef struct property_s {
+	list_t handle;
+	int type;
+	char *name;
+	void *value;
+} property_t;
+
+typedef struct array_s {
+	list_t handle;
+	char *value;
+} array_t;
+
+typedef struct filter_s {
+	char *property;
+#define DBUS_TYPE_OBJECT DBUS_TYPE_OBJECT_PATH
+	int type;
+} filter_t;
+
+typedef struct option_s {
+	int error;
+	union {
+		dbus_bool_t	boolean;
+		dbus_int32_t	int32;
+		dbus_uint32_t	uint32;
+		dbus_int64_t	int64;
+		dbus_uint64_t	uint64;
+		double		number;
+		const char	*string;
+		const list_t	*array;
+	};
+} option_t;
+
+typedef struct entry_s {
+	time_t   age;
+	size_t	 key_len;
+	size_t	 mapent_len;
+	char	*key;
+	char	*mapent;
+} entry_t;
+
+typedef struct device_s {
+	list_t handle;
+	list_t properties;
+	list_t *head;
+	filter_t *opts;
+	entry_t *entry;
+	char* identify;
+	char* node;
+} device_t;
+
+typedef struct session_s {
+	list_t handle;
+	list_t properties;
+	list_t *head;
+	filter_t *opts;
+	char* identify;
+	char* node;
+} session_t;
+
+typedef struct mntopt_s {
+	list_t handle;
+	char* identify;
+	char* options;
+} mntopt_t;
+
+typedef struct config_s {
+	int enabled;
+	char* common;
+	list_t fstypes;
+	list_t byid;
+	list_t label;
+} config_t;
+
+struct lookup_context {
+	pthread_mutex_t mtx;
+	pthread_t watchdog;
+	dbus_bool_t monitor;
+	volatile int active;
+	volatile int running;
+	const char *mapname;
+	list_t devices;
+	list_t sessions;
+	config_t config;
+	DBusConnection *conn;
+	DBusError *error;
+	struct autofs_point *ap;
+	struct map_source *map;
+	struct parse_mod *parse;
+};
+
+static inline void lock(struct lookup_context *ctxt)
+{
+	int status = pthread_mutex_lock(&ctxt->mtx);
+	if (status)
+		fatal(status);
+	return;
+}
+
+static inline void unlock(struct lookup_context *ctxt)
+{
+	int status = pthread_mutex_unlock(&ctxt->mtx);
+	if (status)
+		fatal(status);
+	return;
+}
+
+/*
+ * Use posix_memalign for  a well aligned container which not only has
+ * the required amount of space for the structure of a list member but
+ * also for the used strings therein.   With this such a container can
+ * be freed at once.
+ */
+extern void* newaligned(size_t size) attribute((__warn_unused_result__,__always_inline__));
+extern inline void* newaligned(size_t size)
+{
+	void *restrict new;
+	if (posix_memalign((void**)&new, sizeof(void*), size) != 0) {
+		char buf[MAX_ERR_BUF];
+		const char *const estr = strerror_r(errno, buf, sizeof(buf));
+		logerr(MODPREFIX "memory allocation: %s", estr);
+		return (void*)0;
+	}
+	return new;
+}
+
+/*
+ * Sorted with same order as found in the response of the dbus call
+ * org.freedesktop.DBus.Properties.GetAll, e.g.
+ *  dbus-send --system --print-reply --dest=org.freedesktop.UDisks \
+ *      /org/freedesktop/UDisks/devices/sda \
+ *      org.freedesktop.DBus.Properties.GetAll \
+ *      string:org.freedesktop.UDisks.Device | \
+ *  sed -rn '/dict entry$/,/$/ {
+ *      H
+ *      x
+ *      s@\n*@@g
+ *      s@^\s+string\s"(\w+)"\s+.*@\t\1,@p
+ *  }'
+ *
+ * compare with filter[] found in lookup_udisks.c
+ */
+
+typedef enum {
+	NativePath = 0,
+	DeviceDetectionTime,
+	DeviceMediaDetectionTime,
+	DeviceMajor,
+	DeviceMinor,
+	DeviceFile,
+	DeviceFilePresentation,
+	DeviceFileById,
+	DeviceFileByPath,
+	DeviceIsSystemInternal,
+	DeviceIsPartition,
+	DeviceIsPartitionTable,
+	DeviceIsRemovable,
+	DeviceIsMediaAvailable,
+	DeviceIsMediaChangeDetected,
+	DeviceIsMediaChangeDetectionPolling,
+	DeviceIsMediaChangeDetectionInhibitable,
+	DeviceIsMediaChangeDetectionInhibited,
+	DeviceIsReadOnly,
+	DeviceIsDrive,
+	DeviceIsOpticalDisc,
+	DeviceIsMounted,
+	DeviceMountPaths,
+	DeviceMountedByUid,
+	DeviceIsLuks,
+	DeviceIsLuksCleartext,
+	DeviceIsLinuxMdComponent,
+	DeviceIsLinuxMd,
+	DeviceIsLinuxLvm2LV,
+	DeviceIsLinuxLvm2PV,
+	DeviceIsLinuxDmmpComponent,
+	DeviceIsLinuxDmmp,
+	DeviceIsLinuxLoop,
+	DeviceSize,
+	DeviceBlockSize,
+	DevicePresentationHide,
+	DevicePresentationNopolicy,
+	DevicePresentationName,
+	DevicePresentationIconName,
+	DeviceAutomountHint,
+	JobInProgress,
+	JobId,
+	JobInitiatedByUid,
+	JobIsCancellable,
+	JobPercentage,
+	IdUsage,
+	IdType,
+	IdVersion,
+	IdUuid,
+	IdLabel,
+	LuksHolder,
+	LuksCleartextSlave,
+	LuksCleartextUnlockedByUid,
+	PartitionSlave,
+	PartitionScheme,
+	PartitionType,
+	PartitionLabel,
+	PartitionUuid,
+	PartitionFlags,
+	PartitionNumber,
+	PartitionOffset,
+	PartitionSize,
+	PartitionAlignmentOffset,
+	PartitionTableScheme,
+	PartitionTableCount,
+	DriveVendor,
+	DriveModel,
+	DriveRevision,
+	DriveSerial,
+	DriveWwn,
+	DriveRotationRate,
+	DriveWriteCache,
+	DriveConnectionInterface,
+	DriveConnectionSpeed,
+	DriveMediaCompatibility,
+	DriveMedia,
+	DriveIsMediaEjectable,
+	DriveCanDetach,
+	DriveCanSpindown,
+	DriveIsRotational,
+	DriveAdapter,
+	DrivePorts,
+	DriveSimilarDevices,
+	OpticalDiscIsBlank,
+	OpticalDiscIsAppendable,
+	OpticalDiscIsClosed,
+	OpticalDiscNumTracks,
+	OpticalDiscNumAudioTracks,
+	OpticalDiscNumSessions,
+	DriveAtaSmartIsAvailable,
+	DriveAtaSmartTimeCollected,
+	DriveAtaSmartStatus,
+	DriveAtaSmartBlob,
+	LinuxMdComponentLevel,
+	LinuxMdComponentPosition,
+	LinuxMdComponentNumRaidDevices,
+	LinuxMdComponentUuid,
+	LinuxMdComponentName,
+	LinuxMdComponentHomeHost,
+	LinuxMdComponentVersion,
+	LinuxMdComponentHolder,
+	LinuxMdComponentState,
+	LinuxMdState,
+	LinuxMdLevel,
+	LinuxMdUuid,
+	LinuxMdHomeHost,
+	LinuxMdName,
+	LinuxMdNumRaidDevices,
+	LinuxMdVersion,
+	LinuxMdSlaves,
+	LinuxMdIsDegraded,
+	LinuxMdSyncAction,
+	LinuxMdSyncPercentage,
+	LinuxMdSyncSpeed,
+	LinuxLvm2PVUuid,
+	LinuxLvm2PVNumMetadataAreas,
+	LinuxLvm2PVGroupName,
+	LinuxLvm2PVGroupUuid,
+	LinuxLvm2PVGroupSize,
+	LinuxLvm2PVGroupUnallocatedSize,
+	LinuxLvm2PVGroupSequenceNumber,
+	LinuxLvm2PVGroupExtentSize,
+	LinuxLvm2PVGroupPhysicalVolumes,
+	LinuxLvm2PVGroupLogicalVolumes,
+	LinuxLvm2LVName,
+	LinuxLvm2LVUuid,
+	LinuxLvm2LVGroupName,
+	LinuxLvm2LVGroupUuid,
+	LinuxDmmpComponentHolder,
+	LinuxDmmpName,
+	LinuxDmmpSlaves,
+	LinuxDmmpParameters,
+	LinuxLoopFilename,
+	NullDict
+} devdict_t;
+
+/*
+ * Sorted with same order as found in the response of the dbus call
+ * org.freedesktop.DBus.Properties.GetAll, e.g.
+ *  dbus-send --print-reply --system --dest=org.freedesktop.ConsoleKit \
+ *	/org/freedesktop/ConsoleKit/Session1 \
+ *	org.freedesktop.DBus.Properties.GetAll \
+ *	string:org.freedesktop.ConsoleKit.Session | \
+ *  sed -rn '/dict entry$/,/$/{
+ *	H
+ *	x
+ *	s@\n*@@g
+ *	s@^\s+string\s"([a-z0-9-]+)"\s+.*@\t\1,@p
+ *	}'
+ *
+ * compare with sessions[] found in lookup_udisks.c
+ */
+
+typedef enum {
+        unix_user = 0,
+        user,
+        session_type,
+        remote_host_name,
+        display_device,
+        x11_display,
+        x11_display_device,
+        active,
+        is_local,
+        idle_hint,
+	NullCk
+} ckdict_t;
+
+typedef enum {
+	AutofsUdisks = 0,
+	MountOptions,
+	Common,
+	DiskById,
+	DiskByLabel,
+	FSType,
+	NullCnf
+} cnfxml_t;
+
+#endif
--- a/lib/master_tok.l
+++ b/lib/master_tok.l
@@ -119,7 +119,7 @@ DNNAMESTR2	([[:alnum:]_.\-]+)
 INTMAP		(-hosts|-null)
 MULTI		((multi)(,(sun|hesiod))?(:{OPTWS}|{WS}))
 MULTISEP	([\-]{2}[[:blank:]]+)
-MTYPE		((file|program|exec|sss|yp|nis|nisplus|ldap|ldaps|hesiod|userdir)(,(sun|hesiod|amd))?(:{OPTWS}|{WS}))
+MTYPE		((file|program|exec|sss|yp|nis|nisplus|udisks|udisks2|ldap|ldaps|hesiod|userdir)(,(sun|hesiod|amd))?(:{OPTWS}|{WS}))
 
 
 OPTTOUT		(-t{OPTWS}|-t{OPTWS}={OPTWS}|--timeout{OPTWS}|--timeout{OPTWS}={OPTWS})
--- a/lib/parse_subs.c
+++ b/lib/parse_subs.c
@@ -98,6 +98,8 @@ static struct types map_type[] = {
 	{ "yp", 2 },
 	{ "nis", 3 },
 	{ "nisplus", 7 },
+   { "udisks", 6 },
+	{ "udisks2", 7 },
 	{ "ldap", 4 },
 	{ "ldaps", 5 },
 	{ "hesiod", 6 },
--- /dev/null
+++ b/man/autofs.udisks.5.in
@@ -0,0 +1,121 @@
+.\" t
+.TH AUTOFS.UDISKS 5 "22 Aug 2012"
+.SH NAME
+autofs.udisks \- autofs configuration for local removable devices
+.SH "DESCRIPTION"
+The automount udisks module is able to manage removable devices on the
+local system by connecting to the message bus daemon
+.BR dbus\-daemon (1)
+to monitor all device events of the
+.BR udisks\-daemon (8).
+To grant access for local users the automount
+udisks module also monitors users sessions hold by the ConsoleKit
+daemon, compare with description of the PAM module
+.BR pam_ck_connector (8).
+.P
+To use the automount udisks module an entry in the Master Map
+.BR auto.master (5)
+has to added, like this:
+.sp
+.RS +.2i
+.ta 1.0i
+.nf
+.I /media/autofs udisks:@@autofsmapdir@@/autofs.udisks \-\-timeout=5 \-\-ghost
+.fi
+.RE
+.sp
+Please be aware that format of the file
+.R autofs.udisks
+does
+.B not
+follow the common format of the automounter maps but is an XML
+configuration file. This file is used by the automount udisks module
+to generate the automounter map on the fly.
+.P
+An example of this file is:
+.sp
+.RS +.2i
+.ta 1.0i
+.nf
+<?xml version=\[dq]1.0\[dq] ?>
+<AutofsUdisks enable=\[dq]true\[dq]>
+  <MountOptions>
+    <Common>uid=$UID,gid=$GID,nosuid,nodev</Common>
+    <DiskById value=\[dq]usb\-USB_Flash_Disk_XXXXXXXXXXXX\-0:0\-part1\[dq]>
+      uid=1002,gid=501,user,nosuid,nodev,exec
+    </DiskById>
+    <DiskByLabel value=\[dq]MyPersonal\-DVD\-x86_64XXXX\[dq]>
+      unhide
+    </DiskByLabel>
+    <FSType value=\[dq]vfat\[dq]>fmask=0132,dmask=0022,showexec</FSType>
+    <FSType value=\[dq]ntfs\[dq]>umask=0022</FSType>
+    <FSType value=\[dq]iso9660\[dq]>ro</FSType>
+    <FSType value=\[dq]ext4\[dq]>check=none,noatime,nodiratime,data=journal</FSType>
+    <FSType value=\[dq]ext3\[dq]>check=none,noatime,nodiratime,data=journal</FSType>
+    <FSType value=\[dq]ext2\[dq]>check=none,noatime</FSType>
+    <FSType>ro,nosuid,nodev,noexec</FSType>
+  </MountOptions>
+</AutofsUdisks>
+.fi
+.RE
+.sp
+The entries of such a XML configuration file are
+.TP
+.RB < AutofsUdisks >
+as the outer envelop.  This level has exactly one attribute
+.BR enable =\[dq] true \[dq]|\[dq] false \[dq]
+which allows disabling the automount udisks module without
+removing the module its self.
+.TP
+.RB < MountOptions >
+is the only known entry below which is used to list the
+possible mount options, compare with
+.BR mount (8)
+as well as the variable substitutions mentioned in the manual
+page
+.BR autofs (5)
+for the format of the automounter maps.
+.P
+There are four possible entries below
+.RB < MountOptions >
+to help the the automount udisks module to generate the automounter
+map.
+.TP
+.RB < Common >
+is the entry which provides mount options applied to
+nearly all generated maps.
+This entry will be overwritten by the next entry.
+.TP
+.RB < DiskById\ value =\[dq] \fIID\fR \[dq]>
+is the entry which provides mount options which are applied
+instead of the
+.RB < Common >
+entry if a device is found with an
+.I ID
+listed below
+.IR /dev/disk/by\-id/ .
+This entry will be overwritten by the next entry.
+.TP
+.RB < DiskByLabel\ value =\[dq] \fILABEL\fR \[dq]>
+is the entry which provides mount options which are applied
+instead of the
+.RB < Common >
+or
+.RB < DiskByLabel >
+entries if a device is found labeled with
+.IR LABEL .
+Such labels can be detected by the super user with the
+.BR blkid (8)
+command.
+.TP
+.RB < FSType\  [ value =\[dq] \fIFSTYPE\fR \[dq]]>
+those entries are used to apply file system \fIFSTYPE\fR specific mount
+options to a generated automounter map entry.  There can be one
+.RB < FSType >
+entry without any file system value as a fallback for file systems
+not specified in the configuration file.
+.SH "SEE ALSO"
+.BR auto.master (5),
+.BR udisks\-daemon (8)
+.SH AUTHOR
+This manual page was written by Werner Fink <werner@suse.com>.
--- a/modules/Makefile
+++ b/modules/Makefile
@@ -62,6 +62,14 @@ ifeq ($(SSSD), 1)
   MODS += lookup_sss.so
 endif
 
+ifeq ($(UDISKS), 1)
+  UDISKS_FLAGS += $(shell pkg-config --cflags dbus-1)
+  UDISKS_LIBS += $(shell pkg-config --libs dbus-1)
+  UDISKS_LIBS += $(AUTOFS_LIB)
+  SRCS += lookup_udisks.c
+  MODS += lookup_udisks.so
+endif
+
 CFLAGS += -I../include -I../lib -fPIC -D_GNU_SOURCE
 CFLAGS += -DAUTOFS_LIB_DIR=\"$(autofslibdir)\"
 CFLAGS += -DAUTOFS_MAP_DIR=\"$(autofsmapdir)\"
@@ -133,6 +141,10 @@ lookup_ldap.so: lookup_ldap.c dclist.o b
 		$(LDFLAGS) $(AUTOFS_LIB) $(LIBLDAP) $(LIBRESOLV) $(LIBS)
 	$(STRIP) lookup_ldap.so
 
+lookup_udisks.so: lookup_udisks.c ../include/lookup_udisks.h
+	$(CC) $(SOLDFLAGS) $(CFLAGS) $(UDISKS_FLAGS) -o $@ $< $(UDISKS_LIBS)
+	$(STRIP) $@
+
 mount_nfs.so: mount_nfs.c replicated.o
 	$(CC) $(SOLDFLAGS) $(CFLAGS) -o mount_nfs.so \
 		mount_nfs.c replicated.o $(LDFLAGS) $(AUTOFS_LIB) $(LIBS)
--- a/modules/lookup_multi.c
+++ b/modules/lookup_multi.c
@@ -56,6 +56,8 @@ static struct lookup_mod *nss_open_looku
 	if (!strncmp(argv[0], "file", 4) ||
 	    !strncmp(argv[0], "yp", 2) ||
 	    !strncmp(argv[0], "nisplus", 7) ||
+	    !strncmp(argv[0], "udisks", 6) ||
+	    !strncmp(argv[0], "udisks2", 7) ||
 	    !strncmp(argv[0], "nis", 3) ||
 	    !strncmp(argv[0], "ldaps", 5) ||
 	    !strncmp(argv[0], "ldap", 4) ||
--- /dev/null
+++ b/modules/lookup_udisks.c
@@ -0,0 +1,2449 @@
+/*
+ * lookup_udisks.c - Module for Linux automount to access removable devices
+ *                   listed by the dbus based udisks-daemon
+ *
+ *   Copyright 2012 SuSE LINUX Products GmbH - All Rights Reserved
+ *   Copyright 2012 Werner Fink <werner@suse.de>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
+ *   USA; either version 2 of the License, or (at your option) any later
+ *   version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ */
+
+#include <dbus/dbus.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xmlerror.h>
+
+#define MODULE_LOOKUP
+#include "automount.h"
+#include "nsswitch.h"
+#include "lookup_udisks.h"
+
+extern pthread_attr_t th_attr_detached;
+
+#define MAPFMT_DEFAULT		"sun"
+
+#define DBUS_COMMON_NAME_UDISKS		"org.freedesktop.UDisks"
+#define DBUS_INTERFACE_UDISKS		"org.freedesktop.UDisks"
+#define DBUS_OBJECT_PATH_UDISKS_ROOT	"/org/freedesktop/UDisks"
+
+/*
+ * Sorted with same order as found in the response of the dbus call
+ * org.freedesktop.DBus.Properties.GetAll, e.g.
+ *  dbus-send --system --print-reply --dest=org.freedesktop.UDisks \
+ *	/org/freedesktop/UDisks/devices/sda \
+ *	org.freedesktop.DBus.Properties.GetAll \
+ *	string:org.freedesktop.UDisks.Device | \
+ *  sed -rn '/dict entry$/,/$/ {
+ *	H
+ *	x
+ *	s@\n*@@g
+ *	s@^\s+string\s("\w+")\s+variant\s+(\w+).*@FILTER$\U\2\E,\t\1$@p
+ *  }'
+ *
+ * compare with enum type devdict_t in ../include/lookup_udisks.h
+ * that is if add here a hash key you have to extend dict_t!
+ */
+#define FILTER(name, property)	{ property, DBUS_TYPE_ ## name }
+static filter_t devproperpty[] = {
+	FILTER(STRING,	"NativePath"),
+	FILTER(UINT64,	"DeviceDetectionTime"),
+	FILTER(UINT64,	"DeviceMediaDetectionTime"),
+	FILTER(INT64,	"DeviceMajor"),
+	FILTER(INT64,	"DeviceMinor"),
+	FILTER(STRING,	"DeviceFile"),
+	FILTER(STRING,	"DeviceFilePresentation"),
+	FILTER(ARRAY,	"DeviceFileById"),
+	FILTER(ARRAY,	"DeviceFileByPath"),
+	FILTER(BOOLEAN,	"DeviceIsSystemInternal"),
+	FILTER(BOOLEAN,	"DeviceIsPartition"),
+	FILTER(BOOLEAN,	"DeviceIsPartitionTable"),
+	FILTER(BOOLEAN,	"DeviceIsRemovable"),
+	FILTER(BOOLEAN,	"DeviceIsMediaAvailable"),
+	FILTER(BOOLEAN,	"DeviceIsMediaChangeDetected"),
+	FILTER(BOOLEAN,	"DeviceIsMediaChangeDetectionPolling"),
+	FILTER(BOOLEAN,	"DeviceIsMediaChangeDetectionInhibitable"),
+	FILTER(BOOLEAN,	"DeviceIsMediaChangeDetectionInhibited"),
+	FILTER(BOOLEAN,	"DeviceIsReadOnly"),
+	FILTER(BOOLEAN,	"DeviceIsDrive"),
+	FILTER(BOOLEAN,	"DeviceIsOpticalDisc"),
+	FILTER(BOOLEAN,	"DeviceIsMounted"),
+	FILTER(ARRAY,	"DeviceMountPaths"),
+	FILTER(UINT32,	"DeviceMountedByUid"),
+	FILTER(BOOLEAN,	"DeviceIsLuks"),
+	FILTER(BOOLEAN,	"DeviceIsLuksCleartext"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxMdComponent"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxMd"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxLvm2LV"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxLvm2PV"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxDmmpComponent"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxDmmp"),
+	FILTER(BOOLEAN,	"DeviceIsLinuxLoop"),
+	FILTER(UINT64,	"DeviceSize"),
+	FILTER(UINT64,	"DeviceBlockSize"),
+	FILTER(BOOLEAN,	"DevicePresentationHide"),
+	FILTER(BOOLEAN,	"DevicePresentationNopolicy"),
+	FILTER(STRING,	"DevicePresentationName"),
+	FILTER(STRING,	"DevicePresentationIconName"),
+	FILTER(STRING,	"DeviceAutomountHint"),
+	FILTER(BOOLEAN,	"JobInProgress"),
+	FILTER(STRING,	"JobId"),
+	FILTER(UINT32,	"JobInitiatedByUid"),
+	FILTER(BOOLEAN,	"JobIsCancellable"),
+	FILTER(DOUBLE,	"JobPercentage"),
+	FILTER(STRING,	"IdUsage"),
+	FILTER(STRING,	"IdType"),
+	FILTER(STRING,	"IdVersion"),
+	FILTER(STRING,	"IdUuid"),
+	FILTER(STRING,	"IdLabel"),
+	FILTER(OBJECT,	"LuksHolder"),
+	FILTER(OBJECT,	"LuksCleartextSlave"),
+	FILTER(UINT32,	"LuksCleartextUnlockedByUid"),
+	FILTER(OBJECT,	"PartitionSlave"),
+	FILTER(STRING,	"PartitionScheme"),
+	FILTER(STRING,	"PartitionType"),
+	FILTER(STRING,	"PartitionLabel"),
+	FILTER(STRING,	"PartitionUuid"),
+	FILTER(ARRAY,	"PartitionFlags"),
+	FILTER(INT32,	"PartitionNumber"),
+	FILTER(UINT64,	"PartitionOffset"),
+	FILTER(UINT64,	"PartitionSize"),
+	FILTER(UINT64,	"PartitionAlignmentOffset"),
+	FILTER(STRING,	"PartitionTableScheme"),
+	FILTER(INT32,	"PartitionTableCount"),
+	FILTER(STRING,	"DriveVendor"),
+	FILTER(STRING,	"DriveModel"),
+	FILTER(STRING,	"DriveRevision"),
+	FILTER(STRING,	"DriveSerial"),
+	FILTER(STRING,	"DriveWwn"),
+	FILTER(UINT32,	"DriveRotationRate"),
+	FILTER(STRING,	"DriveWriteCache"),
+	FILTER(STRING,	"DriveConnectionInterface"),
+	FILTER(UINT64,	"DriveConnectionSpeed"),
+	FILTER(ARRAY,	"DriveMediaCompatibility"),
+	FILTER(STRING,	"DriveMedia"),
+	FILTER(BOOLEAN,	"DriveIsMediaEjectable"),
+	FILTER(BOOLEAN,	"DriveCanDetach"),
+	FILTER(BOOLEAN,	"DriveCanSpindown"),
+	FILTER(BOOLEAN,	"DriveIsRotational"),
+	FILTER(OBJECT,	"DriveAdapter"),
+	FILTER(ARRAY,	"DrivePorts"),
+	FILTER(ARRAY,	"DriveSimilarDevices"),
+	FILTER(BOOLEAN,	"OpticalDiscIsBlank"),
+	FILTER(BOOLEAN,	"OpticalDiscIsAppendable"),
+	FILTER(BOOLEAN,	"OpticalDiscIsClosed"),
+	FILTER(UINT32,	"OpticalDiscNumTracks"),
+	FILTER(UINT32,	"OpticalDiscNumAudioTracks"),
+	FILTER(UINT32,	"OpticalDiscNumSessions"),
+	FILTER(BOOLEAN,	"DriveAtaSmartIsAvailable"),
+	FILTER(UINT64,	"DriveAtaSmartTimeCollected"),
+	FILTER(STRING,	"DriveAtaSmartStatus"),
+	FILTER(ARRAY,	"DriveAtaSmartBlob"),
+	FILTER(STRING,	"LinuxMdComponentLevel"),
+	FILTER(INT32,	"LinuxMdComponentPosition"),
+	FILTER(INT32,	"LinuxMdComponentNumRaidDevices"),
+	FILTER(STRING,	"LinuxMdComponentUuid"),
+	FILTER(STRING,	"LinuxMdComponentName"),
+	FILTER(STRING,	"LinuxMdComponentHomeHost"),
+	FILTER(STRING,	"LinuxMdComponentVersion"),
+	FILTER(OBJECT,	"LinuxMdComponentHolder"),
+	FILTER(ARRAY,	"LinuxMdComponentState"),
+	FILTER(STRING,	"LinuxMdState"),
+	FILTER(STRING,	"LinuxMdLevel"),
+	FILTER(STRING,	"LinuxMdUuid"),
+	FILTER(STRING,	"LinuxMdHomeHost"),
+	FILTER(STRING,	"LinuxMdName"),
+	FILTER(INT32,	"LinuxMdNumRaidDevices"),
+	FILTER(STRING,	"LinuxMdVersion"),
+	FILTER(ARRAY,	"LinuxMdSlaves"),
+	FILTER(BOOLEAN,	"LinuxMdIsDegraded"),
+	FILTER(STRING,	"LinuxMdSyncAction"),
+	FILTER(DOUBLE,	"LinuxMdSyncPercentage"),
+	FILTER(UINT64,	"LinuxMdSyncSpeed"),
+	FILTER(STRING,	"LinuxLvm2PVUuid"),
+	FILTER(UINT32,	"LinuxLvm2PVNumMetadataAreas"),
+	FILTER(STRING,	"LinuxLvm2PVGroupName"),
+	FILTER(STRING,	"LinuxLvm2PVGroupUuid"),
+	FILTER(UINT64,	"LinuxLvm2PVGroupSize"),
+	FILTER(UINT64,	"LinuxLvm2PVGroupUnallocatedSize"),
+	FILTER(UINT64,	"LinuxLvm2PVGroupSequenceNumber"),
+	FILTER(UINT64,	"LinuxLvm2PVGroupExtentSize"),
+	FILTER(ARRAY,	"LinuxLvm2PVGroupPhysicalVolumes"),
+	FILTER(ARRAY,	"LinuxLvm2PVGroupLogicalVolumes"),
+	FILTER(STRING,	"LinuxLvm2LVName"),
+	FILTER(STRING,	"LinuxLvm2LVUuid"),
+	FILTER(STRING,	"LinuxLvm2LVGroupName"),
+	FILTER(STRING,	"LinuxLvm2LVGroupUuid"),
+	FILTER(OBJECT,	"LinuxDmmpComponentHolder"),
+	FILTER(STRING,	"LinuxDmmpName"),
+	FILTER(ARRAY,	"LinuxDmmpSlaves"),
+	FILTER(STRING,	"LinuxDmmpParameters"),
+	FILTER(STRING,	"LinuxLoopFilename"),
+	FILTER(BOOLEAN,	(char*)0)
+};
+
+/*
+ * Sorted with same order as found in the response of the dbus call
+ * org.freedesktop.DBus.Properties.GetAll, e.g.
+ *  dbus-send --print-reply --system --dest=org.freedesktop.ConsoleKit \
+ *	/org/freedesktop/ConsoleKit/Session2 \
+ *	org.freedesktop.DBus.Properties.GetAll \
+ *	string:org.freedesktop.ConsoleKit.Session | \
+ *  sed -rn '/dict entry$/,/$/ {
+ *	H
+ *	x
+ *	s@\n*@@g
+ *	s@^\s+string\s("[a-z0-9-]+")\s+variant\s+(\w+).*@FILTER$\U\2\E,\t\1$@p
+ *  }'
+ *
+ * compare with enum type ckdict_t in ../include/lookup_udisks.h
+ * that is if add here a hash key you have to extend ckdict_t!
+ */
+static filter_t sessproperty[] = {
+	FILTER(UINT32,  "unix-user"),
+	FILTER(UINT32,  "user"),
+	FILTER(STRING,  "session-type"),
+	FILTER(STRING,  "remote-host-name"),
+	FILTER(STRING,  "display-device"),
+	FILTER(STRING,  "x11-display"),
+	FILTER(STRING,  "x11-display-device"),
+	FILTER(BOOLEAN, "active"),
+	FILTER(BOOLEAN, "is-local"),
+	FILTER(BOOLEAN, "idle-hint"),
+	FILTER(BOOLEAN,	(char*)0)
+};
+
+#undef FILTER
+
+static inline device_t* add_device(list_t *head, const char *node)
+{
+	const char* identify;
+	device_t *restrict new;
+	list_t *ptr;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		device_t *this = list_entry(ptr, device_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			return this;
+	}
+
+	new = newaligned(alignof(device_t)+strsize(node));
+	if (!new)
+		return (device_t*)0;
+	memset(new, 0, alignof(device_t));
+
+	list_add_tail(&new->handle, head);
+	INIT_LIST_HEAD(&new->properties);
+	new->head = head;
+
+	new->node = ((typeof(new->node))new)+alignof(device_t);
+	strcpy(new->node, node);
+	new->identify = new->node+(identify-node);
+	return new;
+}
+
+static inline device_t* find_device(list_t *head, const char *node)
+{
+	const char* identify;
+	list_t *ptr;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		device_t *this = list_entry(ptr, device_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			return this;
+	}
+	return (device_t*)0;
+}
+
+static inline void delete_device(device_t *this)
+{
+	list_t *ptr, *safe;
+	list_for_each_safe(ptr, safe, &this->properties) {
+		property_t *obj = list_entry(ptr, property_t, handle);
+		if (obj->type == DBUS_TYPE_ARRAY) {
+			list_t *ap, *as;
+			list_for_each_safe(ap, as, (list_t*)obj->value) {
+				array_t *array = list_entry(ap, array_t, handle);
+				list_del(ap);
+				free(array);
+			}
+		}
+		list_del(ptr);
+		free(obj);
+	}
+	list_del(&this->handle);
+	this->head = (list_t*)0;
+	if (this->opts) free(this->opts);
+	if (this->entry) free(this->entry);
+	free(this);
+}
+
+static inline void remove_device(list_t *head, const char *node)
+{
+	list_t *ptr;
+	device_t *this = (device_t*)0;
+	const char* identify;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		this = list_entry(ptr, device_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			break;
+	}
+	if (this) delete_device(this);
+}
+
+static inline void clear_devices(list_t *head)
+{
+	list_t *ptr, *safe;
+	list_for_each_safe(ptr, safe, head) {
+		device_t *this = list_entry(ptr, device_t, handle);
+		delete_device(this);
+	}
+}
+
+static inline session_t* add_session(list_t *head, const char *node)
+{
+	const char* identify;
+	session_t *restrict new;
+	list_t *ptr;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		session_t *this = list_entry(ptr, session_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			return this;
+	}
+
+	new = newaligned(alignof(session_t)+strsize(node));
+	if (!new)
+		return (session_t*)0;
+	memset(new, 0, alignof(session_t));
+
+	list_add_tail(&new->handle, head);
+	INIT_LIST_HEAD(&new->properties);
+	new->head = head;
+
+	new->node = ((typeof(new->node))new)+alignof(session_t);
+	strcpy(new->node, node);
+	new->identify = new->node+(identify-node);
+	return new;
+}
+
+static inline session_t* find_session(list_t *head, const char *node)
+{
+	const char* identify;
+	list_t *ptr;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		session_t *this = list_entry(ptr, session_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			return this;
+	}
+	return (session_t*)0;
+}
+
+static inline void delete_session(session_t *this)
+{
+	list_t *ptr, *safe;
+	list_for_each_safe(ptr, safe, &this->properties) {
+		property_t *obj = list_entry(ptr, property_t, handle);
+		if (obj->type == DBUS_TYPE_ARRAY) {
+			list_t *ap, *as;
+			list_for_each_safe(ap, as, (list_t*)obj->value) {
+				array_t *array = list_entry(ap, array_t, handle);
+				list_del(ap);
+				free(array);
+			}
+		}
+		list_del(ptr);
+		free(obj);
+	}
+	list_del(&this->handle);
+	this->head = (list_t*)0;
+	if (this->opts) free(this->opts);
+	free(this);
+}
+
+static inline void remove_session(list_t *head, const char *node)
+{
+	list_t *ptr;
+	session_t *this = (session_t*)0;
+	const char* identify;
+
+	if ((identify = strrchr(node, '/')))
+		identify++;
+	else	identify = node;
+
+	list_for_each(ptr, head) {
+		this = list_entry(ptr, session_t, handle);
+		if (strcmp(this->identify, identify) == 0)
+			break;
+	}
+	if (this) delete_session(this);
+}
+
+static inline void clear_sessions(list_t *head)
+{
+	list_t *ptr, *safe;
+	list_for_each_safe(ptr, safe, head) {
+		session_t *this = list_entry(ptr, session_t, handle);
+		delete_session(this);
+	}
+}
+
+static filter_t *property;
+static inline property_t *add_property(list_t *head,
+	const char* name,
+	int type,
+	const void *value,
+	size_t len)
+{
+	property_t *restrict new;
+	filter_t *flt;
+	list_t *ptr;
+	size_t slen;
+
+	if (!property) {
+		logerr(MODPREFIX "property not specified");
+		return (property_t*)0;
+	}
+
+	flt = property;
+	do {
+		if (flt->property == (char*)0)
+			break;
+		if (strcmp(flt->property, name) == 0)
+			break;
+	} while (flt++);
+
+	if (flt->property == (char*)0) {
+		warn(LOGOPT_NONE, MODPREFIX "udisks reply property `%s' not known", name);
+		slen = strsize(name);
+	} else {
+		slen = 0;
+		if (flt->type != type)
+			warn(LOGOPT_NONE, MODPREFIX "udisks reply type `%c' not known", type);
+	}
+
+	list_for_each(ptr, head) {
+		property_t *this = list_entry(ptr, property_t, handle);
+		if (strcmp(this->name, name) == 0)
+			return this;
+	}
+	if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH)
+		len++;
+
+	new = newaligned(alignof(property_t)+slen+len);
+	if (!new)
+		return (property_t*)0;
+	memset(new, 0, alignof(property_t));
+
+	list_add_tail(&new->handle, head);
+
+	new->type = type;
+
+	if (flt->property == (char*)0) {
+		new->name = ((typeof(new->name))new)+alignof(property_t);
+		strcpy(new->name, name);
+	} else
+		new->name = flt->property;		/* hash key */
+
+	new->value = ((typeof(new->value))new)+alignof(property_t)+slen;
+	if (type == DBUS_TYPE_ARRAY)
+		INIT_LIST_HEAD(((list_t*)new->value));
+	else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH)
+		strcpy(new->value, value);
+	else
+		memcpy(new->value, value, len);
+
+	return new;
+}
+
+static void append_array(list_t *head, const char *value)
+{
+	array_t *restrict new;
+	const char *string;
+
+	if ((string = strrchr(value, '/')))
+		string++;
+	else	string = value;
+
+	new = newaligned(alignof(array_t)+strsize(string));
+	if (!new)
+		return;
+	memset(new, 0, alignof(array_t));
+	list_add_tail(&new->handle, head);
+
+	new->value = ((typeof(new->value))new)+alignof(array_t);
+	strcpy(new->value, string);
+}
+
+static inline option_t map_property(const list_t *head, const char *restrict property)
+{
+	option_t ret;
+	list_t *ptr;
+
+	list_for_each(ptr, head) {
+		property_t *prop = list_entry(ptr, property_t, handle);
+		if (property == prop->name) {
+			ret.error = 0;
+			switch (prop->type) {
+			case DBUS_TYPE_BOOLEAN:
+				ret.boolean = *(dbus_bool_t*)(prop->value);
+				break;
+			case DBUS_TYPE_INT32:
+				ret.int32 = *(dbus_int32_t*)(prop->value);
+				break;
+			case DBUS_TYPE_UINT32:
+				ret.uint32 = *(dbus_uint32_t*)(prop->value);
+				break;
+			case DBUS_TYPE_INT64:
+				ret.int64 = *(dbus_int64_t*)(prop->value);
+				break;
+			case DBUS_TYPE_UINT64:
+				ret.uint64 =  *(dbus_uint64_t*)(prop->value);
+				break;
+			case DBUS_TYPE_DOUBLE:
+				ret.number = *(double*)(prop->value);
+				break;
+			case DBUS_TYPE_STRING:
+			case DBUS_TYPE_OBJECT:
+				ret.string = (char*)(prop->value);
+				break;
+			case DBUS_TYPE_ARRAY:
+				ret.array = (list_t*)(prop->value);
+				break;
+			default:
+				ret.error = 1;
+				warn(LOGOPT_NONE, MODPREFIX
+				     "udisks dbus type `%c' not handled", prop->type);
+				break;
+			}
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static option_t get_option(const device_t *this, const devdict_t opt)
+{
+	filter_t *flt;
+	option_t ret;
+
+	memset(&ret, 0, sizeof(ret));
+	ret.error = 1;
+	if (sizeof(devproperpty)/sizeof(filter_t) < opt) {
+		logerr(MODPREFIX "udisks option `%d' not known", opt);
+		goto out;
+	}
+	flt = &devproperpty[opt];
+	if (flt->property == (char*)0) {
+		warn(LOGOPT_NONE, MODPREFIX "udisks option `%d' not known", opt);
+		goto out;
+	}
+	ret = map_property(&this->properties, flt->property);
+out:
+	return ret;
+}
+
+static option_t get_session(const session_t *this, const ckdict_t opt)
+{
+	filter_t *flt;
+	option_t ret;
+
+	memset(&ret, 0, sizeof(ret));
+	ret.error = 1;
+	if (sizeof(sessproperty)/sizeof(filter_t) < opt) {
+		logerr(MODPREFIX "udisks option `%d' not known", opt);
+		goto out;
+	}
+	flt = &sessproperty[opt];
+	if (flt->property == (char*)0) {
+		warn(LOGOPT_NONE, MODPREFIX "udisks option `%d' not known", opt);
+		goto out;
+	}
+	ret = map_property(&this->properties, flt->property);
+out:
+	return ret;
+}
+
+static entry_t *do_map_entry(struct lookup_context *ctxt, device_t *this)
+{
+	const int labels[] = {IdLabel, DriveModel, DriveVendor, DriveSerial, -1};
+	const config_t *const config = &ctxt->config;
+	entry_t *restrict entry = (entry_t*)0;
+	char mapent[MAPENT_MAX_LEN+1];
+	const char *fstype;
+	const char *fallbck;
+	const char *common;
+	const char *device;
+	option_t option;
+	size_t maplen;
+	int offset;
+	list_t *ptr;
+	char *key;
+
+	if (!config->enabled)
+		goto out;
+
+	option = get_option(this, DeviceIsSystemInternal);
+	if (option.error || option.boolean == TRUE)
+		goto out;
+
+	option = get_option(this, JobInProgress);
+	if (option.error || option.boolean == TRUE)
+		goto out;
+
+	option = get_option(this, DeviceIsRemovable);
+	if (option.error || option.boolean == FALSE) {
+		/*
+		 * Check for removable master device!
+		 */
+		option = get_option(this, DeviceIsDrive);
+		if (option.error)
+			goto out;
+		if (option.boolean == FALSE) {
+			device_t *master;
+			option = get_option(this, PartitionSlave);
+			if (option.error || strlen(option.string) <= 1)
+				goto out;
+			master = find_device(this->head, option.string);
+			option = get_option(master, DeviceIsRemovable);
+			if (option.error || option.boolean == FALSE)
+				goto out;
+		}
+	}
+
+	option = get_option(this, DeviceIsPartition);
+	if (option.error || option.boolean == FALSE) {
+		/*
+		 * Check for optical device with media!
+		 */
+		option = get_option(this, DeviceIsOpticalDisc);
+		if (option.error || option.boolean == FALSE)
+			goto out;
+		option = get_option(this, OpticalDiscNumAudioTracks);
+		if (option.error || option.uint32 > 0)
+			goto out;
+	}
+
+	option = get_option(this, IdUsage);
+	if (option.error || strcmp(option.string, "filesystem") != 0)
+			goto out;
+
+	option = get_option(this, IdType);
+	if (option.error)
+		goto out;
+	fstype = option.string;
+	if (*fstype == '\0')
+		fstype = "auto";
+
+	option = get_option(this, DeviceFilePresentation);
+	if (option.error)
+		goto out;
+	device = option.string;
+
+	maplen = sizeof(mapent);
+	offset = snprintf(&mapent[0], maplen, "-fstype=%s", fstype);
+	if (offset < 0 || offset >= maplen)
+		goto out;
+	maplen -= offset;
+
+	fallbck = (char*)0;
+	list_for_each(ptr, &config->fstypes) {
+		mntopt_t *fs = list_entry(ptr, mntopt_t, handle);
+		if (strcmp(fstype, fs->identify) == 0) {
+			int len = snprintf(&mapent[offset], maplen, ",%s", fs->options);
+			if (len < 0 || len >= maplen)
+				goto out;
+			offset += len;
+			maplen -= len;
+			fallbck = (char*)0;
+			break;
+		}
+		if (strcmp("auto", fs->identify) == 0)
+			fallbck = fs->identify;
+	}
+
+	if (fallbck) {
+		int len = snprintf(&mapent[offset], maplen, ",%s", fallbck);
+		if (len < 0 || len >= maplen)
+			goto out;
+		offset += len;
+		maplen -= len;
+	}
+
+	/*
+	 * Determine common mount options in order of <DiskByLabel>
+	 * <DiskById>, and last but not least <Common> from the
+	 * configuration file for the current map.
+	 */
+	common = (char*)0;
+	option = get_option(this, IdLabel);
+	if (option.error)
+		goto out;
+	if (*option.string) {
+		list_for_each(ptr, &config->label) {
+			mntopt_t *lb = list_entry(ptr, mntopt_t, handle);
+			if (strcmp(option.string, lb->identify) == 0) {
+				common = lb->options;
+				break;
+			}
+		}
+	}
+	if (!common) {
+		list_t *tmp;
+		option = get_option(this, DeviceFileById);
+		if (option.error)
+			goto out;
+		list_for_each(tmp, option.array) {
+			array_t *str = list_entry(tmp, array_t, handle);
+			list_for_each(ptr, &config->byid) {
+				mntopt_t *id = list_entry(ptr, mntopt_t, handle);
+				if (strcmp(str->value, id->identify) == 0) {
+					common = id->options;
+					break;
+				}
+			}
+			if (common) break;
+		}
+	}
+	if (!common) common = config->common;
+
+	if (common) {
+		int len = snprintf(&mapent[offset], maplen, ",%s", common);
+		if (len < 0 || len >= maplen)
+			goto out;
+		offset += len;
+		maplen -= len;
+	}
+
+	/*
+	 * Now add the device after a colon
+	 */
+	offset = snprintf(&mapent[offset], maplen, " :%s", device);
+	if (offset < 0 || offset >= maplen)
+		goto out;
+	maplen -= offset;
+
+	/*
+	 * The key of the entry
+	 */
+	key = (char*)0;
+	for (offset = 0; labels[offset] >= 0; offset++) {
+		char *ptr;
+
+		option = get_option(this, labels[offset]);
+		if (option.error)
+			continue;
+		if (*option.string == '\0')
+			continue;
+		if (strcasecmp(option.string, "usb") == 0)
+			continue;
+
+		key = strdup(option.string);
+		if (key == (char*)0)
+			goto out;
+
+		for (ptr = key; *ptr; ptr++) {
+			if (*ptr == ' ') *ptr = '_';
+			else if (*ptr == '/') *ptr = '_';
+			else if (*ptr < 32)  *ptr = '?';
+			else if (*ptr > 127) *ptr = '?';
+		}
+
+		break;
+	}
+	if (key == (char*)0)
+		goto out;
+
+	/*
+	 * Allocate the entry and return this.
+	 */
+	entry = newaligned(alignof(entry_t)+strsize(key)+strsize(mapent));
+	if (!entry)
+		goto out;
+	memset(entry, 0, alignof(entry_t));
+
+	entry->key = ((typeof(entry->key))entry)+alignof(entry_t);
+	entry->key_len = strlen(key);
+	strcpy(entry->key, key);
+
+	entry->mapent = ((typeof(entry->mapent))entry)+alignof(entry_t)+strsize(key);
+	entry->mapent_len = strlen(mapent);
+	strcpy(entry->mapent, mapent);
+
+	if (this->entry)
+		free(this->entry);
+	this->entry = entry;
+	free(key);
+out:
+	return entry;
+}
+
+/*
+ * We parse dbus messages structure as response of org.freedesktop.DBus.Properties.GetAll
+ * which looks like this one:
+ *
+ *    array [
+ *       dict_entry(
+ *          string   "DictName"
+ *          variant  [array:string|boolean|double|int32|int64|object_path|string|uint32|uint64]
+ *       )
+ *       ...
+ *    ]
+ *
+ */
+static void __iterate_reply(DBusMessageIter *iter, list_t *head, const char** name)
+{
+	do {
+		int type = dbus_message_iter_get_arg_type(iter);
+		if (type == DBUS_TYPE_INVALID)
+			break;
+		switch (type) {
+		case DBUS_TYPE_STRING: {
+			char *value;
+			dbus_message_iter_get_basic(iter, &value);
+			if (*name == (char*)0) {
+				*name = value;
+				break;
+			}
+			add_property(head, *name, DBUS_TYPE_STRING, value, strlen(value));
+			break;
+		}
+		case DBUS_TYPE_OBJECT_PATH: {
+			char *value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_OBJECT_PATH, value, strlen(value));
+			break;
+		}
+		case DBUS_TYPE_INT32: {
+			dbus_int32_t value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_INT32, &value, sizeof(dbus_int32_t));
+			break;
+		}
+		case DBUS_TYPE_UINT32: {
+			dbus_uint32_t value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_UINT32, &value, sizeof(dbus_uint32_t));
+			break;
+		}
+		case DBUS_TYPE_INT64: {
+			dbus_int64_t value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_INT64, &value, sizeof(dbus_int64_t));
+			break;
+		}
+		case DBUS_TYPE_UINT64: {
+			dbus_uint64_t value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_UINT64, &value, sizeof(dbus_uint64_t));
+			break;
+		}
+		case DBUS_TYPE_DOUBLE: {
+			double value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_DOUBLE, &value, sizeof(double));
+			break;
+		}
+		case DBUS_TYPE_BOOLEAN: {
+			dbus_bool_t value;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_get_basic(iter, &value);
+			add_property(head, *name, DBUS_TYPE_BOOLEAN, &value, sizeof(dbus_bool_t));
+			break;
+		}
+		case DBUS_TYPE_ARRAY: {
+			int tsub;
+			property_t *prop;
+			DBusMessageIter isub;
+
+			if (name == (const char**)0) {
+				/*
+				 * The outer array of the message, check for first entry which
+				 * should be a dict container, anything else is a bug.
+				 */
+				dbus_message_iter_recurse (iter, &isub);
+				if (dbus_message_iter_get_arg_type(&isub) != DBUS_TYPE_DICT_ENTRY)
+					goto err;
+				__iterate_reply(&isub, head, (const char**)0);
+				break;
+			}
+
+			dbus_message_iter_recurse(iter, &isub);
+			tsub = dbus_message_iter_get_arg_type(&isub);
+			prop = add_property(head, *name, DBUS_TYPE_ARRAY, 0, sizeof(list_t));
+
+			while (tsub == DBUS_TYPE_STRING) {
+				char *value;
+				dbus_message_iter_get_basic(&isub, &value);
+				append_array(((list_t*)prop->value),  value);
+
+				dbus_message_iter_next(&isub);
+				tsub = dbus_message_iter_get_arg_type(&isub);
+			}
+			break;
+		}
+		case DBUS_TYPE_VARIANT: {
+			DBusMessageIter isub;
+			if (*name == (char*)0)
+				goto err;
+			dbus_message_iter_recurse(iter, &isub);
+			__iterate_reply(&isub, head, name);
+			break;
+		}
+		case DBUS_TYPE_DICT_ENTRY: {
+			const char *dict;
+			DBusMessageIter isub;
+			dbus_message_iter_recurse(iter, &isub);
+			dict = (const char*)0;
+			__iterate_reply(&isub, head, &dict);
+			dbus_message_iter_next(&isub);
+			__iterate_reply(&isub, head, &dict);
+			break;
+		}
+		default:
+		err:
+			warn(LOGOPT_NONE, MODPREFIX "udisks reply type `%c' not handled", type);
+			break;
+		}
+	} while (dbus_message_iter_next(iter));
+}
+
+static inline void iterate_device_reply(DBusMessageIter *iter, list_t *head)
+{
+	property = &devproperpty[0];
+	__iterate_reply(iter, head, (const char**)0);
+	property = (filter_t*)0;
+}
+
+static int read_device_properties(struct lookup_context *ctxt, device_t *obj)
+{
+	const char *device = "org.freedesktop.UDisks.Device";
+	DBusMessage *reply, *send;
+	DBusMessageIter iter;
+	const char *signature;
+	int ret = NSS_STATUS_UNAVAIL;
+
+	send = dbus_message_new_method_call("org.freedesktop.UDisks",
+					     obj->node,
+					    "org.freedesktop.DBus.Properties",
+					    "GetAll");
+	if (!send)
+		goto out;
+	dbus_message_set_auto_start(send, TRUE);
+	if (!dbus_message_set_destination(send, "org.freedesktop.UDisks"))
+		goto out;
+
+	dbus_message_iter_init_append(send, &iter);
+
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &device);
+
+	reply = dbus_connection_send_with_reply_and_block(ctxt->conn, send, 50000, ctxt->error);
+	dbus_message_unref(send);
+
+	if (dbus_error_is_set(ctxt->error)) {
+		warn(LOGOPT_NONE, MODPREFIX
+		     "udisks map %s, can not connect system dbus: %s", ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto out;
+	}
+	if (!reply)
+		goto out;
+	if (dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+		goto unref;
+	signature = dbus_message_get_signature(reply);
+	if ((int)*signature != DBUS_TYPE_ARRAY)
+		goto unref;
+	dbus_message_iter_init(reply, &iter);
+	iterate_device_reply(&iter, &obj->properties);
+	ret = NSS_STATUS_SUCCESS;
+unref:
+	dbus_message_unref(reply);
+out:
+	if (ret != NSS_STATUS_SUCCESS)
+		logerr(MODPREFIX "%s failed", __FUNCTION__);
+	return ret;
+}
+
+static inline void iterate_session_reply(DBusMessageIter *iter, list_t *head)
+{
+	property = &sessproperty[0];
+	__iterate_reply(iter, head, (const char**)0);
+	property = (filter_t*)0;
+}
+
+static int read_session_properties(struct lookup_context *ctxt, session_t *obj)
+{
+	const char *session = "org.freedesktop.ConsoleKit.Session";
+	DBusMessage *reply, *send;
+	DBusMessageIter iter;
+	const char *signature;
+	int ret = NSS_STATUS_UNAVAIL;
+
+	send = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
+					     obj->node,
+					    "org.freedesktop.DBus.Properties",
+					    "GetAll");
+	if (!send)
+		goto out;
+	dbus_message_set_auto_start(send, TRUE);
+	if (!dbus_message_set_destination(send, "org.freedesktop.ConsoleKit"))
+		goto out;
+
+	dbus_message_iter_init_append(send, &iter);
+
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &session);
+
+	reply = dbus_connection_send_with_reply_and_block(ctxt->conn, send, 50000, ctxt->error);
+	dbus_message_unref(send);
+
+	if (dbus_error_is_set(ctxt->error)) {
+		warn(LOGOPT_NONE, MODPREFIX
+		     "udisks sessions %s, can not connect system dbus: %s", ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto out;
+	}
+	if (!reply)
+		goto out;
+	if (dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+		goto unref;
+	signature = dbus_message_get_signature(reply);
+	if ((int)*signature != DBUS_TYPE_ARRAY)
+		goto unref;
+	dbus_message_iter_init(reply, &iter);
+	iterate_session_reply(&iter, &obj->properties);
+	ret = NSS_STATUS_SUCCESS;
+unref:
+	dbus_message_unref(reply);
+out:
+	if (ret != NSS_STATUS_SUCCESS)
+		logerr(MODPREFIX "%s failed", __FUNCTION__);
+	return ret;
+}
+
+typedef enum member_e {
+	DeviceAdded = 0,
+	DeviceChanged,
+	DeviceRemoved,
+	SessionAdded,
+	SessionRemoved,
+	UnkownMember
+} member_t;
+
+static time_t do_cache_update(struct lookup_context *ctxt,
+	const char *key, const char *mapent,
+	const int update)
+{
+	struct autofs_point *ap = ctxt->ap;
+	struct map_source *map = ctxt->map;
+	struct mapent_cache *mc;
+	time_t age = time(NULL);
+	char path[PATH_MAX+1];
+	int manage = 0;
+
+	if (!ap || !map->mc)
+		return 0;
+	mc = map->mc;
+
+	if ((ap->flags & MOUNT_FLAG_GHOST) && strlen(key)) {
+		int len = snprintf(path, PATH_MAX, "%s/%s", ap->path, key);
+		if (len < 0 || len >= PATH_MAX)
+			return 0;
+		manage = 1;
+	}
+
+	cache_writelock(mc);
+	switch (update) {
+	case DeviceRemoved:
+		debug(LOGOPT_NONE, MODPREFIX "%s %d remove %s -> %s", __FUNCTION__, __LINE__, key, mapent);
+		cache_delete(mc, key);
+		if (manage)
+			rmdir_path(ap, path, ap->dev);
+		break;
+	default:
+	case DeviceAdded:
+		debug(LOGOPT_NONE, MODPREFIX "%s %d added %s -> %s", __FUNCTION__, __LINE__, key, mapent);
+		cache_update(mc, map, key, mapent, age);
+		if (manage)
+			mkdir_path(path, 0555);
+		break;
+	}
+	cache_unlock(mc);
+
+	map->age = age;
+	return age;
+}
+
+static DBusHandlerResult dbusfilter(DBusConnection *connection,
+	DBusMessage *message,
+	void *context)
+{
+	struct lookup_context *ctxt = (struct lookup_context *)context;
+	DBusMessageIter iter;
+	const char *interface;
+	const char *member;
+	const char *path;
+	int type, state;
+	member_t memb;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
+
+	type = dbus_message_get_type(message);
+	switch (type) {
+	case DBUS_MESSAGE_TYPE_SIGNAL:
+	case DBUS_MESSAGE_TYPE_METHOD_CALL:
+		path = dbus_message_get_path(message);
+		if (!path)
+			break;
+		if (strncmp("/org/freedesktop/", path, 17))
+			break;
+		interface = dbus_message_get_interface(message);
+		if (!interface)
+			break;
+		if (strncmp("org.freedesktop.", interface, 16))
+			break;
+		member = dbus_message_get_member(message);
+		if (!member) {
+			warn(LOGOPT_NONE, MODPREFIX
+			     "udisks member of `%s' is missed known", path);
+			break;
+		}
+
+		memb = UnkownMember;
+		if (strcmp("UDisks", path+17) == 0) {
+			if (strcmp("UDisks", interface+16))
+				break;
+			if (strncmp(member, "Device", 6)) {
+				warn(LOGOPT_NONE, MODPREFIX
+				     "udisks member `%s' not known", member);
+				break;
+			}
+			member += 6;
+
+			if (strcmp(member, "Added") == 0)
+				memb = DeviceAdded;
+			else if (strcmp(member, "Changed") == 0)
+				memb = DeviceChanged;
+			else if (strcmp(member, "Removed") == 0)
+				memb = DeviceRemoved;
+
+		} else if (strncmp("ConsoleKit/Seat", path+17, 4) == 0) {
+			if (strcmp("ConsoleKit.Seat", interface+16))
+				break;
+			if (strncmp(member, "Session", 7)) {
+				warn(LOGOPT_NONE, MODPREFIX
+				     "udisks member `%s' not known", member);
+				break;
+			}
+			member += 7;
+
+			if (strcmp(member, "Added") == 0)
+				memb = SessionAdded;
+			else if (strcmp(member, "Removed") == 0)
+				memb = SessionRemoved;
+
+		} else
+			break;
+
+		dbus_message_iter_init(message, &iter);
+		type = dbus_message_iter_get_arg_type(&iter);
+		if (type != DBUS_TYPE_OBJECT_PATH) {
+			warn(LOGOPT_NONE, MODPREFIX
+			     "udisks member `Device%s' without object path", member);
+			break;
+		}
+		dbus_message_iter_get_basic(&iter, &path);
+		lock(ctxt);
+		switch (memb) {
+		case DeviceAdded: {
+			device_t *this = add_device(&ctxt->devices, path);
+			if (this) {
+				entry_t *entry;
+				int ret = read_device_properties(ctxt, this);
+				if (ret != NSS_STATUS_SUCCESS) {
+					remove_device(&ctxt->devices, path);
+					break;
+				}
+				entry = do_map_entry(ctxt, this);
+				if (entry)
+					entry->age = do_cache_update(ctxt, entry->key, entry->mapent, DeviceAdded);
+			}
+			break;
+		}
+		case DeviceChanged: {
+			char *key = (char*)0;
+			device_t *this = find_device(&ctxt->devices, path);
+			if (this) {
+				entry_t *entry = this->entry;
+				if (entry)
+					key = strdup(entry->key);
+				delete_device(this);
+			}
+			this = add_device(&ctxt->devices, path);
+			if (this) {
+				entry_t *entry;
+				int ret = read_device_properties(ctxt, this);
+				if (ret != NSS_STATUS_SUCCESS) {
+					remove_device(&ctxt->devices, path);
+					if (key)
+						free(key);
+					break;
+				}
+				entry = do_map_entry(ctxt, this);
+				if (entry) {
+					if (key == (char*)0)
+						entry->age = do_cache_update(ctxt, entry->key, entry->mapent, DeviceAdded);
+					else if (strcmp(key, entry->key) != 0) {
+						entry->age = do_cache_update(ctxt, entry->key, entry->mapent, DeviceAdded);
+						free(key);
+					}
+				} else {
+					if (key) {
+						(void)do_cache_update(ctxt, key, (char*)0, DeviceRemoved);
+						free(key);
+					}
+				}
+				break;
+			}
+			if (!key)
+				break;
+			do_cache_update(ctxt, key, (char*)0, DeviceRemoved);
+			free(key);
+			break;
+		}
+		case DeviceRemoved: {
+			device_t *this = find_device(&ctxt->devices, path);
+			if (this) {
+				entry_t *entry = this->entry;
+				if (entry)
+					(void)do_cache_update(ctxt, entry->key, (char*)0, DeviceRemoved);
+				delete_device(this);
+			}
+			break;
+		}
+		case SessionAdded: {
+			session_t *this = add_session(&ctxt->sessions, path);
+			if (this) {
+				int ret = read_session_properties(ctxt, this);
+				if (ret == NSS_STATUS_SUCCESS) {
+					debug(LOGOPT_NONE, MODPREFIX "%s %d added session %s", __FUNCTION__, __LINE__, path);
+					break;
+				}
+				remove_session(&ctxt->sessions, path);
+			}
+			break;
+		}
+		case SessionRemoved: {
+			session_t *this = find_session(&ctxt->sessions, path);
+			if (this) {
+				debug(LOGOPT_NONE, MODPREFIX "%s %d removed session %s", __FUNCTION__, __LINE__, path);
+				delete_session(this);
+			}
+			break;
+		}
+		default:
+			warn(LOGOPT_NONE, MODPREFIX "udisks member `Device%s' not known", member);
+			break;
+		}
+		unlock(ctxt);
+	default:
+		break;
+	}
+
+	pthread_setcancelstate(state, NULL);
+
+	if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
+		if (ctxt->active) {
+			lock(ctxt);
+			ctxt->active = 0;
+			unlock(ctxt);
+			pthread_exit(NULL);
+		}
+	}
+
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static void free_config(struct lookup_context *ctxt)
+{
+	list_t *ptr, *safe;
+	if (ctxt->config.common)
+		free(ctxt->config.common);
+	list_for_each_safe(ptr, safe, &ctxt->config.fstypes) {
+		mntopt_t *this = list_entry(ptr, mntopt_t, handle);
+		list_del(ptr);
+		free(this);
+	}
+	list_for_each_safe(ptr, safe, &ctxt->config.byid) {
+		mntopt_t *this = list_entry(ptr, mntopt_t, handle);
+		list_del(ptr);
+		free(this);
+	}
+	list_for_each_safe(ptr, safe, &ctxt->config.label) {
+		mntopt_t *this = list_entry(ptr, mntopt_t, handle);
+		list_del(ptr);
+		free(this);
+	}
+}
+
+#ifdef LIBXML_TREE_ENABLED
+static void xmlerror(void *context, xmlErrorPtr err)
+{
+	struct lookup_context *ctxt = (struct lookup_context*)context;
+	char *message = err->message;
+	char *nl = strrchr(message, '\n');
+	if (nl) *nl = '\0';
+	logerr(MODPREFIX "in %s at line %d: %s", ctxt->mapname, err->line, err->message);
+	xmlResetError(err);
+	ctxt->config.enabled = 0;
+}
+
+#define FILTER(property)	{ #property, property }
+static filter_t cnfproperpty[] = {
+	FILTER(AutofsUdisks),
+	FILTER(MountOptions),
+	FILTER(Common),
+	FILTER(DiskById),
+	FILTER(DiskByLabel),
+	FILTER(FSType),
+	{ (char*)0, 0 }
+};
+#undef FILTER
+
+static filter_t *check_config(struct lookup_context *ctxt, const xmlChar *name, const int depth)
+{
+	filter_t *flt;
+	cnfxml_t obj = 0;
+
+	flt = &cnfproperpty[obj];
+
+	do {
+		if (flt->property == (char*)0)
+			break;
+		if (strcmp(flt->property, (char*)name) == 0)
+			break;
+	} while (flt++);
+
+	switch (flt->type) {
+	case AutofsUdisks:
+	case MountOptions:
+		if (depth == flt->type)
+			break;
+		logerr(MODPREFIX "broken xml configuration file %s", ctxt->mapname);
+		ctxt->config.enabled = 0;
+	default:
+		break;
+	}
+
+	return flt;
+}
+
+static void add_config(struct lookup_context *ctxt, list_t *head, const char *fs, const char* opts)
+{
+	mntopt_t *restrict new;
+
+	new = newaligned(alignof(mntopt_t)+strsize(fs)+strsize(opts));
+	if (!new) {
+		ctxt->config.enabled = 0;
+		return;
+	}
+	memset(new, 0, alignof(mntopt_t));
+
+	list_add_tail(&new->handle, head);
+
+	new->identify = ((typeof(new->identify))new)+alignof(mntopt_t);
+	strcpy(new->identify, fs);
+
+	new->options = ((typeof(new->options))new)+alignof(mntopt_t)+strsize(fs);
+	strcpy(new->options, opts);
+}
+
+static void iterate_config(struct lookup_context *ctxt, const xmlNode *node, int depth)
+{
+	const xmlNode *curr;
+
+	for (curr = node; curr; curr = curr->next) {
+		const xmlAttr *attr;
+		xmlNode *child;
+		xmlChar *entry;
+		xmlChar *opts;
+		filter_t *flt;
+		list_t *head;
+		int cnt;
+
+		if (curr->type != XML_ELEMENT_NODE)
+			continue;
+		child = curr->children;
+		flt = check_config(ctxt, curr->name, depth);
+		head = (list_t*)0;
+		opts = (xmlChar*)0;
+
+		entry = xmlNodeListGetString(curr->doc, child, 1);
+		if (entry) {
+			char *nl;
+			opts = entry;
+			while (*opts == ' ' || *opts == '\n')
+				opts++;
+			if ((nl = strchr((char*)opts, '\n')))
+				*nl = '\0';
+			switch (flt->type) {
+			case AutofsUdisks:
+			case MountOptions:
+				if (*opts == '\0')
+					break;
+				goto err;
+			case Common:
+				if (ctxt->config.common)
+					goto err;
+				ctxt->config.common = strdup((char*)opts);
+				break;
+			case DiskById:
+				if (!curr->properties)
+					goto err;
+				head = &ctxt->config.byid;
+				break;
+			case DiskByLabel:
+				if (!curr->properties)
+					goto err;
+				head = &ctxt->config.label;
+				break;
+			case FSType:
+				head = &ctxt->config.fstypes;
+				if (!curr->properties)
+					add_config(ctxt, head, "auto", (const char*)opts);
+				break;
+			default:
+				goto err;
+			}
+		}
+
+		for (attr = curr->properties, cnt = 0; attr; attr = attr->next, cnt++) {
+			xmlChar *key;
+			if (!attr->name)
+				continue;
+			switch (flt->type) {
+			case MountOptions:
+			case Common:
+				goto err;
+			default:
+				if (!cnt)
+					break;
+				goto err;
+			}
+			key = xmlNodeListGetString(attr->doc, attr->children, 1);
+			if (key) {
+				char *nl;
+				xmlChar *ptr = key;
+				while (*ptr == ' ' || *ptr == '\n')
+					ptr++;
+				if ((nl = strchr((char*)opts, '\n')))
+					*nl = '\0';
+				switch (flt->type) {
+				case AutofsUdisks:
+					if (strcmp("enable", (char*)attr->name))
+						goto err;
+					if (strcasecmp("true", (char*)ptr) == 0 ||
+					    strcasecmp("yes", (char*)ptr) == 0)
+						ctxt->config.enabled = 1;	/* Here we go */
+					break;
+				default:
+					if (strcmp("value", (char*)attr->name))
+						goto err;
+					if (!head || !opts)
+						goto err;
+					add_config(ctxt, head, (const char*)ptr, (const char*)opts);
+					break;
+				}
+				xmlFree(key);
+			}
+		}
+		if (entry)
+			xmlFree(entry);
+
+		iterate_config(ctxt, child, ++depth);
+	}
+	return;
+err:
+	logerr(MODPREFIX "broken xml configuration file %s", ctxt->mapname);
+	ctxt->config.enabled = 0;
+}
+
+static void parse_config(struct lookup_context *ctxt, const char* path)
+{
+	xmlNode *root = (xmlNode*)0;
+	xmlDoc *doc;
+
+	xmlSetStructuredErrorFunc(ctxt, &xmlerror);
+
+	doc = xmlReadFile(path, (const char*)0, XML_PARSE_NONET | XML_PARSE_PEDANTIC);
+	if (!doc)
+		return;
+	root = xmlDocGetRootElement(doc);
+	if (!root) {
+		xmlFreeDoc(doc);
+		return;
+	}
+
+	iterate_config(ctxt, root, 0);
+
+	xmlFreeDoc(doc);
+	xmlCleanupParser();
+}
+#else /* !LIBXML_TREE_ENABLED */
+static void parse_config(struct lookup_context ctxt, const char* path)
+{
+	ctxt->config.enabled = 0;
+}
+#endif /* !LIBXML_TREE_ENABLED */
+
+static void free_context(struct lookup_context *ctxt)
+{
+	if (ctxt->active) {
+		lock(ctxt);
+		ctxt->active = 0;
+		unlock(ctxt);
+		pthread_yield();
+		if (ctxt->running && ctxt->watchdog)
+			pthread_cancel(ctxt->watchdog);
+	}
+
+	lock(ctxt);
+	if (!list_empty(&ctxt->devices)) {
+		list_t *ptr;
+		list_for_each(ptr, &ctxt->devices) {
+                        entry_t *entry;
+			device_t *this = list_entry(ptr, device_t, handle);
+			if (!this)
+				continue;
+			entry = do_map_entry(ctxt, this);
+			if (!entry)
+				continue;
+			do_cache_update(ctxt, entry->key, entry->mapent, DeviceRemoved);
+		}
+		clear_devices(&ctxt->devices);
+	}
+	if (!list_empty(&ctxt->sessions))
+		clear_sessions(&ctxt->sessions);
+	unlock(ctxt);
+	pthread_mutex_destroy(&ctxt->mtx);
+
+	free_config(ctxt);
+
+	if (ctxt->error && dbus_error_is_set(ctxt->error))
+		dbus_error_free(ctxt->error);
+	if (ctxt->conn) {
+		dbus_connection_close(ctxt->conn);
+		dbus_connection_unref(ctxt->conn);
+	}
+	dbus_shutdown();
+
+	free(ctxt);
+}
+
+int lookup_version = AUTOFS_LOOKUP_VERSION;     /* Required by protocol */
+int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **context)
+{
+	struct lookup_context *restrict ctxt;
+	const char *address;
+	struct stat st;
+	int ret;
+
+	*context = NULL;
+
+	debug(LOGOPT_NONE, MODPREFIX "lookup init with argv[0] == %s", argv[0]);
+
+	if (sizeof(devproperpty)/sizeof(filter_t) != NullDict+1) {
+		logerr(MODPREFIX "size of hash array does not fit numbers of symbols");
+		goto err;
+	}
+	if (sizeof(sessproperty)/sizeof(filter_t) != NullCk+1) {
+		logerr(MODPREFIX "size of hash array does not fit numbers of symbols");
+		goto err;
+	}
+
+#ifdef LIBXML_TREE_ENABLED
+	if (sizeof(cnfproperpty)/sizeof(filter_t) != NullCnf+1) {
+		logerr(MODPREFIX "size of hash array does not fit numbers of symbols");
+		goto err;
+	}
+	xmlInitParser();
+
+	/*
+	 * This initialize the library and check potential ABI mismatches
+	 * between the version it was compiled for and the actual shared
+	 * library used.
+	 */
+	LIBXML_TEST_VERSION
+#else /* !LIBXML_TREE_ENABLED */
+	logerr(MODPREFIX "there was no XML support compiled in");
+	goto err;
+#endif /* !LIBXML_TREE_ENABLED */
+	ctxt = newaligned(alignof(struct lookup_context)+sizeof(struct DBusError));
+	if (!ctxt)
+		goto err;
+	memset(ctxt, 0, alignof(struct lookup_context));
+
+	INIT_LIST_HEAD(&ctxt->devices);
+	INIT_LIST_HEAD(&ctxt->sessions);
+	INIT_LIST_HEAD(&ctxt->config.fstypes);
+	INIT_LIST_HEAD(&ctxt->config.byid);
+	INIT_LIST_HEAD(&ctxt->config.label);
+	ctxt->config.enabled = 0;
+	ctxt->error = (struct DBusError*)((void*)ctxt+alignof(struct lookup_context));
+	dbus_error_init(ctxt->error);
+
+	ret = pthread_mutex_init(&ctxt->mtx, NULL);
+	if (ret) {
+		error(LOGOPT_ANY, MODPREFIX "failed to init mutex");
+		goto ferr;
+	}
+
+	/* If a map type isn't explicitly given, parse it like sun entries. */
+	if (mapfmt == NULL)
+		mapfmt = MAPFMT_DEFAULT;
+
+	if (argc < 1) {
+		logerr(MODPREFIX "No map name");
+		goto ferr;
+	}
+	ctxt->mapname = argv[0];
+	if (ctxt->mapname[0] != '/') {
+		logmsg(MODPREFIX
+		       "udisks autofs %s is not an absolute pathname", argv[0]);
+		goto ferr;
+	}
+	if (access(ctxt->mapname, R_OK)) {
+		logerr(MODPREFIX
+		       "udisks autofs %s missing or not readable", argv[0]);
+		goto ferr;
+	}
+	if (stat(ctxt->mapname, &st)) {
+		logerr(MODPREFIX
+		       "udisks autofs %s, could not stat", argv[0]);
+		goto ferr;
+	}
+
+	if (S_ISREG(st.st_mode) == 0) {
+		logerr(MODPREFIX
+		       "udisks autofs %s, is not a regular file", argv[0]);
+		goto ferr;
+	}
+	parse_config(ctxt, ctxt->mapname);
+
+	if (dbus_threads_init_default() == FALSE) {
+		char buf[MAX_ERR_BUF];
+		const char *const estr = strerror_r(errno, buf, sizeof(buf));
+		logerr(MODPREFIX "memory allocation: %s", estr);
+		return NSS_STATUS_UNAVAIL;
+	}
+
+	ctxt->conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, ctxt->error);
+	if (!ctxt->conn) {
+		logerr(MODPREFIX "udisks map %s, can not connect system dbus: %s",
+		       ctxt->mapname, ctxt->error->message);
+		goto ferr;
+	}
+	dbus_connection_set_exit_on_disconnect(ctxt->conn, FALSE);
+
+	ret = dbus_bus_start_service_by_name(ctxt->conn, "org.freedesktop.UDisks", 0, 0, ctxt->error);
+	if ((dbus_bool_t)ret == FALSE) {
+		warn(LOGOPT_NONE, MODPREFIX
+			"udisks map %s, can not start system udisks service: %s", argv[0], ctxt->error->message);
+		goto ferr;
+	}
+
+	ret = dbus_bus_request_name(ctxt->conn, "org.freedesktop.AutoMount", DBUS_NAME_FLAG_REPLACE_EXISTING, ctxt->error);
+	if ((dbus_bool_t)ret == FALSE) {
+		logerr(MODPREFIX "udisks map %s, can not connect system dbus: %s",
+		       ctxt->mapname, ctxt->error->message);
+		goto ferr;
+	}
+
+        /* Open the parser, if we can. */
+	ctxt->parse = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
+	if (!ctxt->parse) {
+		logerr(MODPREFIX "failed to open parse context");
+		goto ferr;
+	}
+
+	ctxt->ap = (struct autofs_point*)0;
+	*context = ctxt;
+	return NSS_STATUS_SUCCESS;
+ferr:
+	free_context(ctxt);
+err:
+	logerr(MODPREFIX "%s failed", __FUNCTION__);
+	return NSS_STATUS_NOTFOUND;
+}
+
+int lookup_read_master(struct master *master, time_t age, void *context)
+{
+	logmsg(MODPREFIX "%s master not supported", __FUNCTION__);
+	return NSS_STATUS_UNKNOWN;
+}
+
+static int read_current_map(struct lookup_context *ctxt)
+{
+	DBusMessage *reply, *send;
+	DBusMessageIter iter, isub;
+	int type, ret = NSS_STATUS_UNAVAIL;
+
+	send = dbus_message_new_method_call("org.freedesktop.UDisks",
+					    "/org/freedesktop/UDisks",
+					    "org.freedesktop.UDisks",
+					    "EnumerateDevices");
+	if (!send)
+		goto err;
+	dbus_message_set_auto_start(send, TRUE);
+	if (!dbus_message_set_destination(send, "org.freedesktop.UDisks"))
+		goto err;
+
+	reply = dbus_connection_send_with_reply_and_block(ctxt->conn, send, 50000, ctxt->error);
+	dbus_message_unref(send);
+
+	if (dbus_error_is_set(ctxt->error)) {
+		logerr(MODPREFIX "udisks map %s, can not connect system dbus: %s",
+		       ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+	}
+	if (!reply)
+		goto err;
+	if (dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+		goto unref;
+
+	/*
+	 * As reply we assume an array of strings here,
+	 * each of them a device path
+	 */
+	dbus_message_iter_init(reply, &iter);
+	type = dbus_message_iter_get_arg_type(&iter);
+	if (type != DBUS_TYPE_ARRAY)
+		goto unref;
+
+	dbus_message_iter_recurse (&iter, &isub);
+	type = dbus_message_iter_get_arg_type(&isub);
+	if (type == DBUS_TYPE_BYTE)
+		goto unref;
+
+	while (type == DBUS_TYPE_OBJECT_PATH) {
+		char *path;
+
+		dbus_message_iter_get_basic(&isub, &path);
+		if (add_device(&ctxt->devices, path) == (device_t*)0)
+			goto unref;
+
+		dbus_message_iter_next (&isub);
+		type = dbus_message_iter_get_arg_type(&isub);
+	}
+	ret = NSS_STATUS_SUCCESS;
+unref:
+	dbus_message_unref(reply);
+err:
+	if (ret != NSS_STATUS_SUCCESS)
+		logerr(MODPREFIX "%s faild", __FUNCTION__);
+	return ret;
+}
+
+static int read_current_sessions(struct lookup_context *ctxt, const char* seat)
+{
+	DBusMessage *reply, *send;
+	DBusMessageIter iter, isub;
+	int type, ret = NSS_STATUS_UNAVAIL;
+
+
+	send = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
+					    seat,
+					    "org.freedesktop.ConsoleKit.Seat",
+					    "GetSessions");
+	if (!send)
+		goto err;
+	dbus_message_set_auto_start(send, TRUE);
+	if (!dbus_message_set_destination(send, "org.freedesktop.ConsoleKit"))
+		goto err;
+
+	reply = dbus_connection_send_with_reply_and_block(ctxt->conn, send, 50000, ctxt->error);
+	dbus_message_unref(send);
+
+	if (dbus_error_is_set(ctxt->error)) {
+		logerr(MODPREFIX "udisks sessions %s, can not connect system dbus: %s",
+		       ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+	}
+	if (!reply)
+		goto err;
+	if (dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+		goto unref;
+
+	/*
+	 * As reply we assume an array of strings here,
+	 * each of them a seat path
+	 */
+	dbus_message_iter_init(reply, &iter);
+	type = dbus_message_iter_get_arg_type(&iter);
+	if (type != DBUS_TYPE_ARRAY)
+		goto unref;
+
+	dbus_message_iter_recurse (&iter, &isub);
+	type = dbus_message_iter_get_arg_type(&isub);
+	if (type == DBUS_TYPE_BYTE)
+		goto unref;
+
+	while (type == DBUS_TYPE_OBJECT_PATH) {
+		char *path;
+
+		dbus_message_iter_get_basic(&isub, &path);
+		if (add_session(&ctxt->sessions, path) == (session_t*)0)
+			goto unref;
+
+		dbus_message_iter_next (&isub);
+		type = dbus_message_iter_get_arg_type(&isub);
+	}
+	ret = NSS_STATUS_SUCCESS;
+unref:
+	dbus_message_unref(reply);
+err:
+	if (ret != NSS_STATUS_SUCCESS)
+		logerr(MODPREFIX "%s faild", __FUNCTION__);
+	return ret;
+}
+
+static int read_current_seats(struct lookup_context *ctxt)
+{
+	DBusMessage *reply, *send;
+	DBusMessageIter iter, isub;
+	int type, ret = NSS_STATUS_UNAVAIL;
+
+	send = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
+					    "/org/freedesktop/ConsoleKit/Manager",
+					    "org.freedesktop.ConsoleKit.Manager",
+					    "GetSeats");
+	if (!send)
+		goto err;
+	dbus_message_set_auto_start(send, TRUE);
+	if (!dbus_message_set_destination(send, "org.freedesktop.ConsoleKit"))
+		goto err;
+
+	reply = dbus_connection_send_with_reply_and_block(ctxt->conn, send, 50000, ctxt->error);
+	dbus_message_unref(send);
+
+	if (dbus_error_is_set(ctxt->error)) {
+		logerr(MODPREFIX "udisks seats %s, can not connect system dbus: %s",
+		       ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+	}
+	if (!reply)
+		goto err;
+	if (dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+		goto unref;
+
+	/*
+	 * As reply we assume an array of strings here,
+	 * each of them a seat path
+	 */
+	dbus_message_iter_init(reply, &iter);
+	type = dbus_message_iter_get_arg_type(&iter);
+	if (type != DBUS_TYPE_ARRAY)
+		goto unref;
+
+	dbus_message_iter_recurse (&iter, &isub);
+	type = dbus_message_iter_get_arg_type(&isub);
+	if (type == DBUS_TYPE_BYTE)
+		goto unref;
+
+	while (type == DBUS_TYPE_OBJECT_PATH) {
+		char *seat;
+
+		dbus_message_iter_get_basic(&isub, &seat);
+		if (read_current_sessions(ctxt, seat) != NSS_STATUS_SUCCESS)
+			goto unref;
+
+		dbus_message_iter_next (&isub);
+		type = dbus_message_iter_get_arg_type(&isub);
+	}
+	ret = NSS_STATUS_SUCCESS;
+unref:
+	dbus_message_unref(reply);
+err:
+	if (ret != NSS_STATUS_SUCCESS)
+		logerr(MODPREFIX "%s faild", __FUNCTION__);
+	return ret;
+}
+
+static void *udisks_dispatcher(void *context)
+{
+	struct lookup_context *ctxt = (struct lookup_context *)context;
+
+	lock(ctxt);
+	ctxt->active = 1;
+	ctxt->running = 1;
+	unlock(ctxt);
+	while (dbus_connection_read_write_dispatch(ctxt->conn, -1)) {
+		if (!ctxt->active)
+			break;
+	}
+	lock(ctxt);
+	ctxt->running = 0;
+	unlock(ctxt);
+	return NULL;
+}
+
+static int enable_udisks_watchdog(struct lookup_context *ctxt)
+{
+	int policy = SCHED_RR, ret;
+	struct sched_param param;
+	char match[128] = "eavesdrop='true',type='signal',sender='org.freedesktop.%s',interface='org.freedesktop.%s'";
+	char *restrict mptr;
+	int offset;
+
+	if (ctxt->monitor)
+		goto dog;
+	offset = 0;
+ckretry:
+	ret = asprintf((char**)&mptr, &match[offset], "ConsoleKit", "ConsoleKit.Seat");
+	if (ret < 0) {
+		char buf[MAX_ERR_BUF];
+		const char *const estr = strerror_r(errno, buf, sizeof(buf));
+		logerr(MODPREFIX "memory allocation: %s", estr);
+		goto err;
+	}
+	dbus_bus_add_match(ctxt->conn, mptr, ctxt->error);
+	free(mptr);
+	if (dbus_error_is_set(ctxt->error)) {
+		if (!offset && strcmp(ctxt->error->name, DBUS_ERROR_MATCH_RULE_INVALID) == 0) {
+			offset = strlen("eavesdrop='true',");
+			dbus_error_free(ctxt->error);
+			goto ckretry;
+		}
+		logerr(MODPREFIX "udisks sessions %s, can not listen system ConsoleKit: %s",
+		       ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+	}
+	offset = 0;
+uretry:
+	ret = asprintf((char**)&mptr, &match[offset], "UDisks", "UDisks");
+	if (ret < 0) {
+		char buf[MAX_ERR_BUF];
+		const char *const estr = strerror_r(errno, buf, sizeof(buf));
+		logerr(MODPREFIX "memory allocation: %s", estr);
+		goto err;
+	}
+	dbus_bus_add_match(ctxt->conn, mptr, ctxt->error);
+	free(mptr);
+	if (dbus_error_is_set(ctxt->error)) {
+		if (!offset && strcmp(ctxt->error->name, DBUS_ERROR_MATCH_RULE_INVALID) == 0) {
+			offset = strlen("eavesdrop='true',");
+			dbus_error_free(ctxt->error);
+			goto uretry;
+		}
+		logerr(MODPREFIX "udisks map %s, can not listen system UDisks: %s",
+		       ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+	}
+	if ((ctxt->monitor = dbus_connection_add_filter(ctxt->conn, dbusfilter, (void *)ctxt, NULL)) != TRUE) {
+		logerr(MODPREFIX "udisks %s, could not add device and session filters: %s", ctxt->mapname, ctxt->error->message);
+		dbus_error_free(ctxt->error);
+		goto err;
+ 	}
+dog:
+	if (ctxt->watchdog)
+		goto out;
+	ret = pthread_getschedparam(pthread_self(), &policy, &param);
+	if (pthread_create(&ctxt->watchdog, &th_attr_detached, &udisks_dispatcher, (void *)ctxt) != 0) {
+		ctxt->watchdog = (pthread_t)0;
+		goto err;
+	}
+	if (ret == 0) pthread_setschedparam(ctxt->watchdog, policy, &param);
+out:
+	return NSS_STATUS_SUCCESS;
+err:
+	return NSS_STATUS_UNAVAIL;
+}
+
+int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
+{
+	struct lookup_context *ctxt = (struct lookup_context *)context;
+	struct map_source *source;
+	struct mapent_cache *mc;
+	int ret, cur_state;
+	list_t *ptr;
+
+	ctxt->ap = ap;
+	ctxt->map = ap->entry->current;
+#if defined(DEBUG) && (DEBUG > 0)
+	ctxt->ap->logopt = LOGOPT_DEBUG;
+#endif
+
+	source = ap->entry->current;
+	ap->entry->current = NULL;
+	master_source_current_signal(ap->entry);
+
+	/*
+	 * If we don't need to create directories then there's no use
+	 * reading the map. We always need to read the whole map for
+	 * direct mounts in order to mount the triggers.
+  	 */
+	ret = NSS_STATUS_SUCCESS;
+	if ((ap->flags & MOUNT_FLAG_GHOST) == 0 && ap->type != LKP_DIRECT) {
+		debug(ap->logopt, "map read not needed, so not done");
+		goto out;
+	}
+
+	if (sizeof(devproperpty)/sizeof(filter_t) != NullDict+1) {
+		logerr(MODPREFIX "size of hash array does not fit numbers of symbols");
+		goto out;
+	}
+
+	mc = source->mc;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
+	ret = enable_udisks_watchdog(context);
+	if (ret != NSS_STATUS_SUCCESS) {
+		warn(LOGOPT_NONE, MODPREFIX "udisks map %s, could not start watchdog",
+		     ctxt->mapname);
+		goto cancel;
+	}
+
+	lock(ctxt);
+	if (list_empty(&ctxt->devices)) {
+		ret = read_current_map(ctxt);
+		if (ret != NSS_STATUS_SUCCESS) {
+			unlock(ctxt);
+			goto cancel;
+		}
+		list_for_each(ptr, &ctxt->devices) {
+			device_t *this = list_entry(ptr, device_t, handle);
+			ret = read_device_properties(ctxt, this);
+			if (ret != NSS_STATUS_SUCCESS) {
+				unlock(ctxt);
+				goto cancel;
+			}
+		}
+	}
+	if (list_empty(&ctxt->sessions)) {
+		ret = read_current_seats(ctxt);
+		if (ret != NSS_STATUS_SUCCESS) {
+			unlock(ctxt);
+			goto cancel;
+		}
+		list_for_each(ptr, &ctxt->sessions) {
+			session_t *this = list_entry(ptr, session_t, handle);
+			ret = read_session_properties(ctxt, this);
+			if (ret != NSS_STATUS_SUCCESS) {
+				unlock(ctxt);
+				goto cancel;
+			}
+		}
+	}
+	list_for_each(ptr, &ctxt->devices) {
+		device_t *this = list_entry(ptr, device_t, handle);
+		entry_t *entry = do_map_entry(ctxt, this);
+		char *key;
+
+		if (entry == (entry_t*)0)
+			continue;
+		if (entry->key == (char*)0)
+			continue;
+
+		key = sanitize_path(entry->key, entry->key_len, ap->type, ap->logopt);
+		if (key == (char*)0)
+			continue;
+
+		entry->age = age;
+
+		cache_writelock(mc);
+		cache_update(mc, source, key, entry->mapent, age);
+		cache_unlock(mc);
+
+		free(key);
+	}
+	unlock(ctxt);
+	source->age = age;
+cancel:
+	pthread_setcancelstate(cur_state, NULL);
+out:
+	return ret;
+}
+
+static int lookup_one(struct autofs_point *ap,
+	char *key, int key_len,
+	struct lookup_context *ctxt)
+{
+	struct map_source *source;
+	struct mapent_cache *mc;
+	time_t age = time(NULL);
+	int ret, cur_state;
+	entry_t *entry;
+	list_t *ptr;
+
+	source = ap->entry->current;
+	ap->entry->current = NULL;
+	master_source_current_signal(ap->entry);
+
+	mc = source->mc;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
+
+	lock(ctxt);
+	entry = (entry_t*)0;
+	list_for_each(ptr, &ctxt->devices) {
+		device_t *this = list_entry(ptr, device_t, handle);
+		entry = this->entry;
+
+		if (entry == (entry_t*)0)
+			continue;
+		if (entry->key == (char*)0)
+			continue;
+
+		if (entry->key_len != key_len)
+			continue;
+
+		if (strcmp(entry->key, key) == 0)
+			break;
+		entry = (entry_t*)0;
+	}
+	unlock(ctxt);
+
+	ret = CHE_MISSING;
+	if (entry == (entry_t*)0)
+		goto out;
+
+	entry->age = age;
+
+	cache_writelock(mc);
+	ret = cache_update(mc, source, key, entry->mapent, age);
+	cache_unlock(mc);
+out:
+	pthread_setcancelstate(cur_state, NULL);
+	return ret;
+}
+
+static int check_map_indirect(struct autofs_point *ap,
+	char *key, int key_len,
+	struct lookup_context *ctxt)
+{
+	struct map_source *source;
+	struct mapent_cache *mc;
+	struct mapent *me;
+	time_t now = time(NULL);
+	time_t t_last_read;
+	int ret, cur_state;
+
+	source = ap->entry->current;
+	ap->entry->current = NULL;
+	master_source_current_signal(ap->entry);
+
+	mc = source->mc;
+
+	master_source_current_wait(ap->entry);
+	ap->entry->current = source;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
+	ret = lookup_one(ap, key, key_len, ctxt);
+	if (ret == CHE_FAIL) {
+		pthread_setcancelstate(cur_state, NULL);
+		return NSS_STATUS_NOTFOUND;
+	}
+	if (ret == CHE_UNAVAIL) {
+		/*
+		 * If the server is down and the entry exists in the cache
+		 * and belongs to this map return success and use the entry.
+		 */
+		struct mapent *exists = cache_lookup(mc, key);
+		if (exists && exists->source == source) {
+			pthread_setcancelstate(cur_state, NULL);
+			return NSS_STATUS_SUCCESS;
+		}
+
+		warn(ap->logopt,
+		     MODPREFIX "lookup for %s failed: connection failed", key);
+
+		pthread_setcancelstate(cur_state, NULL);
+		return NSS_STATUS_UNAVAIL;
+	}
+	if (ret == CHE_COMPLETED) {
+		pthread_setcancelstate(cur_state, NULL);
+		return NSS_STATUS_COMPLETED;
+	}
+	pthread_setcancelstate(cur_state, NULL);
+
+	/*
+	 * Check for map change and update as needed for
+	 * following cache lookup.
+	 */
+	cache_readlock(mc);
+	t_last_read = ap->exp_runfreq + 1;
+	me = cache_lookup_first(mc);
+	while (me) {
+		if (me->source == source) {
+			t_last_read = now - me->age;
+			break;
+		}
+		me = cache_lookup_next(mc, me);
+	}
+	cache_unlock(mc);
+
+	if (t_last_read > ap->exp_runfreq && ret & CHE_UPDATED)
+		source->stale = 1;
+
+	cache_readlock(mc);
+	me = cache_lookup_distinct(mc, "*");
+	if (ret == CHE_MISSING && (!me || me->source != source)) {
+		cache_unlock(mc);
+		return NSS_STATUS_NOTFOUND;
+	}
+	cache_unlock(mc);
+
+	return NSS_STATUS_SUCCESS;
+}
+
+static int check_permsission(struct autofs_point *ap, struct lookup_context *ctxt)
+{
+        struct thread_stdenv_vars *tsv;
+	int state, ret;
+
+	ret = NSS_STATUS_UNAVAIL;
+	if (list_empty(&ctxt->sessions))
+		goto out;
+
+        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);
+
+        tsv = pthread_getspecific(key_thread_stdenv_vars);
+        if (tsv) {
+		list_t *ptr;
+		list_for_each(ptr, &ctxt->sessions) {
+			session_t *session = list_entry(ptr, session_t, handle);
+			option_t opt = get_session(session, unix_user);
+			if (opt.error)
+				break;
+			if (opt.uint32 == (unsigned int)tsv->uid) {
+				option_t opt = get_session(session, is_local);
+				if (opt.error)
+					break;
+				if (opt.boolean) {
+					ret = NSS_STATUS_SUCCESS;
+					break;
+				}
+#if defined(DEBUG) && (DEBUG > 0)
+				opt = get_session(session, x11_display);
+				if (opt.error)
+					break;
+				if (*opt.string == ':')
+					ret = NSS_STATUS_SUCCESS;
+#endif
+				break;
+			}
+		}
+	}
+
+        pthread_setcancelstate(state, NULL);
+out:
+	debug(ap->logopt, MODPREFIX "mount not allowed");
+	return ret;
+}
+
+int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *context)
+{
+	struct lookup_context *ctxt = (struct lookup_context *) context;
+	struct map_source *source;
+	struct mapent_cache *mc;
+	struct mapent *me;
+	char key[KEY_MAX_LEN + 1];
+	int key_len;
+	char *mapent = NULL;
+	char mapent_buf[MAPENT_MAX_LEN + 1];
+	int status = 0;
+	int ret = 1;
+
+	source = ap->entry->current;
+	ap->entry->current = NULL;
+	master_source_current_signal(ap->entry);
+
+	mc = source->mc;
+
+	debug(ap->logopt, MODPREFIX "looking up %s", name);
+
+	status = check_permsission(ap, ctxt);
+	if (status != NSS_STATUS_SUCCESS)
+		return status;
+
+	key_len = snprintf(key, KEY_MAX_LEN + 1, "%s", name);
+	if (key_len < 0 || key_len > KEY_MAX_LEN)
+		return NSS_STATUS_NOTFOUND;
+
+	if (sizeof(sessproperty)/sizeof(filter_t) != NullCk+1) {
+		logerr(MODPREFIX "size of hash array does not fit numbers of symbols");
+		return NSS_STATUS_NOTFOUND;
+	}
+
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, key, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		} else {
+			struct mapent_cache *smc = me->mc;
+			struct mapent *sme;
+
+			if (me->mapent)
+				cache_unlock(smc);
+			else {
+				cache_unlock(smc);
+				cache_writelock(smc);
+				sme = cache_lookup_distinct(smc, key);
+				/* Negative timeout expired for non-existent entry. */
+				if (sme && !sme->mapent)
+					cache_delete(smc, key);
+				cache_unlock(smc);
+			}
+		}
+	}
+
+        /*
+	 * We can't check the direct mount map as if it's not in
+	 * the map cache already we never get a mount lookup, so
+	 * we never know about it.
+	 */
+	if (ap->type == LKP_INDIRECT && *key != '/') {
+		char *lkp_key;
+
+		cache_readlock(mc);
+		me = cache_lookup_distinct(mc, key);
+		if (me && me->multi)
+			lkp_key = strdup(me->multi->key);
+		else
+			lkp_key = strdup(key);
+		cache_unlock(mc);
+
+		if (!lkp_key)
+			return NSS_STATUS_UNKNOWN;
+
+		master_source_current_wait(ap->entry);
+		ap->entry->current = source;
+
+		status = check_map_indirect(ap, lkp_key, strlen(lkp_key), ctxt);
+		free(lkp_key);
+		if (status) {
+			if (status == NSS_STATUS_COMPLETED)
+				return NSS_STATUS_SUCCESS;
+			return NSS_STATUS_NOTFOUND;
+		}
+	}
+
+	cache_readlock(mc);
+	me = cache_lookup(mc, key);
+	/* Stale mapent => check for entry in alternate source or wildcard */
+	if (me && !me->mapent) {
+		while ((me = cache_lookup_key_next(me)))
+			if (me->source == source)
+				break;
+		if (!me)
+			me = cache_lookup_distinct(mc, "*");
+	}
+	if (me && me->mapent && (me->source == source || *me->key == '/')) {
+		pthread_cleanup_push(cache_lock_cleanup, mc);
+		strcpy(mapent_buf, me->mapent);
+		mapent = &mapent_buf[0];
+		pthread_cleanup_pop(0);
+	}
+	cache_unlock(mc);
+
+	if (!me)
+		return NSS_STATUS_NOTFOUND;
+
+	if (!mapent)
+		return NSS_STATUS_TRYAGAIN;
+
+	master_source_current_wait(ap->entry);
+	ap->entry->current = source;
+
+	debug(ap->logopt, MODPREFIX "%s -> %s", key, mapent);
+	ret = ctxt->parse->parse_mount(ap, key, key_len,
+				       mapent, ctxt->parse->context);
+	if (ret) {
+		time_t now = time(NULL);
+		int rv = CHE_OK;
+
+		/* Record the the mount fail in the cache */
+		cache_writelock(mc);
+		me = cache_lookup_distinct(mc, key);
+		if (!me)
+			rv = cache_update(mc, source, key, NULL, now);
+		if (rv != CHE_FAIL) {
+			me = cache_lookup_distinct(mc, key);
+			me->status = now + ap->negative_timeout;
+		}
+		cache_unlock(mc);
+		return NSS_STATUS_TRYAGAIN;
+	}
+
+	return NSS_STATUS_SUCCESS;
+}
+
+int lookup_done(void *context)
+{
+	struct lookup_context *ctxt = (struct lookup_context *)context;
+	int ret = NSS_STATUS_UNAVAIL;
+	if (!ctxt)
+		goto out;
+	ret = close_parse(ctxt->parse);
+	free_context(ctxt);
+out:
+	return ret;
+}
--- a/modules/parse_sun.c
+++ b/modules/parse_sun.c
@@ -847,6 +847,7 @@ static int validate_location(unsigned in
 		    ((esc = strchr(ptr, '\\')) && *(esc + 1) == ':') ||
 		    !strncmp(ptr, "file:", 5) || !strncmp(ptr, "yp:", 3) ||
 		    !strncmp(ptr, "nis:", 4) || !strncmp(ptr, "nisplus:", 8) ||
+		    !strncmp(ptr, "udisks:", 7) || !strncmp(ptr, "udisks2:", 8) ||
 		    !strncmp(ptr, "ldap:", 5) || !strncmp(ptr, "ldaps:", 6) ||
 		    !strncmp(ptr, "sss:", 4) || !strncmp(ptr, "dir:", 4))
 			return 1;
--- /dev/null
+++ b/samples/autofs.udisks
@@ -0,0 +1,28 @@
+<?xml version="1.0" ?>
+
+<AutofsUdisks enable="true">
+  <MountOptions>
+    <Common>uid=$UID,gid=$GID,nosuid,nodev</Common>
+ 
+    <FSType value="vfat">fmask=0132,dmask=0022,showexec</FSType>
+    <FSType value="ntfs">umask=0022</FSType>
+    <FSType value="iso9660">ro</FSType>
+    <FSType value="ext4">check=none,noatime,nodiratime,data=journal</FSType>
+    <FSType value="ext3">check=none,noatime,nodiratime,data=journal</FSType>
+    <FSType value="ext2">check=none,noatime</FSType>
+    <FSType>ro,nosuid,nodev,noexec</FSType>
+  </MountOptions>
+</AutofsUdisks>

Places

File autofs-5.1.1-dbus-udisks-monitor.patch of Package autofs (Revision ec6db2d99f67b40173469626eefee043)

Places