short i/o: fix calls to read to use xread or read_in_full

[thirdparty/git.git] / dir.c

diff --git a/dir.c b/dir.c
index e6a61ee913d9f0f4f56402bdb451689cb80373ab..32b57f0125d1b9e95345eb23a9a32fbf8444b1b8 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -5,9 +5,6 @@
  * Copyright (C) Linus Torvalds, 2005-2006
  *              Junio Hamano, 2005-2006
  */
-#include <dirent.h>
-#include <fnmatch.h>
-
 #include "cache.h"
 #include "dir.h"
 
@@ -43,6 +40,18 @@ int common_prefix(const char **pathspec)
        return prefix;
 }
 
+/*
+ * Does 'match' matches the given name?
+ * A match is found if
+ *
+ * (1) the 'match' string is leading directory of 'name', or
+ * (2) the 'match' string is a wildcard and matches 'name', or
+ * (3) the 'match' string is exactly the same as 'name'.
+ *
+ * and the return value tells which case it was.
+ *
+ * It returns 0 when there is no match.
+ */
 static int match_one(const char *match, const char *name, int namelen)
 {
        int matchlen;
@@ -50,27 +59,30 @@ static int match_one(const char *match, const char *name, int namelen)
        /* If the match was just the prefix, we matched */
        matchlen = strlen(match);
        if (!matchlen)
-               return 1;
+               return MATCHED_RECURSIVELY;
 
        /*
         * If we don't match the matchstring exactly,
         * we need to match by fnmatch
         */
        if (strncmp(match, name, matchlen))
-               return !fnmatch(match, name, 0);
+               return !fnmatch(match, name, 0) ? MATCHED_FNMATCH : 0;
 
-       /*
-        * If we did match the string exactly, we still
-        * need to make sure that it happened on a path
-        * component boundary (ie either the last character
-        * of the match was '/', or the next character of
-        * the name was '/' or the terminating NUL.
-        */
-       return  match[matchlen-1] == '/' ||
-               name[matchlen] == '/' ||
-               !name[matchlen];
+       if (!name[matchlen])
+               return MATCHED_EXACTLY;
+       if (match[matchlen-1] == '/' || name[matchlen] == '/')
+               return MATCHED_RECURSIVELY;
+       return 0;
 }
 
+/*
+ * Given a name and a list of pathspecs, see if the name matches
+ * any of the pathspecs.  The caller is also interested in seeing
+ * all pathspec matches some names it calls this function with
+ * (otherwise the user could have mistyped the unmatched pathspec),
+ * and a mark is left in seen[] array for pathspec element that
+ * actually matched anything.
+ */
 int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen)
 {
        int retval;
@@ -80,12 +92,16 @@ int match_pathspec(const char **pathspec, const char *name, int namelen, int pre
        namelen -= prefix;
 
        for (retval = 0; (match = *pathspec++) != NULL; seen++) {
-               if (retval & *seen)
+               int how;
+               if (retval && *seen == MATCHED_EXACTLY)
                        continue;
                match += prefix;
-               if (match_one(match, name, namelen)) {
-                       retval = 1;
-                       *seen = 1;
+               how = match_one(match, name, namelen);
+               if (how) {
+                       if (retval < how)
+                               retval = how;
+                       if (*seen < how)
+                               *seen = how;
                }
        }
        return retval;
@@ -126,7 +142,7 @@ static int add_excludes_from_file_1(const char *fname,
                return 0;
        }
        buf = xmalloc(size+1);
-       if (read(fd, buf, size) != size)
+       if (read_in_full(fd, buf, size) != size)
                goto err;
        close(fd);
 
@@ -244,12 +260,12 @@ int excluded(struct dir_struct *dir, const char *pathname)
        return 0;
 }
 
-static void add_name(struct dir_struct *dir, const char *pathname, int len)
+struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len)
 {
        struct dir_entry *ent;
 
        if (cache_name_pos(pathname, len) >= 0)
-               return;
+               return NULL;
 
        if (dir->nr == dir->alloc) {
                int alloc = alloc_nr(dir->alloc);
@@ -257,10 +273,12 @@ static void add_name(struct dir_struct *dir, const char *pathname, int len)
                dir->entries = xrealloc(dir->entries, alloc*sizeof(ent));
        }
        ent = xmalloc(sizeof(*ent) + len + 1);
+       ent->ignored = ent->ignored_dir = 0;
        ent->len = len;
        memcpy(ent->name, pathname, len);
        ent->name[len] = 0;
        dir->entries[dir->nr++] = ent;
+       return ent;
 }
 
 static int dir_exists(const char *dirname, int len)
@@ -348,7 +366,7 @@ static int read_directory_recursive(struct dir_struct *dir, const char *path, co
                        if (check_only)
                                goto exit_early;
                        else
-                               add_name(dir, fullname, baselen + len);
+                               dir_add_name(dir, fullname, baselen + len);
                }
 exit_early:
                closedir(fdir);