1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <stdio.h>
27 #include <errno.h>
28 #include <string.h>
29 #include <strings.h>
30 #include <stdarg.h>
31 #include <fcntl.h>
32 #include <libintl.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <ctype.h>
36 #include <sys/param.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <sys/mnttab.h>
40
41 #include <dbus/dbus.h>
42 #include <dbus/dbus-glib.h>
43 #include <dbus/dbus-glib-lowlevel.h>
44 #include <libhal.h>
45 #include <libhal-storage.h>
46
47 #include "rmm_common.h"
48
49 #define RMM_PRINT_DEVICE_WIDTH 20
50
51 extern int rmm_debug;
52
53 static const char *action_strings[] = {
54 "eject",
55 "mount",
56 "remount",
57 "unmount",
58 "clear_mounts",
59 "closetray"
60 };
61
62
63 LibHalContext *
64 rmm_hal_init(LibHalDeviceAdded devadd_cb, LibHalDeviceRemoved devrem_cb,
65 LibHalDevicePropertyModified propmod_cb, LibHalDeviceCondition cond_cb,
66 DBusError *error, rmm_error_t *rmm_error)
67 {
68 DBusConnection *dbus_conn;
69 LibHalContext *ctx;
70 char **devices;
71 int nr;
72
73 dbus_error_init(error);
74
75 /*
76 * setup D-Bus connection
77 */
78 if (!(dbus_conn = dbus_bus_get(DBUS_BUS_SYSTEM, error))) {
79 dprintf("cannot get system bus: %s\n", rmm_strerror(error, -1));
80 *rmm_error = RMM_EDBUS_CONNECT;
81 return (NULL);
82 }
83 rmm_dbus_error_free(error);
84
85 dbus_connection_setup_with_g_main(dbus_conn, NULL);
86 dbus_connection_set_exit_on_disconnect(dbus_conn, B_TRUE);
87
88 if ((ctx = libhal_ctx_new()) == NULL) {
89 dprintf("libhal_ctx_new failed");
90 *rmm_error = RMM_EHAL_CONNECT;
91 return (NULL);
92 }
93
94 libhal_ctx_set_dbus_connection(ctx, dbus_conn);
95
96 /*
97 * register callbacks
98 */
99 if (devadd_cb != NULL) {
100 libhal_ctx_set_device_added(ctx, devadd_cb);
101 }
102 if (devrem_cb != NULL) {
103 libhal_ctx_set_device_removed(ctx, devrem_cb);
104 }
105 if (propmod_cb != NULL) {
106 libhal_ctx_set_device_property_modified(ctx, propmod_cb);
107 if (!libhal_device_property_watch_all(ctx, error)) {
108 dprintf("property_watch_all failed %s",
109 rmm_strerror(error, -1));
110 libhal_ctx_free(ctx);
111 *rmm_error = RMM_EHAL_CONNECT;
112 return (NULL);
113 }
114 }
115 if (cond_cb != NULL) {
116 libhal_ctx_set_device_condition(ctx, cond_cb);
117 }
118
119 if (!libhal_ctx_init(ctx, error)) {
120 dprintf("libhal_ctx_init failed: %s", rmm_strerror(error, -1));
121 libhal_ctx_free(ctx);
122 *rmm_error = RMM_EHAL_CONNECT;
123 return (NULL);
124 }
125 rmm_dbus_error_free(error);
126
127 /*
128 * The above functions do not guarantee that HAL is actually running.
129 * Check by invoking a method.
130 */
131 if (!(devices = libhal_get_all_devices(ctx, &nr, error))) {
132 dprintf("HAL is not running: %s", rmm_strerror(error, -1));
133 libhal_ctx_shutdown(ctx, NULL);
134 libhal_ctx_free(ctx);
135 *rmm_error = RMM_EHAL_CONNECT;
136 return (NULL);
137 } else {
138 rmm_dbus_error_free(error);
139 libhal_free_string_array(devices);
140 }
141
142 return (ctx);
143 }
144
145
146 void
147 rmm_hal_fini(LibHalContext *hal_ctx)
148 {
149 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
150
151 (void) dbus_connection_unref(dbus_conn);
152 (void) libhal_ctx_free(hal_ctx);
153 }
154
155
156 /*
157 * find volume from any type of name, similar to the old media_findname()
158 * returns the LibHalDrive object and a list of LibHalVolume objects.
159 */
160 LibHalDrive *
161 rmm_hal_volume_find(LibHalContext *hal_ctx, const char *name, DBusError *error,
162 GSList **volumes)
163 {
164 LibHalDrive *drive;
165 char *p;
166 char lastc;
167
168 *volumes = NULL;
169
170 /* temporarily remove trailing slash */
171 p = (char *)name + strlen(name) - 1;
172 if (*p == '/') {
173 lastc = *p;
174 *p = '\0';
175 } else {
176 p = NULL;
177 }
178
179 if (name[0] == '/') {
180 if (((drive = rmm_hal_volume_findby(hal_ctx,
181 "info.udi", name, volumes)) != NULL) ||
182 ((drive = rmm_hal_volume_findby(hal_ctx,
183 "block.device", name, volumes)) != NULL) ||
184 ((drive = rmm_hal_volume_findby(hal_ctx,
185 "block.solaris.raw_device", name, volumes)) != NULL) ||
186 ((drive = rmm_hal_volume_findby(hal_ctx,
187 "volume.mount_point", name, volumes)) != NULL)) {
188 goto out;
189 } else {
190 goto out;
191 }
192 }
193
194 /* try volume label */
195 if ((drive = rmm_hal_volume_findby(hal_ctx,
196 "volume.label", name, volumes)) != NULL) {
197 goto out;
198 }
199
200 drive = rmm_hal_volume_findby_nickname(hal_ctx, name, volumes);
201
202 out:
203 if (p != NULL) {
204 *p = lastc;
205 }
206 return (drive);
207 }
208
209 /*
210 * find default volume. Returns volume pointer and name in 'name'.
211 */
212 LibHalDrive *
213 rmm_hal_volume_find_default(LibHalContext *hal_ctx, DBusError *error,
214 const char **name_out, GSList **volumes)
215 {
216 LibHalDrive *drive;
217 static const char *names[] = { "floppy", "cdrom", "rmdisk" };
218 int i;
219
220 *volumes = NULL;
221
222 for (i = 0; i < NELEM(names); i++) {
223 if ((drive = rmm_hal_volume_findby_nickname(hal_ctx,
224 names[i], volumes)) != NULL) {
225 /*
226 * Skip floppy if it has no media.
227 * XXX might want to actually check for media
228 * every time instead of relying on volcheck.
229 */
230 if ((strcmp(names[i], "floppy") != 0) ||
231 libhal_device_get_property_bool(hal_ctx,
232 libhal_drive_get_udi(drive),
233 "storage.removable.media_available", NULL)) {
234 *name_out = names[i];
235 break;
236 }
237 }
238 rmm_dbus_error_free(error);
239 }
240
241 return (drive);
242 }
243
244 /*
245 * find volume by property=value
246 * returns the LibHalDrive object and a list of LibHalVolume objects.
247 * XXX add support for multiple properties, reduce D-Bus traffic
248 */
249 LibHalDrive *
250 rmm_hal_volume_findby(LibHalContext *hal_ctx, const char *property,
251 const char *value, GSList **volumes)
252 {
253 DBusError error;
254 LibHalDrive *drive = NULL;
255 LibHalVolume *v = NULL;
256 char **udis;
257 int num_udis;
258 int i;
259 int i_drive = -1;
260
261 *volumes = NULL;
262
263 dbus_error_init(&error);
264
265 /* get all devices with property=value */
266 if ((udis = libhal_manager_find_device_string_match(hal_ctx, property,
267 value, &num_udis, &error)) == NULL) {
268 rmm_dbus_error_free(&error);
269 return (NULL);
270 }
271
272 /* find volumes and drives among these devices */
273 for (i = 0; i < num_udis; i++) {
274 rmm_dbus_error_free(&error);
275 if (libhal_device_query_capability(hal_ctx, udis[i], "volume",
276 &error)) {
277 v = libhal_volume_from_udi(hal_ctx, udis[i]);
278 if (v != NULL) {
279 *volumes = g_slist_prepend(*volumes, v);
280 }
281 } else if ((*volumes == NULL) &&
282 libhal_device_query_capability(hal_ctx, udis[i], "storage",
283 &error)) {
284 i_drive = i;
285 }
286 }
287
288 if (*volumes != NULL) {
289 /* used prepend, preserve original order */
290 *volumes = g_slist_reverse(*volumes);
291
292 v = (LibHalVolume *)(*volumes)->data;
293 drive = libhal_drive_from_udi(hal_ctx,
294 libhal_volume_get_storage_device_udi(v));
295 if (drive == NULL) {
296 rmm_volumes_free (*volumes);
297 *volumes = NULL;
298 }
299 } else if (i_drive >= 0) {
300 drive = libhal_drive_from_udi(hal_ctx, udis[i_drive]);
301 }
302
303 libhal_free_string_array(udis);
304 rmm_dbus_error_free(&error);
305
306 return (drive);
307 }
308
309 static void
310 rmm_print_nicknames_one(LibHalDrive *d, LibHalVolume *v,
311 const char *device, char **drive_nicknames)
312 {
313 const char *volume_label = NULL;
314 const char *mount_point = NULL;
315 boolean_t comma;
316 int i;
317
318 (void) printf("%-*s ", RMM_PRINT_DEVICE_WIDTH, device);
319 comma = B_FALSE;
320
321 if (drive_nicknames != NULL) {
322 for (i = 0; drive_nicknames[i] != NULL; i++) {
323 (void) printf("%s%s", comma ? "," : "",
324 drive_nicknames[i]);
325 comma = B_TRUE;
326 }
327 }
328
329 if ((v != NULL) &&
330 ((volume_label = libhal_volume_get_label(v)) != NULL) &&
331 (strlen(volume_label) > 0)) {
332 (void) printf("%s%s", comma ? "," : "", volume_label);
333 comma = B_TRUE;
334 }
335
336 if ((v != NULL) &&
337 ((mount_point = libhal_volume_get_mount_point(v)) != NULL) &&
338 (strlen(mount_point) > 0)) {
339 (void) printf("%s%s", comma ? "," : "", mount_point);
340 comma = B_TRUE;
341 }
342
343 (void) printf("\n");
344 }
345
346 /*
347 * print nicknames for each available volume
348 *
349 * print_mask:
350 * RMM_PRINT_MOUNTABLE print only mountable volumes
351 * RMM_PRINT_EJECTABLE print volume-less ejectable drives
352 */
353 void
354 rmm_print_volume_nicknames(LibHalContext *hal_ctx, DBusError *error,
355 int print_mask)
356 {
357 char **udis;
358 int num_udis;
359 GSList *volumes = NULL;
360 LibHalDrive *d, *d_tmp;
361 LibHalVolume *v;
362 const char *device;
363 char **nicknames;
364 int i;
365 GSList *j;
366 int nprinted;
367
368 dbus_error_init(error);
369
370 if ((udis = libhal_find_device_by_capability(hal_ctx, "storage",
371 &num_udis, error)) == NULL) {
372 rmm_dbus_error_free(error);
373 return;
374 }
375
376 for (i = 0; i < num_udis; i++) {
377 if ((d = libhal_drive_from_udi(hal_ctx, udis[i])) == NULL) {
378 continue;
379 }
380
381 /* find volumes belonging to this drive */
382 if ((d_tmp = rmm_hal_volume_findby(hal_ctx,
383 "block.storage_device", udis[i], &volumes)) != NULL) {
384 libhal_drive_free(d_tmp);
385 }
386
387 nicknames = libhal_device_get_property_strlist(hal_ctx,
388 udis[i], "storage.solaris.nicknames", NULL);
389
390 nprinted = 0;
391 for (j = volumes; j != NULL; j = g_slist_next(j)) {
392 v = (LibHalVolume *)(j->data);
393
394 if ((device = libhal_volume_get_device_file(v)) ==
395 NULL) {
396 continue;
397 }
398 if ((print_mask & RMM_PRINT_MOUNTABLE) &&
399 (libhal_volume_get_fsusage(v) !=
400 LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM)) {
401 continue;
402 }
403
404 rmm_print_nicknames_one(d, v, device, nicknames);
405 nprinted++;
406 }
407
408 if ((nprinted == 0) &&
409 (print_mask & RMM_PRINT_EJECTABLE) &&
410 libhal_drive_requires_eject(d) &&
411 ((device = libhal_drive_get_device_file(d)) != NULL)) {
412 rmm_print_nicknames_one(d, NULL, device, nicknames);
413 }
414
415 libhal_free_string_array(nicknames);
416 libhal_drive_free(d);
417 rmm_volumes_free(volumes);
418 volumes = NULL;
419 }
420
421 libhal_free_string_array(udis);
422 }
423
424 /*
425 * find volume by nickname
426 * returns the LibHalDrive object and a list of LibHalVolume objects.
427 */
428 LibHalDrive *
429 rmm_hal_volume_findby_nickname(LibHalContext *hal_ctx, const char *name,
430 GSList **volumes)
431 {
432 DBusError error;
433 LibHalDrive *drive = NULL;
434 LibHalDrive *drive_tmp;
435 char **udis;
436 int num_udis;
437 char **nicknames;
438 int i, j;
439
440 *volumes = NULL;
441
442 dbus_error_init(&error);
443
444 if ((udis = libhal_find_device_by_capability(hal_ctx, "storage",
445 &num_udis, &error)) == NULL) {
446 rmm_dbus_error_free(&error);
447 return (NULL);
448 }
449
450 /* find a drive by nickname */
451 for (i = 0; (i < num_udis) && (drive == NULL); i++) {
452 if ((nicknames = libhal_device_get_property_strlist(hal_ctx,
453 udis[i], "storage.solaris.nicknames", &error)) == NULL) {
454 rmm_dbus_error_free(&error);
455 continue;
456 }
457 for (j = 0; (nicknames[j] != NULL) && (drive == NULL); j++) {
458 if (strcmp(nicknames[j], name) == 0) {
459 drive = libhal_drive_from_udi(hal_ctx, udis[i]);
460 }
461 }
462 libhal_free_string_array(nicknames);
463 }
464 libhal_free_string_array(udis);
465
466 if (drive != NULL) {
467 /* found the drive, now find its volumes */
468 if ((drive_tmp = rmm_hal_volume_findby(hal_ctx,
469 "block.storage_device", libhal_drive_get_udi(drive),
470 volumes)) != NULL) {
471 libhal_drive_free(drive_tmp);
472 }
473 }
474
475 rmm_dbus_error_free(&error);
476
477 return (drive);
478 }
479
480 void
481 rmm_volumes_free(GSList *volumes)
482 {
483 GSList *i;
484
485 for (i = volumes; i != NULL; i = g_slist_next(i)) {
486 libhal_volume_free((LibHalVolume *)(i->data));
487 }
488 g_slist_free(volumes);
489 }
490
491 /*
492 * Call HAL's Mount() method on the given device
493 */
494 boolean_t
495 rmm_hal_mount(LibHalContext *hal_ctx, const char *udi,
496 char **opts, int num_opts, char *mountpoint, DBusError *error)
497 {
498 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
499 DBusMessage *dmesg, *reply;
500 char *fstype;
501
502 dprintf("mounting %s...\n", udi);
503
504 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal", udi,
505 "org.freedesktop.Hal.Device.Volume", "Mount"))) {
506 dprintf(
507 "mount failed for %s: cannot create dbus message\n", udi);
508 return (B_FALSE);
509 }
510
511 fstype = "";
512 if (mountpoint == NULL) {
513 mountpoint = "";
514 }
515
516 if (!dbus_message_append_args(dmesg, DBUS_TYPE_STRING, &mountpoint,
517 DBUS_TYPE_STRING, &fstype,
518 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &opts, num_opts,
519 DBUS_TYPE_INVALID)) {
520 dprintf("mount failed for %s: cannot append args\n", udi);
521 dbus_message_unref(dmesg);
522 return (B_FALSE);
523 }
524
525 dbus_error_init(error);
526 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
527 dmesg, RMM_MOUNT_TIMEOUT, error))) {
528 dprintf("mount failed for %s: %s\n", udi, error->message);
529 dbus_message_unref(dmesg);
530 return (B_FALSE);
531 }
532
533 dprintf("mounted %s\n", udi);
534
535 dbus_message_unref(dmesg);
536 dbus_message_unref(reply);
537
538 rmm_dbus_error_free(error);
539
540 return (B_TRUE);
541 }
542
543
544 /*
545 * Call HAL's Unmount() method on the given device
546 */
547 boolean_t
548 rmm_hal_unmount(LibHalContext *hal_ctx, const char *udi, DBusError *error)
549 {
550 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
551 DBusMessage *dmesg, *reply;
552 char **opts = NULL;
553
554 dprintf("unmounting %s...\n", udi);
555
556 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal", udi,
557 "org.freedesktop.Hal.Device.Volume", "Unmount"))) {
558 dprintf(
559 "unmount failed %s: cannot create dbus message\n", udi);
560 return (B_FALSE);
561 }
562
563 if (!dbus_message_append_args(dmesg, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
564 &opts, 0, DBUS_TYPE_INVALID)) {
565 dprintf("unmount failed %s: cannot append args\n", udi);
566 dbus_message_unref(dmesg);
567 return (B_FALSE);
568 }
569
570 dbus_error_init(error);
571 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
572 dmesg, RMM_UNMOUNT_TIMEOUT, error))) {
573 dprintf("unmount failed for %s: %s\n", udi, error->message);
574 dbus_message_unref(dmesg);
575 return (B_FALSE);
576 }
577
578 dprintf("unmounted %s\n", udi);
579
580 dbus_message_unref(dmesg);
581 dbus_message_unref(reply);
582
583 rmm_dbus_error_free(error);
584
585 return (B_TRUE);
586 }
587
588
589 /*
590 * Call HAL's Eject() method on the given device
591 */
592 boolean_t
593 rmm_hal_eject(LibHalContext *hal_ctx, const char *udi, DBusError *error)
594 {
595 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
596 DBusMessage *dmesg, *reply;
597 char **options = NULL;
598 uint_t num_options = 0;
599
600 dprintf("ejecting %s...\n", udi);
601
602 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal", udi,
603 "org.freedesktop.Hal.Device.Storage", "Eject"))) {
604 dprintf("eject %s: cannot create dbus message\n", udi);
605 return (B_FALSE);
606 }
607
608 if (!dbus_message_append_args(dmesg,
609 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
610 DBUS_TYPE_INVALID)) {
611 dprintf("eject %s: cannot append args to dbus message ", udi);
612 dbus_message_unref(dmesg);
613 return (B_FALSE);
614 }
615
616 dbus_error_init(error);
617 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
618 dmesg, RMM_EJECT_TIMEOUT, error))) {
619 dprintf("eject %s: %s\n", udi, error->message);
620 dbus_message_unref(dmesg);
621 return (B_FALSE);
622 }
623
624 dprintf("ejected %s\n", udi);
625
626 dbus_message_unref(dmesg);
627 dbus_message_unref(reply);
628
629 rmm_dbus_error_free(error);
630
631 return (B_TRUE);
632 }
633
634 /*
635 * Call HAL's CloseTray() method on the given device
636 */
637 boolean_t
638 rmm_hal_closetray(LibHalContext *hal_ctx, const char *udi, DBusError *error)
639 {
640 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
641 DBusMessage *dmesg, *reply;
642 char **options = NULL;
643 uint_t num_options = 0;
644
645 dprintf("closing tray %s...\n", udi);
646
647 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal", udi,
648 "org.freedesktop.Hal.Device.Storage", "CloseTray"))) {
649 dprintf(
650 "closetray failed for %s: cannot create dbus message\n",
651 udi);
652 return (B_FALSE);
653 }
654
655 if (!dbus_message_append_args(dmesg,
656 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
657 DBUS_TYPE_INVALID)) {
658 dprintf("closetray %s: cannot append args to dbus message ",
659 udi);
660 dbus_message_unref(dmesg);
661 return (B_FALSE);
662 }
663
664 dbus_error_init(error);
665 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
666 dmesg, RMM_CLOSETRAY_TIMEOUT, error))) {
667 dprintf("closetray failed for %s: %s\n", udi, error->message);
668 dbus_message_unref(dmesg);
669 return (B_FALSE);
670 }
671
672 dprintf("closetray ok %s\n", udi);
673
674 dbus_message_unref(dmesg);
675 dbus_message_unref(reply);
676
677 rmm_dbus_error_free(error);
678
679 return (B_TRUE);
680 }
681
682 /*
683 * Call HAL's Rescan() method on the given device
684 */
685 boolean_t
686 rmm_hal_rescan(LibHalContext *hal_ctx, const char *udi, DBusError *error)
687 {
688 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
689 DBusMessage *dmesg, *reply;
690
691 dprintf("rescanning %s...\n", udi);
692
693 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal", udi,
694 "org.freedesktop.Hal.Device", "Rescan"))) {
695 dprintf("rescan failed for %s: cannot create dbus message\n",
696 udi);
697 return (B_FALSE);
698 }
699
700 dbus_error_init(error);
701 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
702 dmesg, -1, error))) {
703 dprintf("rescan failed for %s: %s\n", udi, error->message);
704 dbus_message_unref(dmesg);
705 return (B_FALSE);
706 }
707
708 dprintf("rescan ok %s\n", udi);
709
710 dbus_message_unref(dmesg);
711 dbus_message_unref(reply);
712
713 rmm_dbus_error_free(error);
714
715 return (B_TRUE);
716 }
717
718 boolean_t
719 rmm_hal_claim_branch(LibHalContext *hal_ctx, const char *udi)
720 {
721 DBusError error;
722 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
723 DBusMessage *dmesg, *reply;
724 const char *claimed_by = "rmvolmgr";
725
726 dprintf("claiming branch %s...\n", udi);
727
728 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal",
729 "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager",
730 "ClaimBranch"))) {
731 dprintf("cannot create dbus message\n");
732 return (B_FALSE);
733 }
734
735 if (!dbus_message_append_args(dmesg, DBUS_TYPE_STRING, &udi,
736 DBUS_TYPE_STRING, &claimed_by, DBUS_TYPE_INVALID)) {
737 dprintf("cannot append args to dbus message\n");
738 dbus_message_unref(dmesg);
739 return (B_FALSE);
740 }
741
742 dbus_error_init(&error);
743 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
744 dmesg, -1, &error))) {
745 dprintf("cannot send dbus message\n");
746 dbus_message_unref(dmesg);
747 rmm_dbus_error_free(&error);
748 return (B_FALSE);
749 }
750
751 dprintf("claim branch ok %s\n", udi);
752
753 dbus_message_unref(dmesg);
754 dbus_message_unref(reply);
755
756 return (B_TRUE);
757 }
758
759 boolean_t
760 rmm_hal_unclaim_branch(LibHalContext *hal_ctx, const char *udi)
761 {
762 DBusError error;
763 DBusConnection *dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
764 DBusMessage *dmesg, *reply;
765 const char *claimed_by = "rmvolmgr";
766
767 dprintf("unclaiming branch %s...\n", udi);
768
769 if (!(dmesg = dbus_message_new_method_call("org.freedesktop.Hal",
770 "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager",
771 "UnclaimBranch"))) {
772 dprintf("cannot create dbus message\n");
773 return (B_FALSE);
774 }
775
776 if (!dbus_message_append_args(dmesg, DBUS_TYPE_STRING, &udi,
777 DBUS_TYPE_STRING, &claimed_by, DBUS_TYPE_INVALID)) {
778 dprintf("cannot append args to dbus message\n");
779 dbus_message_unref(dmesg);
780 return (B_FALSE);
781 }
782
783 dbus_error_init(&error);
784 if (!(reply = dbus_connection_send_with_reply_and_block(dbus_conn,
785 dmesg, -1, &error))) {
786 dprintf("cannot send dbus message\n");
787 dbus_message_unref(dmesg);
788 rmm_dbus_error_free(&error);
789 return (B_FALSE);
790 }
791
792 dprintf("unclaim branch ok %s\n", udi);
793
794 dbus_message_unref(dmesg);
795 dbus_message_unref(reply);
796
797 return (B_TRUE);
798 }
799
800 static boolean_t
801 rmm_action_one(LibHalContext *hal_ctx, const char *name, action_t action,
802 const char *dev, const char *udi, LibHalVolume *v,
803 char **opts, int num_opts, char *mountpoint)
804 {
805 char dev_str[MAXPATHLEN];
806 char *mountp;
807 DBusError error;
808 boolean_t ret = B_FALSE;
809
810 if (strcmp(name, dev) == 0) {
811 (void) snprintf(dev_str, sizeof (dev_str), name);
812 } else {
813 (void) snprintf(dev_str, sizeof (dev_str), "%s %s", name, dev);
814 }
815
816 dbus_error_init(&error);
817
818 switch (action) {
819 case EJECT:
820 ret = rmm_hal_eject(hal_ctx, udi, &error);
821 break;
822 case INSERT:
823 case REMOUNT:
824 if (libhal_volume_is_mounted(v)) {
825 goto done;
826 }
827 ret = rmm_hal_mount(hal_ctx, udi,
828 opts, num_opts, mountpoint, &error);
829 break;
830 case UNMOUNT:
831 if (!libhal_volume_is_mounted(v)) {
832 goto done;
833 }
834 ret = rmm_hal_unmount(hal_ctx, udi, &error);
835 break;
836 case CLOSETRAY:
837 ret = rmm_hal_closetray(hal_ctx, udi, &error);
838 break;
839 }
840
841 if (!ret) {
842 (void) fprintf(stderr, gettext("%s of %s failed: %s\n"),
843 action_strings[action], dev_str, rmm_strerror(&error, -1));
844 goto done;
845 }
846
847 switch (action) {
848 case EJECT:
849 (void) printf(gettext("%s ejected\n"), dev_str);
850 break;
851 case INSERT:
852 case REMOUNT:
853 mountp = rmm_get_mnttab_mount_point(dev);
854 if (mountp != NULL) {
855 (void) printf(gettext("%s mounted at %s\n"),
856 dev_str, mountp);
857 free(mountp);
858 }
859 break;
860 case UNMOUNT:
861 (void) printf(gettext("%s unmounted\n"), dev_str);
862 break;
863 case CLOSETRAY:
864 (void) printf(gettext("%s tray closed\n"), dev_str);
865 break;
866 }
867
868 done:
869 rmm_dbus_error_free(&error);
870 return (ret);
871 }
872
873 /*
874 * top level action routine
875 *
876 * If non-null 'aa' is passed, it will be used, otherwise a local copy
877 * will be created.
878 */
879 boolean_t
880 rmm_action(LibHalContext *hal_ctx, const char *name, action_t action,
881 struct action_arg *aap, char **opts, int num_opts, char *mountpoint)
882 {
883 DBusError error;
884 GSList *volumes, *i;
885 LibHalDrive *d;
886 LibHalVolume *v;
887 const char *udi, *d_udi;
888 const char *dev, *d_dev;
889 struct action_arg aa_local;
890 boolean_t ret = B_FALSE;
891
892 dprintf("rmm_action %s %s\n", name, action_strings[action]);
893
894 if (aap == NULL) {
895 bzero(&aa_local, sizeof (aa_local));
896 aap = &aa_local;
897 }
898
899 dbus_error_init(&error);
900
901 /* find the drive and its volumes */
902 d = rmm_hal_volume_find(hal_ctx, name, &error, &volumes);
903 rmm_dbus_error_free(&error);
904 if (d == NULL) {
905 (void) fprintf(stderr, gettext("cannot find '%s'\n"), name);
906 return (B_FALSE);
907 }
908 d_udi = libhal_drive_get_udi(d);
909 d_dev = libhal_drive_get_device_file(d);
910 if ((d_udi == NULL) || (d_dev == NULL)) {
911 goto out;
912 }
913
914 /*
915 * For those drives that do not require media eject,
916 * EJECT turns into UNMOUNT.
917 */
918 if ((action == EJECT) && !libhal_drive_requires_eject(d)) {
919 action = UNMOUNT;
920 }
921
922 /* per drive action */
923 if ((action == EJECT) || (action == CLOSETRAY)) {
924 ret = rmm_action_one(hal_ctx, name, action, d_dev, d_udi, NULL,
925 opts, num_opts, NULL);
926
927 if (!ret || (action == CLOSETRAY)) {
928 goto out;
929 }
930 }
931
932 /* per volume action */
933 for (i = volumes; i != NULL; i = g_slist_next(i)) {
934 v = (LibHalVolume *)i->data;
935 udi = libhal_volume_get_udi(v);
936 dev = libhal_volume_get_device_file(v);
937
938 if ((udi == NULL) || (dev == NULL)) {
939 continue;
940 }
941 if (aap == &aa_local) {
942 if (!rmm_volume_aa_from_prop(hal_ctx, udi, v, aap)) {
943 dprintf("rmm_volume_aa_from_prop failed %s\n",
944 udi);
945 continue;
946 }
947 }
948 aap->aa_action = action;
949
950 /* ejected above, just need postprocess */
951 if (action != EJECT) {
952 ret = rmm_action_one(hal_ctx, name, action, dev, udi, v,
953 opts, num_opts, mountpoint);
954 }
955 if (ret) {
956 (void) vold_postprocess(hal_ctx, udi, aap);
957 }
958
959 if (aap == &aa_local) {
960 rmm_volume_aa_free(aap);
961 }
962 }
963
964 out:
965 rmm_volumes_free(volumes);
966 libhal_drive_free(d);
967
968 return (ret);
969 }
970
971
972 /*
973 * rescan by name
974 * if name is NULL, rescan all drives
975 */
976 boolean_t
977 rmm_rescan(LibHalContext *hal_ctx, const char *name, boolean_t query)
978 {
979 DBusError error;
980 GSList *volumes;
981 LibHalDrive *drive = NULL;
982 const char *drive_udi;
983 char **udis;
984 int num_udis;
985 char *nickname;
986 char **nicks = NULL;
987 boolean_t do_free_udis = FALSE;
988 int i;
989 boolean_t ret = B_FALSE;
990
991 dprintf("rmm_rescan %s\n", name != NULL ? name : "all");
992
993 dbus_error_init(&error);
994
995 if (name != NULL) {
996 if ((drive = rmm_hal_volume_find(hal_ctx, name, &error,
997 &volumes)) == NULL) {
998 rmm_dbus_error_free(&error);
999 (void) fprintf(stderr,
1000 gettext("cannot find '%s'\n"), name);
1001 return (B_FALSE);
1002 }
1003 rmm_dbus_error_free(&error);
1004 g_slist_free(volumes);
1005
1006 drive_udi = libhal_drive_get_udi(drive);
1007 udis = (char **)&drive_udi;
1008 num_udis = 1;
1009 } else {
1010 if ((udis = libhal_find_device_by_capability(hal_ctx,
1011 "storage", &num_udis, &error)) == NULL) {
1012 rmm_dbus_error_free(&error);
1013 return (B_TRUE);
1014 }
1015 rmm_dbus_error_free(&error);
1016 do_free_udis = TRUE;
1017 }
1018
1019 for (i = 0; i < num_udis; i++) {
1020 if (name == NULL) {
1021 nicks = libhal_device_get_property_strlist(hal_ctx,
1022 udis[i], "storage.solaris.nicknames", NULL);
1023 if (nicks != NULL) {
1024 nickname = nicks[0];
1025 } else {
1026 nickname = "";
1027 }
1028 }
1029 if (!(ret = rmm_hal_rescan(hal_ctx, udis[i], &error))) {
1030 (void) fprintf(stderr,
1031 gettext("rescan of %s failed: %s\n"),
1032 name ? name : nickname,
1033 rmm_strerror(&error, -1));
1034 libhal_free_string_array(nicks);
1035 continue;
1036 }
1037 if (query) {
1038 ret = libhal_device_get_property_bool(hal_ctx, udis[i],
1039 "storage.removable.media_available", NULL);
1040 if (ret) {
1041 printf(gettext("%s is available\n"),
1042 name ? name : nickname);
1043 } else {
1044 printf(gettext("%s is not available\n"),
1045 name ? name : nickname);
1046 }
1047 }
1048 libhal_free_string_array(nicks);
1049 }
1050
1051 if (drive != NULL) {
1052 libhal_drive_free(drive);
1053 }
1054 if (do_free_udis) {
1055 libhal_free_string_array(udis);
1056 }
1057
1058 return (ret);
1059 }
1060
1061
1062 /*
1063 * set action_arg from volume properties
1064 */
1065 boolean_t
1066 rmm_volume_aa_from_prop(LibHalContext *hal_ctx, const char *udi_arg,
1067 LibHalVolume *volume_arg, struct action_arg *aap)
1068 {
1069 LibHalVolume *volume = volume_arg;
1070 const char *udi = udi_arg;
1071 const char *drive_udi;
1072 char *volume_label;
1073 char *mountpoint;
1074 int len;
1075 int ret = B_FALSE;
1076
1077 /* at least udi or volume must be supplied */
1078 if ((udi == NULL) && (volume == NULL)) {
1079 return (B_FALSE);
1080 }
1081 if (volume == NULL) {
1082 if ((volume = libhal_volume_from_udi(hal_ctx, udi)) == NULL) {
1083 dprintf("cannot get volume %s\n", udi);
1084 goto out;
1085 }
1086 }
1087 if (udi == NULL) {
1088 if ((udi = libhal_volume_get_udi(volume)) == NULL) {
1089 dprintf("cannot get udi\n");
1090 goto out;
1091 }
1092 }
1093 drive_udi = libhal_volume_get_storage_device_udi(volume);
1094
1095 if (!(aap->aa_symdev = libhal_device_get_property_string(hal_ctx,
1096 drive_udi, "storage.solaris.legacy.symdev", NULL))) {
1097 dprintf("property %s not found %s\n",
1098 "storage.solaris.legacy.symdev", drive_udi);
1099 goto out;
1100 }
1101 if (!(aap->aa_media = libhal_device_get_property_string(hal_ctx,
1102 drive_udi, "storage.solaris.legacy.media_type", NULL))) {
1103 dprintf("property %s not found %s\n",
1104 "storage.solaris.legacy.media_type", drive_udi);
1105 goto out;
1106 }
1107
1108 /* name is derived from volume label */
1109 aap->aa_name = NULL;
1110 if ((volume_label = (char *)libhal_device_get_property_string(hal_ctx,
1111 udi, "volume.label", NULL)) != NULL) {
1112 if ((len = strlen(volume_label)) > 0) {
1113 aap->aa_name = rmm_vold_convert_volume_label(
1114 volume_label, len);
1115 if (strlen(aap->aa_name) == 0) {
1116 free(aap->aa_name);
1117 aap->aa_name = NULL;
1118 }
1119 }
1120 libhal_free_string(volume_label);
1121 }
1122 /* if no label, then unnamed_<mediatype> */
1123 if (aap->aa_name == NULL) {
1124 aap->aa_name = (char *)calloc(1, sizeof ("unnamed_floppyNNNN"));
1125 if (aap->aa_name == NULL) {
1126 goto out;
1127 }
1128 (void) snprintf(aap->aa_name, sizeof ("unnamed_floppyNNNN"),
1129 "unnamed_%s", aap->aa_media);
1130 }
1131
1132 if (!(aap->aa_path = libhal_device_get_property_string(hal_ctx, udi,
1133 "block.device", NULL))) {
1134 dprintf("property %s not found %s\n", "block.device", udi);
1135 goto out;
1136 }
1137 if (!(aap->aa_rawpath = libhal_device_get_property_string(hal_ctx, udi,
1138 "block.solaris.raw_device", NULL))) {
1139 dprintf("property %s not found %s\n",
1140 "block.solaris.raw_device", udi);
1141 goto out;
1142 }
1143 if (!(aap->aa_type = libhal_device_get_property_string(hal_ctx, udi,
1144 "volume.fstype", NULL))) {
1145 dprintf("property %s not found %s\n", "volume.fstype", udi);
1146 goto out;
1147 }
1148 if (!libhal_device_get_property_bool(hal_ctx, udi,
1149 "volume.is_partition", NULL)) {
1150 aap->aa_partname = NULL;
1151 } else if (!(aap->aa_partname = libhal_device_get_property_string(
1152 hal_ctx, udi, "block.solaris.slice", NULL))) {
1153 dprintf("property %s not found %s\n",
1154 "block.solaris.slice", udi);
1155 goto out;
1156 }
1157 if (!(mountpoint = libhal_device_get_property_string(hal_ctx, udi,
1158 "volume.mount_point", NULL))) {
1159 dprintf("property %s not found %s\n",
1160 "volume.mount_point", udi);
1161 goto out;
1162 }
1163 /*
1164 * aa_mountpoint can be reallocated in rmm_volume_aa_update_mountpoint()
1165 * won't have to choose between free() or libhal_free_string() later on
1166 */
1167 aap->aa_mountpoint = strdup(mountpoint);
1168 libhal_free_string(mountpoint);
1169 if (aap->aa_mountpoint == NULL) {
1170 dprintf("mountpoint is NULL %s\n", udi);
1171 goto out;
1172 }
1173
1174 ret = B_TRUE;
1175
1176 out:
1177 if ((volume != NULL) && (volume != volume_arg)) {
1178 libhal_volume_free(volume);
1179 }
1180 if (!ret) {
1181 rmm_volume_aa_free(aap);
1182 }
1183 return (ret);
1184 }
1185
1186 /* ARGSUSED */
1187 void
1188 rmm_volume_aa_update_mountpoint(LibHalContext *hal_ctx, const char *udi,
1189 struct action_arg *aap)
1190 {
1191 if (aap->aa_mountpoint != NULL) {
1192 free(aap->aa_mountpoint);
1193 }
1194 aap->aa_mountpoint = rmm_get_mnttab_mount_point(aap->aa_path);
1195 }
1196
1197 void
1198 rmm_volume_aa_free(struct action_arg *aap)
1199 {
1200 if (aap->aa_symdev != NULL) {
1201 libhal_free_string(aap->aa_symdev);
1202 aap->aa_symdev = NULL;
1203 }
1204 if (aap->aa_name != NULL) {
1205 free(aap->aa_name);
1206 aap->aa_name = NULL;
1207 }
1208 if (aap->aa_path != NULL) {
1209 libhal_free_string(aap->aa_path);
1210 aap->aa_path = NULL;
1211 }
1212 if (aap->aa_rawpath != NULL) {
1213 libhal_free_string(aap->aa_rawpath);
1214 aap->aa_rawpath = NULL;
1215 }
1216 if (aap->aa_type != NULL) {
1217 libhal_free_string(aap->aa_type);
1218 aap->aa_type = NULL;
1219 }
1220 if (aap->aa_media != NULL) {
1221 libhal_free_string(aap->aa_media);
1222 aap->aa_media = NULL;
1223 }
1224 if (aap->aa_partname != NULL) {
1225 libhal_free_string(aap->aa_partname);
1226 aap->aa_partname = NULL;
1227 }
1228 if (aap->aa_mountpoint != NULL) {
1229 free(aap->aa_mountpoint);
1230 aap->aa_mountpoint = NULL;
1231 }
1232 }
1233
1234 /*
1235 * get device's mount point from mnttab
1236 */
1237 char *
1238 rmm_get_mnttab_mount_point(const char *special)
1239 {
1240 char *mount_point = NULL;
1241 FILE *f;
1242 struct mnttab mnt;
1243 struct mnttab mpref = { NULL, NULL, NULL, NULL, NULL };
1244
1245 if ((f = fopen(MNTTAB, "r")) != NULL) {
1246 mpref.mnt_special = (char *)special;
1247 if (getmntany(f, &mnt, &mpref) == 0) {
1248 mount_point = strdup(mnt.mnt_mountp);
1249 }
1250 fclose(f);
1251 }
1252
1253 return (mount_point);
1254 }
1255
1256
1257 /*
1258 * get human readable string from error values
1259 */
1260 const char *
1261 rmm_strerror(DBusError *dbus_error, int rmm_error)
1262 {
1263 const char *str;
1264
1265 if ((dbus_error != NULL) && dbus_error_is_set(dbus_error)) {
1266 str = dbus_error->message;
1267 } else {
1268 switch (rmm_error) {
1269 case RMM_EOK:
1270 str = gettext("success");
1271 break;
1272 case RMM_EDBUS_CONNECT:
1273 str = gettext("cannot connect to D-Bus");
1274 break;
1275 case RMM_EHAL_CONNECT:
1276 str = gettext("cannot connect to HAL");
1277 break;
1278 default:
1279 str = gettext("undefined error");
1280 break;
1281 }
1282 }
1283
1284 return (str);
1285 }
1286
1287 void
1288 rmm_dbus_error_free(DBusError *error)
1289 {
1290 if (error != NULL && dbus_error_is_set(error)) {
1291 dbus_error_free(error);
1292 }
1293 }
1294
1295 static int
1296 rmm_vold_isbadchar(int c)
1297 {
1298 int ret_val = 0;
1299
1300
1301 switch (c) {
1302 case '/':
1303 case ';':
1304 case '|':
1305 ret_val = 1;
1306 break;
1307 default:
1308 if (iscntrl(c) || isspace(c)) {
1309 ret_val = 1;
1310 }
1311 }
1312
1313 return (ret_val);
1314 }
1315
1316 char *
1317 rmm_vold_convert_volume_label(const char *name, size_t len)
1318 {
1319 char buf[MAXNAMELEN+1];
1320 char *s = buf;
1321 int i;
1322
1323 if (len > MAXNAMELEN) {
1324 len = MAXNAMELEN;
1325 }
1326
1327 for (i = 0; i < len; i++) {
1328 if (name[i] == '\0') {
1329 break;
1330 }
1331 if (isgraph((int)name[i])) {
1332 if (isupper((int)name[i])) {
1333 *s++ = tolower((int)name[i]);
1334 } else if (rmm_vold_isbadchar((int)name[i])) {
1335 *s++ = '_';
1336 } else {
1337 *s++ = name[i];
1338 }
1339 }
1340 }
1341 *s = '\0';
1342 s = strdup(buf);
1343
1344 return (s);
1345 }
1346
1347 /*
1348 * swiped from mkdir.c
1349 */
1350 int
1351 makepath(char *dir, mode_t mode)
1352 {
1353 int err;
1354 char *slash;
1355
1356
1357 if ((mkdir(dir, mode) == 0) || (errno == EEXIST)) {
1358 return (0);
1359 }
1360 if (errno != ENOENT) {
1361 return (-1);
1362 }
1363 if ((slash = strrchr(dir, '/')) == NULL) {
1364 return (-1);
1365 }
1366 *slash = '\0';
1367 err = makepath(dir, mode);
1368 *slash++ = '/';
1369
1370 if (err || (*slash == '\0')) {
1371 return (err);
1372 }
1373
1374 return (mkdir(dir, mode));
1375 }
1376
1377
1378 void
1379 dprintf(const char *fmt, ...)
1380 {
1381
1382 va_list ap;
1383 const char *p;
1384 char msg[BUFSIZ];
1385 char *errmsg = strerror(errno);
1386 char *s;
1387
1388 if (rmm_debug == 0) {
1389 return;
1390 }
1391
1392 (void) memset(msg, 0, BUFSIZ);
1393
1394 /* scan for %m and replace with errno msg */
1395 s = &msg[strlen(msg)];
1396 p = fmt;
1397
1398 while (*p != '\0') {
1399 if ((*p == '%') && (*(p+1) == 'm')) {
1400 (void) strcat(s, errmsg);
1401 p += 2;
1402 s += strlen(errmsg);
1403 continue;
1404 }
1405 *s++ = *p++;
1406 }
1407 *s = '\0'; /* don't forget the null byte */
1408
1409 va_start(ap, fmt);
1410 (void) vfprintf(stderr, msg, ap);
1411 va_end(ap);
1412 }