 @@ -1,99 +1,99 @@
-# $NetBSD: Makefile,v 1.23 2008/12/19 23:13:24 jmcneill Exp $
+# $NetBSD: Makefile,v 1.24 2008/12/20 16:23:26 reinoud Exp $
+#
 DISTNAME=		hal-0.5.11
-PKGREVISION=		15
+PKGREVISION=		16
 CATEGORIES=		sysutils
 MASTER_SITES=		http://hal.freedesktop.org/releases/
 EXTRACT_SUFX=		.tar.bz2
 MAINTAINER=		jmcneill@NetBSD.org
 HOMEPAGE=		http://hal.freedesktop.org/
 COMMENT=		FreeDesktop hardware abstraction layer
 BUILD_DEFS+=		VARBASE
 PKG_DESTDIR_SUPPORT=	user-destdir
 GNU_CONFIGURE=		YES
 USE_DIRS+=		xdg-1.4
 USE_PKGLOCALEDIR=	YES
 USE_TOOLS+=		gmake intltool msgfmt perl pkg-config
 USE_TOOLS+=		autoconf automake autoreconf
 USE_LIBTOOL=		YES
 MAKE_DIRS=		${VARBASE}/cache/hald
 SPECIAL_PERMS+=		${VARBASE}/cache/hald ${HAL_USER} ${HAL_GROUP} 0644
 EGDIR=			${PREFIX}/share/examples/hal
 CONF_FILES=		${EGDIR}/hal.conf ${PKG_SYSCONFBASE}/dbus-1/system.d/hal.conf
 CONFIGURE_ARGS+=	--localstatedir=${VARBASE}
 CONFIGURE_ARGS+=	--with-pci-ids=${PREFIX}/share/pciids
 CONFIGURE_ARGS+=	--with-usb-ids=${PREFIX}/share/usbids
 .include "../../mk/bsd.prefs.mk"
 .if ${OPSYS} == "FreeBSD" || ${OPSYS} == "DragonFly"
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-eject=/usr/sbin/cdcontrol
 CONFIGURE_ARGS+=	--with-backend=freebsd
 PLIST_SRC=		PLIST.FreeBSD PLIST
 .endif
 .if !empty(MACHINE_PLATFORM:MNetBSD-[5-9]*)
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-backend=netbsd
 HAL_GROUP=		operator
 .elif ${OPSYS} == "NetBSD"
 # Pull in the dummy backend for older NetBSD
 CONFIGURE_ARGS+=	--with-backend=dummy
 PLIST_SRC=		PLIST
 .endif
 .if ${OPSYS} == "Linux"
 .include "../../devel/libusb/buildlink3.mk"
 .include "../../devel/libvolume_id/buildlink3.mk"
 .include "../../sysutils/pciutils/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-backend=linux
 .endif
 REPLACE_INTERPRETER+=	bash
 REPLACE.bash.old=	/bin/bash
 REPLACE.bash.new=	${SH}
 .for halscript in luks-remove luks-setup luks-teardown system-wol-enable system-wol-enabled system-wol-supported
 REPLACE_FILES.bash+=	tools/hal-${halscript}
 .endfor
 HAL_USER?=		haldaemon
 HAL_GROUP?=		haldaemon
 CONFIGURE_ARGS+=	--with-hal-user=${HAL_USER}
 CONFIGURE_ARGS+=	--with-hal-group=${HAL_GROUP}
 RCD_SCRIPTS=		hal
 .if ${HAL_GROUP} != "operator"
 PKG_GROUPS=		${HAL_GROUP}
 .endif
 PKG_USERS=		${HAL_USER}:${HAL_GROUP}
 PKG_HOME.haldaemon=	${VARBASE}/run/hal
 FILES_SUBST+=		HAL_USER=${HAL_USER}
 FILES_SUBST+=		HAL_GROUP=${HAL_GROUP}
 post-extract:
 	${CP} -r ${FILESDIR}/hald-netbsd ${WRKSRC}/hald/netbsd
 	${CP} -r ${FILESDIR}/tools-netbsd ${WRKSRC}/tools/netbsd
 pre-configure:
 	cd ${WRKSRC} && autoreconf -vi
 .include "../../devel/GConf/schemas.mk"
 .include "../../devel/glib2/buildlink3.mk"
 .include "../../misc/pciids/buildlink3.mk"
 .include "../../misc/usbids/buildlink3.mk"
 .include "../../security/policykit/buildlink3.mk"
 .include "../../sysutils/dbus/buildlink3.mk"
 .include "../../sysutils/dbus-glib/buildlink3.mk"
 .include "../../sysutils/hal-info/buildlink3.mk"
 .include "../../mk/bsd.pkg.mk"

 @@ -1,411 +1,482 @@
 /*
  * Copyright (c) 2008 Reinoud Zandijk
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/scsiio.h>
 #include <sys/disklabel.h>
 #include <dev/scsipi/scsi_spc.h>
 #include <dev/scsipi/scsipi_all.h>
 #include <dev/scsipi/scsipi_cd.h>
 #include <string.h>
 #include <machine/disklabel.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include "../osspec.h"
 #include "../logger.h"
 #include "../hald.h"
 #include "../hald_dbus.h"
 #include "../device_info.h"
 #include "../util.h"
 #include "devinfo_optical.h"
 #include "devinfo.h"
 #define	DEVINFO_PROBE_STORAGE_TIMEOUT   60000
 static HalDevice *devinfo_optical_add(HalDevice *, const char *, char *,char *);
 static HalDevice *devinfo_optical_volume_add(HalDevice *, const char *, char *, char *);
 static const gchar *
 devinfo_storage_get_prober (HalDevice *d, int *timeout)
+{
 	        *timeout = DEVINFO_PROBE_STORAGE_TIMEOUT;
 		        return "hald-probe-storage";
+}
 #if notyet
 const gchar *
 devinfo_volume_get_prober (HalDevice *d, int *timeout)
+{
 	        *timeout = DEVINFO_PROBE_VOLUME_TIMEOUT;
 		        return "hald-probe-volume";
+}
 #endif
 DevinfoDevHandler devinfo_optical_handler = {
         devinfo_optical_add,
 	NULL,	/* remove */
 	NULL,	/* hotplug_begin_add */
 	NULL,	/* hotplug_begin_remove */
 	NULL,	/* probing_done */
         NULL /* devinfo_storage_get_prober */	/* get_prober */
 };
 DevinfoDevHandler devinfo_optical_volume_handler = {
         devinfo_optical_volume_add,
 	NULL,	/* remove */
 	NULL,	/* hotplug_begin_add */
 	NULL,	/* hotplug_begin_remove */
 	NULL,	/* probing_done */
         NULL /* devinfo_storage_get_prober */	/* get_prober */
 };
 /* XXX i dont know how to link cdutils here XXX ! */
-bool
+static bool
 scsi_command (int fd, void *cmd, size_t cmdlen, void *data, size_t datalen,
     int timeout, int flags)
+{
 	scsireq_t req;
 	memset(&req, 0, sizeof(req));
 	memcpy(req.cmd, cmd, cmdlen);
 	req.cmdlen = cmdlen;
 	req.databuf = data;
 	req.datalen = datalen;
 	req.timeout = timeout;
 	req.flags = flags;
 	req.senselen = SENSEBUFLEN;
 	if (ioctl(fd, SCIOCCOMMAND, &req) == -1)
 		return false;
 	if (req.retsts == SCCMD_OK)
 		return true;
 	return false;
+}
 static void
 optical_get_str(char *str, unsigned char *buf, int len)
+{
 	char *pos;
 	int i;
 	pos = str;
 	for (i = 0; i < len; i++) {
 		if (isprint(buf[i]))
 			*pos++ = buf[i];
+	}
 	*pos = (char) 0;
 	pos--;
 	while (*pos == ' ')
 		*pos-- = (char) 0;
+}
 static void
 devinfo_optical_identify_drive(HalDevice *d, char *devstr)
+{
 	uint8_t cmd[12], buf[100];
 	char str[100];
 	int fd, ok;
 	fd = open(devstr, O_RDONLY, 0);
 	if(!fd)
 		return;
 	HAL_INFO(("devinfo_optical_identify_drive: SCSI call"));
 	cmd[0] = 0x12;	/* INQUIRY */
 	cmd[1] = 0;	/* basic inquiry */
 	cmd[2] = 0;	/* no page or operation code */
 	cmd[3] = 0;	/* reserved/MSB result */
 	cmd[4] = 96;	/* all but vendor specific */
 	cmd[5] = 0;	/* control */
 	ok = scsi_command(fd, cmd, 6, buf, 96, 30000, SCCMD_READ);
 	close(fd);
 	if (!ok)
 		return;
 	optical_get_str(str, buf+8, 8);
 	hal_device_property_set_string (d, "storage.vendor", str);
 	optical_get_str(str, buf+16, 16);
 	hal_device_property_set_string (d, "storage.model", str);
 	optical_get_str(str, buf+32, 4);
 	hal_device_property_set_string (d, "storage.firmware_version", str);
+}
 static char const *
 get_profile_name(HalDevice *d, int profile)
+{
 	switch (profile) {
 	case 0x00 : return NULL;	// "Unknown[0] profile";
 	case 0x01 : return NULL;	// "Non removeable disc";
 	case 0x02 : return NULL;	// "Removable disc";
 	case 0x03 : return "mo";	// Magneto Optical with sector erase";
 	case 0x04 : return "mo";	// "Magneto Optical write once";
 	case 0x05 : return "mo";	// "Advance Storage Magneto Optical";
 	case 0x08 : return "cd";	// "CD-ROM"; no writing
 	case 0x09 : return "cdr";	// "CD-R recordable";
 	case 0x0a : return "cdrw";	// "CD-RW rewritable";
 	case 0x10 : return "dvd";	// "DVD-ROM"; no writing
 	case 0x11 : return "dvdr";	// "DVD-R sequential";
 	case 0x12 : return "dvdram";	// "DVD-RAM rewritable";
 	case 0x13 : return "dvdrw";	// "DVD-RW restricted overwrite";
 	case 0x14 : return "dvdrw";	// "DVD-RW sequential";
 	case 0x15 : return "dvdr";	// "DVD-R dual layer sequential";
 	case 0x16 : return "dvdr";	// "DVD-R dual layer jump";
 	case 0x17 : return "dvdrw";	// "DVD-RW dual layer";
 	case 0x18 : return NULL;	// "DVD-Download disc"; UNKNOWN
 	case 0x1a : return "dvdplusrw";	// "DVD+RW rewritable";
 	case 0x1b : return "dvdplusr";	// "DVD+R recordable";
 	case 0x20 : return "ddcd";	// "DDCD readonly (retracted)"; no writing
 	case 0x21 : return "ddcdr";	// "DDCD-R recordable (retracted)";	OK?
 	case 0x22 : return "ddcdrw";	// "DDCD-RW rewritable (retracted)"; OK?
 	case 0x2a : return "dvdplusrwdl";//"DVD+RW double layer";
 	case 0x2b : return "dvdplusrdl";// "DVD+R double layer";
 	case 0x40 : return "bd";	// "BD-ROM";
 	case 0x41 : return "bdr";	// "BD-R Sequential Recording (SRM)";
 	case 0x42 : return "bdr";	// "BD-R Random Recording (RRM)";
 	case 0x43 : return "bdre";	// "BD-RE rewritable";
 	case 0x50 : return "hddvd";	// "HD DVD-ROM (retracted)";
 	case 0x51 : return "hddvdr";	// "HD DVD-R (retracted)";
 	case 0x52 : return "hddvdram";	// "HD DVD-RAM (retracted)";
 	case 0x53 : return "hddvdrw";	// "HD DVD-RW (retracted)";
 	case 0x58 : return "hddvdrdl";	// "HD DVD-R dual layer (retracted)";
 	case 0x5a : return "hddvdrwdl"; // "HD DVD-RW dual layer (retracted)";
+	}
 	/* reserved */
 	return NULL;
+}
 #define feat_tbl_len 300
 #define max_profile 255
 static void
 devinfo_optical_disc_caps(int fd, HalDevice *d)
+{
 	uint8_t cmd[12], buf[feat_tbl_len], *fpos, *pos;
 	char str[100];
 	uint8_t present[max_profile+1];
 	char const *name;
 	int feature, feature_cur, feature_len, req_feature;
 	int cnt, profile;
 	int mrw, mrw_w, ok;
 	/* set defaults */
 	for (profile = 0; profile <= max_profile; profile++) {
 		present[profile] = FALSE;
+	}
 	HAL_INFO(("devinfo_optical_disc_caps: get feature 0 SCSI call"));
 	req_feature = 0;
 	cmd[0] = 0x46;			/* Get configuration */
 	cmd[1] = 0;			/* RT=0 -> all independent of current setting */
 	cmd[2] = (req_feature) >> 8;	/* MSB feature number */
 	cmd[3] = (req_feature) & 0xff;	/* LSB feature number */
 	cmd[7] = (feat_tbl_len) >> 8;	/* MSB buffersize */
 	cmd[8] = (feat_tbl_len) & 0xff;	/* LSB buffersize */
 	cmd[9] = 0;			/* control */
 	ok = scsi_command(fd, cmd, 10, buf, feat_tbl_len, 30000, SCCMD_READ);
 	if (!ok)
 		return;
 	HAL_INFO(("devinfo_optical_disc_caps: processing profiles\n"));
 	fpos = buf + 8;
 	feature     =  fpos[1] | (fpos[0] << 8);
 	feature_cur = (fpos[2] & 1);
 	feature_len =  fpos[3];
 	if (feature != 0) {
 		HAL_INFO(("cdrom drive on crack, its not returning feature 0\n"));
 		return;
+	}
 	if ((feature_len & 3) != 0)
 		HAL_INFO(("*** drive returned bad feature length ***"));
 	/* process feature */
 	pos = &fpos[4];
 	for (cnt=0; cnt < feature_len; cnt += 4) {
 		profile = pos[1] | (pos[0] << 8);
 		if (profile <= max_profile) {
 			present[profile] = TRUE;
 		} else {
 			if (profile != 0xffff)
 				HAL_INFO(("devinfo_optical_disc_caps: bump max_profile!, "
 					  "found profile %d", profile));
+		}
 		pos += 4;
+	}
 	/* set hal properties */
 	for (profile = 0; profile <= max_profile; profile++) {
 		/* process profile */
 		name = get_profile_name(d, profile);
 		if (name) {
 			strcpy(str, "storage.cdrom.");
 			strcat(str, name);
 			HAL_INFO(("Profile %d : %s : %s", profile, str,
 				present[profile] ? "true":"false"));
 			hal_device_property_set_bool(d, str, present[profile]);
+		}
+	}
 	/* set MRW support; feature 0x28, version 0/1 */
 	HAL_INFO(("devinfo_optical_disc_caps: get feature 0x28 SCSI call"));
 	req_feature = 0x28;
 	cmd[0] = 0x46;			/* Get configuration */
 	cmd[1] = 0;			/* RT=0 -> all independent of current setting */
 	cmd[2] = (req_feature) >> 8;	/* MSB feature number */
 	cmd[3] = (req_feature) & 0xff;	/* LSB feature number */
 	cmd[7] = (feat_tbl_len) >> 8;	/* MSB buffersize */
 	cmd[8] = (feat_tbl_len) & 0xff;	/* LSB buffersize */
 	cmd[9] = 0;			/* control */
 	ok = scsi_command(fd, cmd, 10, buf, feat_tbl_len, 30000, SCCMD_READ);
 	if (!ok)
 		return;
 	feature     =  fpos[1] | (fpos[0] << 8);
 	feature_cur = (fpos[2] & 1);
 	feature_len =  fpos[3];
 	if ((feature_len & 3) != 0)
 		HAL_INFO(("*** drive returned bad feature length ***"));
 	HAL_INFO(("devinfo_optical_disc_caps: processing MRW\n"));
 	/* process feature */
 	pos = &fpos[4];
 	mrw   = FALSE;
 	mrw_w = FALSE;
 	if (feature == 0x28) {
 		mrw = TRUE;
 		if (pos[0] & 1)
 			mrw_w = TRUE;
+	}
 	hal_device_property_set_bool(d, "storage.cdrom.mrw", mrw);
 	hal_device_property_set_bool(d, "storage.cdrom.mrw_w", mrw_w);
 	/*
 	 * XXX very rare to now have multi-session support; could be detected
 	 * in the change bits of page 5, but set to true for now
 	 */
-	hal_device_property_set_bool(d,"storage.cdrom.support_multisession", TRUE);
+	hal_device_property_set_bool(d, "storage.cdrom.support_multisession", TRUE);
 	/* XXX realy? */
-	hal_device_property_set_bool(d,"storage.cdrom.support_media_changed", TRUE);
+	hal_device_property_set_bool(d, "storage.cdrom.support_media_changed", TRUE);
 	/* media dependent; addon-storage will handle these */
 	//hal_device_property_set_int(d,"storage.cdrom.read_speed", 0);
 	//hal_device_property_set_int(d,"storage.cdrom.write_speed", 0);
 	//hal_device_property_set_string(d, "storage.cdrom.write_speeds", FALSE);
+}
 #undef max_profile
 #undef feat_tbl_len
 static HalDevice *
 devinfo_optical_volume_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
+{
 	HalDevice *d;
 	struct stat devstat;
 	char *devstr;
 	int error;
 	HAL_INFO (("devinfo_optical_volume_add: parent=%p devnode=%s devfs_path=%s device_type=%s",
 	    parent, devnode, devfs_path, device_type));
 	d = hal_device_new ();
 	devstr = malloc(strlen(devnode) + 10);
 	/* info */
 	devinfo_set_default_properties (d, parent, devnode, devnode);
 	hal_device_add_capability (d, "block");
 	hal_device_add_capability (d, "volume");
 	hal_device_add_capability (d, "volume.disc");
 	/* block */
 	sprintf(devstr, "/dev/%s", devnode);
         hal_device_property_set_string (d, "block.device", devstr);
 	error = stat(devstr, &devstat);
 	if (!error) {
 	        hal_device_property_set_int (d, "block.major", major(devstat.st_rdev));
 	        hal_device_property_set_int (d, "block.minor", minor(devstat.st_rdev));
+	}
 	sprintf(devstr, "/dev/r%s", devnode);
         hal_device_property_set_string (d, "block.netbsd.raw_device", devstr);
         hal_device_property_set_bool (d, "block.is_volume", TRUE);
         hal_device_property_set_bool (d, "block.no_partitions", TRUE);
         hal_device_property_set_bool (d, "block.have_scanned", TRUE);
 	/* volume */
 	hal_device_property_set_bool  (d, "volume.ignore", FALSE);
 	hal_device_property_set_string(d, "volume.fsusage", "filesytem");
 	hal_device_property_set_string(d, "volume.fstype",  "");
 	hal_device_property_set_string(d, "volume.label",   "");
 	hal_device_property_set_bool  (d, "volume.is_disc", TRUE);
 	hal_device_property_set_bool  (d, "volume.is_partition", FALSE);
 	/* rest by addon */
 	/* volume.disc */
 	/* by addon */
 	devinfo_add_enqueue (d, devnode, &devinfo_optical_volume_handler);
 	return d;
+}
 static HalDevice *
 devinfo_optical_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
+{
 	HalDevice *d;
 	struct stat devstat;
 	char *devstr;
 	char *parent_devnode;
 	int fd, error;
 	if (strncmp(devnode, "cd", 2) != 0) {
 		return (NULL);
+	}
 	HAL_INFO (("devinfo_optical_add: parent=%p devnode=%s devfs_path=%s device_type=%s",
 	    parent, devnode, devfs_path, device_type));
 	d = hal_device_new ();
 	devstr = malloc(strlen(devnode) + 10);
 	/* info */
 	devinfo_set_default_properties (d, parent, devnode, devnode);
 //	hal_device_property_set_string (d, "netbsd.device", devfs_path);
         hal_device_property_set_string (d, "info.subsystem", "block");
 	hal_device_add_capability (d, "block");
 	hal_device_add_capability (d, "storage");
 	hal_device_add_capability (d, "storage.cdrom");
 	/* block */
 	sprintf(devstr, "/dev/%s%c", devnode, 'a' + RAW_PART);
         hal_device_property_set_string (d, "block.device", devstr);
 	error = stat(devstr, &devstat);
 	if (!error) {
 	        hal_device_property_set_int (d, "block.major", major(devstat.st_rdev));
 	        hal_device_property_set_int (d, "block.minor", minor(devstat.st_rdev));
+	}
 	sprintf(devstr, "/dev/r%s%c", devnode, 'a' + RAW_PART);
         hal_device_property_set_string (d, "block.netbsd.raw_device", devstr);
         hal_device_property_set_bool (d, "block.is_volume", FALSE);
         hal_device_property_set_bool (d, "block.no_partitions", TRUE);
         hal_device_property_set_bool (d, "block.have_scanned", TRUE);
 	/* storage */
 	parent_devnode = hal_device_property_get_string (parent, "netbsd.device");
 	if (strstr (parent_devnode, "umass") == parent_devnode)
 		hal_device_property_set_string (d, "storage.bus", "usb");
 	else if (strstr (parent_devnode, "atapi") == parent_devnode)
 		hal_device_property_set_string (d, "storage.bus", "ide");
 	else
 		hal_device_property_set_string (d, "storage.bus", "scsi");
 	hal_device_property_set_string (d, "storage.drive_type", "cdrom");
 	hal_device_property_set_bool (d, "storage.removable", TRUE);
 	/* "storage.removable.media_available" set by addon-storage */
 	/* "storage.removable.media_size" set by addon-storage */
 	hal_device_property_set_bool (d, "storage.removable.support_async_notification", FALSE);
 	hal_device_property_set_bool (d, "storage.requires_eject", TRUE);
 	hal_device_property_set_bool (d, "storage.hotpluggable", TRUE);
 	hal_device_property_set_bool (d, "storage.media_check_enabled", TRUE);	   /* XXX */
 	hal_device_property_set_bool (d, "storage.automount_enabled_hint", FALSE); /* multiple choice */
 	hal_device_property_set_bool (d, "storage.no_partitions_hint", TRUE);
 	hal_device_property_set_string (d, "storage.originating_device", "");      /* XXX */
 	fd = open(devstr, O_RDONLY, 0);
 	if (fd) {
 		/* get drive's vendor and model name */
 		devinfo_optical_identify_drive(d, devstr);
 		/* get CD specific `storage.cdrom' values */
 		devinfo_optical_disc_caps(fd, d);
 	close(fd);
+	}
 	devinfo_add_enqueue (d, devnode, &devinfo_optical_handler);
 	if (fd) {
 		/* create CD volume node */
 		sprintf(devstr, "%s%c", devnode, 'a' + RAW_PART);
 		devinfo_optical_volume_add(d, devstr, devfs_path, "volume");
+	}
 	close(fd);
 	return (d);
+}

 @@ -1,332 +1,516 @@
 /***************************************************************************
+ *
  * addon-storage.c : watch removable media state changes
+ *
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <errno.h>
 #include <string.h>
 #include <strings.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <syslog.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/statvfs.h>
 #include <sys/dkio.h>
 #include <dev/scsipi/scsi_spc.h>
 #include <dev/scsipi/scsipi_all.h>
 #include <dev/scsipi/scsipi_cd.h>
 #include <sys/scsiio.h>
 #include <libhal.h>
 #include <logger.h>
 #define	SLEEP_PERIOD	5
 #define _EXPOSE_MMC
 #include <sys/cdio.h>
 enum discstate {
 	DISC_INSERTED,
 	DISC_EJECTED,
 	DISC_NONE,
 	DISC_UNKNOWN
 };
 static enum discstate
 scsi_test_unit_ready (int fd)
+{
 	struct scsi_test_unit_ready tur;
 	scsireq_t req;
 	memset(&tur, 0, sizeof(tur));
 	tur.opcode = SCSI_TEST_UNIT_READY;
 	memset(&req, 0, sizeof(req));
 	memcpy(req.cmd, &tur, sizeof(tur));
 	req.cmdlen = sizeof(tur);
 	req.databuf = NULL;
 	req.datalen = 0;
 	req.timeout = 10000;
 	req.flags = SCCMD_READ;
 	req.senselen = SENSEBUFLEN;
 	if (ioctl(fd, SCIOCCOMMAND, &req) == -1)
 		return DISC_UNKNOWN;
 	if (req.retsts == SCCMD_OK)
 		return DISC_INSERTED;
 	return DISC_EJECTED;
+}
 static void
 my_dbus_error_free(DBusError *error)
+{
 	if (dbus_error_is_set(error)) {
 		dbus_error_free(error);
+	}
+}
 static void
 force_unmount (LibHalContext *ctx, const char *udi)
+{
 	DBusError error;
 	DBusMessage *msg = NULL;
 	DBusMessage *reply = NULL;
 	char **options = NULL;
 	unsigned int num_options = 0;
 	DBusConnection *dbus_connection;
 	char *device_file;
 	dbus_error_init (&error);
 	dbus_connection = libhal_ctx_get_dbus_connection (ctx);
 	msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
 					    "org.freedesktop.Hal.Device.Volume",
 					    "Unmount");
 	if (msg == NULL) {
 		HAL_DEBUG (("Could not create dbus message for %s", udi));
 		goto out;
+	}
 	options = calloc (1, sizeof (char *));
 	if (options == NULL) {
 		HAL_DEBUG (("Could not allocate options array"));
 		goto out;
+	}
 	device_file = libhal_device_get_property_string (ctx, udi, "block.device", &error);
 	if (device_file != NULL) {
 		libhal_free_string (device_file);
+	}
 	dbus_error_free (&error);
 	if (!dbus_message_append_args (msg,
 				       DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
 				       DBUS_TYPE_INVALID)) {
 		HAL_DEBUG (("Could not append args to dbus message for %s", udi));
 		goto out;
+	}
 	if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error))) {
 		HAL_DEBUG (("Unmount failed for %s: %s : %s\n", udi, error.name, error.message));
 		goto out;
+	}
 	if (dbus_error_is_set (&error)) {
 		HAL_DEBUG (("Unmount failed for %s\n%s : %s\n", udi, error.name, error.message));
 		goto out;
+	}
 	HAL_DEBUG (("Succesfully unmounted udi '%s'", udi));
 out:
 	dbus_error_free (&error);
 	if (options != NULL)
 		free (options);
 	if (msg != NULL)
 		dbus_message_unref (msg);
 	if (reply != NULL)
 		dbus_message_unref (reply);
+}
 static void
 unmount_childs (LibHalContext *ctx, const char *udi)
+{
 	DBusError error;
 	int num_volumes;
 	char **volumes;
 	dbus_error_init (&error);
 	/* need to force unmount all partitions */
 	if ((volumes = libhal_manager_find_device_string_match (
 	     ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
 		dbus_error_free (&error);
 		int i;
 		for (i = 0; i < num_volumes; i++) {
 			char *vol_udi;
 			vol_udi = volumes[i];
 			if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
 				dbus_error_free (&error);
 				if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
 					dbus_error_free (&error);
 					HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
 					force_unmount (ctx, vol_udi);
+				}
+			}
+		}
 		libhal_free_string_array (volumes);
+	}
 	my_dbus_error_free (&error);
+}
 /** Check if a filesystem on a special device file is mounted
+ *
  *  @param  device_file         Special device file, e.g. /dev/cdrom
  *  @return                     TRUE iff there is a filesystem system mounted
  *                              on the special device file
  */
 static dbus_bool_t
 is_mounted (const char *device_file)
+{
         int count;
 	struct statvfs *statvfs;
 	count = getmntinfo(&statvfs, ST_WAIT);
 	while (count-- > 0) {
 		if (strcmp(statvfs->f_mntfromname, device_file) == 0)
 			return TRUE;
+	}
 	return FALSE;
+}
 static void
 close_device (int *fd)
+{
 	if (*fd > 0) {
 		close (*fd);
 		*fd = -1;
+	}
+}
 /* XXX why not share this further */
 static char const *
 get_profile_typestring(int profile)
+{
 	switch (profile) {
 	case 0x00 : return "unknown";	  // "Unknown[0] profile";
 	case 0x01 : return "unknown";	  // "Non removeable disc";
 	case 0x02 : return "unknown";	  // "Removable disc";
 	case 0x03 : return "mo";	  // Magneto Optical with sector erase";
 	case 0x04 : return "mo";	  // "Magneto Optical write once";
 	case 0x05 : return "mo";	  // "Advance Storage Magneto Optical";
 	case 0x08 : return "cd_rom";	  // "CD-ROM"; no writing
 	case 0x09 : return "cd_r";	  // "CD-R recordable";
 	case 0x0a : return "cd_rw";	  // "CD-RW rewritable";
 	case 0x10 : return "dvd_rom";	  // "DVD-ROM"; no writing
 	case 0x11 : return "dvd_r";	  // "DVD-R sequential";
 	case 0x12 : return "dvd_ram";	  // "DVD-RAM rewritable";
 	case 0x13 : return "dvd_rw";	  // "DVD-RW restricted overwrite";
 	case 0x14 : return "dvd_rw";	  // "DVD-RW sequential";
 	case 0x15 : return "dvd_r";	  // "DVD-R dual layer sequential";
 	case 0x16 : return "dvd_r";	  // "DVD-R dual layer jump";
 	case 0x17 : return "dvd_rw";	  // "DVD-RW dual layer";
 	case 0x18 : return "unknown";	  // "DVD-Download disc"; UNKNOWN
 	case 0x1a : return "dvd_plus_rw"; // "DVD+RW rewritable";
 	case 0x1b : return "dvd_plus_r";  // "DVD+R recordable";
 	case 0x20 : return "ddcd_rom";	  // "DDCD readonly (retracted)"; no writing
 	case 0x21 : return "ddcd_r";	  // "DDCD-R recordable (retracted)";	OK?
 	case 0x22 : return "ddcd_rw";	  // "DDCD-RW rewritable (retracted)"; OK?
 	case 0x2a : return "dvd_plus_rw_dl";//"DVD+RW double layer";
 	case 0x2b : return "dvd_plus_r_dl";// "DVD+R double layer";
 	case 0x40 : return "bd_rom";	  // "BD-ROM";
 	case 0x41 : return "bd_r";	  // "BD-R Sequential Recording (SRM)";
 	case 0x42 : return "bd_r";	  // "BD-R Random Recording (RRM)";
 	case 0x43 : return "bd_re";	  // "BD-RE rewritable";
 	case 0x50 : return "hddvd_rom";	  // "HD DVD-ROM (retracted)";
 	case 0x51 : return "hddvd_r";	  // "HD DVD-R (retracted)";
 	case 0x52 : return "hddvd_ram";	  // "HD DVD-RAM (retracted)";
 	case 0x53 : return "hddvd_rw";	  // "HD DVD-RW (retracted)";
 	case 0x58 : return "hddvd_r_dl";  // "HD DVD-R dual layer (retracted)";
 	case 0x5a : return "hddvd_rw_dl"; // "HD DVD-RW dual layer (retracted)";
+	}
 	/* reserved */
 	return "unknown";
+}
 static void
 set_volume_properties(int fd, LibHalContext *ctx, char *udi, int state)
+{
 	struct mmc_discinfo  di;
 	struct mmc_trackinfo ti;
 	struct volume_id *vid;
 	DBusError error;
 	uint64_t capacity;
 	char const *disc_type;
 	char *disc_fstype, *disc_label;
 	int has_audio, has_data, is_vcd, is_svcd, is_videodvd, is_appendable, is_blank, is_rewritable;
 	int tracknr, err;
 	disc_fstype = "";
 	disc_label  = "";
 	disc_type   = "unknown";
 	has_audio = has_data = is_vcd = is_svcd = is_videodvd = is_appendable = is_blank = is_rewritable = 0;
 	capacity  = 0;
 	dbus_error_init (&error);
 	if (state == DISC_INSERTED) {
 		/* fetch new values */
 		memset(&di, 0, sizeof(struct mmc_discinfo));
 		err = ioctl(fd, MMCGETDISCINFO, &di);
 		if (!err) {
 			disc_type = get_profile_typestring(di.mmc_profile);
 			is_rewritable = di.mmc_cur & MMC_CAP_REWRITABLE;
 			is_blank      = (di.disc_state == MMC_STATE_EMPTY);
 			is_appendable = (di.disc_state != MMC_STATE_FULL);
 			/* can't check is_videodvd, is_svcd, is_vcd (yet); use volume lib */
 			disc_fstype = "cd9660";
 			disc_label  = "label";
 vid = NULL;
 #if 0
 			vid = volume_id_open_fd (fd);
 			if (vid) {
 				if (volume_id_probe_all (vid, 0, psize) == 0) {
 					hal_device_property_set_string (d, "volume.label", vid->label);
 					hal_device_property_set_string (d, "volume.partition.label", vid->label);
 					hal_device_property_set_string (d, "volume.uuid", vid->uuid);
 					hal_device_property_set_string (d, "volume.partition.uuid", vid->uuid);
+				}
 				volume_id_close (vid);
+			}
 #endif
 			for (tracknr = di.first_track; tracknr <= di.last_track_last_session; tracknr++) {
 				memset(&ti, 0, sizeof(struct mmc_trackinfo));
 				ti.tracknr = tracknr;
 				err = ioctl(fd, MMCGETTRACKINFO, &ti);
 				if (err)
 					break;
 				if (!(ti.flags & MMC_TRACKINFO_BLANK)) {
 					if (ti.flags & MMC_TRACKINFO_DATA)
 						has_data = TRUE;
 					if (ti.flags & MMC_TRACKINFO_AUDIO)
 						has_audio = TRUE;
+				}
 				capacity += (ti.track_size + ti.free_blocks) * di.sector_size;
+			}
+		}
+	}
 	/* add volume properties (ignoring dbus errors) */
 	libhal_device_set_property_bool   (ctx, udi, "volume.ignore", FALSE, &error);		/* make visible */
 	libhal_device_set_property_bool   (ctx, udi, "volume.ismounted", FALSE, &error);	/* XXX fixme XXX */
 	libhal_device_set_property_bool   (ctx, udi, "volume.ismounted_readonly", FALSE, &error);	/* XXX fixme XXX */
 	libhal_device_set_property_string (ctx, udi, "volume.fsusage", "filesystem", &error);
 	libhal_device_set_property_string (ctx, udi, "volume.fstype",  disc_fstype, &error);
 	libhal_device_set_property_string (ctx, udi, "volume.label", disc_label, &error);
 	libhal_device_set_property_string (ctx, udi, "volume.uuid", "", &error);
 	libhal_device_set_property_uint64 (ctx, udi, "volume.size", capacity, &error);
 	/* add volume.disc properties (ignoring dbus errors) */
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.has_audio", has_audio, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.has_data", has_data, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_vcd", is_vcd, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_svcd", is_svcd, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_videodvd", is_videodvd, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_appendable", is_appendable, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_blank", is_blank, &error);
 	libhal_device_set_property_bool   (ctx, udi, "volume.disc.is_rewritable", is_rewritable, &error);
 	libhal_device_set_property_string (ctx, udi, "volume.disc.type", disc_type, &error);
 	libhal_device_set_property_uint64 (ctx, udi, "volume.disc.capacity", capacity, &error);
 	my_dbus_error_free (&error);
+}
 static void
 update_disc_volume_properties(int fd, LibHalContext *ctx, const char *udi, int state)
+{
 	DBusError error;
 	char **volumes;
 	char *vol_udi;
 	int num_volumes, i;
 	dbus_error_init (&error);
 	/* update volume children */
 	if ((volumes = libhal_manager_find_device_string_match (
 	     ctx, "info.parent", udi, &num_volumes, &error)) != NULL) {
 		dbus_error_free (&error);
 		for (i = 0; i < num_volumes; i++) {
 			vol_udi = volumes[i];
 			if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
 				dbus_error_free (&error);
 				HAL_DEBUG(("Updating child %s of %s\n", udi, vol_udi));
 				set_volume_properties(fd, ctx, vol_udi, state);
 #if 0
 				if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
 					dbus_error_free (&error);
 					HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
 					force_unmount (ctx, vol_udi);
+				}
 #endif
+			}
+		}
 		libhal_free_string_array (volumes);
+	}
 	my_dbus_error_free (&error);
+}
 int
 main (int argc, char *argv[])
+{
 	char *udi;
 	char *device_file, *raw_device_file;
 	LibHalContext *ctx = NULL;
 	DBusError error;
 	char *bus;
 	char *drive_type;
 	int state, last_state;
 	char *support_media_changed_str;
 	int support_media_changed;
 	int fd = -1;
 	if ((udi = getenv ("UDI")) == NULL)
 		goto out;
 	if ((device_file = getenv ("HAL_PROP_BLOCK_DEVICE")) == NULL)
 		goto out;
 	if ((raw_device_file = getenv ("HAL_PROP_BLOCK_NETBSD_RAW_DEVICE")) == NULL)
 		goto out;
 	if ((bus = getenv ("HAL_PROP_STORAGE_BUS")) == NULL)
 		goto out;
 	if ((drive_type = getenv ("HAL_PROP_STORAGE_DRIVE_TYPE")) == NULL)
 		goto out;
 	setup_logger ();
 	support_media_changed_str = getenv ("HAL_PROP_STORAGE_CDROM_SUPPORT_MEDIA_CHANGED");
 	if (support_media_changed_str != NULL && strcmp (support_media_changed_str, "true") == 0)
 		support_media_changed = TRUE;
 	else
 		support_media_changed = FALSE;
 	dbus_error_init (&error);
 	if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
 		goto out;
+	}
 	my_dbus_error_free (&error);
 	if (!libhal_device_addon_is_ready (ctx, udi, &error)) {
 		goto out;
+	}
 	my_dbus_error_free (&error);
 	printf ("Doing addon-storage for %s (bus %s) (drive_type %s) (udi %s)\n", device_file, bus, drive_type, udi);
 	last_state = state = DISC_NONE;
 	/* Linux version of this addon attempts to re-open the device O_EXCL
 	 * every 2 seconds, trying to figure out if some other app,
 	 * like a cd burner, is using the device. Aside from questionable
 	 * value of this (apps should use HAL's locked property or/and
 	 * Solaris in_use facility), but also frequent opens/closes
 	 * keeps media constantly spun up. All this needs more thought.
 	 */
 	for (;;) {
 		sleep (SLEEP_PERIOD);
 		if (is_mounted (device_file)) {
 			close_device (&fd);
 		} else if ((fd < 0) && ((fd = open (raw_device_file, O_RDONLY | O_NONBLOCK)) < 0)) {
 			HAL_DEBUG (("open failed for %s: %s", raw_device_file, strerror (errno)));
 		} else {
 			/* Check if a disc is in the drive */
 			state = scsi_test_unit_ready (fd);
 			if (state == last_state) {
 				HAL_DEBUG (("state has not changed %d %s", state, device_file));
 				/* TODO check if eject button was pressed */
 				/* see linux addons/addon-storage.c */
 				continue;
 			} else {
 				HAL_DEBUG (("new state %d %s", state, device_file));
+			}
 			switch (state) {
 			case DISC_EJECTED:
 				HAL_DEBUG (("Media removal detected on %s", device_file));
 				last_state = state;
 				libhal_device_set_property_bool (ctx, udi, "storage.removable.media_available", FALSE, &error);
 				my_dbus_error_free (&error);
 				/* attempt to unmount all childs */
 				unmount_childs (ctx, udi);
 				update_disc_volume_properties(fd, ctx, udi, state);
 				/* could have a fs on the main block device; do a rescan to remove it */
 				libhal_device_rescan (ctx, udi, &error);
 				my_dbus_error_free (&error);
 				break;
 			case DISC_INSERTED:
 				HAL_DEBUG (("Media insertion detected on %s", device_file));
 				last_state = state;
 				libhal_device_set_property_bool (ctx, udi, "storage.removable.media_available", TRUE, &error);
 				my_dbus_error_free (&error);
 				update_disc_volume_properties(fd, ctx, udi, state);
 				/* could have a fs on the main block device; do a rescan to add it */
 				libhal_device_rescan (ctx, udi, &error);
 				my_dbus_error_free (&error);
 				break;
 			case DISC_UNKNOWN:
 			default:
 				HAL_DEBUG (("Device gone detected on %s", device_file));
 				last_state = state;
 				unmount_childs (ctx, udi);
 				close_device (&fd);
 				goto out;
+			}
+		}
+	}
 out:
 	if (ctx != NULL) {
 		my_dbus_error_free (&error);
 		libhal_ctx_shutdown (ctx, &error);
 		libhal_ctx_free (ctx);
+	}
 	return 0;
+}