Changeset 950e2da

Timestamp:

Nov 19, 2010, 2:15:49 AM (14 years ago)

Author:

Karl Ramm <kcr@1ts.org>

Branches:

master, release-1.10, release-1.7, release-1.8, release-1.9

Children:

1dd285b

Parents:

5fca55f

git-author:

Jason Gross <jgross@MIT.EDU> (11/17/10 02:18:48)

git-committer:

Karl Ramm <kcr@1ts.org> (11/19/10 02:15:49)

Message:

Fixed :unsub to make it work if ~/.zephyr.subs is a symlink (trac 133)

link() fails on AFS if the target is a symlink.  Additionally, on
systems where link() succeeds, barnowl overwrites the symlink, instead
of the actual file.  To fix this, I've changed owl_util_file_deleteline
to resolve symlinks on the passed file name first.  The new (backup)
file is written in the resolved directory, not the directory where the
symlink itself is found.

A helper function, owl_util_recursive_resolve_link, is added to
recursivly resolve symlinks (if necessary).

Reviewed-By: Karl Ramm <kcr@1ts.org>

File:

• util.c (modified) (8 diffs)

util.c

@@ -7 +7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
-
+#include <assert.h>
+#include <glib.h>
+#include <glib/gstdio.h>
 #include <glib-object.h>
 
@@ -376 +378 @@
 }
 
+
+/* If filename is a link, recursively resolve symlinks.  Otherwise, return the filename
+ * unchanged.  On error, call owl_function_error and return NULL.
+ *
+ * This function assumes that filename eventually resolves to an acutal file.
+ * If you want to check this, you should stat() the file first.
+ *
+ * The caller of this function is responsible for freeing the return value.
+ *
+ * Error conditions are the same as g_file_read_link.
+ */
+gchar *owl_util_recursive_resolve_link(const char *filename)
+{
+  gchar *last_filename = g_strdup(filename);
+  GError *err = NULL;
+  while (last_filename != NULL && g_file_test(last_filename, G_FILE_TEST_IS_SYMLINK)) {
+    gchar *cur_filename = g_file_read_link(last_filename, &err);
+    g_free(last_filename);
+    last_filename = cur_filename;
+  }
+  if (last_filename == NULL) {
+    owl_function_error("Cannot resolve symlinked file %s: %s",
+                       filename, err->message);
+    g_error_free(err);
+  }
+  return last_filename;
+}
+
 /* Delete all lines matching "line" from the named file.  If no such
  * line is found the file is left intact.  If backup==1 then leave a
@@ -386 +416 @@
 {
   char *backupfile, *newfile, *buf = NULL;
+  gchar *actual_filename; /* gchar; we need to g_free it */
   FILE *old, *new;
   struct stat st;
@@ -401 +432 @@
   }
 
-  newfile = owl_sprintf("%s.new", filename);
+  /* resolve symlinks, because link() fails on symlinks, at least on AFS */
+  actual_filename = owl_util_recursive_resolve_link(filename);
+  if (actual_filename == NULL)
+    return -1; /* resolving the symlink failed, but we already logged this error */
+
+  newfile = owl_sprintf("%s.new", actual_filename);
   if ((new = fopen(newfile, "w")) == NULL) {
     owl_function_error("Cannot open %s (for writing): %s",
-                       filename, strerror(errno));
+                       actual_filename, strerror(errno));
     owl_free(newfile);
     fclose(old);
+    free(actual_filename);
     return -1;
   }
@@ -412 +449 @@
   if (fchmod(fileno(new), st.st_mode & 0777) != 0) {
     owl_function_error("Cannot set permissions on %s: %s",
-                       filename, strerror(errno));
+                       actual_filename, strerror(errno));
     unlink(newfile);
     fclose(new);
     owl_free(newfile);
     fclose(old);
+    free(actual_filename);
     return -1;
   }
@@ -431 +469 @@
 
   if (backup) {
-    backupfile = owl_sprintf("%s.backup", filename);
+    backupfile = owl_sprintf("%s.backup", actual_filename);
     unlink(backupfile);
-    if (link(filename, backupfile) != 0) {
+    if (link(actual_filename, backupfile) != 0) {
       owl_function_error("Cannot link %s: %s", backupfile, strerror(errno));
       owl_free(backupfile);
@@ -443 +481 @@
   }
 
-  if (rename(newfile, filename) != 0) {
+  if (rename(newfile, actual_filename) != 0) {
     owl_function_error("Cannot move %s to %s: %s",
-                       newfile, filename, strerror(errno));
+                       newfile, actual_filename, strerror(errno));
     numremoved = -1;
   }
@@ -451 +489 @@
   unlink(newfile);
   owl_free(newfile);
+
+  g_free(actual_filename);
 
   return numremoved;