Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
SUSE:SLE-15-SP3:GA
autofs.28865
autofs-5.1.1-dbus-udisks-monitor.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File autofs-5.1.1-dbus-udisks-monitor.patch of Package autofs.28865
--- Makefile.conf.in | 3 daemon/lookup.c | 4 include/lookup_udisks.h | 381 +++++++ lib/master_tok.l | 2 lib/parse_subs.c | 2 man/autofs.udisks.5.in | 121 ++ modules/Makefile | 12 modules/lookup_multi.c | 2 modules/lookup_udisks.c | 2449 ++++++++++++++++++++++++++++++++++++++++++++++++ modules/parse_sun.c | 1 samples/autofs.udisks | 28 11 files changed, 3004 insertions(+), 1 deletion(-) --- 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, ¶m); + 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, ¶m); +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" ?> +<!-- + This files contains a several entries. The upper envelop AutofsUdisks can be + disabled. The inner envelop MountOptions includes one or more mount options. + Those options are split into DiskByLabel, DiskById, and Common entries, which + are applied in matching order. And the options for several file system types + with a fallback. See autofs.udisks(5) for more information. +--> +<AutofsUdisks enable="true"> + <MountOptions> + <Common>uid=$UID,gid=$GID,nosuid,nodev</Common> + <!-- + <DiskById value="usb-USB_Flash_Disk_XXXXXXXXXXXX-0:0-part1"> + uid=1002,gid=501,user,nosuid,nodev,exec + </DiskById> + <DiskByLabel value="MyPersonal-DVD-x86_64XXXX"> + unhide + </DiskByLabel> + --> + <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>
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
