#include "cache.h"
#include "attr.h"
#include "run-command.h"
+#include "quote.h"
/*
* convert.c - convert a file when checking it out and checking it in.
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-enum action {
+enum crlf_action {
CRLF_GUESS = -1,
CRLF_BINARY = 0,
CRLF_TEXT,
CRLF_INPUT,
CRLF_CRLF,
- CRLF_AUTO,
+ CRLF_AUTO
};
struct text_stat {
return 0;
}
-static enum eol determine_output_conversion(enum action action)
+static enum eol output_eol(enum crlf_action crlf_action)
{
- switch (action) {
+ switch (crlf_action) {
case CRLF_BINARY:
return EOL_UNSET;
case CRLF_CRLF:
return EOL_CRLF;
else if (auto_crlf == AUTO_CRLF_INPUT)
return EOL_LF;
- else if (eol == EOL_UNSET)
+ else if (core_eol == EOL_UNSET)
return EOL_NATIVE;
}
- return eol;
+ return core_eol;
}
-static void check_safe_crlf(const char *path, enum action action,
+static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
struct text_stat *stats, enum safe_crlf checksafe)
{
if (!checksafe)
return;
- if (determine_output_conversion(action) == EOL_LF) {
+ if (output_eol(crlf_action) == EOL_LF) {
/*
* CRLFs would not be restored by checkout:
* check if we'd remove CRLFs
else /* i.e. SAFE_CRLF_FAIL */
die("CRLF would be replaced by LF in %s.", path);
}
- } else if (determine_output_conversion(action) == EOL_CRLF) {
+ } else if (output_eol(crlf_action) == EOL_CRLF) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
}
static int crlf_to_git(const char *path, const char *src, size_t len,
- struct strbuf *buf, enum action action, enum safe_crlf checksafe)
+ struct strbuf *buf,
+ enum crlf_action crlf_action, enum safe_crlf checksafe)
{
struct text_stat stats;
char *dst;
- if (action == CRLF_BINARY ||
- (action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE) || !len)
+ if (crlf_action == CRLF_BINARY ||
+ (crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE) || !len)
return 0;
gather_stats(src, len, &stats);
- if (action == CRLF_AUTO || action == CRLF_GUESS) {
+ if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
/*
* We're currently not going to even try to convert stuff
* that has bare CR characters. Does anybody do that crazy
if (is_binary(len, &stats))
return 0;
- if (action == CRLF_GUESS) {
+ if (crlf_action == CRLF_GUESS) {
/*
* If the file in the index has any CR in it, do not convert.
* This is the new safer autocrlf handling.
}
}
- check_safe_crlf(path, action, &stats, checksafe);
+ check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CR? Nothing to convert, regardless. */
if (!stats.cr)
if (strbuf_avail(buf) + buf->len < len)
strbuf_grow(buf, len - buf->len);
dst = buf->buf;
- if (action == CRLF_AUTO || action == CRLF_GUESS) {
+ if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
}
static int crlf_to_worktree(const char *path, const char *src, size_t len,
- struct strbuf *buf, enum action action)
+ struct strbuf *buf, enum crlf_action crlf_action)
{
char *to_free = NULL;
struct text_stat stats;
- if (!len || determine_output_conversion(action) != EOL_CRLF)
+ if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
gather_stats(src, len, &stats);
if (stats.lf == stats.crlf)
return 0;
- if (action == CRLF_AUTO || action == CRLF_GUESS) {
- if (action == CRLF_GUESS) {
+ if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
+ if (crlf_action == CRLF_GUESS) {
/* If we have any CR or CRLF line endings, we do not touch it */
/* This is the new safer autocrlf-handling */
if (stats.cr > 0 || stats.crlf > 0)
const char *src;
unsigned long size;
const char *cmd;
+ const char *path;
};
static int filter_buffer(int in, int out, void *data)
int write_err, status;
const char *argv[] = { NULL, NULL };
- argv[0] = params->cmd;
+ /* apply % substitution to cmd */
+ struct strbuf cmd = STRBUF_INIT;
+ struct strbuf path = STRBUF_INIT;
+ struct strbuf_expand_dict_entry dict[] = {
+ { "f", NULL, },
+ { NULL, NULL, },
+ };
+
+ /* quote the path to preserve spaces, etc. */
+ sq_quote_buf(&path, params->path);
+ dict[0].value = path.buf;
+
+ /* expand all %f with the quoted path */
+ strbuf_expand(&cmd, params->cmd, strbuf_expand_dict_cb, &dict);
+ strbuf_release(&path);
+
+ argv[0] = cmd.buf;
memset(&child_process, 0, sizeof(child_process));
child_process.argv = argv;
status = finish_command(&child_process);
if (status)
error("external filter %s failed %d", params->cmd, status);
+
+ strbuf_release(&cmd);
return (write_err || status);
}
params.src = src;
params.size = len;
params.cmd = cmd;
+ params.path = path;
fflush(NULL);
if (start_async(&async))
return 0;
}
-static void setup_convert_check(struct git_attr_check *check)
-{
- static struct git_attr *attr_text;
- static struct git_attr *attr_crlf;
- static struct git_attr *attr_eol;
- static struct git_attr *attr_ident;
- static struct git_attr *attr_filter;
-
- if (!attr_text) {
- attr_text = git_attr("text");
- attr_crlf = git_attr("crlf");
- attr_eol = git_attr("eol");
- attr_ident = git_attr("ident");
- attr_filter = git_attr("filter");
- user_convert_tail = &user_convert;
- git_config(read_convert_config, NULL);
- }
- check[0].attr = attr_crlf;
- check[1].attr = attr_ident;
- check[2].attr = attr_filter;
- check[3].attr = attr_eol;
- check[4].attr = attr_text;
-}
-
static int count_ident(const char *cp, unsigned long size)
{
/*
dollar = memchr(src, '$', len);
if (!dollar)
break;
- memcpy(dst, src, dollar + 1 - src);
+ memmove(dst, src, dollar + 1 - src);
dst += dollar + 1 - src;
len -= dollar + 1 - src;
src = dollar + 1;
src = dollar + 1;
}
}
- memcpy(dst, src, len);
+ memmove(dst, src, len);
strbuf_setlen(buf, dst + len - buf->buf);
return 1;
}
return 1;
}
-static int git_path_check_crlf(const char *path, struct git_attr_check *check)
+static enum crlf_action git_path_check_crlf(const char *path, struct git_attr_check *check)
{
const char *value = check->value;
return CRLF_GUESS;
}
-static int git_path_check_eol(const char *path, struct git_attr_check *check)
+static enum eol git_path_check_eol(const char *path, struct git_attr_check *check)
{
const char *value = check->value;
return !!ATTR_TRUE(value);
}
-static enum action determine_action(enum action text_attr, enum eol eol_attr)
+static enum crlf_action input_crlf_action(enum crlf_action text_attr, enum eol eol_attr)
{
if (text_attr == CRLF_BINARY)
return CRLF_BINARY;
return text_attr;
}
+struct conv_attrs {
+ struct convert_driver *drv;
+ enum crlf_action crlf_action;
+ enum eol eol_attr;
+ int ident;
+};
+
+static const char *conv_attr_name[] = {
+ "crlf", "ident", "filter", "eol", "text",
+};
+#define NUM_CONV_ATTRS ARRAY_SIZE(conv_attr_name)
+
+static void convert_attrs(struct conv_attrs *ca, const char *path)
+{
+ int i;
+ static struct git_attr_check ccheck[NUM_CONV_ATTRS];
+
+ if (!ccheck[0].attr) {
+ for (i = 0; i < NUM_CONV_ATTRS; i++)
+ ccheck[i].attr = git_attr(conv_attr_name[i]);
+ user_convert_tail = &user_convert;
+ git_config(read_convert_config, NULL);
+ }
+
+ if (!git_check_attr(path, NUM_CONV_ATTRS, ccheck)) {
+ ca->crlf_action = git_path_check_crlf(path, ccheck + 4);
+ if (ca->crlf_action == CRLF_GUESS)
+ ca->crlf_action = git_path_check_crlf(path, ccheck + 0);
+ ca->ident = git_path_check_ident(path, ccheck + 1);
+ ca->drv = git_path_check_convert(path, ccheck + 2);
+ ca->eol_attr = git_path_check_eol(path, ccheck + 3);
+ } else {
+ ca->drv = NULL;
+ ca->crlf_action = CRLF_GUESS;
+ ca->eol_attr = EOL_UNSET;
+ ca->ident = 0;
+ }
+}
+
int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe)
{
- struct git_attr_check check[5];
- enum action action = CRLF_GUESS;
- enum eol eol_attr = EOL_UNSET;
- int ident = 0, ret = 0;
+ int ret = 0;
const char *filter = NULL;
+ struct conv_attrs ca;
- setup_convert_check(check);
- if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
- struct convert_driver *drv;
- action = git_path_check_crlf(path, check + 4);
- if (action == CRLF_GUESS)
- action = git_path_check_crlf(path, check + 0);
- ident = git_path_check_ident(path, check + 1);
- drv = git_path_check_convert(path, check + 2);
- eol_attr = git_path_check_eol(path, check + 3);
- if (drv && drv->clean)
- filter = drv->clean;
- }
+ convert_attrs(&ca, path);
+ if (ca.drv)
+ filter = ca.drv->clean;
ret |= apply_filter(path, src, len, dst, filter);
if (ret) {
src = dst->buf;
len = dst->len;
}
- action = determine_action(action, eol_attr);
- ret |= crlf_to_git(path, src, len, dst, action, checksafe);
+ ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+ ret |= crlf_to_git(path, src, len, dst, ca.crlf_action, checksafe);
if (ret) {
src = dst->buf;
len = dst->len;
}
- return ret | ident_to_git(path, src, len, dst, ident);
+ return ret | ident_to_git(path, src, len, dst, ca.ident);
}
static int convert_to_working_tree_internal(const char *path, const char *src,
size_t len, struct strbuf *dst,
int normalizing)
{
- struct git_attr_check check[5];
- enum action action = CRLF_GUESS;
- enum eol eol_attr = EOL_UNSET;
- int ident = 0, ret = 0;
+ int ret = 0;
const char *filter = NULL;
+ struct conv_attrs ca;
- setup_convert_check(check);
- if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
- struct convert_driver *drv;
- action = git_path_check_crlf(path, check + 4);
- if (action == CRLF_GUESS)
- action = git_path_check_crlf(path, check + 0);
- ident = git_path_check_ident(path, check + 1);
- drv = git_path_check_convert(path, check + 2);
- eol_attr = git_path_check_eol(path, check + 3);
- if (drv && drv->smudge)
- filter = drv->smudge;
- }
+ convert_attrs(&ca, path);
+ if (ca.drv)
+ filter = ca.drv->smudge;
- ret |= ident_to_worktree(path, src, len, dst, ident);
+ ret |= ident_to_worktree(path, src, len, dst, ca.ident);
if (ret) {
src = dst->buf;
len = dst->len;
* is a smudge filter. The filter might expect CRLFs.
*/
if (filter || !normalizing) {
- action = determine_action(action, eol_attr);
- ret |= crlf_to_worktree(path, src, len, dst, action);
+ ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+ ret |= crlf_to_worktree(path, src, len, dst, ca.crlf_action);
if (ret) {
src = dst->buf;
len = dst->len;
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, 0);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+}
+
+/*****************************************************************
+ *
+ * Streaming converison support
+ *
+ *****************************************************************/
+
+typedef int (*filter_fn)(struct stream_filter *,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p);
+typedef void (*free_fn)(struct stream_filter *);
+
+struct stream_filter_vtbl {
+ filter_fn filter;
+ free_fn free;
+};
+
+struct stream_filter {
+ struct stream_filter_vtbl *vtbl;
+};
+
+static int null_filter_fn(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ size_t count;
+
+ if (!input)
+ return 0; /* we do not keep any states */
+ count = *isize_p;
+ if (*osize_p < count)
+ count = *osize_p;
+ if (count) {
+ memmove(output, input, count);
+ *isize_p -= count;
+ *osize_p -= count;
+ }
+ return 0;
+}
+
+static void null_free_fn(struct stream_filter *filter)
+{
+ ; /* nothing -- null instances are shared */
+}
+
+static struct stream_filter_vtbl null_vtbl = {
+ null_filter_fn,
+ null_free_fn,
+};
+
+static struct stream_filter null_filter_singleton = {
+ &null_vtbl,
+};
+
+int is_null_stream_filter(struct stream_filter *filter)
+{
+ return filter == &null_filter_singleton;
+}
+
+
+/*
+ * LF-to-CRLF filter
+ */
+
+struct lf_to_crlf_filter {
+ struct stream_filter filter;
+ int want_lf;
+};
+
+static int lf_to_crlf_filter_fn(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ size_t count, o = 0;
+ struct lf_to_crlf_filter *lf_to_crlf = (struct lf_to_crlf_filter *)filter;
+
+ /* Output a pending LF if we need to */
+ if (lf_to_crlf->want_lf) {
+ output[o++] = '\n';
+ lf_to_crlf->want_lf = 0;
+ }
+
+ if (!input)
+ return 0; /* We've already dealt with the state */
+
+ count = *isize_p;
+ if (count) {
+ size_t i;
+ for (i = 0; o < *osize_p && i < count; i++) {
+ char ch = input[i];
+ if (ch == '\n') {
+ output[o++] = '\r';
+ if (o >= *osize_p) {
+ lf_to_crlf->want_lf = 1;
+ continue; /* We need to increase i */
+ }
+ }
+ output[o++] = ch;
+ }
+
+ *osize_p -= o;
+ *isize_p -= i;
+ }
+ return 0;
+}
+
+static void lf_to_crlf_free_fn(struct stream_filter *filter)
+{
+ free(filter);
+}
+
+static struct stream_filter_vtbl lf_to_crlf_vtbl = {
+ lf_to_crlf_filter_fn,
+ lf_to_crlf_free_fn,
+};
+
+static struct stream_filter *lf_to_crlf_filter(void)
+{
+ struct lf_to_crlf_filter *lf_to_crlf = xmalloc(sizeof(*lf_to_crlf));
+
+ lf_to_crlf->filter.vtbl = &lf_to_crlf_vtbl;
+ lf_to_crlf->want_lf = 0;
+ return (struct stream_filter *)lf_to_crlf;
+}
+
+/*
+ * Cascade filter
+ */
+#define FILTER_BUFFER 1024
+struct cascade_filter {
+ struct stream_filter filter;
+ struct stream_filter *one;
+ struct stream_filter *two;
+ char buf[FILTER_BUFFER];
+ int end, ptr;
+};
+
+static int cascade_filter_fn(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ struct cascade_filter *cas = (struct cascade_filter *) filter;
+ size_t filled = 0;
+ size_t sz = *osize_p;
+ size_t to_feed, remaining;
+
+ /*
+ * input -- (one) --> buf -- (two) --> output
+ */
+ while (filled < sz) {
+ remaining = sz - filled;
+
+ /* do we already have something to feed two with? */
+ if (cas->ptr < cas->end) {
+ to_feed = cas->end - cas->ptr;
+ if (stream_filter(cas->two,
+ cas->buf + cas->ptr, &to_feed,
+ output + filled, &remaining))
+ return -1;
+ cas->ptr += (cas->end - cas->ptr) - to_feed;
+ filled = sz - remaining;
+ continue;
+ }
+
+ /* feed one from upstream and have it emit into our buffer */
+ to_feed = input ? *isize_p : 0;
+ if (input && !to_feed)
+ break;
+ remaining = sizeof(cas->buf);
+ if (stream_filter(cas->one,
+ input, &to_feed,
+ cas->buf, &remaining))
+ return -1;
+ cas->end = sizeof(cas->buf) - remaining;
+ cas->ptr = 0;
+ if (input) {
+ size_t fed = *isize_p - to_feed;
+ *isize_p -= fed;
+ input += fed;
+ }
+
+ /* do we know that we drained one completely? */
+ if (input || cas->end)
+ continue;
+
+ /* tell two to drain; we have nothing more to give it */
+ to_feed = 0;
+ remaining = sz - filled;
+ if (stream_filter(cas->two,
+ NULL, &to_feed,
+ output + filled, &remaining))
+ return -1;
+ if (remaining == (sz - filled))
+ break; /* completely drained two */
+ filled = sz - remaining;
+ }
+ *osize_p -= filled;
+ return 0;
+}
+
+static void cascade_free_fn(struct stream_filter *filter)
+{
+ struct cascade_filter *cas = (struct cascade_filter *)filter;
+ free_stream_filter(cas->one);
+ free_stream_filter(cas->two);
+ free(filter);
+}
+
+static struct stream_filter_vtbl cascade_vtbl = {
+ cascade_filter_fn,
+ cascade_free_fn,
+};
+
+static struct stream_filter *cascade_filter(struct stream_filter *one,
+ struct stream_filter *two)
+{
+ struct cascade_filter *cascade;
+
+ if (!one || is_null_stream_filter(one))
+ return two;
+ if (!two || is_null_stream_filter(two))
+ return one;
+
+ cascade = xmalloc(sizeof(*cascade));
+ cascade->one = one;
+ cascade->two = two;
+ cascade->end = cascade->ptr = 0;
+ cascade->filter.vtbl = &cascade_vtbl;
+ return (struct stream_filter *)cascade;
+}
+
+/*
+ * ident filter
+ */
+#define IDENT_DRAINING (-1)
+#define IDENT_SKIPPING (-2)
+struct ident_filter {
+ struct stream_filter filter;
+ struct strbuf left;
+ int state;
+ char ident[45]; /* ": x40 $" */
+};
+
+static int is_foreign_ident(const char *str)
+{
+ int i;
+
+ if (prefixcmp(str, "$Id: "))
+ return 0;
+ for (i = 5; str[i]; i++) {
+ if (isspace(str[i]) && str[i+1] != '$')
+ return 1;
+ }
+ return 0;
+}
+
+static void ident_drain(struct ident_filter *ident, char **output_p, size_t *osize_p)
+{
+ size_t to_drain = ident->left.len;
+
+ if (*osize_p < to_drain)
+ to_drain = *osize_p;
+ if (to_drain) {
+ memcpy(*output_p, ident->left.buf, to_drain);
+ strbuf_remove(&ident->left, 0, to_drain);
+ *output_p += to_drain;
+ *osize_p -= to_drain;
+ }
+ if (!ident->left.len)
+ ident->state = 0;
+}
+
+static int ident_filter_fn(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ struct ident_filter *ident = (struct ident_filter *)filter;
+ static const char head[] = "$Id";
+
+ if (!input) {
+ /* drain upon eof */
+ switch (ident->state) {
+ default:
+ strbuf_add(&ident->left, head, ident->state);
+ case IDENT_SKIPPING:
+ /* fallthru */
+ case IDENT_DRAINING:
+ ident_drain(ident, &output, osize_p);
+ }
+ return 0;
+ }
+
+ while (*isize_p || (ident->state == IDENT_DRAINING)) {
+ int ch;
+
+ if (ident->state == IDENT_DRAINING) {
+ ident_drain(ident, &output, osize_p);
+ if (!*osize_p)
+ break;
+ continue;
+ }
+
+ ch = *(input++);
+ (*isize_p)--;
+
+ if (ident->state == IDENT_SKIPPING) {
+ /*
+ * Skipping until '$' or LF, but keeping them
+ * in case it is a foreign ident.
+ */
+ strbuf_addch(&ident->left, ch);
+ if (ch != '\n' && ch != '$')
+ continue;
+ if (ch == '$' && !is_foreign_ident(ident->left.buf)) {
+ strbuf_setlen(&ident->left, sizeof(head) - 1);
+ strbuf_addstr(&ident->left, ident->ident);
+ }
+ ident->state = IDENT_DRAINING;
+ continue;
+ }
+
+ if (ident->state < sizeof(head) &&
+ head[ident->state] == ch) {
+ ident->state++;
+ continue;
+ }
+
+ if (ident->state)
+ strbuf_add(&ident->left, head, ident->state);
+ if (ident->state == sizeof(head) - 1) {
+ if (ch != ':' && ch != '$') {
+ strbuf_addch(&ident->left, ch);
+ ident->state = 0;
+ continue;
+ }
+
+ if (ch == ':') {
+ strbuf_addch(&ident->left, ch);
+ ident->state = IDENT_SKIPPING;
+ } else {
+ strbuf_addstr(&ident->left, ident->ident);
+ ident->state = IDENT_DRAINING;
+ }
+ continue;
+ }
+
+ strbuf_addch(&ident->left, ch);
+ ident->state = IDENT_DRAINING;
+ }
+ return 0;
+}
+
+static void ident_free_fn(struct stream_filter *filter)
+{
+ struct ident_filter *ident = (struct ident_filter *)filter;
+ strbuf_release(&ident->left);
+ free(filter);
+}
+
+static struct stream_filter_vtbl ident_vtbl = {
+ ident_filter_fn,
+ ident_free_fn,
+};
+
+static struct stream_filter *ident_filter(const unsigned char *sha1)
+{
+ struct ident_filter *ident = xmalloc(sizeof(*ident));
+
+ sprintf(ident->ident, ": %s $", sha1_to_hex(sha1));
+ strbuf_init(&ident->left, 0);
+ ident->filter.vtbl = &ident_vtbl;
+ ident->state = 0;
+ return (struct stream_filter *)ident;
+}
+
+/*
+ * Return an appropriately constructed filter for the path, or NULL if
+ * the contents cannot be filtered without reading the whole thing
+ * in-core.
+ *
+ * Note that you would be crazy to set CRLF, smuge/clean or ident to a
+ * large binary blob you would want us not to slurp into the memory!
+ */
+struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
+{
+ struct conv_attrs ca;
+ enum crlf_action crlf_action;
+ struct stream_filter *filter = NULL;
+
+ convert_attrs(&ca, path);
+
+ if (ca.drv && (ca.drv->smudge || ca.drv->clean))
+ return filter;
+
+ if (ca.ident)
+ filter = ident_filter(sha1);
+
+ crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
+
+ if ((crlf_action == CRLF_BINARY) || (crlf_action == CRLF_INPUT) ||
+ (crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE))
+ filter = cascade_filter(filter, &null_filter_singleton);
+
+ else if (output_eol(crlf_action) == EOL_CRLF &&
+ !(crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS))
+ filter = cascade_filter(filter, lf_to_crlf_filter());
+
+ return filter;
+}
+
+void free_stream_filter(struct stream_filter *filter)
+{
+ filter->vtbl->free(filter);
+}
+
+int stream_filter(struct stream_filter *filter,
+ const char *input, size_t *isize_p,
+ char *output, size_t *osize_p)
+{
+ return filter->vtbl->filter(filter, input, isize_p, output, osize_p);
}