Use symbolic name SHORT_NAME_AMBIGUOUS as error return value

[thirdparty/git.git] / path.c

diff --git a/path.c b/path.c
index d635470de1ad9f8a0f43e264d27f3d4c4b9b8705..334b2bd195f56ac6aaf9f9b8a36fe59115cd758c 100644 (file)
--- a/path.c
+++ b/path.c
@@ -131,75 +131,121 @@ int validate_symref(const char *path)
        return -1;
 }
 
-static char *current_dir()
+static char *user_path(char *buf, char *path, int sz)
 {
-       return getcwd(pathname, sizeof(pathname));
-}
-
-static int user_chdir(char *path)
-{
-       char *dir = path;
+       struct passwd *pw;
+       char *slash;
+       int len, baselen;
 
-       if(*dir == '~') {               /* user-relative path */
-               struct passwd *pw;
-               char *slash = strchr(dir, '/');
-
-               dir++;
-               /* '~/' and '~' (no slash) means users own home-dir */
-               if(!*dir || *dir == '/')
-                       pw = getpwuid(getuid());
-               else {
-                       if (slash) {
-                               *slash = '\0';
-                               pw = getpwnam(dir);
-                               *slash = '/';
-                       }
-                       else
-                               pw = getpwnam(dir);
+       if (!path || path[0] != '~')
+               return NULL;
+       path++;
+       slash = strchr(path, '/');
+       if (path[0] == '/' || !path[0]) {
+               pw = getpwuid(getuid());
+       }
+       else {
+               if (slash) {
+                       *slash = 0;
+                       pw = getpwnam(path);
+                       *slash = '/';
                }
-
-               /* make sure we got something back that we can chdir() to */
-               if(!pw || chdir(pw->pw_dir) < 0)
-                       return -1;
-
-               if(!slash || !slash[1]) /* no path following username */
-                       return 0;
-
-               dir = slash + 1;
+               else
+                       pw = getpwnam(path);
        }
-
-       /* ~foo/path/to/repo is now path/to/repo and we're in foo's homedir */
-       if(chdir(dir) < 0)
-               return -1;
-
-       return 0;
+       if (!pw || !pw->pw_dir || sz <= strlen(pw->pw_dir))
+               return NULL;
+       baselen = strlen(pw->pw_dir);
+       memcpy(buf, pw->pw_dir, baselen);
+       while ((1 < baselen) && (buf[baselen-1] == '/')) {
+               buf[baselen-1] = 0;
+               baselen--;
+       }
+       if (slash && slash[1]) {
+               len = strlen(slash);
+               if (sz <= baselen + len)
+                       return NULL;
+               memcpy(buf + baselen, slash, len + 1);
+       }
+       return buf;
 }
 
+/*
+ * First, one directory to try is determined by the following algorithm.
+ *
+ * (0) If "strict" is given, the path is used as given and no DWIM is
+ *     done. Otherwise:
+ * (1) "~/path" to mean path under the running user's home directory;
+ * (2) "~user/path" to mean path under named user's home directory;
+ * (3) "relative/path" to mean cwd relative directory; or
+ * (4) "/absolute/path" to mean absolute directory.
+ *
+ * Unless "strict" is given, we try access() for existence of "%s.git/.git",
+ * "%s/.git", "%s.git", "%s" in this order.  The first one that exists is
+ * what we try.
+ *
+ * Second, we try chdir() to that.  Upon failure, we return NULL.
+ *
+ * Then, we try if the current directory is a valid git repository.
+ * Upon failure, we return NULL.
+ *
+ * If all goes well, we return the directory we used to chdir() (but
+ * before ~user is expanded), avoiding getcwd() resolving symbolic
+ * links.  User relative paths are also returned as they are given,
+ * except DWIM suffixing.
+ */
 char *enter_repo(char *path, int strict)
 {
-       if(!path)
+       static char used_path[PATH_MAX];
+       static char validated_path[PATH_MAX];
+
+       if (!path)
                return NULL;
 
-       if (strict) {
-               if((path[0] != '/') || chdir(path) < 0)
+       if (!strict) {
+               static const char *suffix[] = {
+                       ".git/.git", "/.git", ".git", "", NULL,
+               };
+               int len = strlen(path);
+               int i;
+               while ((1 < len) && (path[len-1] == '/')) {
+                       path[len-1] = 0;
+                       len--;
+               }
+               if (PATH_MAX <= len)
                        return NULL;
-       }
-       else {
-               if (!*path)
-                       ; /* happy -- no chdir */
-               else if (!user_chdir(path))
-                       ; /* happy -- as given */
-               else if (!user_chdir(mkpath("%s.git", path)))
-                       ; /* happy -- uemacs --> uemacs.git */
-               else
+               if (path[0] == '~') {
+                       if (!user_path(used_path, path, PATH_MAX))
+                               return NULL;
+                       strcpy(validated_path, path);
+                       path = used_path;
+               }
+               else if (PATH_MAX - 10 < len)
+                       return NULL;
+               else {
+                       path = strcpy(used_path, path);
+                       strcpy(validated_path, path);
+               }
+               len = strlen(path);
+               for (i = 0; suffix[i]; i++) {
+                       strcpy(path + len, suffix[i]);
+                       if (!access(path, F_OK)) {
+                               strcat(validated_path, suffix[i]);
+                               break;
+                       }
+               }
+               if (!suffix[i] || chdir(path))
                        return NULL;
-               (void)chdir(".git");
+               path = validated_path;
        }
+       else if (chdir(path))
+               return NULL;
 
-       if(access("objects", X_OK) == 0 && access("refs", X_OK) == 0 &&
-          validate_symref("HEAD") == 0) {
+       if (access("objects", X_OK) == 0 && access("refs", X_OK) == 0 &&
+           validate_symref("HEAD") == 0) {
                putenv("GIT_DIR=.");
-               return current_dir();
+               check_repository_format();
+               return path;
        }
 
        return NULL;