1 /* Required for strdup, snprintf, getopt */
2 #define _XOPEN_SOURCE 500
13 #include <sys/select.h>
14 #include <sys/inotify.h>
16 #include <gdk/gdkkeysyms.h>
18 typedef struct sProperty
24 typedef struct sDevice
34 typedef struct sGuiContext
42 char *post_mount_command;
45 GIOChannel *inotify_channel;
50 char **pmount_argv = NULL;
53 Parses a string of the form name=value and places the components in a Property
54 structure. Returns 0 on success, or -1 if the string wasn't a valid property.
56 int parse_property(char *str, int size, Property *prop)
61 for(i=0; (equals<0 && i<size); ++i)
68 prop->name = malloc(equals+1);
69 strncpy(prop->name, str, equals);
70 prop->name[equals] = 0;
72 prop->value = malloc(size-equals);
73 strncpy(prop->value, str+equals+1, size-equals-1);
74 prop->value[size-equals-1] = 0;
80 Retrieves all properties associated with a /dev node. The returned array is
81 terminated with an entry containing NULL values. Use free_properties to free
84 Property *get_device_properties(char *node)
86 static const char *udevadm_path = NULL;
93 Property *props = NULL;
99 udevadm_path = "/bin/udevadm";
100 if(stat(udevadm_path, &st)<0 || !(st.st_mode&0111))
102 udevadm_path = "/sbin/udevadm";
103 if(stat(udevadm_path, &st)<0 || !(st.st_mode&0111))
106 perror("Unable to find udevadm");
119 printf("Running udevadm info -q property -n \"%s\"\n", node);
124 if(execl(udevadm_path, "udevadm", "info", "-q", "property", "-n", node, NULL)<0)
125 fprintf(stderr, "Unable to execute %s: %s\n", udevadm_path, strerror(errno));
141 buf = (char *)malloc(bufsize);
153 len = read(pipe_fd[0], buf+pos, bufsize-pos);
162 for(i=0; (newline<0 && i<pos); ++i)
171 /* There was no newline in the buffer but there is more output to
172 be read. Try again with a larger buffer. */
174 buf = (char *)realloc(buf, bufsize);
178 if(parse_property(buf, newline, &prop)==0)
180 /* Reserve space for a sentinel value as well. */
181 props = (Property *)realloc(props, (n_props+2)*sizeof(Property));
182 props[n_props] = prop;
185 memmove(buf, buf+newline+1, pos-newline-1);
196 /* Terminate the array with NULL pointers. */
197 props[n_props].name = NULL;
198 props[n_props].value = NULL;
201 waitpid(pid, NULL, 0);
208 Looks for a property in an array of properties and returns its value. Returns
209 NULL if the property was not found.
211 char *get_property_value(Property *props, char *name)
214 for(i=0; props[i].name; ++i)
215 if(strcmp(props[i].name, name)==0)
216 return props[i].value;
221 Checks if a property has a specific value. A NULL value is matched if the
222 property does not exist.
224 int match_property_value(Property *props, char *name, char *value)
226 char *v = get_property_value(props, name);
229 return strcmp(v, value)==0;
233 Frees an array of properties and all strings contained in it.
235 void free_properties(Property *props)
240 for(i=0; props[i].name; ++i)
243 free(props[i].value);
249 Returns an array of user-mountable devices listed in fstab.
251 char **get_fstab_devices(void)
255 char **devices = NULL;
258 file = setmntent("/etc/fstab", "r");
262 while((me = getmntent(file)))
263 if(hasmntopt(me, "user")!=NULL)
265 devices = (char **)realloc(devices, (n_devices+2)*sizeof(char *));
266 devices[n_devices] = strdup(me->mnt_fsname);
272 devices[n_devices] = NULL;
278 Checks if an array of strings contains the specified string.
280 int is_in_array(char **array, char *str)
285 for(i=0; array[i]; ++i)
286 if(!strcmp(str, array[i]))
292 Frees an array of strings.
294 void free_string_array(char **array)
299 for(i=0; array[i]; ++i)
305 Checks if a partition identified by a sysfs path is on a removable device.
307 int is_removable(char *devpath)
314 len = snprintf(fnbuf, sizeof(fnbuf), "/sys%s", devpath);
315 /* Default to not removable if the path was too long. */
316 if(len+10>=(int)sizeof(fnbuf))
319 /* We got a partition as a parameter, but the removable property is on the
320 disk. Replace the last component with "removable". */
321 for(ptr=fnbuf+len; (ptr>fnbuf && *ptr!='/'); --ptr) ;
322 strcpy(ptr, "/removable");
324 fd = open(fnbuf, O_RDONLY);
333 printf(" Removable\n");
337 printf(" Not removable\n");
344 Checks if a partition's disk or any of its parent devices are connected to any
345 of a set of buses. The device is identified by a sysfs path. The bus array
346 must be terminated with a NULL entry.
348 int check_buses(char *devpath, char **buses)
354 len = snprintf(fnbuf, sizeof(fnbuf), "/sys%s", devpath);
355 /* Default to no match if the path was too long. */
356 if(len+10>=(int)sizeof(fnbuf))
359 for(ptr=fnbuf+len; ptr>fnbuf+12; --ptr)
363 /* Replace the last component with "subsystem". */
364 strcpy(ptr, "/subsystem");
365 len = readlink(fnbuf, linkbuf, sizeof(linkbuf)-1);
370 /* Extract the last component of the subsystem symlink. */
371 for(; (len>0 && linkbuf[len-1]!='/'); --len) ;
376 printf(" Subsystem of %s is %s\n", fnbuf, linkbuf+len);
379 if(is_in_array(buses, linkbuf+len))
388 Check if an array of properties describes a device that can be mounted. An
389 array of explicitly allowed devices can be passed in as well. Both arrays must
390 be terminated by a NULL entry.
392 int can_mount(Property *props, char **allowed)
394 static char *removable_buses[] = { "usb", "firewire", 0 };
399 devname = get_property_value(props, "DEVNAME");
400 if(is_in_array(allowed, devname))
403 /* Special case for CD devices, since they are not partitions. Only allow
404 mounting if media is inserted. */
405 if(match_property_value(props, "ID_TYPE", "cd") && match_property_value(props, "ID_CDROM_MEDIA", "1"))
408 /* Only allow mounting partitions. */
409 if(!match_property_value(props, "DEVTYPE", "partition"))
412 devpath = get_property_value(props, "DEVPATH");
413 if(is_removable(devpath))
416 /* Certain buses are removable by nature, but devices only advertise
417 themselves as removable if they support removable media, e.g. memory card
419 bus = get_property_value(props, "ID_BUS");
420 if(is_in_array(removable_buses, bus))
423 return check_buses(devpath, removable_buses);
427 Returns an array of all device nodes in a directory. Symbolic links are
430 char **get_device_nodes(char *dirname)
439 char **checked = NULL;
443 dir = opendir(dirname);
447 while((de = readdir(dir)))
452 /* Ignore . and .. entries. */
453 if(de->d_name[0]=='.' && (de->d_name[1]==0 || (de->d_name[1]=='.' && de->d_name[2]==0)))
456 snprintf(fnbuf, sizeof(fnbuf), "%s/%s", dirname, de->d_name);
460 if(S_ISLNK(st.st_mode))
463 len = readlink(fnbuf, linkbuf, sizeof(linkbuf)-1);
471 /* There may be multiple symlinks to the same device. Only include each
472 device once in the returned array. */
475 for(i=0; (!duplicate && i<n_checked); ++i)
476 if(strcmp(node, checked[i])==0)
482 printf("Device %s is a duplicate\n", fnbuf);
486 checked = (char **)realloc(checked, (n_checked+1)*sizeof(char *));
487 checked[n_checked] = strdup(node);
490 nodes = (char **)realloc(nodes, (n_nodes+2)*sizeof(char *));
491 nodes[n_nodes] = strdup(fnbuf);
498 for(i=0; i<n_checked; ++i)
504 nodes[n_nodes] = NULL;
510 Reads the list of mounted devices from /etc/mtab and records the mount points.
512 void check_mounts(Device *devices)
517 file = setmntent("/etc/mtab", "r");
521 while((me = getmntent(file)))
525 for(i=0; devices[i].node; ++i)
526 if(!strcmp(devices[i].devname, me->mnt_fsname))
528 devices[i].mount_point = strdup(me->mnt_dir);
531 printf("Device %s is mounted on %s\n", devices[i].node, devices[i].mount_point);
539 Returns an array of all mountable devices.
541 Device *get_devices(void)
544 Device *devices = NULL;
549 nodes = get_device_nodes("/dev/disk/by-id");
550 fstab = get_fstab_devices();
552 for(i=0; nodes[i]; ++i)
557 printf("Examining device %s\n", nodes[i]);
559 props = get_device_properties(nodes[i]);
563 printf(" No properties\n");
571 for(j=0; props[j].name; ++j)
572 printf(" %s = %s\n", props[j].name, props[j].value);
575 if(can_mount(props, fstab))
586 printf(" Using device\n");
588 devname = get_property_value(props, "DEVNAME");
590 /* Get a human-readable label for the device. Use filesystem label,
591 filesystem UUID or device node name in order of preference. */
592 label = get_property_value(props, "ID_FS_LABEL");
594 label = get_property_value(props, "ID_FS_UUID");
600 for(ptr=label; *ptr; ++ptr)
605 vendor = get_property_value(props, "ID_VENDOR");
606 model = get_property_value(props, "ID_MODEL");
608 pos = snprintf(buf, sizeof(buf), "%s", label);
610 pos += snprintf(buf+pos, sizeof(buf)-pos, " (%s %s)", vendor, model);
614 /* Reserve space for a sentinel entry. */
615 devices = (Device *)realloc(devices, (n_devices+2)*sizeof(Device));
616 devices[n_devices].node = nodes[i];
617 devices[n_devices].devname = strdup(devname);
618 devices[n_devices].label = strdup(label);
619 devices[n_devices].description = strdup(buf);
620 devices[n_devices].mount_point = NULL;
621 devices[n_devices].time = st.st_mtime;
626 free_properties(props);
630 free_string_array(fstab);
634 /* Terminate the array with NULL pointers. */
635 devices[n_devices].node = NULL;
636 devices[n_devices].devname = NULL;
637 devices[n_devices].label = NULL;
638 devices[n_devices].description = NULL;
639 devices[n_devices].mount_point = NULL;
641 check_mounts(devices);
648 Frees an array of devices and all strings contained in it.
650 void free_devices(Device *devices)
655 for(i=0; devices[i].node; ++i)
657 free(devices[i].node);
658 free(devices[i].devname);
659 free(devices[i].label);
660 free(devices[i].description);
661 if(devices[i].mount_point)
662 free(devices[i].mount_point);
668 Mounts a device if it was not mounted, or unmounts if it was.
670 int toggle_device(Device *device, char *out_buf, int out_size)
672 int umount = !!device->mount_point;
673 char mount_point[1024];
677 struct timeval timeout;
684 /* Find a mount point that does not exist yet. */
689 len = snprintf(mount_point, sizeof(mount_point), "/media/%s", device->label);
690 if(len+2>=(int)sizeof(mount_point))
694 len += snprintf(mount_point+len, sizeof(mount_point)-len, "_%c", suffix);
696 if(access(mount_point, F_OK)<0 && errno==ENOENT)
714 /* Complete construction of pmount call */
717 pmount_argv[0] = "pmount";
720 while(pmount_argv[++last]);
722 pmount_argv[last] = device->node;
723 pmount_argv[last+1] = mount_point+7;
724 pmount_argv[last+2] = NULL;
729 printf("Running pumount %s\n", device->node);
733 printf("Running pmount");
734 while(pmount_argv[++i])
735 printf(" %s", pmount_argv[i]);
745 execl("/usr/bin/pumount", "pumount", device->node, NULL);
747 execvp("/usr/bin/pmount", pmount_argv);
757 FD_SET(pipe_fd[0], &fds);
759 timeout.tv_usec = 200000;
763 /* The write fd for the pipe may be inherited by a fuse server
764 process and stay open indefinitely. */
765 if(select(pipe_fd[0]+1, &fds, NULL, NULL, &timeout))
769 len = read(pipe_fd[0], out_buf+pos, out_size-pos-1);
774 else if(waitpid(pid, &status, 0))
783 waitpid(pid, &status, 0);
789 if(WIFEXITED(status))
791 if(WEXITSTATUS(status))
792 printf("Command exited successfully\n");
794 printf("Command exited with status %d\n", WEXITSTATUS(status));
796 else if(WIFSIGNALED(status))
797 printf("Command terminated with signal %d\n", WTERMSIG(status));
799 printf("Command exited with unknown result %04X\n", status);
802 if(!WIFEXITED(status) || WEXITSTATUS(status))
807 free(device->mount_point);
808 device->mount_point = NULL;
811 device->mount_point = strdup(mount_point);
817 Refreshes both the internal devices array and the GUI list.
819 int refresh_devices(GuiContext *context, int umount)
822 GtkTreeSelection *selection;
828 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(context->list)));
829 gtk_list_store_clear(store);
831 free_devices(context->devices);
833 context->devices = get_devices();
834 if(!context->devices)
837 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->list));
839 /* Populate the list with devices in appropriate state. */
842 for(i=0; context->devices[i].node; ++i)
846 dev = &context->devices[i];
847 if(umount<0 || !dev->mount_point==!umount)
849 gtk_list_store_append(store, &iter);
850 gtk_list_store_set(store, &iter,
853 2, !!dev->mount_point,
858 /* Pre-select the device that appeared on the system most recently. */
860 gtk_tree_selection_select_iter(selection, &iter);
871 Handles an automatic refresh of the device list in response to inotify events.
873 gboolean refresh_devices_idle(gpointer data)
875 GuiContext *context = (GuiContext *)data;
878 n_listed = refresh_devices(context, -1);
879 context->refresh_pending = 0;
881 if(context->autohide)
884 gtk_widget_show_all(context->window);
886 gtk_widget_hide(context->window);
893 Callback for selection in the device list changing. Updates the action button
894 label according to device status.
896 void selection_changed(GtkTreeSelection *selection, gpointer user_data)
898 GuiContext *context = (GuiContext *)user_data;
903 if(!gtk_tree_selection_get_selected(selection, &model, &iter))
906 gtk_tree_model_get(model, &iter, 1, &device, -1);
907 gtk_button_set_label(GTK_BUTTON(context->button), (device->mount_point ? "Unmount" : "Mount"));
911 Callback for activating a row in the device list. Mounts or unmounts the
912 device depending on operating mode.
914 void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
916 GuiContext *context = (GuiContext *)user_data;
924 model = gtk_tree_view_get_model(list);
926 if(!gtk_tree_model_get_iter(model, &iter, path))
929 gtk_tree_model_get(model, &iter, 1, &device, -1);
930 ret = toggle_device(device, output, sizeof(output));
935 /* Pmount terminated with nonzero status or a signal. Display an
936 error to the user. */
937 dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", output);
939 g_signal_connect(dialog, "response", G_CALLBACK(>k_widget_destroy), dialog);
941 g_signal_connect(dialog, "response", G_CALLBACK(>k_main_quit), NULL);
942 gtk_widget_show_all(dialog);
948 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
949 2, !!device->mount_point,
950 3, device->mount_point,
953 gtk_button_set_label(GTK_BUTTON(context->button), (device->mount_point ? "Unmount" : "Mount"));
958 if(context->post_mount_command && device->mount_point)
961 printf("Running %s in %s\n", context->post_mount_command, device->mount_point);
966 chdir(device->mount_point);
967 execlp(context->post_mount_command, context->post_mount_command, NULL);
977 Callback for the mount/unmount button. Causes the selected row in the device
978 list to be activated.
980 void button_clicked(GtkButton *button, gpointer user_data)
982 GuiContext *context = (GuiContext *)user_data;
983 GtkTreeSelection *selection;
987 GtkTreeViewColumn *column;
989 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->list));
990 gtk_tree_selection_get_selected(selection, &model, &iter);
991 path = gtk_tree_model_get_path(model, &iter);
992 column = gtk_tree_view_get_column(GTK_TREE_VIEW(context->list), 0);
993 gtk_tree_view_row_activated(GTK_TREE_VIEW(context->list), path, column);
994 gtk_tree_path_free(path);
1000 Global key press callback for the window.
1002 gboolean key_press(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1004 if(event->key.keyval==GDK_KEY_Escape)
1017 Callback for inotify events.
1019 gboolean inotify_event_available(GIOChannel *source, GIOCondition condition, gpointer user_data)
1021 GuiContext *context = (GuiContext *)user_data;
1023 char eventbuf[sizeof(struct inotify_event)+NAME_MAX+1];
1026 fd = g_io_channel_unix_get_fd(source);
1027 len = read(fd, eventbuf, sizeof(eventbuf));
1028 if(len>=(int)sizeof(struct inotify_event))
1030 if(!context->refresh_pending)
1032 g_timeout_add(500, &refresh_devices_idle, context);
1033 context->refresh_pending = 1;
1042 void show_help(void)
1044 printf("pmount-gui\n"
1045 "Copyright (c) 2011-2016 Mikko Rasa, Mikkosoft Productions\n\n"
1046 "Usage: pmount-gui [-v] [-u] [-r <command>] [-m|-M] [-h] [-- <pmount options>]\n\n"
1048 " -v Increase verbosity\n"
1049 " -u Unmount a device (default is mount)\n"
1050 " -r Run a command after mounting\n"
1051 " -m Start a persistent mount manager\n"
1052 " -M Like -m, but hide the window if there are no devices\n"
1053 " -h Display this help\n");
1056 int main(int argc, char **argv)
1060 GtkWidget *viewport;
1061 GtkListStore *store;
1062 GtkTreeSelection *selection;
1063 GtkCellRenderer *mounted_toggle;
1069 context.manager = 0;
1070 context.autohide = 0;
1071 context.devices = NULL;
1072 context.post_mount_command = NULL;
1073 context.inotify_fd = -1;
1074 context.dev_wd = -1;
1075 context.inotify_channel = NULL;
1076 context.refresh_pending = 0;
1078 gtk_init(&argc, &argv);
1080 while((opt = getopt(argc, argv, "vur:mMh"))!=-1) switch(opt)
1089 context.post_mount_command = optarg;
1092 context.manager = 1;
1093 context.autohide = 0;
1096 context.manager = 1;
1097 context.autohide = 1;
1104 /* argc - optind equals to number of options after "--" */
1105 /* One empty element at the beginning is for program name for execvp */
1106 /* Three empty elements at the end are required options for pmount + NULL */
1108 pmount_argv = malloc(sizeof(char *)*(argc-optind+4));
1110 for(i=0; i<(argc-optind); ++i)
1111 pmount_argv[i+1] = argv[optind+i];
1112 pmount_argv[argc-optind+1] = NULL;
1114 context.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1115 gtk_container_set_border_width(GTK_CONTAINER(context.window), 5);
1116 g_signal_connect(context.window, "destroy", G_CALLBACK(>k_main_quit), NULL);
1118 box = gtk_vbox_new(FALSE, 5);
1119 gtk_container_add(GTK_CONTAINER(context.window), box);
1121 viewport = gtk_viewport_new(NULL, NULL);
1122 gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_IN);
1123 gtk_box_pack_start(GTK_BOX(box), viewport, TRUE, TRUE, 0);
1125 context.list = gtk_tree_view_new();
1126 gtk_container_add(GTK_CONTAINER(viewport), context.list);
1127 g_signal_connect(context.list, "row-activated", G_CALLBACK(&row_activated), &context);
1129 store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN, G_TYPE_STRING);
1130 gtk_tree_view_set_model(GTK_TREE_VIEW(context.list), GTK_TREE_MODEL(store));
1131 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context.list),
1132 -1, "Device", gtk_cell_renderer_text_new(), "text", 0, NULL);
1136 GtkTreeViewColumn *mounted_column;
1137 GtkCellRenderer *mount_point_renderer;
1139 mounted_column = gtk_tree_view_column_new();
1140 gtk_tree_view_column_set_title(mounted_column, "Mounted");
1142 mounted_toggle = gtk_cell_renderer_toggle_new();
1143 gtk_tree_view_column_pack_start(mounted_column, mounted_toggle, FALSE);
1144 gtk_tree_view_column_add_attribute(mounted_column, mounted_toggle, "active", 2);
1146 mount_point_renderer = gtk_cell_renderer_text_new();
1147 gtk_tree_view_column_pack_start(mounted_column, mount_point_renderer, TRUE);
1148 gtk_tree_view_column_add_attribute(mounted_column, mount_point_renderer, "text", 3);
1150 gtk_tree_view_insert_column(GTK_TREE_VIEW(context.list), mounted_column, -1);
1152 context.inotify_fd = inotify_init();
1153 if(context.inotify_fd>=0)
1155 context.dev_wd = inotify_add_watch(context.inotify_fd, "/dev/disk/by-id", IN_CREATE|IN_DELETE);
1157 context.inotify_channel = g_io_channel_unix_new(context.inotify_fd);
1158 g_io_add_watch(context.inotify_channel, G_IO_IN, &inotify_event_available, &context);
1161 printf("Warning: Unable to initialize inotify\n");
1166 g_signal_connect(context.window, "key-press-event", G_CALLBACK(&key_press), NULL);
1168 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context.list));
1169 g_signal_connect(selection, "changed", G_CALLBACK(&selection_changed), &context);
1171 context.button = gtk_button_new_with_label(umount ? "Unmount" : "Mount");
1172 g_signal_connect(context.button, "clicked", G_CALLBACK(&button_clicked), &context);
1173 gtk_box_pack_start(GTK_BOX(box), context.button, FALSE, TRUE, 0);
1175 n_listed = refresh_devices(&context, umount);
1177 if(n_listed || (context.manager && !context.autohide))
1178 gtk_widget_show_all(context.window);
1179 else if(!context.manager)
1183 /* Don't show the main window if no devices were listed. */
1184 dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1185 "No devices to %s", (umount ? "unmount" : "mount"));
1186 g_signal_connect(dialog, "response", G_CALLBACK(>k_main_quit), NULL);
1187 gtk_widget_show_all(dialog);
1192 free_devices(context.devices);
1193 if(context.inotify_fd>=0)
1194 close(context.inotify_fd);