X-Git-Url: http://git.tdb.fi/?p=pmount-gui.git;a=blobdiff_plain;f=main.c;h=f8b4c2ef664eabe93f1c92f0fa5fb2b062f19e56;hp=ee55972c95d8570a7625e7e2c9cb638ca09a39e0;hb=201d78e7bebc0fbf56dceab237d6ee1af8d77c6b;hpb=4fbc637701094f8722f44f4461537be4d4d0d7d4 diff --git a/main.c b/main.c index ee55972..f8b4c2e 100644 --- a/main.c +++ b/main.c @@ -1,11 +1,17 @@ +/* Required for strdup, snprintf, getopt */ +#define _XOPEN_SOURCE 500 #include #include #include +#include +#include #include #include #include #include +#include #include +#include typedef struct sProperty { @@ -24,6 +30,10 @@ typedef struct sDevice int verbosity = 0; +/** +Parses a string of the form name=value and places the components in a Property +structure. Returns 0 on success, or -1 if the string wasn't a valid property. +*/ int parse_property(char *str, int size, Property *prop) { int equals = -1; @@ -47,6 +57,11 @@ int parse_property(char *str, int size, Property *prop) return 0; } +/** +Retrieves all properties associated with a /dev node. The returned array is +terminated with an entry containing NULL values. Use free_properties to free +the array. +*/ Property *get_device_properties(char *node) { int pid; @@ -57,6 +72,7 @@ Property *get_device_properties(char *node) pid = fork(); if(pid==0) { + /* Child process */ if(verbosity>=2) printf("Running udevadm info -q property -n \"%s\"\n", node); @@ -68,7 +84,9 @@ Property *get_device_properties(char *node) } else if(pid>0) { - char buf[256]; + /* Parent process */ + char *buf; + int bufsize; int pos = 0; int eof = 0; Property *props = NULL; @@ -76,6 +94,9 @@ Property *get_device_properties(char *node) close(pipe_fd[1]); + bufsize = 256; + buf = (char *)malloc(bufsize); + while(1) { int newline; @@ -86,7 +107,7 @@ Property *get_device_properties(char *node) { int len; - len = read(pipe_fd[0], buf+pos, sizeof(buf)-pos); + len = read(pipe_fd[0], buf+pos, bufsize-pos); if(len==0) eof = 1; else if(len==-1) @@ -100,10 +121,20 @@ Property *get_device_properties(char *node) newline = i; if(newline<0) - break; + { + if(eof) + break; + + /* There was no newline in the buffer but there is more output to + be read. Try again with a larger buffer. */ + bufsize *= 2; + buf = (char *)realloc(buf, bufsize); + continue; + } if(parse_property(buf, newline, &prop)==0) { + /* Reserve space for a sentinel value as well. */ props = (Property *)realloc(props, (n_props+2)*sizeof(Property)); props[n_props] = prop; ++n_props; @@ -115,8 +146,11 @@ Property *get_device_properties(char *node) break; } + free(buf); + if(props) { + /* Terminate the array with NULL pointers. */ props[n_props].name = NULL; props[n_props].value = NULL; } @@ -135,6 +169,10 @@ Property *get_device_properties(char *node) } } +/** +Looks for a property in an array of properties and returns its value. Returns +NULL if the property was not found. +*/ char *get_property_value(Property *props, char *name) { int i; @@ -144,6 +182,10 @@ char *get_property_value(Property *props, char *name) return NULL; } +/** +Checks if a property has a specific value. A NULL value is matched if the +property does not exist. +*/ int match_property_value(Property *props, char *name, char *value) { char *v = get_property_value(props, name); @@ -152,6 +194,9 @@ int match_property_value(Property *props, char *name, char *value) return strcmp(v, value)==0; } +/** +Frees an array of properties and all strings contained in it. +*/ void free_properties(Property *props) { int i; @@ -165,49 +210,212 @@ void free_properties(Property *props) free(props); } -char **get_mounted_devices(void) +/** +Reads device names from an fstab/mtab file. +*/ +char **get_mount_entries(char *filename, int (*predicate)(struct mntent *)) { - FILE *mtab; + FILE *file; struct mntent *me; - char **mounted = NULL; - int n_mounted = 0; + char **devices = NULL; + int n_devices = 0; - mtab = setmntent("/etc/mtab", "r"); - if(!mtab) + file = setmntent(filename, "r"); + if(!file) return NULL; - while((me = getmntent(mtab))) - { - mounted = (char **)realloc(mounted, (n_mounted+2)*sizeof(char *)); - mounted[n_mounted] = strdup(me->mnt_fsname); - ++n_mounted; - } + while((me = getmntent(file))) + if(!predicate || predicate(me)) + { + devices = (char **)realloc(devices, (n_devices+2)*sizeof(char *)); + devices[n_devices] = strdup(me->mnt_fsname); + ++n_devices; + } + + endmntent(file); + if(devices) + devices[n_devices] = NULL; + + return devices; +} - endmntent(mtab); - mounted[n_mounted] = NULL; +/** +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; +} - return mounted; +/** +Returns an array of user-mountable devices listed in fstab. +*/ +char **get_fstab_devices(void) +{ + return get_mount_entries("/etc/fstab", &is_user_mountable); } -int is_mounted(char **mounted, char *devname) +/** +Checks if an array of strings contains the specified string. +*/ +int is_in_array(char **array, char *str) { int i; - for(i=0; mounted[i]; ++i) - if(!strcmp(devname, mounted[i])) + if(!array || !str) + return 0; + for(i=0; array[i]; ++i) + if(!strcmp(str, array[i])) return 1; return 0; } -void free_mounted_devices(char **mounted) +/** +Frees an array of strings. +*/ +void free_string_array(char **array) { int i; - if(!mounted) + if(!array) return; - for(i=0; mounted[i]; ++i) - free(mounted[i]); - free(mounted); + for(i=0; array[i]; ++i) + free(array[i]); + free(array); +} + +/** +Checks if a partition identified by a sysfs path is on a removable device. +*/ +int is_removable(char *devpath) +{ + char fnbuf[256]; + int len; + char *ptr; + int fd; + + len = snprintf(fnbuf, sizeof(fnbuf), "/sys%s", devpath); + /* Default to not removable if the path was too long. */ + if(len+10>=(int)sizeof(fnbuf)) + return 0; + + /* We got a partition as a parameter, but the removable property is on the + disk. Replace the last component with "removable". */ + for(ptr=fnbuf+len; (ptr>fnbuf && *ptr!='/'); --ptr) ; + strcpy(ptr, "/removable"); + + fd = open(fnbuf, O_RDONLY); + if(fd!=-1) + { + char c; + read(fd, &c, 1); + close(fd); + if(c=='1') + { + if(verbosity>=2) + printf(" Removable\n"); + return 1; + } + if(verbosity>=2) + printf(" Not removable\n"); + } + + return 0; } +/** +Checks if a partition's disk or any of its parent devices are connected to any +of a set of buses. The device is identified by a sysfs path. The bus array +must be terminated with a NULL entry. +*/ +int check_buses(char *devpath, char **buses) +{ + char fnbuf[256]; + char *ptr; + int len; + + len = snprintf(fnbuf, sizeof(fnbuf), "/sys%s", devpath); + /* Default to no match if the path was too long. */ + if(len+10>=(int)sizeof(fnbuf)) + return 0; + + for(ptr=fnbuf+len; ptr>fnbuf+12; --ptr) + if(*ptr=='/') + { + char linkbuf[256]; + /* Replace the last component with "subsystem". */ + strcpy(ptr, "/subsystem"); + len = readlink(fnbuf, linkbuf, sizeof(linkbuf)-1); + + if(len!=-1) + { + linkbuf[len] = 0; + /* Extract the last component of the subsystem symlink. */ + for(; (len>0 && linkbuf[len-1]!='/'); --len) ; + + if(verbosity>=2) + { + *ptr = 0; + printf(" Subsystem of %s is %s\n", fnbuf, linkbuf+len); + } + + if(is_in_array(buses, linkbuf+len)) + return 1; + } + } + + return 0; +} + +/** +Check if an array of properties describes a device that can be mounted. An +array of explicitly allowed devices can be passed in as well. Both arrays must +be terminated by a NULL entry. +*/ +int can_mount(Property *props, char **allowed) +{ + static char *removable_buses[] = { "usb", "firewire", 0 }; + char *devname; + char *devpath; + char *bus; + + devname = get_property_value(props, "DEVNAME"); + if(is_in_array(allowed, devname)) + return 1; + + /* Special case for CD devices, since they are not partitions. Only allow + mounting if media is inserted. */ + if(match_property_value(props, "ID_TYPE", "cd") && match_property_value(props, "ID_CDROM_MEDIA", "1")) + return 1; + + /* Only allow mounting partitions. */ + if(!match_property_value(props, "DEVTYPE", "partition")) + return 0; + + devpath = get_property_value(props, "DEVPATH"); + if(is_removable(devpath)) + return 1; + + /* Certain buses are removable by nature, but devices only advertise + themselves as removable if they support removable media, e.g. memory card + readers. */ + bus = get_property_value(props, "ID_BUS"); + if(is_in_array(removable_buses, bus)) + return 1; + + return check_buses(devpath, removable_buses); +} + +/** +Returns an array of all device nodes in a directory. Symbolic links are +dereferenced. +*/ char **get_device_nodes(char *dirname) { DIR *dir; @@ -230,6 +438,7 @@ char **get_device_nodes(char *dirname) char *node; int duplicate = 0; + /* Ignore . and .. entries. */ if(de->d_name[0]=='.' && (de->d_name[1]==0 || (de->d_name[1]=='.' && de->d_name[2]==0))) continue; @@ -248,6 +457,8 @@ char **get_device_nodes(char *dirname) } } + /* There may be multiple symlinks to the same device. Only include each + device once in the returned array. */ if(checked) { for(i=0; (!duplicate && i=1) + if(verbosity>=2) printf("Device %s is a duplicate\n", fnbuf); continue; } @@ -284,23 +495,28 @@ char **get_device_nodes(char *dirname) return nodes; } +/** Returns an array of all mountable devices. */ Device *get_devices(void) { char **nodes = NULL; Device *devices = NULL; int n_devices = 0; char **mounted = NULL; + char **fstab = 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) { + Property *props; + if(verbosity>=1) printf("Examining device %s\n", nodes[i]); - Property *props = get_device_properties(nodes[i]); + props = get_device_properties(nodes[i]); if(!props) { if(verbosity>=2) @@ -315,7 +531,7 @@ Device *get_devices(void) printf(" %s = %s\n", props[j].name, props[j].value); } - if(match_property_value(props, "ID_BUS", "usb") && match_property_value(props, "DEVTYPE", "partition")) + if(can_mount(props, fstab)) { char *devname; char *label; @@ -330,6 +546,8 @@ Device *get_devices(void) devname = get_property_value(props, "DEVNAME"); + /* Get a human-readable label for the device. Use filesystem label, + filesystem UUID or device node name in order of preference. */ label = get_property_value(props, "ID_FS_LABEL"); if(!label) label = get_property_value(props, "ID_FS_UUID"); @@ -352,11 +570,12 @@ Device *get_devices(void) stat(nodes[i], &st); + /* Reserve space for a sentinel entry. */ devices = (Device *)realloc(devices, (n_devices+2)*sizeof(Device)); devices[n_devices].node = nodes[i]; devices[n_devices].label = strdup(label); devices[n_devices].description = strdup(buf); - devices[n_devices].mounted = is_mounted(mounted, devname); + devices[n_devices].mounted = is_in_array(mounted, devname); devices[n_devices].time = st.st_mtime; ++n_devices; } @@ -366,10 +585,11 @@ Device *get_devices(void) } free(nodes); - free_mounted_devices(mounted); + free_string_array(mounted); if(devices) { + /* Terminate the array with NULL pointers. */ devices[n_devices].node = NULL; devices[n_devices].label = NULL; devices[n_devices].description = NULL; @@ -378,6 +598,9 @@ Device *get_devices(void) return devices; } +/** +Frees an array of devices and all strings contained in it. +*/ void free_devices(Device *devices) { int i; @@ -387,10 +610,15 @@ void free_devices(Device *devices) { free(devices[i].node); free(devices[i].label); + free(devices[i].description); } free(devices); } +/** +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) { GtkTreeModel *model; @@ -412,7 +640,8 @@ void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *colu pid = fork(); if(pid==0) { - if(verbosity>=2) + /* Child process */ + if(verbosity>=1) { if(umount) printf("Running pumount %s\n", device->node); @@ -432,29 +661,65 @@ void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *colu } else if(pid>0) { + /* Parent process */ char buf[1024]; int pos = 0; - int status; + int status = 0; + fd_set fds; + struct timeval timeout; close(pipe_fd[1]); + FD_ZERO(&fds); + FD_SET(pipe_fd[0], &fds); + timeout.tv_sec = 0; + timeout.tv_usec = 200000; while(1) { - int len; + /* The write fd for the pipe may be inherited by a fuse server + process and stay open indefinitely. */ + if(select(pipe_fd[0]+1, &fds, NULL, NULL, &timeout)) + { + int len; - len = read(pipe_fd[0], buf+pos, sizeof(buf)-pos-1); - if(len<=0) + len = read(pipe_fd[0], buf+pos, sizeof(buf)-pos-1); + if(len<=0) + break; + pos += len; + } + else if(waitpid(pid, &status, 0)) + { + pid = 0; break; - pos += len; + } } + if(pid) + waitpid(pid, &status, 0); + buf[pos] = 0; - waitpid(pid, &status, 0); + if(verbosity>=1) + { + if(WIFEXITED(status)) + { + if(WEXITSTATUS(status)) + printf("Command exited successfully\n"); + else + printf("Command exited with status %d\n", WEXITSTATUS(status)); + } + else if(WIFSIGNALED(status)) + printf("Command terminated with signal %d\n", WTERMSIG(status)); + else + printf("Command exited with unknown result %04X\n", status); + } + if(!WIFEXITED(status) || WEXITSTATUS(status)) { 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); gtk_widget_show_all(dialog); @@ -462,21 +727,58 @@ void row_activated(GtkTreeView *list, GtkTreePath *path, GtkTreeViewColumn *colu else gtk_main_quit(); } - else - { - } } (void)column; } +/** +Callback for the mount/unmount button. Causes the selected row in the device +list to be activated. +*/ +void button_clicked(GtkButton *button, gpointer user_data) +{ + GtkWidget *list = (GtkWidget *)user_data; + GtkTreeSelection *selection; + GtkTreeIter iter; + GtkTreeModel *model; + GtkTreePath *path; + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(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)); + gtk_tree_path_free(path); + + (void)button; +} + +/** +Global key press callback for the window. +*/ +gboolean key_press(GtkWidget *widget, GdkEvent *event, gpointer user_data) +{ + if(event->key.keyval==GDK_KEY_Escape) + { + gtk_main_quit(); + return TRUE; + } + + (void)widget; + (void)user_data; + + return FALSE; +} + int main(int argc, char **argv) { GtkWidget *window; + GtkWidget *box; GtkWidget *viewport; GtkWidget *list; GtkListStore *store; GtkTreeSelection *selection; + GtkWidget *button; GtkTreeIter iter; Device *devices; int i; @@ -499,15 +801,19 @@ int main(int argc, char **argv) window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(window), 5); - g_signal_connect(window, "destroy", >k_main_quit, NULL); + g_signal_connect(window, "destroy", G_CALLBACK(>k_main_quit), NULL); + g_signal_connect(window, "key-press-event", G_CALLBACK(&key_press), NULL); + + box = gtk_vbox_new(FALSE, 5); + gtk_container_add(GTK_CONTAINER(window), box); viewport = gtk_viewport_new(NULL, NULL); gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_IN); - gtk_container_add(GTK_CONTAINER(window), viewport); + 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", (GCallback)&row_activated, &umount); + g_signal_connect(list, "row-activated", G_CALLBACK(&row_activated), &umount); 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)); @@ -516,10 +822,15 @@ int main(int argc, char **argv) selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); + 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); + 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) @@ -528,6 +839,7 @@ int main(int argc, char **argv) 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); } @@ -543,9 +855,10 @@ int main(int argc, char **argv) { GtkWidget *dialog; + /* Don't show the main window if no devices were listed. */ dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "No devices to %s", (umount ? "unmount" : "mount")); - g_signal_connect(dialog, "response", >k_main_quit, NULL); + g_signal_connect(dialog, "response", G_CALLBACK(>k_main_quit), NULL); gtk_widget_show_all(dialog); }