2005-06-06 04:59:54 +00:00
|
|
|
#include "cache.h"
|
2006-04-02 12:44:09 +00:00
|
|
|
#include "blob.h"
|
2009-01-10 12:07:50 +00:00
|
|
|
#include "dir.h"
|
2011-05-12 21:31:08 +00:00
|
|
|
#include "streaming.h"
|
2005-06-06 04:59:54 +00:00
|
|
|
|
2009-02-09 20:54:08 +00:00
|
|
|
static void create_directories(const char *path, int path_len,
|
|
|
|
const struct checkout *state)
|
2005-06-06 04:59:54 +00:00
|
|
|
{
|
2009-02-09 20:54:08 +00:00
|
|
|
char *buf = xmalloc(path_len + 1);
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
while (len < path_len) {
|
|
|
|
do {
|
|
|
|
buf[len] = path[len];
|
|
|
|
len++;
|
|
|
|
} while (len < path_len && path[len] != '/');
|
|
|
|
if (len >= path_len)
|
|
|
|
break;
|
2005-06-06 04:59:54 +00:00
|
|
|
buf[len] = 0;
|
Do not expect unlink(2) to fail on a directory.
When "git checkout-index" checks out path A/B/C, it makes sure A
and A/B are truly directories; if there is a regular file or
symlink at A, we prefer to remove it.
We used to do this by catching an error return from mkdir(2),
and on EEXIST did unlink(2), and when it succeeded, tried
another mkdir(2).
Thomas Glanzmann found out the above does not work on Solaris
for a root user, as unlink(2) was so old fashioned there that it
allowed to unlink a directory.
As pointed out, this still doesn't guarantee that git won't call
"unlink()" on a directory (race conditions etc), but that's
fundamentally true (there is no "funlink()" like there is
"fstat()"), and besides, that is in no way git-specific (ie it's
true of any application that gets run as root).
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-18 05:58:28 +00:00
|
|
|
|
2009-01-18 15:14:52 +00:00
|
|
|
/*
|
|
|
|
* For 'checkout-index --prefix=<dir>', <dir> is
|
|
|
|
* allowed to be a symlink to an existing directory,
|
|
|
|
* and we set 'state->base_dir_len' below, such that
|
|
|
|
* we test the path components of the prefix with the
|
|
|
|
* stat() function instead of the lstat() function.
|
|
|
|
*/
|
2009-02-09 20:54:06 +00:00
|
|
|
if (has_dirs_only_path(buf, len, state->base_dir_len))
|
Do not expect unlink(2) to fail on a directory.
When "git checkout-index" checks out path A/B/C, it makes sure A
and A/B are truly directories; if there is a regular file or
symlink at A, we prefer to remove it.
We used to do this by catching an error return from mkdir(2),
and on EEXIST did unlink(2), and when it succeeded, tried
another mkdir(2).
Thomas Glanzmann found out the above does not work on Solaris
for a root user, as unlink(2) was so old fashioned there that it
allowed to unlink a directory.
As pointed out, this still doesn't guarantee that git won't call
"unlink()" on a directory (race conditions etc), but that's
fundamentally true (there is no "funlink()" like there is
"fstat()"), and besides, that is in no way git-specific (ie it's
true of any application that gets run as root).
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-18 05:58:28 +00:00
|
|
|
continue; /* ok, it is already a directory. */
|
|
|
|
|
|
|
|
/*
|
2009-01-18 15:14:52 +00:00
|
|
|
* If this mkdir() would fail, it could be that there
|
|
|
|
* is already a symlink or something else exists
|
|
|
|
* there, therefore we then try to unlink it and try
|
|
|
|
* one more time to create the directory.
|
Do not expect unlink(2) to fail on a directory.
When "git checkout-index" checks out path A/B/C, it makes sure A
and A/B are truly directories; if there is a regular file or
symlink at A, we prefer to remove it.
We used to do this by catching an error return from mkdir(2),
and on EEXIST did unlink(2), and when it succeeded, tried
another mkdir(2).
Thomas Glanzmann found out the above does not work on Solaris
for a root user, as unlink(2) was so old fashioned there that it
allowed to unlink a directory.
As pointed out, this still doesn't guarantee that git won't call
"unlink()" on a directory (race conditions etc), but that's
fundamentally true (there is no "funlink()" like there is
"fstat()"), and besides, that is in no way git-specific (ie it's
true of any application that gets run as root).
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-18 05:58:28 +00:00
|
|
|
*/
|
2005-07-06 08:21:46 +00:00
|
|
|
if (mkdir(buf, 0777)) {
|
Do not expect unlink(2) to fail on a directory.
When "git checkout-index" checks out path A/B/C, it makes sure A
and A/B are truly directories; if there is a regular file or
symlink at A, we prefer to remove it.
We used to do this by catching an error return from mkdir(2),
and on EEXIST did unlink(2), and when it succeeded, tried
another mkdir(2).
Thomas Glanzmann found out the above does not work on Solaris
for a root user, as unlink(2) was so old fashioned there that it
allowed to unlink a directory.
As pointed out, this still doesn't guarantee that git won't call
"unlink()" on a directory (race conditions etc), but that's
fundamentally true (there is no "funlink()" like there is
"fstat()"), and besides, that is in no way git-specific (ie it's
true of any application that gets run as root).
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-18 05:58:28 +00:00
|
|
|
if (errno == EEXIST && state->force &&
|
2009-04-29 21:22:56 +00:00
|
|
|
!unlink_or_warn(buf) && !mkdir(buf, 0777))
|
Do not expect unlink(2) to fail on a directory.
When "git checkout-index" checks out path A/B/C, it makes sure A
and A/B are truly directories; if there is a regular file or
symlink at A, we prefer to remove it.
We used to do this by catching an error return from mkdir(2),
and on EEXIST did unlink(2), and when it succeeded, tried
another mkdir(2).
Thomas Glanzmann found out the above does not work on Solaris
for a root user, as unlink(2) was so old fashioned there that it
allowed to unlink a directory.
As pointed out, this still doesn't guarantee that git won't call
"unlink()" on a directory (race conditions etc), but that's
fundamentally true (there is no "funlink()" like there is
"fstat()"), and besides, that is in no way git-specific (ie it's
true of any application that gets run as root).
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-18 05:58:28 +00:00
|
|
|
continue;
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno("cannot create directory at '%s'", buf);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
2014-03-13 09:19:08 +00:00
|
|
|
static void remove_subtree(struct strbuf *path)
|
2005-06-06 04:59:54 +00:00
|
|
|
{
|
2014-03-13 09:19:08 +00:00
|
|
|
DIR *dir = opendir(path->buf);
|
2005-06-06 04:59:54 +00:00
|
|
|
struct dirent *de;
|
2014-03-13 09:19:08 +00:00
|
|
|
int origlen = path->len;
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2005-06-06 04:59:54 +00:00
|
|
|
if (!dir)
|
2014-03-13 09:19:08 +00:00
|
|
|
die_errno("cannot opendir '%s'", path->buf);
|
2005-06-06 04:59:54 +00:00
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
|
|
struct stat st;
|
2014-03-13 09:19:08 +00:00
|
|
|
|
2009-01-10 12:07:50 +00:00
|
|
|
if (is_dot_or_dotdot(de->d_name))
|
2005-06-06 04:59:54 +00:00
|
|
|
continue;
|
2014-03-13 09:19:08 +00:00
|
|
|
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
strbuf_addstr(path, de->d_name);
|
|
|
|
if (lstat(path->buf, &st))
|
|
|
|
die_errno("cannot lstat '%s'", path->buf);
|
2005-06-06 04:59:54 +00:00
|
|
|
if (S_ISDIR(st.st_mode))
|
2014-03-13 09:19:08 +00:00
|
|
|
remove_subtree(path);
|
|
|
|
else if (unlink(path->buf))
|
|
|
|
die_errno("cannot unlink '%s'", path->buf);
|
|
|
|
strbuf_setlen(path, origlen);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
closedir(dir);
|
2014-03-13 09:19:08 +00:00
|
|
|
if (rmdir(path->buf))
|
|
|
|
die_errno("cannot rmdir '%s'", path->buf);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
2005-07-14 16:58:45 +00:00
|
|
|
static int create_file(const char *path, unsigned int mode)
|
2005-06-06 04:59:54 +00:00
|
|
|
{
|
|
|
|
mode = (mode & 0100) ? 0777 : 0666;
|
2006-01-05 08:58:06 +00:00
|
|
|
return open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
static void *read_blob_entry(const struct cache_entry *ce, unsigned long *size)
|
2007-04-13 16:26:04 +00:00
|
|
|
{
|
|
|
|
enum object_type type;
|
|
|
|
void *new = read_sha1_file(ce->sha1, &type, size);
|
|
|
|
|
|
|
|
if (new) {
|
|
|
|
if (type == OBJ_BLOB)
|
|
|
|
return new;
|
|
|
|
free(new);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
static int open_output_fd(char *path, const struct cache_entry *ce, int to_tempfile)
|
2011-05-13 04:36:42 +00:00
|
|
|
{
|
|
|
|
int symlink = (ce->ce_mode & S_IFMT) != S_IFREG;
|
|
|
|
if (to_tempfile) {
|
|
|
|
strcpy(path, symlink
|
|
|
|
? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
|
|
|
|
return mkstemp(path);
|
|
|
|
} else {
|
|
|
|
return create_file(path, !symlink ? ce->ce_mode : 0666);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fstat_output(int fd, const struct checkout *state, struct stat *st)
|
|
|
|
{
|
|
|
|
/* use fstat() only when path == ce->name */
|
|
|
|
if (fstat_is_reliable() &&
|
|
|
|
state->refresh_cache && !state->base_dir_len) {
|
|
|
|
fstat(fd, st);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
static int streaming_write_entry(const struct cache_entry *ce, char *path,
|
2011-05-20 21:33:31 +00:00
|
|
|
struct stream_filter *filter,
|
2011-05-12 21:31:08 +00:00
|
|
|
const struct checkout *state, int to_tempfile,
|
|
|
|
int *fstat_done, struct stat *statbuf)
|
|
|
|
{
|
2013-03-25 21:49:36 +00:00
|
|
|
int result = 0;
|
2012-03-07 10:54:15 +00:00
|
|
|
int fd;
|
2011-05-12 21:31:08 +00:00
|
|
|
|
|
|
|
fd = open_output_fd(path, ce, to_tempfile);
|
2013-03-25 21:49:36 +00:00
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
result |= stream_blob_to_fd(fd, ce->sha1, filter, 1);
|
|
|
|
*fstat_done = fstat_output(fd, state, statbuf);
|
|
|
|
result |= close(fd);
|
|
|
|
|
|
|
|
if (result)
|
2011-05-12 21:31:08 +00:00
|
|
|
unlink(path);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
static int write_entry(struct cache_entry *ce,
|
|
|
|
char *path, const struct checkout *state, int to_tempfile)
|
2005-06-06 04:59:54 +00:00
|
|
|
{
|
2009-02-09 20:54:50 +00:00
|
|
|
unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT;
|
2009-02-09 20:54:51 +00:00
|
|
|
int fd, ret, fstat_done = 0;
|
2009-02-09 20:54:50 +00:00
|
|
|
char *new;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
unsigned long size;
|
|
|
|
size_t wrote, newsize = 0;
|
2009-02-09 20:54:51 +00:00
|
|
|
struct stat st;
|
2009-02-09 20:54:50 +00:00
|
|
|
|
2011-05-20 21:33:31 +00:00
|
|
|
if (ce_mode_s_ifmt == S_IFREG) {
|
2013-03-14 20:00:51 +00:00
|
|
|
struct stream_filter *filter = get_stream_filter(ce->name, ce->sha1);
|
2011-05-20 21:33:31 +00:00
|
|
|
if (filter &&
|
|
|
|
!streaming_write_entry(ce, path, filter,
|
|
|
|
state, to_tempfile,
|
|
|
|
&fstat_done, &st))
|
|
|
|
goto finish;
|
|
|
|
}
|
2011-05-12 21:31:08 +00:00
|
|
|
|
2009-02-09 20:54:50 +00:00
|
|
|
switch (ce_mode_s_ifmt) {
|
2005-06-06 04:59:54 +00:00
|
|
|
case S_IFREG:
|
2009-02-09 20:54:50 +00:00
|
|
|
case S_IFLNK:
|
|
|
|
new = read_blob_entry(ce, &size);
|
2007-04-13 16:26:04 +00:00
|
|
|
if (!new)
|
2010-11-28 04:36:38 +00:00
|
|
|
return error("unable to read sha1 file of %s (%s)",
|
2007-04-13 16:26:04 +00:00
|
|
|
path, sha1_to_hex(ce->sha1));
|
2007-08-14 08:41:02 +00:00
|
|
|
|
2009-02-09 20:54:50 +00:00
|
|
|
if (ce_mode_s_ifmt == S_IFLNK && has_symlinks && !to_tempfile) {
|
|
|
|
ret = symlink(new, path);
|
|
|
|
free(new);
|
|
|
|
if (ret)
|
2010-11-28 04:36:38 +00:00
|
|
|
return error("unable to create symlink %s (%s)",
|
2009-02-09 20:54:50 +00:00
|
|
|
path, strerror(errno));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-08-14 08:41:02 +00:00
|
|
|
/*
|
|
|
|
* Convert from git internal format to working tree format
|
|
|
|
*/
|
2009-02-09 20:54:50 +00:00
|
|
|
if (ce_mode_s_ifmt == S_IFREG &&
|
|
|
|
convert_to_working_tree(ce->name, new, size, &buf)) {
|
2007-08-14 08:41:02 +00:00
|
|
|
free(new);
|
2007-10-21 09:23:49 +00:00
|
|
|
new = strbuf_detach(&buf, &newsize);
|
|
|
|
size = newsize;
|
2007-08-14 08:41:02 +00:00
|
|
|
}
|
|
|
|
|
2011-05-13 04:36:42 +00:00
|
|
|
fd = open_output_fd(path, ce, to_tempfile);
|
2005-06-06 04:59:54 +00:00
|
|
|
if (fd < 0) {
|
|
|
|
free(new);
|
2010-11-28 04:36:38 +00:00
|
|
|
return error("unable to create file %s (%s)",
|
2005-06-06 04:59:54 +00:00
|
|
|
path, strerror(errno));
|
|
|
|
}
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-13 19:07:23 +00:00
|
|
|
|
2007-01-08 15:58:23 +00:00
|
|
|
wrote = write_in_full(fd, new, size);
|
2011-05-13 04:36:42 +00:00
|
|
|
if (!to_tempfile)
|
|
|
|
fstat_done = fstat_output(fd, state, &st);
|
2005-06-06 04:59:54 +00:00
|
|
|
close(fd);
|
|
|
|
free(new);
|
|
|
|
if (wrote != size)
|
2010-11-28 04:36:38 +00:00
|
|
|
return error("unable to write file %s", path);
|
2005-06-06 04:59:54 +00:00
|
|
|
break;
|
2007-05-21 20:08:28 +00:00
|
|
|
case S_IFGITLINK:
|
2007-04-13 16:26:04 +00:00
|
|
|
if (to_tempfile)
|
2013-07-18 12:26:55 +00:00
|
|
|
return error("cannot create temporary submodule %s", path);
|
2007-04-13 16:26:04 +00:00
|
|
|
if (mkdir(path, 0777) < 0)
|
2013-07-18 12:26:55 +00:00
|
|
|
return error("cannot create submodule directory %s", path);
|
2007-04-13 16:26:04 +00:00
|
|
|
break;
|
2005-06-06 04:59:54 +00:00
|
|
|
default:
|
2010-11-28 04:36:38 +00:00
|
|
|
return error("unknown file mode for %s in index", path);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
2011-05-12 21:31:08 +00:00
|
|
|
finish:
|
2005-06-06 06:15:40 +00:00
|
|
|
if (state->refresh_cache) {
|
2014-06-13 12:19:34 +00:00
|
|
|
assert(state->istate);
|
2009-02-09 20:54:51 +00:00
|
|
|
if (!fstat_done)
|
|
|
|
lstat(ce->name, &st);
|
2005-06-06 04:59:54 +00:00
|
|
|
fill_stat_cache_info(ce, &st);
|
2014-06-13 12:19:34 +00:00
|
|
|
state->istate->cache_changed |= CE_ENTRY_CHANGED;
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-30 03:22:25 +00:00
|
|
|
/*
|
|
|
|
* This is like 'lstat()', except it refuses to follow symlinks
|
2009-08-17 06:53:12 +00:00
|
|
|
* in the path, after skipping "skiplen".
|
2009-07-30 03:22:25 +00:00
|
|
|
*/
|
2010-01-12 06:27:31 +00:00
|
|
|
static int check_path(const char *path, int len, struct stat *st, int skiplen)
|
2009-07-30 03:22:25 +00:00
|
|
|
{
|
2009-08-17 06:53:12 +00:00
|
|
|
const char *slash = path + len;
|
|
|
|
|
|
|
|
while (path < slash && *slash != '/')
|
|
|
|
slash--;
|
|
|
|
if (!has_dirs_only_path(path, slash - path, skiplen)) {
|
2009-07-30 03:22:25 +00:00
|
|
|
errno = ENOENT;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return lstat(path, st);
|
|
|
|
}
|
|
|
|
|
2013-10-23 17:52:42 +00:00
|
|
|
/*
|
|
|
|
* Write the contents from ce out to the working tree.
|
|
|
|
*
|
|
|
|
* When topath[] is not NULL, instead of writing to the working tree
|
|
|
|
* file named by ce, a temporary file is created by this function and
|
|
|
|
* its name is returned in topath[], which must be able to hold at
|
|
|
|
* least TEMPORARY_FILENAME_LENGTH bytes long.
|
|
|
|
*/
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
int checkout_entry(struct cache_entry *ce,
|
|
|
|
const struct checkout *state, char *topath)
|
2005-06-06 04:59:54 +00:00
|
|
|
{
|
2014-03-13 09:19:07 +00:00
|
|
|
static struct strbuf path = STRBUF_INIT;
|
2006-03-05 08:24:15 +00:00
|
|
|
struct stat st;
|
2005-06-06 04:59:54 +00:00
|
|
|
|
2006-03-05 08:24:15 +00:00
|
|
|
if (topath)
|
|
|
|
return write_entry(ce, topath, state, 1);
|
|
|
|
|
2014-03-13 09:19:07 +00:00
|
|
|
strbuf_reset(&path);
|
|
|
|
strbuf_add(&path, state->base_dir, state->base_dir_len);
|
|
|
|
strbuf_add(&path, ce->name, ce_namelen(ce));
|
2005-06-06 04:59:54 +00:00
|
|
|
|
2014-03-13 09:19:07 +00:00
|
|
|
if (!check_path(path.buf, path.len, &st, state->base_dir_len)) {
|
2009-12-14 11:43:58 +00:00
|
|
|
unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);
|
2005-06-06 04:59:54 +00:00
|
|
|
if (!changed)
|
|
|
|
return 0;
|
|
|
|
if (!state->force) {
|
|
|
|
if (!state->quiet)
|
2014-03-13 09:19:07 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"%s already exists, no checkout\n",
|
|
|
|
path.buf);
|
2005-10-03 19:44:48 +00:00
|
|
|
return -1;
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We unlink the old file, to get the new one with the
|
|
|
|
* right permissions (including umask, which is nasty
|
|
|
|
* to emulate by hand - much easier to let the system
|
|
|
|
* just do the right thing)
|
|
|
|
*/
|
2005-07-14 16:58:45 +00:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2007-04-13 16:26:04 +00:00
|
|
|
/* If it is a gitlink, leave it alone! */
|
2008-01-15 00:03:17 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
2007-04-13 16:26:04 +00:00
|
|
|
return 0;
|
2005-07-14 16:58:45 +00:00
|
|
|
if (!state->force)
|
2014-03-13 09:19:07 +00:00
|
|
|
return error("%s is a directory", path.buf);
|
2014-03-13 09:19:08 +00:00
|
|
|
remove_subtree(&path);
|
2014-03-13 09:19:07 +00:00
|
|
|
} else if (unlink(path.buf))
|
|
|
|
return error("unable to unlink old '%s' (%s)",
|
|
|
|
path.buf, strerror(errno));
|
2006-03-05 08:24:15 +00:00
|
|
|
} else if (state->not_new)
|
2005-06-06 04:59:54 +00:00
|
|
|
return 0;
|
2014-03-13 09:19:07 +00:00
|
|
|
|
|
|
|
create_directories(path.buf, path.len, state);
|
|
|
|
return write_entry(ce, path.buf, state, 0);
|
2005-06-06 04:59:54 +00:00
|
|
|
}
|