1 /***************************************************************************
2 *
3 * addon-storage.c : watch removable media state changes
4 *
5 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
6 * Use is subject to license terms.
7 *
8 * Licensed under the Academic Free License version 2.1
9 *
10 **************************************************************************/
11
12 #ifdef HAVE_CONFIG_H
13 # include <config.h>
14 #endif
15
16 #include <errno.h>
17 #include <string.h>
18 #include <strings.h>
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <sys/wait.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include <sys/mnttab.h>
29 #include <sys/dkio.h>
30 #include <priv.h>
31 #include <libsysevent.h>
32 #include <sys/sysevent/dev.h>
33
34 #include <libhal.h>
35
36 #include "../../hald/logger.h"
37
38 #define SLEEP_PERIOD 5
39
40 static char *udi;
41 static char *devfs_path;
42 LibHalContext *ctx = NULL;
43 static sysevent_handle_t *shp = NULL;
44
45 static void sysevent_dev_handler(sysevent_t *);
46
47 static void
48 my_dbus_error_free(DBusError *error)
49 {
50 if (dbus_error_is_set(error)) {
51 dbus_error_free(error);
52 }
53 }
54
55 static void
56 sysevent_init ()
57 {
58 const char *subcl[1];
59
60 shp = sysevent_bind_handle (sysevent_dev_handler);
61 if (shp == NULL) {
62 HAL_DEBUG (("sysevent_bind_handle failed %d", errno));
63 return;
64 }
65
66 subcl[0] = ESC_DEV_EJECT_REQUEST;
67 if (sysevent_subscribe_event (shp, EC_DEV_STATUS, subcl, 1) != 0) {
68 HAL_INFO (("subscribe(dev_status) failed %d", errno));
69 sysevent_unbind_handle (shp);
70 return;
71 }
72 }
73
74 static void
75 sysevent_fini ()
76 {
77 if (shp != NULL) {
78 sysevent_unbind_handle (shp);
79 shp = NULL;
80 }
81 }
82
83 static void
84 sysevent_dev_handler (sysevent_t *ev)
85 {
86 char *class;
87 char *subclass;
88 nvlist_t *attr_list;
89 char *phys_path, *path;
90 char *p;
91 int len;
92 DBusError error;
93
94 if ((class = sysevent_get_class_name (ev)) == NULL)
95 return;
96
97 if ((subclass = sysevent_get_subclass_name (ev)) == NULL)
98 return;
99
100 if ((strcmp (class, EC_DEV_STATUS) != 0) ||
101 (strcmp (subclass, ESC_DEV_EJECT_REQUEST) != 0))
102 return;
103
104 if (sysevent_get_attr_list (ev, &attr_list) != 0)
105 return;
106
107 if (nvlist_lookup_string (attr_list, DEV_PHYS_PATH, &phys_path) != 0) {
108 goto out;
109 }
110
111 /* see if event belongs to our LUN (ignore slice and "/devices" ) */
112 if (strncmp (phys_path, "/devices", sizeof ("/devices") - 1) == 0)
113 path = phys_path + sizeof ("/devices") - 1;
114 else
115 path = phys_path;
116
117 if ((p = strrchr (path, ':')) == NULL)
118 goto out;
119 len = (uintptr_t)p - (uintptr_t)path;
120 if (strncmp (path, devfs_path, len) != 0)
121 goto out;
122
123 HAL_DEBUG (("sysevent_dev_handler %s %s", subclass, phys_path));
124
125 /* we got it, tell the world */
126 dbus_error_init (&error);
127 libhal_device_emit_condition (ctx, udi, "EjectPressed", "", &error);
128 dbus_error_free (&error);
129
130 out:
131 nvlist_free(attr_list);
132 }
133
134 static void
135 force_unmount (LibHalContext *ctx, const char *udi)
136 {
137 DBusError error;
138 DBusMessage *msg = NULL;
139 DBusMessage *reply = NULL;
140 char **options = NULL;
141 unsigned int num_options = 0;
142 DBusConnection *dbus_connection;
143 char *device_file;
144
145 dbus_error_init (&error);
146
147 dbus_connection = libhal_ctx_get_dbus_connection (ctx);
148
149 msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
150 "org.freedesktop.Hal.Device.Volume",
151 "Unmount");
152 if (msg == NULL) {
153 HAL_DEBUG (("Could not create dbus message for %s", udi));
154 goto out;
155 }
156
157
158 options = calloc (1, sizeof (char *));
159 if (options == NULL) {
160 HAL_DEBUG (("Could not allocate options array"));
161 goto out;
162 }
163
164 device_file = libhal_device_get_property_string (ctx, udi, "block.device", &error);
165 if (device_file != NULL) {
166 libhal_free_string (device_file);
167 }
168 dbus_error_free (&error);
169
170 if (!dbus_message_append_args (msg,
171 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
172 DBUS_TYPE_INVALID)) {
173 HAL_DEBUG (("Could not append args to dbus message for %s", udi));
174 goto out;
175 }
176
177 if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error))) {
178 HAL_DEBUG (("Unmount failed for %s: %s : %s\n", udi, error.name, error.message));
179 goto out;
180 }
181
182 if (dbus_error_is_set (&error)) {
183 HAL_DEBUG (("Unmount failed for %s\n%s : %s\n", udi, error.name, error.message));
184 goto out;
185 }
186
187 HAL_DEBUG (("Succesfully unmounted udi '%s'", udi));
188
189 out:
190 dbus_error_free (&error);
191 if (options != NULL)
192 free (options);
193 if (msg != NULL)
194 dbus_message_unref (msg);
195 if (reply != NULL)
196 dbus_message_unref (reply);
197 }
198
199 static void
200 unmount_childs (LibHalContext *ctx, const char *udi)
201 {
202 DBusError error;
203 int num_volumes;
204 char **volumes;
205
206 dbus_error_init (&error);
207
208 /* need to force unmount all partitions */
209 if ((volumes = libhal_manager_find_device_string_match (
210 ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
211 dbus_error_free (&error);
212 int i;
213
214 for (i = 0; i < num_volumes; i++) {
215 char *vol_udi;
216
217 vol_udi = volumes[i];
218 if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
219 dbus_error_free (&error);
220 if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
221 dbus_error_free (&error);
222 HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
223 force_unmount (ctx, vol_udi);
224 }
225 }
226 }
227 libhal_free_string_array (volumes);
228 }
229 my_dbus_error_free (&error);
230 }
231
232 /** Check if a filesystem on a special device file is mounted
233 *
234 * @param device_file Special device file, e.g. /dev/cdrom
235 * @return TRUE iff there is a filesystem system mounted
236 * on the special device file
237 */
238 static dbus_bool_t
239 is_mounted (const char *device_file)
240 {
241 FILE *f;
242 dbus_bool_t rc = FALSE;
243 struct mnttab mp;
244 struct mnttab mpref;
245
246 if ((f = fopen ("/etc/mnttab", "r")) == NULL)
247 return rc;
248
249 bzero(&mp, sizeof (mp));
250 bzero(&mpref, sizeof (mpref));
251 mpref.mnt_special = (char *)device_file;
252 if (getmntany(f, &mp, &mpref) == 0) {
253 rc = TRUE;
254 }
255
256 fclose (f);
257 return rc;
258 }
259
260 void
261 close_device (int *fd)
262 {
263 if (*fd > 0) {
264 close (*fd);
265 *fd = -1;
266 }
267 }
268
269 void
270 drop_privileges ()
271 {
272 priv_set_t *pPrivSet = NULL;
273 priv_set_t *lPrivSet = NULL;
274
275 /*
276 * Start with the 'basic' privilege set and then remove any
277 * of the 'basic' privileges that will not be needed.
278 */
279 if ((pPrivSet = priv_str_to_set("basic", ",", NULL)) == NULL) {
280 return;
281 }
282
283 /* Clear privileges we will not need from the 'basic' set */
284 (void) priv_delset(pPrivSet, PRIV_FILE_LINK_ANY);
285 (void) priv_delset(pPrivSet, PRIV_PROC_INFO);
286 (void) priv_delset(pPrivSet, PRIV_PROC_SESSION);
287
288 /* to open logindevperm'd devices */
289 (void) priv_addset(pPrivSet, PRIV_FILE_DAC_READ);
290
291 /* to receive sysevents */
292 (void) priv_addset(pPrivSet, PRIV_SYS_CONFIG);
293
294 /* Set the permitted privilege set. */
295 if (setppriv(PRIV_SET, PRIV_PERMITTED, pPrivSet) != 0) {
296 return;
297 }
298
299 /* Clear the limit set. */
300 if ((lPrivSet = priv_allocset()) == NULL) {
301 return;
302 }
303
304 priv_emptyset(lPrivSet);
305
306 if (setppriv(PRIV_SET, PRIV_LIMIT, lPrivSet) != 0) {
307 return;
308 }
309
310 priv_freeset(lPrivSet);
311 }
312
313 int
314 main (int argc, char *argv[])
315 {
316 char *device_file, *raw_device_file;
317 DBusError error;
318 char *bus;
319 char *drive_type;
320 int state, last_state;
321 char *support_media_changed_str;
322 int support_media_changed;
323 int fd = -1;
324
325 if ((udi = getenv ("UDI")) == NULL)
326 goto out;
327 if ((device_file = getenv ("HAL_PROP_BLOCK_DEVICE")) == NULL)
328 goto out;
329 if ((raw_device_file = getenv ("HAL_PROP_BLOCK_SOLARIS_RAW_DEVICE")) == NULL)
330 goto out;
331 if ((bus = getenv ("HAL_PROP_STORAGE_BUS")) == NULL)
332 goto out;
333 if ((drive_type = getenv ("HAL_PROP_STORAGE_DRIVE_TYPE")) == NULL)
334 goto out;
335 if ((devfs_path = getenv ("HAL_PROP_SOLARIS_DEVFS_PATH")) == NULL)
336 goto out;
337
338 drop_privileges ();
339
340 setup_logger ();
341
342 sysevent_init ();
343
344 support_media_changed_str = getenv ("HAL_PROP_STORAGE_CDROM_SUPPORT_MEDIA_CHANGED");
345 if (support_media_changed_str != NULL && strcmp (support_media_changed_str, "true") == 0)
346 support_media_changed = TRUE;
347 else
348 support_media_changed = FALSE;
349
350 dbus_error_init (&error);
351
352 if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
353 goto out;
354 }
355 my_dbus_error_free (&error);
356
357 if (!libhal_device_addon_is_ready (ctx, udi, &error)) {
358 goto out;
359 }
360 my_dbus_error_free (&error);
361
362 printf ("Doing addon-storage for %s (bus %s) (drive_type %s) (udi %s)\n", device_file, bus, drive_type, udi);
363
364 last_state = state = DKIO_NONE;
365
366 /* Linux version of this addon attempts to re-open the device O_EXCL
367 * every 2 seconds, trying to figure out if some other app,
368 * like a cd burner, is using the device. Aside from questionable
369 * value of this (apps should use HAL's locked property or/and
370 * Solaris in_use facility), but also frequent opens/closes
371 * keeps media constantly spun up. All this needs more thought.
372 */
373 for (;;) {
374 if (is_mounted (device_file)) {
375 close_device (&fd);
376 sleep (SLEEP_PERIOD);
377 } else if ((fd < 0) && ((fd = open (raw_device_file, O_RDONLY | O_NONBLOCK)) < 0)) {
378 HAL_DEBUG (("open failed for %s: %s", raw_device_file, strerror (errno)));
379 sleep (SLEEP_PERIOD);
380 } else {
381 /* Check if a disc is in the drive */
382 /* XXX initial call always returns inserted
383 * causing unnecessary rescan - optimize?
384 */
385 if (ioctl (fd, DKIOCSTATE, &state) == 0) {
386 if (state == last_state) {
387 HAL_DEBUG (("state has not changed %d %s", state, device_file));
388 continue;
389 } else {
390 HAL_DEBUG (("new state %d %s", state, device_file));
391 }
392
393 switch (state) {
394 case DKIO_EJECTED:
395 HAL_DEBUG (("Media removal detected on %s", device_file));
396 last_state = state;
397
398 libhal_device_set_property_bool (ctx, udi, "storage.removable.media_available", FALSE, &error);
399 my_dbus_error_free (&error);
400
401 /* attempt to unmount all childs */
402 unmount_childs (ctx, udi);
403
404 /* could have a fs on the main block device; do a rescan to remove it */
405 libhal_device_rescan (ctx, udi, &error);
406 my_dbus_error_free (&error);
407 break;
408
409 case DKIO_INSERTED:
410 HAL_DEBUG (("Media insertion detected on %s", device_file));
411 last_state = state;
412
413 libhal_device_set_property_bool (ctx, udi, "storage.removable.media_available", TRUE, &error);
414 my_dbus_error_free (&error);
415
416 /* could have a fs on the main block device; do a rescan to add it */
417 libhal_device_rescan (ctx, udi, &error);
418 my_dbus_error_free (&error);
419 break;
420
421 case DKIO_DEV_GONE:
422 HAL_DEBUG (("Device gone detected on %s", device_file));
423 last_state = state;
424
425 unmount_childs (ctx, udi);
426 close_device (&fd);
427 goto out;
428
429 case DKIO_NONE:
430 default:
431 break;
432 }
433 } else {
434 HAL_DEBUG (("DKIOCSTATE failed: %s\n", strerror(errno)));
435 sleep (SLEEP_PERIOD);
436 }
437 }
438 }
439
440 out:
441 sysevent_fini ();
442 if (ctx != NULL) {
443 my_dbus_error_free (&error);
444 libhal_ctx_shutdown (ctx, &error);
445 libhal_ctx_free (ctx);
446 }
447
448 return 0;
449 }