#include <fcntl.h>
#include <dirent.h>
#include <mntent.h>
+#include <errno.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/select.h>
+#include <sys/inotify.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
typedef struct sDevice
{
char *node;
+ char *devname;
char *label;
char *description;
- int mounted;
+ char *mount_point;
time_t time;
} Device;
+typedef struct sGuiContext
+{
+ int manager;
+ int autohide;
+ Device *devices;
+ GtkWidget *window;
+ GtkWidget *list;
+ GtkWidget *button;
+ char *post_mount_command;
+ int inotify_fd;
+ int dev_wd;
+ GIOChannel *inotify_channel;
+ int refresh_pending;
+} GuiContext;
+
int verbosity = 0;
/**
}
/**
-Reads device names from an fstab/mtab file.
+Returns an array of user-mountable devices listed in fstab.
*/
-char **get_mount_entries(char *filename, int (*predicate)(struct mntent *))
+char **get_fstab_devices(void)
{
FILE *file;
struct mntent *me;
char **devices = NULL;
int n_devices = 0;
- file = setmntent(filename, "r");
+ file = setmntent("/etc/fstab", "r");
if(!file)
return NULL;
while((me = getmntent(file)))
- if(!predicate || predicate(me))
+ if(hasmntopt(me, "user")!=NULL)
{
devices = (char **)realloc(devices, (n_devices+2)*sizeof(char *));
devices[n_devices] = strdup(me->mnt_fsname);
return devices;
}
-/**
-Returns an array of all currently mounted devices.
-*/
-char **get_mounted_devices(void)
-{
- return get_mount_entries("/etc/mtab", NULL);
-}
-
-/**
-Checks if an fstab entry has the user option set.
-*/
-int is_user_mountable(struct mntent *me)
-{
- return hasmntopt(me, "user")!=NULL;
-}
-
-/**
-Returns an array of user-mountable devices listed in fstab.
-*/
-char **get_fstab_devices(void)
-{
- return get_mount_entries("/etc/fstab", &is_user_mountable);
-}
-
/**
Checks if an array of strings contains the specified string.
*/
return nodes;
}
-/** Returns an array of all mountable devices. */
+/**
+Reads the list of mounted devices from /etc/mtab and records the mount points.
+*/
+void check_mounts(Device *devices)
+{
+ FILE *file;
+ struct mntent *me;
+
+ file = setmntent("/etc/mtab", "r");
+ if(!file)
+ return;
+
+ while((me = getmntent(file)))
+ {
+ int i;
+
+ for(i=0; devices[i].node; ++i)
+ if(!strcmp(devices[i].devname, me->mnt_fsname))
+ {
+ devices[i].mount_point = strdup(me->mnt_dir);
+
+ if(verbosity>=1)
+ printf("Device %s is mounted on %s\n", devices[i].node, devices[i].mount_point);
+ }
+ }
+
+ endmntent(file);
+}
+
+/**
+Returns an array of all mountable devices.
+*/
Device *get_devices(void)
{
char **nodes = NULL;
int i;
nodes = get_device_nodes("/dev/disk/by-id");
- mounted = get_mounted_devices();
fstab = get_fstab_devices();
for(i=0; nodes[i]; ++i)
/* Reserve space for a sentinel entry. */
devices = (Device *)realloc(devices, (n_devices+2)*sizeof(Device));
devices[n_devices].node = nodes[i];
+ devices[n_devices].devname = strdup(devname);
devices[n_devices].label = strdup(label);
devices[n_devices].description = strdup(buf);
- devices[n_devices].mounted = is_in_array(mounted, devname);
+ devices[n_devices].mount_point = NULL;
devices[n_devices].time = st.st_mtime;
++n_devices;
}
{
/* Terminate the array with NULL pointers. */
devices[n_devices].node = NULL;
+ devices[n_devices].devname = NULL;
devices[n_devices].label = NULL;
devices[n_devices].description = NULL;
+ devices[n_devices].mount_point = NULL;
+
+ check_mounts(devices);
}
return devices;
for(i=0; devices[i].node; ++i)
{
free(devices[i].node);
+ free(devices[i].devname);
free(devices[i].label);
free(devices[i].description);
+ if(devices[i].mount_point)
+ free(devices[i].mount_point);
}
free(devices);
}
/**
-Callback for activating a row in the device list. Mounts or unmounts the
-device depending on operating mode.
+Mounts a device if it was not mounted, or unmounts if it was.
*/
-void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
+int toggle_device(Device *device, char *out_buf, int out_size)
{
- GtkTreeModel *model;
- GtkTreeIter iter;
- int umount = *(int *)user_data;
- char buf[1024];
+ int umount = !!device->mount_point;
+ char mount_point[1024];
int pos = 0;
int status = 0;
fd_set fds;
struct timeval timeout;
- Device *device;
int pid;
int pipe_fd[2];
+ char suffix = 0;
- model = gtk_tree_view_get_model(list);
+ out_buf[0] = 0;
- if(!gtk_tree_model_get_iter(model, &iter, path))
- return;
+ /* Find a mount point that does not exist yet. */
+ while(1)
+ {
+ int len;
- gtk_tree_model_get(model, &iter, 1, &device, -1);
+ len = snprintf(mount_point, sizeof(mount_point), "/media/%s", device->label);
+ if(len+2>=(int)sizeof(mount_point))
+ return -1;
+
+ if(suffix)
+ len += snprintf(mount_point+len, sizeof(mount_point)-len, "_%c", suffix);
+
+ if(access(mount_point, F_OK)<0 && errno==ENOENT)
+ break;
+
+ if(suffix==0)
+ suffix = '1';
+ else if(suffix<'9')
+ ++suffix;
+ else
+ return -1;
+ }
pipe(pipe_fd);
if(umount)
printf("Running pumount %s\n", device->node);
else
- printf("Running pmount %s %s\n", device->node, device->label);
+ printf("Running pmount %s %s\n", device->node, mount_point+7);
}
close(pipe_fd[0]);
if(umount)
execl("/usr/bin/pumount", "pumount", device->node, NULL);
else
- execl("/usr/bin/pmount", "pmount", device->node, device->label, NULL);
+ execl("/usr/bin/pmount", "pmount", device->node, mount_point+7, NULL);
_exit(1);
}
else if(pid<0)
- return;
+ return -1;
/* Parent process */
{
int len;
- len = read(pipe_fd[0], buf+pos, sizeof(buf)-pos-1);
+ len = read(pipe_fd[0], out_buf+pos, out_size-pos-1);
if(len<=0)
break;
pos += len;
}
}
+ close(pipe_fd[0]);
if(pid)
waitpid(pid, &status, 0);
- buf[pos] = 0;
+ out_buf[pos] = 0;
if(verbosity>=1)
{
}
if(!WIFEXITED(status) || WEXITSTATUS(status))
+ return -1;
+
+ if(umount)
+ {
+ free(device->mount_point);
+ device->mount_point = NULL;
+ }
+ else
+ device->mount_point = strdup(mount_point);
+
+ return 0;
+}
+
+/**
+Refreshes both the internal devices array and the GUI list.
+*/
+int refresh_devices(GuiContext *context, int umount)
+{
+ GtkListStore *store;
+ GtkTreeSelection *selection;
+ int n_listed;
+ time_t latest;
+ int i;
+ GtkTreeIter iter;
+
+ store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(context->list)));
+ gtk_list_store_clear(store);
+
+ free_devices(context->devices);
+
+ context->devices = get_devices();
+ if(!context->devices)
+ return 0;
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->list));
+
+ /* Populate the list with devices in appropriate state. */
+ n_listed = 0;
+ latest = 0;
+ for(i=0; context->devices[i].node; ++i)
+ {
+ Device *dev;
+
+ dev = &context->devices[i];
+ if(umount<0 || !dev->mount_point==!umount)
+ {
+ gtk_list_store_append(store, &iter);
+ gtk_list_store_set(store, &iter,
+ 0, dev->description,
+ 1, dev,
+ 2, !!dev->mount_point,
+ 3, dev->mount_point,
+ -1);
+ if(dev->time>latest)
+ {
+ /* Pre-select the device that appeared on the system most recently. */
+ latest = dev->time;
+ gtk_tree_selection_select_iter(selection, &iter);
+ }
+
+ ++n_listed;
+ }
+ }
+
+ return n_listed;
+}
+
+/**
+Handles an automatic refresh of the device list in response to inotify events.
+*/
+gboolean refresh_devices_idle(gpointer data)
+{
+ GuiContext *context = (GuiContext *)data;
+ int n_listed;
+
+ n_listed = refresh_devices(context, -1);
+ context->refresh_pending = 0;
+
+ if(context->autohide)
+ {
+ if(n_listed)
+ gtk_widget_show_all(context->window);
+ else
+ gtk_widget_hide(context->window);
+ }
+
+ return FALSE;
+}
+
+/**
+Callback for selection in the device list changing. Updates the action button
+label according to device status.
+*/
+void selection_changed(GtkTreeSelection *selection, gpointer user_data)
+{
+ GuiContext *context = (GuiContext *)user_data;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ Device *device;
+
+ if(!gtk_tree_selection_get_selected(selection, &model, &iter))
+ return;
+
+ gtk_tree_model_get(model, &iter, 1, &device, -1);
+ gtk_button_set_label(GTK_BUTTON(context->button), (device->mount_point ? "Unmount" : "Mount"));
+}
+
+/**
+Callback for activating a row in the device list. Mounts or unmounts the
+device depending on operating mode.
+*/
+void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
+{
+ GuiContext *context = (GuiContext *)user_data;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ Device *device;
+ int ret;
+ char output[1024];
+ int pid;
+
+ model = gtk_tree_view_get_model(list);
+
+ if(!gtk_tree_model_get_iter(model, &iter, path))
+ return;
+
+ gtk_tree_model_get(model, &iter, 1, &device, -1);
+ ret = toggle_device(device, output, sizeof(output));
+ if(ret)
{
GtkWidget *dialog;
/* Pmount terminated with nonzero status or a signal. Display an
error to the user. */
- dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", buf);
- g_signal_connect(dialog, "response", >k_main_quit, NULL);
+ dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", output);
+ if(context->manager)
+ g_signal_connect(dialog, "response", G_CALLBACK(>k_widget_destroy), dialog);
+ else
+ g_signal_connect(dialog, "response", G_CALLBACK(>k_main_quit), NULL);
gtk_widget_show_all(dialog);
return;
}
- gtk_main_quit();
+ if(context->manager)
+ {
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter,
+ 2, !!device->mount_point,
+ 3, device->mount_point,
+ -1);
+
+ gtk_button_set_label(GTK_BUTTON(context->button), (device->mount_point ? "Unmount" : "Mount"));
+ }
+ else
+ gtk_main_quit();
+
+ if(context->post_mount_command && device->mount_point)
+ {
+ if(verbosity>=1)
+ printf("Running %s in %s\n", context->post_mount_command, device->mount_point);
+
+ pid = fork();
+ if(pid==0)
+ {
+ chdir(device->mount_point);
+ execlp(context->post_mount_command, context->post_mount_command, NULL);
+ _exit(1);
+ }
+ }
(void)column;
+ (void)user_data;
}
/**
*/
void button_clicked(GtkButton *button, gpointer user_data)
{
- GtkWidget *list = (GtkWidget *)user_data;
+ GuiContext *context = (GuiContext *)user_data;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
+ GtkTreeViewColumn *column;
- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->list));
gtk_tree_selection_get_selected(selection, &model, &iter);
path = gtk_tree_model_get_path(model, &iter);
- gtk_tree_view_row_activated(GTK_TREE_VIEW(list), path, gtk_tree_view_get_column(GTK_TREE_VIEW(list), 0));
+ column = gtk_tree_view_get_column(GTK_TREE_VIEW(context->list), 0);
+ gtk_tree_view_row_activated(GTK_TREE_VIEW(context->list), path, column);
gtk_tree_path_free(path);
(void)button;
return FALSE;
}
+/**
+Callback for inotify events.
+*/
+gboolean inotify_event_available(GIOChannel *source, GIOCondition condition, gpointer user_data)
+{
+ GuiContext *context = (GuiContext *)user_data;
+ int fd;
+ char eventbuf[sizeof(struct inotify_event)+NAME_MAX+1];
+ int len;
+
+ fd = g_io_channel_unix_get_fd(source);
+ len = read(fd, eventbuf, sizeof(eventbuf));
+ if(len>=(int)sizeof(struct inotify_event))
+ {
+ if(!context->refresh_pending)
+ {
+ g_timeout_add(500, &refresh_devices_idle, context);
+ context->refresh_pending = 1;
+ }
+ }
+
+ (void)condition;
+
+ return TRUE;
+}
+
+void show_help(void)
+{
+ printf("pmount-gui\n"
+ "Copyright (c) 2011-2015 Mikko Rasa, Mikkosoft Productions\n\n"
+ "Usage: pmount-gui [-v] [-u] [-r <command>] [-h]\n\n"
+ "Options:\n"
+ " -v Increase verbosity\n"
+ " -u Unmount a device (default is mount)\n"
+ " -r Run a command after mounting\n"
+ " -m Start a persistent mount manager\n"
+ " -M Like -m, but hide the window if there are no devices\n"
+ " -h Display this help\n");
+}
+
int main(int argc, char **argv)
{
- GtkWidget *window;
+ GuiContext context;
GtkWidget *box;
GtkWidget *viewport;
- GtkWidget *list;
GtkListStore *store;
GtkTreeSelection *selection;
- GtkWidget *button;
- GtkTreeIter iter;
- Device *devices;
- int i;
- time_t latest;
+ GtkCellRenderer *mounted_toggle;
int opt;
int umount = 0;
int n_listed;
+ context.manager = 0;
+ context.autohide = 0;
+ context.devices = NULL;
+ context.post_mount_command = NULL;
+ context.inotify_fd = -1;
+ context.dev_wd = -1;
+ context.inotify_channel = NULL;
+ context.refresh_pending = 0;
+
gtk_init(&argc, &argv);
- while((opt = getopt(argc, argv, "vu"))!=-1) switch(opt)
+ while((opt = getopt(argc, argv, "vur:mMh"))!=-1) switch(opt)
{
case 'v':
++verbosity;
case 'u':
umount = 1;
break;
+ case 'r':
+ context.post_mount_command = optarg;
+ break;
+ case 'm':
+ context.manager = 1;
+ context.autohide = 0;
+ break;
+ case 'M':
+ context.manager = 1;
+ context.autohide = 1;
+ break;
+ case 'h':
+ show_help();
+ return 0;
}
- window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_container_set_border_width(GTK_CONTAINER(window), 5);
- g_signal_connect(window, "destroy", G_CALLBACK(>k_main_quit), NULL);
- g_signal_connect(window, "key-press-event", G_CALLBACK(&key_press), NULL);
+ context.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_container_set_border_width(GTK_CONTAINER(context.window), 5);
+ g_signal_connect(context.window, "destroy", G_CALLBACK(>k_main_quit), NULL);
+ g_signal_connect(context.window, "key-press-event", G_CALLBACK(&key_press), NULL);
box = gtk_vbox_new(FALSE, 5);
- gtk_container_add(GTK_CONTAINER(window), box);
+ gtk_container_add(GTK_CONTAINER(context.window), box);
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(box), viewport, TRUE, TRUE, 0);
- list = gtk_tree_view_new();
- gtk_container_add(GTK_CONTAINER(viewport), list);
- g_signal_connect(list, "row-activated", G_CALLBACK(&row_activated), &umount);
+ context.list = gtk_tree_view_new();
+ gtk_container_add(GTK_CONTAINER(viewport), context.list);
+ g_signal_connect(context.list, "row-activated", G_CALLBACK(&row_activated), &context);
- store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
- gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
- gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(list),
+ store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN, G_TYPE_STRING);
+ gtk_tree_view_set_model(GTK_TREE_VIEW(context.list), GTK_TREE_MODEL(store));
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context.list),
-1, "Device", gtk_cell_renderer_text_new(), "text", 0, NULL);
- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
+ if(context.manager)
+ {
+ GtkTreeViewColumn *mounted_column;
+ GtkCellRenderer *mount_point_renderer;
- button = gtk_button_new_with_label(umount ? "Unmount" : "Mount");
- g_signal_connect(button, "clicked", G_CALLBACK(&button_clicked), list);
- gtk_box_pack_start(GTK_BOX(box), button, FALSE, TRUE, 0);
+ mounted_column = gtk_tree_view_column_new();
+ gtk_tree_view_column_set_title(mounted_column, "Mounted");
- devices = get_devices();
- n_listed = 0;
- if(devices)
- {
- /* Populate the list with devices in appropriate state. */
- latest = 0;
- for(i=0; devices[i].node; ++i)
- if(!devices[i].mounted==!umount)
- {
- gtk_list_store_append(store, &iter);
- gtk_list_store_set(store, &iter, 0, devices[i].description, 1, &devices[i], -1);
- if(devices[i].time>latest)
- {
- /* Pre-select the device that appeared on the system most recently. */
- latest = devices[i].time;
- gtk_tree_selection_select_iter(selection, &iter);
- }
+ mounted_toggle = gtk_cell_renderer_toggle_new();
+ gtk_tree_view_column_pack_start(mounted_column, mounted_toggle, FALSE);
+ gtk_tree_view_column_add_attribute(mounted_column, mounted_toggle, "active", 2);
- ++n_listed;
- }
+ mount_point_renderer = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start(mounted_column, mount_point_renderer, TRUE);
+ gtk_tree_view_column_add_attribute(mounted_column, mount_point_renderer, "text", 3);
+
+ gtk_tree_view_insert_column(GTK_TREE_VIEW(context.list), mounted_column, -1);
+ context.inotify_fd = inotify_init();
+ if(context.inotify_fd>=0)
+ {
+ context.dev_wd = inotify_add_watch(context.inotify_fd, "/dev/disk/by-id", IN_CREATE|IN_DELETE);
+
+ context.inotify_channel = g_io_channel_unix_new(context.inotify_fd);
+ g_io_add_watch(context.inotify_channel, G_IO_IN, &inotify_event_available, &context);
+ }
+ else
+ printf("Warning: Unable to initialize inotify\n");
+
+ umount = -1;
}
- if(n_listed)
- gtk_widget_show_all(window);
- else
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context.list));
+ g_signal_connect(selection, "changed", G_CALLBACK(&selection_changed), &context);
+
+ context.button = gtk_button_new_with_label(umount ? "Unmount" : "Mount");
+ g_signal_connect(context.button, "clicked", G_CALLBACK(&button_clicked), &context);
+ gtk_box_pack_start(GTK_BOX(box), context.button, FALSE, TRUE, 0);
+
+ n_listed = refresh_devices(&context, umount);
+
+ if(n_listed || (context.manager && !context.autohide))
+ gtk_widget_show_all(context.window);
+ else if(!context.manager)
{
GtkWidget *dialog;
gtk_main();
- free_devices(devices);
+ free_devices(context.devices);
+ if(context.inotify_fd>=0)
+ close(context.inotify_fd);
return 0;
}
projects / pmount-gui.git / blobdiff