2023-04-11 07:41:50 +00:00
|
|
|
#include "git-compat-util.h"
|
2023-03-21 06:25:58 +00:00
|
|
|
#include "abspath.h"
|
2023-02-24 00:09:24 +00:00
|
|
|
#include "alloc.h"
|
2023-03-21 06:25:57 +00:00
|
|
|
#include "environment.h"
|
2023-03-21 06:25:54 +00:00
|
|
|
#include "gettext.h"
|
2023-02-24 00:09:27 +00:00
|
|
|
#include "hex.h"
|
2023-04-11 07:41:49 +00:00
|
|
|
#include "object-name.h"
|
2009-03-21 21:35:51 +00:00
|
|
|
#include "refs.h"
|
2018-04-19 17:58:08 +00:00
|
|
|
#include "string-list.h"
|
2014-05-22 09:30:14 +00:00
|
|
|
#include "utf8.h"
|
date API: create a date.h, split from cache.h
Move the declaration of the date.c functions from cache.h, and adjust
the relevant users to include the new date.h header.
The show_ident_date() function belonged in pretty.h (it's defined in
pretty.c), its two users outside of pretty.c didn't strictly need to
include pretty.h, as they get it indirectly, but let's add it to them
anyway.
Similarly, the change to "builtin/{fast-import,show-branch,tag}.c"
isn't needed as far as the compiler is concerned, but since they all
use the "DATE_MODE()" macro we now define in date.h, let's have them
include it.
We could simply include this new header in "cache.h", but as this
change shows these functions weren't common enough to warrant
including in it in the first place. By moving them out of cache.h
changes to this API will no longer cause a (mostly) full re-build of
the project when "make" is run.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-02-16 08:14:02 +00:00
|
|
|
#include "date.h"
|
2023-03-21 06:26:01 +00:00
|
|
|
#include "wrapper.h"
|
2005-04-26 01:26:45 +00:00
|
|
|
|
2013-12-01 07:49:16 +00:00
|
|
|
int starts_with(const char *str, const char *prefix)
|
|
|
|
{
|
|
|
|
for (; ; str++, prefix++)
|
|
|
|
if (!*prefix)
|
|
|
|
return 1;
|
|
|
|
else if (*str != *prefix)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-03-09 17:35:29 +00:00
|
|
|
int istarts_with(const char *str, const char *prefix)
|
|
|
|
{
|
|
|
|
for (; ; str++, prefix++)
|
|
|
|
if (!*prefix)
|
|
|
|
return 1;
|
|
|
|
else if (tolower(*str) != tolower(*prefix))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-09 20:40:07 +00:00
|
|
|
int skip_to_optional_arg_default(const char *str, const char *prefix,
|
|
|
|
const char **arg, const char *def)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (!skip_prefix(str, prefix, &p))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!*p) {
|
|
|
|
if (arg)
|
|
|
|
*arg = def;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*p != '=')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (arg)
|
|
|
|
*arg = p + 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-09-27 10:58:23 +00:00
|
|
|
/*
|
|
|
|
* Used as the default ->buf value, so that people can always assume
|
|
|
|
* buf is non NULL and ->buf is NUL terminated even for a freshly
|
|
|
|
* initialized strbuf.
|
|
|
|
*/
|
|
|
|
char strbuf_slopbuf[1];
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_init(struct strbuf *sb, size_t hint)
|
|
|
|
{
|
2021-07-01 10:51:26 +00:00
|
|
|
struct strbuf blank = STRBUF_INIT;
|
|
|
|
memcpy(sb, &blank, sizeof(*sb));
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (hint)
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, hint);
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_release(struct strbuf *sb)
|
|
|
|
{
|
2007-09-27 10:58:23 +00:00
|
|
|
if (sb->alloc) {
|
|
|
|
free(sb->buf);
|
|
|
|
strbuf_init(sb, 0);
|
|
|
|
}
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
2007-09-27 10:58:23 +00:00
|
|
|
char *strbuf_detach(struct strbuf *sb, size_t *sz)
|
2007-09-15 13:56:50 +00:00
|
|
|
{
|
2012-10-18 10:00:12 +00:00
|
|
|
char *res;
|
|
|
|
strbuf_grow(sb, 0);
|
|
|
|
res = sb->buf;
|
2007-09-27 10:58:23 +00:00
|
|
|
if (sz)
|
|
|
|
*sz = sb->len;
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_init(sb, 0);
|
2007-09-06 11:20:05 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
|
|
|
|
{
|
|
|
|
strbuf_release(sb);
|
|
|
|
sb->buf = buf;
|
|
|
|
sb->len = len;
|
|
|
|
sb->alloc = alloc;
|
|
|
|
strbuf_grow(sb, 0);
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_grow(struct strbuf *sb, size_t extra)
|
|
|
|
{
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
int new_buf = !sb->alloc;
|
2010-10-11 02:59:26 +00:00
|
|
|
if (unsigned_add_overflows(extra, 1) ||
|
|
|
|
unsigned_add_overflows(sb->len, extra + 1))
|
2007-09-06 11:20:05 +00:00
|
|
|
die("you want to use way too much memory");
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (new_buf)
|
2007-09-27 10:58:23 +00:00
|
|
|
sb->buf = NULL;
|
2007-09-06 11:20:05 +00:00
|
|
|
ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (new_buf)
|
|
|
|
sb->buf[0] = '\0';
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
2008-07-13 18:29:18 +00:00
|
|
|
void strbuf_trim(struct strbuf *sb)
|
|
|
|
{
|
2014-04-30 08:58:06 +00:00
|
|
|
strbuf_rtrim(sb);
|
|
|
|
strbuf_ltrim(sb);
|
2008-07-13 18:29:18 +00:00
|
|
|
}
|
2018-02-12 09:49:37 +00:00
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
void strbuf_rtrim(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
|
|
|
|
sb->len--;
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2018-02-12 09:49:37 +00:00
|
|
|
void strbuf_trim_trailing_dir_sep(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
while (sb->len > 0 && is_dir_sep((unsigned char)sb->buf[sb->len - 1]))
|
|
|
|
sb->len--;
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2018-08-08 15:06:16 +00:00
|
|
|
void strbuf_trim_trailing_newline(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
if (sb->len > 0 && sb->buf[sb->len - 1] == '\n') {
|
|
|
|
if (--sb->len > 0 && sb->buf[sb->len - 1] == '\r')
|
|
|
|
--sb->len;
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-13 18:29:18 +00:00
|
|
|
void strbuf_ltrim(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
char *b = sb->buf;
|
|
|
|
while (sb->len > 0 && isspace(*b)) {
|
|
|
|
b++;
|
|
|
|
sb->len--;
|
|
|
|
}
|
|
|
|
memmove(sb->buf, b, sb->len);
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2014-05-22 09:30:14 +00:00
|
|
|
int strbuf_reencode(struct strbuf *sb, const char *from, const char *to)
|
|
|
|
{
|
|
|
|
char *out;
|
2018-07-24 10:50:33 +00:00
|
|
|
size_t len;
|
2014-05-22 09:30:14 +00:00
|
|
|
|
|
|
|
if (same_encoding(from, to))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out = reencode_string_len(sb->buf, sb->len, to, from, &len);
|
|
|
|
if (!out)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strbuf_attach(sb, out, len, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-23 20:03:47 +00:00
|
|
|
void strbuf_tolower(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
char *p = sb->buf, *end = sb->buf + sb->len;
|
|
|
|
for (; p < end; p++)
|
|
|
|
*p = tolower(*p);
|
|
|
|
}
|
|
|
|
|
2012-11-04 06:46:53 +00:00
|
|
|
struct strbuf **strbuf_split_buf(const char *str, size_t slen,
|
|
|
|
int terminator, int max)
|
2008-07-13 18:29:18 +00:00
|
|
|
{
|
2012-11-04 06:46:51 +00:00
|
|
|
struct strbuf **ret = NULL;
|
|
|
|
size_t nr = 0, alloc = 0;
|
2008-07-13 18:29:18 +00:00
|
|
|
struct strbuf *t;
|
|
|
|
|
2012-11-04 06:46:52 +00:00
|
|
|
while (slen) {
|
|
|
|
int len = slen;
|
|
|
|
if (max <= 0 || nr + 1 < max) {
|
2012-11-04 06:46:53 +00:00
|
|
|
const char *end = memchr(str, terminator, slen);
|
2012-11-04 06:46:52 +00:00
|
|
|
if (end)
|
|
|
|
len = end - str + 1;
|
|
|
|
}
|
2008-07-13 18:29:18 +00:00
|
|
|
t = xmalloc(sizeof(struct strbuf));
|
|
|
|
strbuf_init(t, len);
|
2012-11-04 06:46:52 +00:00
|
|
|
strbuf_add(t, str, len);
|
2012-11-04 06:46:51 +00:00
|
|
|
ALLOC_GROW(ret, nr + 2, alloc);
|
|
|
|
ret[nr++] = t;
|
2012-11-04 06:46:52 +00:00
|
|
|
str += len;
|
|
|
|
slen -= len;
|
2008-07-13 18:29:18 +00:00
|
|
|
}
|
2012-11-04 06:46:51 +00:00
|
|
|
ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
|
|
|
|
ret[nr] = NULL;
|
2008-07-13 18:29:18 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-04-19 17:58:08 +00:00
|
|
|
void strbuf_add_separated_string_list(struct strbuf *str,
|
|
|
|
const char *sep,
|
|
|
|
struct string_list *slist)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
int sep_needed = 0;
|
|
|
|
|
|
|
|
for_each_string_list_item(item, slist) {
|
|
|
|
if (sep_needed)
|
|
|
|
strbuf_addstr(str, sep);
|
|
|
|
strbuf_addstr(str, item->string);
|
|
|
|
sep_needed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-13 18:29:18 +00:00
|
|
|
void strbuf_list_free(struct strbuf **sbs)
|
|
|
|
{
|
|
|
|
struct strbuf **s = sbs;
|
|
|
|
|
2021-04-25 14:16:16 +00:00
|
|
|
if (!s)
|
|
|
|
return;
|
2008-07-13 18:29:18 +00:00
|
|
|
while (*s) {
|
|
|
|
strbuf_release(*s);
|
|
|
|
free(*s++);
|
|
|
|
}
|
|
|
|
free(sbs);
|
|
|
|
}
|
|
|
|
|
2008-07-13 18:28:24 +00:00
|
|
|
int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
|
2007-09-24 09:25:03 +00:00
|
|
|
{
|
2018-07-24 10:51:08 +00:00
|
|
|
size_t len = a->len < b->len ? a->len: b->len;
|
2009-03-19 22:27:32 +00:00
|
|
|
int cmp = memcmp(a->buf, b->buf, len);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
return a->len < b->len ? -1: a->len != b->len;
|
2007-09-24 09:25:03 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
|
|
|
|
const void *data, size_t dlen)
|
|
|
|
{
|
2010-10-11 02:59:26 +00:00
|
|
|
if (unsigned_add_overflows(pos, len))
|
2007-09-15 13:56:50 +00:00
|
|
|
die("you want to use way too much memory");
|
|
|
|
if (pos > sb->len)
|
|
|
|
die("`pos' is too far after the end of the buffer");
|
|
|
|
if (pos + len > sb->len)
|
|
|
|
die("`pos + len' is too far after the end of the buffer");
|
|
|
|
|
|
|
|
if (dlen >= len)
|
|
|
|
strbuf_grow(sb, dlen - len);
|
|
|
|
memmove(sb->buf + pos + dlen,
|
|
|
|
sb->buf + pos + len,
|
|
|
|
sb->len - pos - len);
|
|
|
|
memcpy(sb->buf + pos, data, dlen);
|
|
|
|
strbuf_setlen(sb, sb->len + dlen - len);
|
|
|
|
}
|
|
|
|
|
2007-09-19 22:42:12 +00:00
|
|
|
void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
|
|
|
|
{
|
|
|
|
strbuf_splice(sb, pos, 0, data, len);
|
|
|
|
}
|
|
|
|
|
2019-02-25 23:16:07 +00:00
|
|
|
void strbuf_vinsertf(struct strbuf *sb, size_t pos, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
int len, len2;
|
|
|
|
char save;
|
|
|
|
va_list cp;
|
|
|
|
|
|
|
|
if (pos > sb->len)
|
|
|
|
die("`pos' is too far after the end of the buffer");
|
|
|
|
va_copy(cp, ap);
|
|
|
|
len = vsnprintf(sb->buf + sb->len, 0, fmt, cp);
|
|
|
|
va_end(cp);
|
|
|
|
if (len < 0)
|
|
|
|
BUG("your vsnprintf is broken (returned %d)", len);
|
|
|
|
if (!len)
|
|
|
|
return; /* nothing to do */
|
|
|
|
if (unsigned_add_overflows(sb->len, len))
|
|
|
|
die("you want to use way too much memory");
|
|
|
|
strbuf_grow(sb, len);
|
|
|
|
memmove(sb->buf + pos + len, sb->buf + pos, sb->len - pos);
|
|
|
|
/* vsnprintf() will append a NUL, overwriting one of our characters */
|
|
|
|
save = sb->buf[pos + len];
|
|
|
|
len2 = vsnprintf(sb->buf + pos, len + 1, fmt, ap);
|
|
|
|
sb->buf[pos + len] = save;
|
|
|
|
if (len2 != len)
|
|
|
|
BUG("your vsnprintf is broken (returns inconsistent lengths)");
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_insertf(struct strbuf *sb, size_t pos, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
strbuf_vinsertf(sb, pos, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2007-09-19 22:42:12 +00:00
|
|
|
void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
|
|
|
|
{
|
2016-09-13 16:40:22 +00:00
|
|
|
strbuf_splice(sb, pos, len, "", 0);
|
2007-09-19 22:42:12 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_add(struct strbuf *sb, const void *data, size_t len)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_grow(sb, len);
|
|
|
|
memcpy(sb->buf + sb->len, data, len);
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:46:44 +00:00
|
|
|
void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
|
|
|
|
{
|
|
|
|
strbuf_grow(sb, sb2->len);
|
|
|
|
memcpy(sb->buf + sb->len, sb2->buf, sb2->len);
|
|
|
|
strbuf_setlen(sb, sb->len + sb2->len);
|
|
|
|
}
|
|
|
|
|
2019-02-25 23:16:06 +00:00
|
|
|
const char *strbuf_join_argv(struct strbuf *buf,
|
|
|
|
int argc, const char **argv, char delim)
|
|
|
|
{
|
|
|
|
if (!argc)
|
|
|
|
return buf->buf;
|
|
|
|
|
|
|
|
strbuf_addstr(buf, *argv);
|
|
|
|
while (--argc) {
|
|
|
|
strbuf_addch(buf, delim);
|
|
|
|
strbuf_addstr(buf, *(++argv));
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf->buf;
|
|
|
|
}
|
|
|
|
|
2014-09-07 07:03:32 +00:00
|
|
|
void strbuf_addchars(struct strbuf *sb, int c, size_t n)
|
|
|
|
{
|
|
|
|
strbuf_grow(sb, n);
|
|
|
|
memset(sb->buf + sb->len, c, n);
|
|
|
|
strbuf_setlen(sb, sb->len + n);
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
va_list ap;
|
2011-02-26 05:08:53 +00:00
|
|
|
va_start(ap, fmt);
|
|
|
|
strbuf_vaddf(sb, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2013-01-16 19:18:48 +00:00
|
|
|
static void add_lines(struct strbuf *out,
|
|
|
|
const char *prefix1,
|
|
|
|
const char *prefix2,
|
|
|
|
const char *buf, size_t size)
|
|
|
|
{
|
|
|
|
while (size) {
|
|
|
|
const char *prefix;
|
|
|
|
const char *next = memchr(buf, '\n', size);
|
|
|
|
next = next ? (next + 1) : (buf + size);
|
|
|
|
|
2014-10-27 21:13:15 +00:00
|
|
|
prefix = ((prefix2 && (buf[0] == '\n' || buf[0] == '\t'))
|
|
|
|
? prefix2 : prefix1);
|
2013-01-16 19:18:48 +00:00
|
|
|
strbuf_addstr(out, prefix);
|
|
|
|
strbuf_add(out, buf, next - buf);
|
|
|
|
size -= next - buf;
|
|
|
|
buf = next;
|
|
|
|
}
|
|
|
|
strbuf_complete_line(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_add_commented_lines(struct strbuf *out, const char *buf, size_t size)
|
|
|
|
{
|
|
|
|
static char prefix1[3];
|
|
|
|
static char prefix2[2];
|
|
|
|
|
|
|
|
if (prefix1[0] != comment_line_char) {
|
2015-09-24 21:06:08 +00:00
|
|
|
xsnprintf(prefix1, sizeof(prefix1), "%c ", comment_line_char);
|
|
|
|
xsnprintf(prefix2, sizeof(prefix2), "%c", comment_line_char);
|
2013-01-16 19:18:48 +00:00
|
|
|
}
|
|
|
|
add_lines(out, prefix1, prefix2, buf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_commented_addf(struct strbuf *sb, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int incomplete_line = sb->len && sb->buf[sb->len - 1] != '\n';
|
|
|
|
|
|
|
|
va_start(params, fmt);
|
|
|
|
strbuf_vaddf(&buf, fmt, params);
|
|
|
|
va_end(params);
|
|
|
|
|
|
|
|
strbuf_add_commented_lines(sb, buf.buf, buf.len);
|
|
|
|
if (incomplete_line)
|
|
|
|
sb->buf[--sb->len] = '\0';
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
2011-02-26 05:08:53 +00:00
|
|
|
void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
va_list cp;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2007-11-13 08:22:44 +00:00
|
|
|
if (!strbuf_avail(sb))
|
|
|
|
strbuf_grow(sb, 64);
|
2011-02-26 05:08:53 +00:00
|
|
|
va_copy(cp, ap);
|
|
|
|
len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, cp);
|
|
|
|
va_end(cp);
|
2007-11-13 08:22:44 +00:00
|
|
|
if (len < 0)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("your vsnprintf is broken (returned %d)", len);
|
2007-09-10 10:35:04 +00:00
|
|
|
if (len > strbuf_avail(sb)) {
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_grow(sb, len);
|
|
|
|
len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
|
2011-02-26 05:08:53 +00:00
|
|
|
if (len > strbuf_avail(sb))
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("your vsnprintf is broken (insatiable)");
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
|
|
|
|
void *context)
|
2007-11-09 00:49:42 +00:00
|
|
|
{
|
|
|
|
for (;;) {
|
2008-02-09 14:40:19 +00:00
|
|
|
const char *percent;
|
|
|
|
size_t consumed;
|
2007-11-09 00:49:42 +00:00
|
|
|
|
|
|
|
percent = strchrnul(format, '%');
|
|
|
|
strbuf_add(sb, format, percent - format);
|
|
|
|
if (!*percent)
|
|
|
|
break;
|
|
|
|
format = percent + 1;
|
|
|
|
|
2010-01-13 17:35:31 +00:00
|
|
|
if (*format == '%') {
|
|
|
|
strbuf_addch(sb, '%');
|
|
|
|
format++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
consumed = fn(sb, format, context);
|
|
|
|
if (consumed)
|
|
|
|
format += consumed;
|
|
|
|
else
|
2007-11-09 00:49:42 +00:00
|
|
|
strbuf_addch(sb, '%');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-28 21:33:36 +00:00
|
|
|
size_t strbuf_expand_literal_cb(struct strbuf *sb,
|
|
|
|
const char *placeholder,
|
2022-08-25 17:09:48 +00:00
|
|
|
void *context UNUSED)
|
2019-01-28 21:33:36 +00:00
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
|
|
|
|
switch (placeholder[0]) {
|
|
|
|
case 'n': /* newline */
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
return 1;
|
|
|
|
case 'x':
|
|
|
|
/* %x00 == NUL, %x0a == LF, etc. */
|
|
|
|
ch = hex2chr(placeholder + 1);
|
|
|
|
if (ch < 0)
|
|
|
|
return 0;
|
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-22 23:09:30 +00:00
|
|
|
size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
struct strbuf_expand_dict_entry *e = context;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
|
|
|
|
if (!strncmp(placeholder, e->placeholder, len)) {
|
|
|
|
if (e->value)
|
|
|
|
strbuf_addstr(sb, e->value);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:36:42 +00:00
|
|
|
void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src)
|
|
|
|
{
|
2018-07-24 10:51:08 +00:00
|
|
|
size_t i, len = src->len;
|
2010-01-13 17:36:42 +00:00
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (src->buf[i] == '%')
|
|
|
|
strbuf_addch(dst, '%');
|
|
|
|
strbuf_addch(dst, src->buf[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
credential: fix matching URLs with multiple levels in path
46fd7b3900 ("credential: allow wildcard patterns when matching config",
2020-02-20) introduced support for matching credential helpers using
urlmatch. In doing so, it introduced code to percent-encode the paths
we get from the credential helper so that they could be effectively
matched by the urlmatch code.
Unfortunately, that code had a bug: it percent-encoded the slashes in
the path, resulting in any URL path that contained multiple levels
(i.e., a directory component) not matching.
We are currently the only caller of the percent-encoding code and could
simply change it not to encode slashes. However, we still want to
encode slashes in the username component, so we need to have both
behaviors available.
So instead, let's add a flag to control encoding slashes, which is the
behavior we want here, and use it when calling the code in this case.
Add a test for credential helper URLs using multiple slashes in the
path, which our test suite previously lacked, as well as one ensuring
that we handle usernames with slashes gracefully. Since we're testing
other percent-encoding handling, let's add one for non-ASCII UTF-8
characters as well.
Reported-by: Ilya Tretyakov <it@it3xl.ru>
Signed-off-by: Carlo Marcelo Arenas Belón <carenas@gmail.com>
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-27 01:18:08 +00:00
|
|
|
#define URL_UNSAFE_CHARS " <>\"%{}|\\^`:?#[]@!$&'()*+,;="
|
credential: allow wildcard patterns when matching config
In some cases, a user will want to use a specific credential helper for
a wildcard pattern, such as https://*.corp.example.com. We have code
that handles this already with the urlmatch code, so let's use that
instead of our custom code.
Since the urlmatch code is a superset of our current matching in terms
of capabilities, there shouldn't be any cases of things that matched
previously that don't match now. However, in addition to wildcard
matching, we now use partial path matching, which can cause slightly
different behavior in the case that a helper applies to the prefix
(considering path components) of the remote URL. While different, this
is probably the behavior people were wanting anyway.
Since we're using the urlmatch code, we need to encode the components
we've gotten into a URL to match, so add a function to percent-encode
data and format the URL with it. We now also no longer need to the
custom code to match URLs, so let's remove it.
Additionally, the urlmatch code always looks for the best match, whereas
we want all matches for credential helpers to preserve existing
behavior. Let's add an optional field, select_fn, that lets us control
which items we want (in this case, all of them) and default it to the
best-match code that already exists for other users.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-20 02:24:13 +00:00
|
|
|
|
credential: fix matching URLs with multiple levels in path
46fd7b3900 ("credential: allow wildcard patterns when matching config",
2020-02-20) introduced support for matching credential helpers using
urlmatch. In doing so, it introduced code to percent-encode the paths
we get from the credential helper so that they could be effectively
matched by the urlmatch code.
Unfortunately, that code had a bug: it percent-encoded the slashes in
the path, resulting in any URL path that contained multiple levels
(i.e., a directory component) not matching.
We are currently the only caller of the percent-encoding code and could
simply change it not to encode slashes. However, we still want to
encode slashes in the username component, so we need to have both
behaviors available.
So instead, let's add a flag to control encoding slashes, which is the
behavior we want here, and use it when calling the code in this case.
Add a test for credential helper URLs using multiple slashes in the
path, which our test suite previously lacked, as well as one ensuring
that we handle usernames with slashes gracefully. Since we're testing
other percent-encoding handling, let's add one for non-ASCII UTF-8
characters as well.
Reported-by: Ilya Tretyakov <it@it3xl.ru>
Signed-off-by: Carlo Marcelo Arenas Belón <carenas@gmail.com>
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-27 01:18:08 +00:00
|
|
|
void strbuf_add_percentencode(struct strbuf *dst, const char *src, int flags)
|
credential: allow wildcard patterns when matching config
In some cases, a user will want to use a specific credential helper for
a wildcard pattern, such as https://*.corp.example.com. We have code
that handles this already with the urlmatch code, so let's use that
instead of our custom code.
Since the urlmatch code is a superset of our current matching in terms
of capabilities, there shouldn't be any cases of things that matched
previously that don't match now. However, in addition to wildcard
matching, we now use partial path matching, which can cause slightly
different behavior in the case that a helper applies to the prefix
(considering path components) of the remote URL. While different, this
is probably the behavior people were wanting anyway.
Since we're using the urlmatch code, we need to encode the components
we've gotten into a URL to match, so add a function to percent-encode
data and format the URL with it. We now also no longer need to the
custom code to match URLs, so let's remove it.
Additionally, the urlmatch code always looks for the best match, whereas
we want all matches for credential helpers to preserve existing
behavior. Let's add an optional field, select_fn, that lets us control
which items we want (in this case, all of them) and default it to the
best-match code that already exists for other users.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-20 02:24:13 +00:00
|
|
|
{
|
|
|
|
size_t i, len = strlen(src);
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
unsigned char ch = src[i];
|
credential: fix matching URLs with multiple levels in path
46fd7b3900 ("credential: allow wildcard patterns when matching config",
2020-02-20) introduced support for matching credential helpers using
urlmatch. In doing so, it introduced code to percent-encode the paths
we get from the credential helper so that they could be effectively
matched by the urlmatch code.
Unfortunately, that code had a bug: it percent-encoded the slashes in
the path, resulting in any URL path that contained multiple levels
(i.e., a directory component) not matching.
We are currently the only caller of the percent-encoding code and could
simply change it not to encode slashes. However, we still want to
encode slashes in the username component, so we need to have both
behaviors available.
So instead, let's add a flag to control encoding slashes, which is the
behavior we want here, and use it when calling the code in this case.
Add a test for credential helper URLs using multiple slashes in the
path, which our test suite previously lacked, as well as one ensuring
that we handle usernames with slashes gracefully. Since we're testing
other percent-encoding handling, let's add one for non-ASCII UTF-8
characters as well.
Reported-by: Ilya Tretyakov <it@it3xl.ru>
Signed-off-by: Carlo Marcelo Arenas Belón <carenas@gmail.com>
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-27 01:18:08 +00:00
|
|
|
if (ch <= 0x1F || ch >= 0x7F ||
|
|
|
|
(ch == '/' && (flags & STRBUF_ENCODE_SLASH)) ||
|
|
|
|
strchr(URL_UNSAFE_CHARS, ch))
|
credential: allow wildcard patterns when matching config
In some cases, a user will want to use a specific credential helper for
a wildcard pattern, such as https://*.corp.example.com. We have code
that handles this already with the urlmatch code, so let's use that
instead of our custom code.
Since the urlmatch code is a superset of our current matching in terms
of capabilities, there shouldn't be any cases of things that matched
previously that don't match now. However, in addition to wildcard
matching, we now use partial path matching, which can cause slightly
different behavior in the case that a helper applies to the prefix
(considering path components) of the remote URL. While different, this
is probably the behavior people were wanting anyway.
Since we're using the urlmatch code, we need to encode the components
we've gotten into a URL to match, so add a function to percent-encode
data and format the URL with it. We now also no longer need to the
custom code to match URLs, so let's remove it.
Additionally, the urlmatch code always looks for the best match, whereas
we want all matches for credential helpers to preserve existing
behavior. Let's add an optional field, select_fn, that lets us control
which items we want (in this case, all of them) and default it to the
best-match code that already exists for other users.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-20 02:24:13 +00:00
|
|
|
strbuf_addf(dst, "%%%02X", (unsigned char)ch);
|
|
|
|
else
|
|
|
|
strbuf_addch(dst, ch);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
size_t res;
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
strbuf_grow(sb, size);
|
|
|
|
res = fread(sb->buf + sb->len, 1, size, f);
|
2009-01-06 20:41:14 +00:00
|
|
|
if (res > 0)
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_setlen(sb, sb->len + res);
|
2009-06-22 16:42:33 +00:00
|
|
|
else if (oldalloc == 0)
|
2009-01-06 20:41:14 +00:00
|
|
|
strbuf_release(sb);
|
2007-09-06 11:20:05 +00:00
|
|
|
return res;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint)
|
2007-09-06 11:20:05 +00:00
|
|
|
{
|
|
|
|
size_t oldlen = sb->len;
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, hint ? hint : 8192);
|
2007-09-06 11:20:05 +00:00
|
|
|
for (;;) {
|
2015-05-31 18:16:45 +00:00
|
|
|
ssize_t want = sb->alloc - sb->len - 1;
|
|
|
|
ssize_t got = read_in_full(fd, sb->buf + sb->len, want);
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2015-05-31 18:16:45 +00:00
|
|
|
if (got < 0) {
|
2009-01-06 20:41:14 +00:00
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
|
|
|
else
|
|
|
|
strbuf_setlen(sb, oldlen);
|
2007-09-06 11:20:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2015-05-31 18:16:45 +00:00
|
|
|
sb->len += got;
|
|
|
|
if (got < want)
|
2007-09-06 11:20:05 +00:00
|
|
|
break;
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, 8192);
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
return sb->len - oldlen;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:08 +00:00
|
|
|
ssize_t strbuf_read_once(struct strbuf *sb, int fd, size_t hint)
|
|
|
|
{
|
2017-12-07 20:51:26 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2015-12-16 00:04:08 +00:00
|
|
|
ssize_t cnt;
|
|
|
|
|
|
|
|
strbuf_grow(sb, hint ? hint : 8192);
|
|
|
|
cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
|
|
|
|
if (cnt > 0)
|
|
|
|
strbuf_setlen(sb, sb->len + cnt);
|
2017-12-07 20:51:26 +00:00
|
|
|
else if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
2015-12-16 00:04:08 +00:00
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2016-03-01 02:07:15 +00:00
|
|
|
ssize_t strbuf_write(struct strbuf *sb, FILE *f)
|
|
|
|
{
|
|
|
|
return sb->len ? fwrite(sb->buf, 1, sb->len, f) : 0;
|
|
|
|
}
|
|
|
|
|
2008-12-17 17:36:40 +00:00
|
|
|
#define STRBUF_MAXLINK (2*PATH_MAX)
|
|
|
|
|
|
|
|
int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint)
|
|
|
|
{
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
|
|
|
|
2008-12-17 17:36:40 +00:00
|
|
|
if (hint < 32)
|
|
|
|
hint = 32;
|
|
|
|
|
|
|
|
while (hint < STRBUF_MAXLINK) {
|
2018-07-24 10:51:25 +00:00
|
|
|
ssize_t len;
|
2008-12-17 17:36:40 +00:00
|
|
|
|
|
|
|
strbuf_grow(sb, hint);
|
|
|
|
len = readlink(path, sb->buf, hint);
|
|
|
|
if (len < 0) {
|
|
|
|
if (errno != ERANGE)
|
|
|
|
break;
|
|
|
|
} else if (len < hint) {
|
|
|
|
strbuf_setlen(sb, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* .. the buffer was too small - try again */
|
|
|
|
hint *= 2;
|
|
|
|
}
|
2009-01-06 20:41:14 +00:00
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
2008-12-17 17:36:40 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:24:29 +00:00
|
|
|
int strbuf_getcwd(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
size_t oldalloc = sb->alloc;
|
|
|
|
size_t guessed_len = 128;
|
|
|
|
|
|
|
|
for (;; guessed_len *= 2) {
|
|
|
|
strbuf_grow(sb, guessed_len);
|
|
|
|
if (getcwd(sb->buf, sb->alloc)) {
|
|
|
|
strbuf_setlen(sb, strlen(sb->buf));
|
|
|
|
return 0;
|
|
|
|
}
|
2017-03-26 13:43:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If getcwd(3) is implemented as a syscall that falls
|
|
|
|
* back to a regular lookup using readdir(3) etc. then
|
|
|
|
* we may be able to avoid EACCES by providing enough
|
|
|
|
* space to the syscall as it's not necessarily bound
|
|
|
|
* to the same restrictions as the fallback.
|
|
|
|
*/
|
|
|
|
if (errno == EACCES && guessed_len < PATH_MAX)
|
|
|
|
continue;
|
|
|
|
|
2014-07-28 18:24:29 +00:00
|
|
|
if (errno != ERANGE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
|
|
|
else
|
|
|
|
strbuf_reset(sb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-04-16 09:01:38 +00:00
|
|
|
#ifdef HAVE_GETDELIM
|
|
|
|
int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
|
|
|
|
{
|
|
|
|
ssize_t r;
|
|
|
|
|
|
|
|
if (feof(fp))
|
|
|
|
return EOF;
|
|
|
|
|
|
|
|
strbuf_reset(sb);
|
|
|
|
|
|
|
|
/* Translate slopbuf to NULL, as we cannot call realloc on it */
|
|
|
|
if (!sb->alloc)
|
|
|
|
sb->buf = NULL;
|
2017-08-10 20:56:40 +00:00
|
|
|
errno = 0;
|
2015-04-16 09:01:38 +00:00
|
|
|
r = getdelim(&sb->buf, &sb->alloc, term, fp);
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
sb->len = r;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
assert(r == -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Normally we would have called xrealloc, which will try to free
|
|
|
|
* memory and recover. But we have no way to tell getdelim() to do so.
|
|
|
|
* Worse, we cannot try to recover ENOMEM ourselves, because we have
|
|
|
|
* no idea how many bytes were read by getdelim.
|
|
|
|
*
|
|
|
|
* Dying here is reasonable. It mirrors what xrealloc would do on
|
|
|
|
* catastrophic memory failure. We skip the opportunity to free pack
|
|
|
|
* memory and retry, but that's unlikely to help for a malloc small
|
|
|
|
* enough to hold a single line of input, anyway.
|
|
|
|
*/
|
|
|
|
if (errno == ENOMEM)
|
|
|
|
die("Out of memory, getdelim failed");
|
|
|
|
|
strbuf_getwholeline: NUL-terminate getdelim buffer on error
Commit 0cc30e0 (strbuf_getwholeline: use getdelim if it is
available, 2015-04-16) tries to clean up after getdelim()
returns EOF, but gets one case wrong, which can lead in some
obscure cases to us reading uninitialized memory.
After getdelim() returns -1, we re-initialize the strbuf
only if sb->buf is NULL. The thinking was that either:
1. We fed an existing allocated buffer to getdelim(), and
at most it would have realloc'd, leaving our NUL in
place.
2. We didn't have a buffer to feed, so we gave getdelim()
NULL; sb->buf will remain NULL, and we just want to
restore the empty slopbuf.
But that second case isn't quite right. getdelim() may
allocate a buffer, write nothing into it, and then return
EOF. The resulting strbuf rightfully has sb->len set to "0",
but is missing the NUL terminator in the first byte.
Most call-sites are fine with this. They see the EOF and
don't bother looking at the strbuf. Or they notice that
sb->len is empty, and don't look at the contents. But
there's at least one case that does neither, and relies on
parsing the resulting (possibly zero-length) string:
fast-import. You can see this in action with the new test
(though we probably only notice failure there when run with
--valgrind or ASAN).
We can fix this by unconditionally resetting the strbuf when
we have a buffer after getdelim(). That fixes case 2 above.
Case 1 is probably already fine in practice, but it does not
hurt for us to re-assert our invariants (especially because
we are relying on whatever getdelim() happens to do, which
may vary from platform to platform). Our fix covers that
case, too.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-05 18:43:30 +00:00
|
|
|
/*
|
|
|
|
* Restore strbuf invariants; if getdelim left us with a NULL pointer,
|
|
|
|
* we can just re-init, but otherwise we should make sure that our
|
|
|
|
* length is empty, and that the result is NUL-terminated.
|
|
|
|
*/
|
2015-04-16 09:01:38 +00:00
|
|
|
if (!sb->buf)
|
|
|
|
strbuf_init(sb, 0);
|
strbuf_getwholeline: NUL-terminate getdelim buffer on error
Commit 0cc30e0 (strbuf_getwholeline: use getdelim if it is
available, 2015-04-16) tries to clean up after getdelim()
returns EOF, but gets one case wrong, which can lead in some
obscure cases to us reading uninitialized memory.
After getdelim() returns -1, we re-initialize the strbuf
only if sb->buf is NULL. The thinking was that either:
1. We fed an existing allocated buffer to getdelim(), and
at most it would have realloc'd, leaving our NUL in
place.
2. We didn't have a buffer to feed, so we gave getdelim()
NULL; sb->buf will remain NULL, and we just want to
restore the empty slopbuf.
But that second case isn't quite right. getdelim() may
allocate a buffer, write nothing into it, and then return
EOF. The resulting strbuf rightfully has sb->len set to "0",
but is missing the NUL terminator in the first byte.
Most call-sites are fine with this. They see the EOF and
don't bother looking at the strbuf. Or they notice that
sb->len is empty, and don't look at the contents. But
there's at least one case that does neither, and relies on
parsing the resulting (possibly zero-length) string:
fast-import. You can see this in action with the new test
(though we probably only notice failure there when run with
--valgrind or ASAN).
We can fix this by unconditionally resetting the strbuf when
we have a buffer after getdelim(). That fixes case 2 above.
Case 1 is probably already fine in practice, but it does not
hurt for us to re-assert our invariants (especially because
we are relying on whatever getdelim() happens to do, which
may vary from platform to platform). Our fix covers that
case, too.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-05 18:43:30 +00:00
|
|
|
else
|
|
|
|
strbuf_reset(sb);
|
2015-04-16 09:01:38 +00:00
|
|
|
return EOF;
|
|
|
|
}
|
|
|
|
#else
|
2009-08-05 03:31:56 +00:00
|
|
|
int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
|
2007-09-15 13:56:50 +00:00
|
|
|
{
|
2005-04-26 01:26:45 +00:00
|
|
|
int ch;
|
2007-09-17 09:19:04 +00:00
|
|
|
|
|
|
|
if (feof(fp))
|
|
|
|
return EOF;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
strbuf_reset(sb);
|
2015-04-16 08:49:06 +00:00
|
|
|
flockfile(fp);
|
|
|
|
while ((ch = getc_unlocked(fp)) != EOF) {
|
2015-04-16 08:58:54 +00:00
|
|
|
if (!strbuf_avail(sb))
|
|
|
|
strbuf_grow(sb, 1);
|
2007-09-06 11:20:05 +00:00
|
|
|
sb->buf[sb->len++] = ch;
|
2009-08-05 03:31:56 +00:00
|
|
|
if (ch == term)
|
|
|
|
break;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
2015-04-16 08:49:06 +00:00
|
|
|
funlockfile(fp);
|
2007-09-17 09:19:04 +00:00
|
|
|
if (ch == EOF && sb->len == 0)
|
|
|
|
return EOF;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
sb->buf[sb->len] = '\0';
|
2007-09-17 09:19:04 +00:00
|
|
|
return 0;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
2015-04-16 09:01:38 +00:00
|
|
|
#endif
|
2007-09-18 00:06:46 +00:00
|
|
|
|
2020-03-30 13:46:27 +00:00
|
|
|
int strbuf_appendwholeline(struct strbuf *sb, FILE *fp, int term)
|
|
|
|
{
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
if (strbuf_getwholeline(&line, fp, term))
|
|
|
|
return EOF;
|
|
|
|
strbuf_addbuf(sb, &line);
|
|
|
|
strbuf_release(&line);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-14 02:32:23 +00:00
|
|
|
static int strbuf_getdelim(struct strbuf *sb, FILE *fp, int term)
|
2009-08-05 03:31:56 +00:00
|
|
|
{
|
|
|
|
if (strbuf_getwholeline(sb, fp, term))
|
|
|
|
return EOF;
|
2016-01-13 23:10:45 +00:00
|
|
|
if (sb->buf[sb->len - 1] == term)
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
2009-08-05 03:31:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-14 02:32:23 +00:00
|
|
|
int strbuf_getline(struct strbuf *sb, FILE *fp)
|
2015-10-28 20:17:29 +00:00
|
|
|
{
|
|
|
|
if (strbuf_getwholeline(sb, fp, '\n'))
|
|
|
|
return EOF;
|
|
|
|
if (sb->buf[sb->len - 1] == '\n') {
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
|
|
|
if (sb->len && sb->buf[sb->len - 1] == '\r')
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-13 23:31:17 +00:00
|
|
|
int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
|
|
|
|
{
|
2016-01-14 02:32:23 +00:00
|
|
|
return strbuf_getdelim(sb, fp, '\n');
|
2016-01-13 23:31:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
|
|
|
|
{
|
2016-01-14 02:32:23 +00:00
|
|
|
return strbuf_getdelim(sb, fp, '\0');
|
2016-01-13 23:31:17 +00:00
|
|
|
}
|
|
|
|
|
2012-02-22 19:34:22 +00:00
|
|
|
int strbuf_getwholeline_fd(struct strbuf *sb, int fd, int term)
|
|
|
|
{
|
|
|
|
strbuf_reset(sb);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
char ch;
|
|
|
|
ssize_t len = xread(fd, &ch, 1);
|
|
|
|
if (len <= 0)
|
|
|
|
return EOF;
|
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
if (ch == term)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-03 13:59:32 +00:00
|
|
|
ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
|
2007-09-18 00:06:46 +00:00
|
|
|
{
|
2015-07-03 13:59:32 +00:00
|
|
|
int fd;
|
|
|
|
ssize_t len;
|
2018-02-23 07:00:54 +00:00
|
|
|
int saved_errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
2007-09-27 13:25:55 +00:00
|
|
|
len = strbuf_read(sb, fd, hint);
|
2018-02-23 07:00:54 +00:00
|
|
|
saved_errno = errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
close(fd);
|
2018-02-23 07:00:54 +00:00
|
|
|
if (len < 0) {
|
|
|
|
errno = saved_errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
return -1;
|
2018-02-23 07:00:54 +00:00
|
|
|
}
|
2007-09-18 00:06:46 +00:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
2011-11-05 04:06:30 +00:00
|
|
|
|
|
|
|
void strbuf_add_lines(struct strbuf *out, const char *prefix,
|
|
|
|
const char *buf, size_t size)
|
|
|
|
{
|
2013-01-16 19:18:48 +00:00
|
|
|
add_lines(out, prefix, NULL, buf, size);
|
2011-11-05 04:06:30 +00:00
|
|
|
}
|
2011-12-20 00:05:16 +00:00
|
|
|
|
2012-11-25 11:08:34 +00:00
|
|
|
void strbuf_addstr_xml_quoted(struct strbuf *buf, const char *s)
|
|
|
|
{
|
|
|
|
while (*s) {
|
|
|
|
size_t len = strcspn(s, "\"<>&");
|
|
|
|
strbuf_add(buf, s, len);
|
|
|
|
s += len;
|
|
|
|
switch (*s) {
|
|
|
|
case '"':
|
|
|
|
strbuf_addstr(buf, """);
|
|
|
|
break;
|
|
|
|
case '<':
|
|
|
|
strbuf_addstr(buf, "<");
|
|
|
|
break;
|
|
|
|
case '>':
|
|
|
|
strbuf_addstr(buf, ">");
|
|
|
|
break;
|
|
|
|
case '&':
|
|
|
|
strbuf_addstr(buf, "&");
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 22:54:11 +00:00
|
|
|
int is_rfc3986_reserved_or_unreserved(char ch)
|
2011-12-10 10:34:20 +00:00
|
|
|
{
|
2019-06-27 22:54:11 +00:00
|
|
|
if (is_rfc3986_unreserved(ch))
|
|
|
|
return 1;
|
2011-12-10 10:34:20 +00:00
|
|
|
switch (ch) {
|
|
|
|
case '!': case '*': case '\'': case '(': case ')': case ';':
|
|
|
|
case ':': case '@': case '&': case '=': case '+': case '$':
|
|
|
|
case ',': case '/': case '?': case '#': case '[': case ']':
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-27 22:54:11 +00:00
|
|
|
int is_rfc3986_unreserved(char ch)
|
2011-12-10 10:34:20 +00:00
|
|
|
{
|
|
|
|
return isalnum(ch) ||
|
|
|
|
ch == '-' || ch == '_' || ch == '.' || ch == '~';
|
|
|
|
}
|
|
|
|
|
2012-09-16 05:43:15 +00:00
|
|
|
static void strbuf_add_urlencode(struct strbuf *sb, const char *s, size_t len,
|
2019-06-27 22:54:11 +00:00
|
|
|
char_predicate allow_unencoded_fn)
|
2011-12-10 10:34:20 +00:00
|
|
|
{
|
|
|
|
strbuf_grow(sb, len);
|
|
|
|
while (len--) {
|
|
|
|
char ch = *s++;
|
2019-06-27 22:54:11 +00:00
|
|
|
if (allow_unencoded_fn(ch))
|
2011-12-10 10:34:20 +00:00
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
else
|
2017-12-22 17:24:37 +00:00
|
|
|
strbuf_addf(sb, "%%%02x", (unsigned char)ch);
|
2011-12-10 10:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
|
2019-06-27 22:54:11 +00:00
|
|
|
char_predicate allow_unencoded_fn)
|
2011-12-10 10:34:20 +00:00
|
|
|
{
|
2019-06-27 22:54:11 +00:00
|
|
|
strbuf_add_urlencode(sb, s, strlen(s), allow_unencoded_fn);
|
2011-12-10 10:34:20 +00:00
|
|
|
}
|
2012-04-23 12:30:22 +00:00
|
|
|
|
2019-07-02 18:22:48 +00:00
|
|
|
static void strbuf_humanise(struct strbuf *buf, off_t bytes,
|
|
|
|
int humanise_rate)
|
2013-04-10 19:03:23 +00:00
|
|
|
{
|
|
|
|
if (bytes > 1 << 30) {
|
2019-07-02 18:22:48 +00:00
|
|
|
strbuf_addf(buf,
|
|
|
|
humanise_rate == 0 ?
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 gibibyte */
|
|
|
|
_("%u.%2.2u GiB") :
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 gibibyte/second */
|
|
|
|
_("%u.%2.2u GiB/s"),
|
2018-07-24 10:52:29 +00:00
|
|
|
(unsigned)(bytes >> 30),
|
|
|
|
(unsigned)(bytes & ((1 << 30) - 1)) / 10737419);
|
2013-04-10 19:03:23 +00:00
|
|
|
} else if (bytes > 1 << 20) {
|
2018-07-24 10:52:29 +00:00
|
|
|
unsigned x = bytes + 5243; /* for rounding */
|
2019-07-02 18:22:48 +00:00
|
|
|
strbuf_addf(buf,
|
|
|
|
humanise_rate == 0 ?
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 mebibyte */
|
|
|
|
_("%u.%2.2u MiB") :
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 mebibyte/second */
|
|
|
|
_("%u.%2.2u MiB/s"),
|
2013-04-10 19:03:23 +00:00
|
|
|
x >> 20, ((x & ((1 << 20) - 1)) * 100) >> 20);
|
|
|
|
} else if (bytes > 1 << 10) {
|
2018-07-24 10:52:29 +00:00
|
|
|
unsigned x = bytes + 5; /* for rounding */
|
2019-07-02 18:22:48 +00:00
|
|
|
strbuf_addf(buf,
|
|
|
|
humanise_rate == 0 ?
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 kibibyte */
|
|
|
|
_("%u.%2.2u KiB") :
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 kibibyte/second */
|
|
|
|
_("%u.%2.2u KiB/s"),
|
2013-04-10 19:03:23 +00:00
|
|
|
x >> 10, ((x & ((1 << 10) - 1)) * 100) >> 10);
|
|
|
|
} else {
|
2019-07-02 18:22:48 +00:00
|
|
|
strbuf_addf(buf,
|
|
|
|
humanise_rate == 0 ?
|
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 byte */
|
gettext API users: don't explicitly cast ngettext()'s "n"
Change a few stray users of the inline gettext.h Q_() function to stop
casting its "n" argument, the vast majority of the users of that
wrapper API use the implicit cast to "unsigned long".
The ngettext() function (which Q_() resolves to) takes an "unsigned
long int", and so does our Q_() wrapper for it, see 0c9ea33b90f (i18n:
add stub Q_() wrapper for ngettext, 2011-03-09). The function isn't
ours, but provided by e.g. GNU libintl.
This amends code added in added in 7171a0b0cf5 (index-pack: correct
"len" type in unpack_data(), 2016-07-13). The cast it added for the
printf format to die() was needed, but not the cast to Q_().
Likewise the casts in strbuf.c added in 8f354a1faed (l10n: localizable
upload progress messages, 2019-07-02) and for
builtin/merge-recursive.c in ccf7813139f (i18n: merge-recursive: mark
error messages for translation, 2016-09-15) weren't needed.
In the latter case the cast was copy/pasted from the argument to
warning() itself, added in b74d779bd90 (MinGW: Fix compiler warning in
merge-recursive, 2009-05-23). The cast for warning() is needed, but
not the one for ngettext()'s "n" argument.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-03-07 15:27:07 +00:00
|
|
|
Q_("%u byte", "%u bytes", bytes) :
|
2019-07-02 18:22:48 +00:00
|
|
|
/* TRANSLATORS: IEC 80000-13:2008 byte/second */
|
gettext API users: don't explicitly cast ngettext()'s "n"
Change a few stray users of the inline gettext.h Q_() function to stop
casting its "n" argument, the vast majority of the users of that
wrapper API use the implicit cast to "unsigned long".
The ngettext() function (which Q_() resolves to) takes an "unsigned
long int", and so does our Q_() wrapper for it, see 0c9ea33b90f (i18n:
add stub Q_() wrapper for ngettext, 2011-03-09). The function isn't
ours, but provided by e.g. GNU libintl.
This amends code added in added in 7171a0b0cf5 (index-pack: correct
"len" type in unpack_data(), 2016-07-13). The cast it added for the
printf format to die() was needed, but not the cast to Q_().
Likewise the casts in strbuf.c added in 8f354a1faed (l10n: localizable
upload progress messages, 2019-07-02) and for
builtin/merge-recursive.c in ccf7813139f (i18n: merge-recursive: mark
error messages for translation, 2016-09-15) weren't needed.
In the latter case the cast was copy/pasted from the argument to
warning() itself, added in b74d779bd90 (MinGW: Fix compiler warning in
merge-recursive, 2009-05-23). The cast for warning() is needed, but
not the one for ngettext()'s "n" argument.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-03-07 15:27:07 +00:00
|
|
|
Q_("%u byte/s", "%u bytes/s", bytes),
|
2019-07-02 18:22:48 +00:00
|
|
|
(unsigned)bytes);
|
2013-04-10 19:03:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-02 18:22:48 +00:00
|
|
|
void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)
|
|
|
|
{
|
|
|
|
strbuf_humanise(buf, bytes, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_humanise_rate(struct strbuf *buf, off_t bytes)
|
|
|
|
{
|
|
|
|
strbuf_humanise(buf, bytes, 1);
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:33:55 +00:00
|
|
|
void strbuf_add_absolute_path(struct strbuf *sb, const char *path)
|
|
|
|
{
|
|
|
|
if (!*path)
|
|
|
|
die("The empty string is not a valid path");
|
|
|
|
if (!is_absolute_path(path)) {
|
|
|
|
struct stat cwd_stat, pwd_stat;
|
|
|
|
size_t orig_len = sb->len;
|
|
|
|
char *cwd = xgetcwd();
|
|
|
|
char *pwd = getenv("PWD");
|
|
|
|
if (pwd && strcmp(pwd, cwd) &&
|
|
|
|
!stat(cwd, &cwd_stat) &&
|
|
|
|
(cwd_stat.st_dev || cwd_stat.st_ino) &&
|
|
|
|
!stat(pwd, &pwd_stat) &&
|
|
|
|
pwd_stat.st_dev == cwd_stat.st_dev &&
|
|
|
|
pwd_stat.st_ino == cwd_stat.st_ino)
|
|
|
|
strbuf_addstr(sb, pwd);
|
|
|
|
else
|
|
|
|
strbuf_addstr(sb, cwd);
|
|
|
|
if (sb->len > orig_len && !is_dir_sep(sb->buf[sb->len - 1]))
|
|
|
|
strbuf_addch(sb, '/');
|
|
|
|
free(cwd);
|
|
|
|
}
|
|
|
|
strbuf_addstr(sb, path);
|
|
|
|
}
|
|
|
|
|
2017-02-25 16:00:33 +00:00
|
|
|
void strbuf_add_real_path(struct strbuf *sb, const char *path)
|
|
|
|
{
|
|
|
|
if (sb->len) {
|
|
|
|
struct strbuf resolved = STRBUF_INIT;
|
|
|
|
strbuf_realpath(&resolved, path, 1);
|
|
|
|
strbuf_addbuf(sb, &resolved);
|
|
|
|
strbuf_release(&resolved);
|
|
|
|
} else
|
|
|
|
strbuf_realpath(sb, path, 1);
|
|
|
|
}
|
|
|
|
|
2012-04-23 12:30:22 +00:00
|
|
|
int printf_ln(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (ret < 0 || putchar('\n') == EOF)
|
|
|
|
return -1;
|
|
|
|
return ret + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fprintf_ln(FILE *fp, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = vfprintf(fp, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (ret < 0 || putc('\n', fp) == EOF)
|
|
|
|
return -1;
|
|
|
|
return ret + 1;
|
|
|
|
}
|
2014-05-22 09:44:09 +00:00
|
|
|
|
|
|
|
char *xstrdup_tolower(const char *string)
|
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
size_t len, i;
|
|
|
|
|
|
|
|
len = strlen(string);
|
2016-02-22 22:44:28 +00:00
|
|
|
result = xmallocz(len);
|
2014-05-22 09:44:09 +00:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
result[i] = tolower(string[i]);
|
|
|
|
return result;
|
|
|
|
}
|
strbuf: add xstrfmt helper
You can use a strbuf to build up a string from parts, and
then detach it. In the general case, you might use multiple
strbuf_add* functions to do the building. However, in many
cases, a single strbuf_addf is sufficient, and we end up
with:
struct strbuf buf = STRBUF_INIT;
...
strbuf_addf(&buf, fmt, some, args);
str = strbuf_detach(&buf, NULL);
We can make this much more readable (and avoid introducing
an extra variable, which can clutter the code) by
introducing a convenience function:
str = xstrfmt(fmt, some, args);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 20:01:34 +00:00
|
|
|
|
2018-02-15 15:27:06 +00:00
|
|
|
char *xstrdup_toupper(const char *string)
|
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
size_t len, i;
|
|
|
|
|
|
|
|
len = strlen(string);
|
|
|
|
result = xmallocz(len);
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
result[i] = toupper(string[i]);
|
2014-05-22 09:44:09 +00:00
|
|
|
return result;
|
|
|
|
}
|
strbuf: add xstrfmt helper
You can use a strbuf to build up a string from parts, and
then detach it. In the general case, you might use multiple
strbuf_add* functions to do the building. However, in many
cases, a single strbuf_addf is sufficient, and we end up
with:
struct strbuf buf = STRBUF_INIT;
...
strbuf_addf(&buf, fmt, some, args);
str = strbuf_detach(&buf, NULL);
We can make this much more readable (and avoid introducing
an extra variable, which can clutter the code) by
introducing a convenience function:
str = xstrfmt(fmt, some, args);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 20:01:34 +00:00
|
|
|
|
|
|
|
char *xstrvfmt(const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_vaddf(&buf, fmt, ap);
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *xstrfmt(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = xstrvfmt(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2015-06-25 16:55:45 +00:00
|
|
|
|
2017-06-15 12:29:53 +00:00
|
|
|
void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm,
|
2017-07-01 13:15:47 +00:00
|
|
|
int tz_offset, int suppress_tz_name)
|
2015-06-25 16:55:45 +00:00
|
|
|
{
|
2017-06-15 12:29:53 +00:00
|
|
|
struct strbuf munged_fmt = STRBUF_INIT;
|
2015-06-30 13:26:53 +00:00
|
|
|
size_t hint = 128;
|
2015-06-25 16:55:45 +00:00
|
|
|
size_t len;
|
|
|
|
|
2015-06-30 13:26:53 +00:00
|
|
|
if (!*fmt)
|
|
|
|
return;
|
|
|
|
|
2017-06-15 12:29:53 +00:00
|
|
|
/*
|
|
|
|
* There is no portable way to pass timezone information to
|
strbuf_addftime(): handle "%s" manually
The strftime() function has a non-standard "%s" extension, which prints
the number of seconds since the epoch. But the "struct tm" we get has
already been adjusted for a particular time zone; going back to an epoch
time requires knowing that zone offset. Since strftime() doesn't take
such an argument, round-tripping to a "struct tm" and back to the "%s"
format may produce the wrong value (off by tz_offset seconds).
Since we're already passing in the zone offset courtesy of c3fbf81a85
(strbuf: let strbuf_addftime handle %z and %Z itself, 2017-06-15), we
can use that same value to adjust our epoch seconds accordingly.
Note that the description above makes it sound like strftime()'s "%s" is
useless (and really, the issue is shared by mktime(), which is what
strftime() would use under the hood). But it gets the two cases for
which it's designed correct:
- the result of gmtime() will have a zero offset, so no adjustment is
necessary
- the result of localtime() will be offset by the local zone offset,
and mktime() and strftime() are defined to assume this offset when
converting back (there's actually some magic here; some
implementations record this in the "struct tm", but we can't
portably access or manipulate it. But they somehow "know" whether a
"struct tm" is from gmtime() or localtime()).
This latter point means that "format-local:%s" actually works correctly
already, because in that case we rely on the system routines due to
6eced3ec5e (date: use localtime() for "-local" time formats,
2017-06-15). Our problem comes when trying to show times in the author's
zone, as the system routines provide no mechanism for converting in
non-local zones. So in those cases we have a "struct tm" that came from
gmtime(), but has been manipulated according to our offset.
The tests cover the broken round-trip by formatting "%s" for a time in a
non-system timezone. We use the made-up "+1234" here, which has two
advantages. One, we know it won't ever be the real system zone (and so
we're actually testing a case that would break). And two, since it has a
minute component, we're testing the full decoding of the +HHMM zone into
a number of seconds. Likewise, we test the "-1234" variant to make sure
there aren't any sign mistakes.
There's one final test, which covers "format-local:%s". As noted, this
already passes, but it's important to check that we didn't regress this
case. In particular, the caller in show_date() is relying on localtime()
to have done the zone adjustment, independent of any tz_offset we
compute ourselves. These should match up, since our local_tzoffset() is
likewise built around localtime(). But it would be easy for a caller to
forget to pass in a correct tz_offset to strbuf_addftime(). Fortunately
show_date() does this correctly (it has to because of the existing
handling of %z), and the test continues to pass. So this one is just
future-proofing against a change in our assumptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-11-02 11:35:34 +00:00
|
|
|
* strftime, so we handle %z and %Z here. Likewise '%s', because
|
|
|
|
* going back to an epoch time requires knowing the zone.
|
|
|
|
*
|
|
|
|
* Note that tz_offset is in the "[-+]HHMM" decimal form; this is what
|
|
|
|
* we want for %z, but the computation for %s has to convert to number
|
|
|
|
* of seconds.
|
2017-06-15 12:29:53 +00:00
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
const char *percent = strchrnul(fmt, '%');
|
|
|
|
strbuf_add(&munged_fmt, fmt, percent - fmt);
|
|
|
|
if (!*percent)
|
|
|
|
break;
|
|
|
|
fmt = percent + 1;
|
|
|
|
switch (*fmt) {
|
|
|
|
case '%':
|
|
|
|
strbuf_addstr(&munged_fmt, "%%");
|
|
|
|
fmt++;
|
|
|
|
break;
|
strbuf_addftime(): handle "%s" manually
The strftime() function has a non-standard "%s" extension, which prints
the number of seconds since the epoch. But the "struct tm" we get has
already been adjusted for a particular time zone; going back to an epoch
time requires knowing that zone offset. Since strftime() doesn't take
such an argument, round-tripping to a "struct tm" and back to the "%s"
format may produce the wrong value (off by tz_offset seconds).
Since we're already passing in the zone offset courtesy of c3fbf81a85
(strbuf: let strbuf_addftime handle %z and %Z itself, 2017-06-15), we
can use that same value to adjust our epoch seconds accordingly.
Note that the description above makes it sound like strftime()'s "%s" is
useless (and really, the issue is shared by mktime(), which is what
strftime() would use under the hood). But it gets the two cases for
which it's designed correct:
- the result of gmtime() will have a zero offset, so no adjustment is
necessary
- the result of localtime() will be offset by the local zone offset,
and mktime() and strftime() are defined to assume this offset when
converting back (there's actually some magic here; some
implementations record this in the "struct tm", but we can't
portably access or manipulate it. But they somehow "know" whether a
"struct tm" is from gmtime() or localtime()).
This latter point means that "format-local:%s" actually works correctly
already, because in that case we rely on the system routines due to
6eced3ec5e (date: use localtime() for "-local" time formats,
2017-06-15). Our problem comes when trying to show times in the author's
zone, as the system routines provide no mechanism for converting in
non-local zones. So in those cases we have a "struct tm" that came from
gmtime(), but has been manipulated according to our offset.
The tests cover the broken round-trip by formatting "%s" for a time in a
non-system timezone. We use the made-up "+1234" here, which has two
advantages. One, we know it won't ever be the real system zone (and so
we're actually testing a case that would break). And two, since it has a
minute component, we're testing the full decoding of the +HHMM zone into
a number of seconds. Likewise, we test the "-1234" variant to make sure
there aren't any sign mistakes.
There's one final test, which covers "format-local:%s". As noted, this
already passes, but it's important to check that we didn't regress this
case. In particular, the caller in show_date() is relying on localtime()
to have done the zone adjustment, independent of any tz_offset we
compute ourselves. These should match up, since our local_tzoffset() is
likewise built around localtime(). But it would be easy for a caller to
forget to pass in a correct tz_offset to strbuf_addftime(). Fortunately
show_date() does this correctly (it has to because of the existing
handling of %z), and the test continues to pass. So this one is just
future-proofing against a change in our assumptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-11-02 11:35:34 +00:00
|
|
|
case 's':
|
|
|
|
strbuf_addf(&munged_fmt, "%"PRItime,
|
|
|
|
(timestamp_t)tm_to_time_t(tm) -
|
|
|
|
3600 * (tz_offset / 100) -
|
|
|
|
60 * (tz_offset % 100));
|
|
|
|
fmt++;
|
|
|
|
break;
|
2017-06-15 12:29:53 +00:00
|
|
|
case 'z':
|
|
|
|
strbuf_addf(&munged_fmt, "%+05d", tz_offset);
|
|
|
|
fmt++;
|
|
|
|
break;
|
|
|
|
case 'Z':
|
2017-07-01 13:15:47 +00:00
|
|
|
if (suppress_tz_name) {
|
2017-06-15 12:29:53 +00:00
|
|
|
fmt++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
default:
|
|
|
|
strbuf_addch(&munged_fmt, '%');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fmt = munged_fmt.buf;
|
|
|
|
|
2015-06-30 13:26:53 +00:00
|
|
|
strbuf_grow(sb, hint);
|
2015-06-25 16:55:45 +00:00
|
|
|
len = strftime(sb->buf + sb->len, sb->alloc - sb->len, fmt, tm);
|
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
/*
|
2015-06-30 13:26:53 +00:00
|
|
|
* strftime reports "0" if it could not fit the result in the buffer.
|
|
|
|
* Unfortunately, it also reports "0" if the requested time string
|
|
|
|
* takes 0 bytes. So our strategy is to munge the format so that the
|
|
|
|
* output contains at least one character, and then drop the extra
|
|
|
|
* character before returning.
|
2015-06-25 16:55:45 +00:00
|
|
|
*/
|
2017-06-15 12:29:53 +00:00
|
|
|
strbuf_addch(&munged_fmt, ' ');
|
2015-06-30 13:26:53 +00:00
|
|
|
while (!len) {
|
|
|
|
hint *= 2;
|
|
|
|
strbuf_grow(sb, hint);
|
|
|
|
len = strftime(sb->buf + sb->len, sb->alloc - sb->len,
|
|
|
|
munged_fmt.buf, tm);
|
|
|
|
}
|
|
|
|
len--; /* drop munged space */
|
2015-06-25 16:55:45 +00:00
|
|
|
}
|
2017-06-15 12:29:53 +00:00
|
|
|
strbuf_release(&munged_fmt);
|
2015-06-30 13:26:53 +00:00
|
|
|
strbuf_setlen(sb, sb->len + len);
|
2015-06-25 16:55:45 +00:00
|
|
|
}
|
2015-09-24 21:05:45 +00:00
|
|
|
|
2021-10-08 21:08:17 +00:00
|
|
|
void strbuf_repo_add_unique_abbrev(struct strbuf *sb, struct repository *repo,
|
|
|
|
const struct object_id *oid, int abbrev_len)
|
2015-09-24 21:05:45 +00:00
|
|
|
{
|
|
|
|
int r;
|
2018-07-16 01:27:57 +00:00
|
|
|
strbuf_grow(sb, GIT_MAX_HEXSZ + 1);
|
2021-10-08 21:08:17 +00:00
|
|
|
r = repo_find_unique_abbrev_r(repo, sb->buf + sb->len, oid, abbrev_len);
|
2015-09-24 21:05:45 +00:00
|
|
|
strbuf_setlen(sb, sb->len + r);
|
|
|
|
}
|
2015-10-26 22:55:20 +00:00
|
|
|
|
2021-10-08 21:08:17 +00:00
|
|
|
void strbuf_add_unique_abbrev(struct strbuf *sb, const struct object_id *oid,
|
|
|
|
int abbrev_len)
|
|
|
|
{
|
|
|
|
strbuf_repo_add_unique_abbrev(sb, the_repository, oid, abbrev_len);
|
|
|
|
}
|
|
|
|
|
2015-10-16 15:16:42 +00:00
|
|
|
/*
|
|
|
|
* Returns the length of a line, without trailing spaces.
|
|
|
|
*
|
|
|
|
* If the line ends with newline, it will be removed too.
|
|
|
|
*/
|
|
|
|
static size_t cleanup(char *line, size_t len)
|
|
|
|
{
|
|
|
|
while (len) {
|
|
|
|
unsigned char c = line[len - 1];
|
|
|
|
if (!isspace(c))
|
|
|
|
break;
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove empty lines from the beginning and end
|
|
|
|
* and also trailing spaces from every line.
|
|
|
|
*
|
|
|
|
* Turn multiple consecutive empty lines between paragraphs
|
|
|
|
* into just one empty line.
|
|
|
|
*
|
|
|
|
* If the input has only empty lines and spaces,
|
|
|
|
* no output will be produced.
|
|
|
|
*
|
|
|
|
* If last line does not have a newline at the end, one is added.
|
|
|
|
*
|
|
|
|
* Enable skip_comments to skip every line starting with comment
|
|
|
|
* character.
|
|
|
|
*/
|
|
|
|
void strbuf_stripspace(struct strbuf *sb, int skip_comments)
|
|
|
|
{
|
2018-07-24 10:51:08 +00:00
|
|
|
size_t empties = 0;
|
2015-10-16 15:16:42 +00:00
|
|
|
size_t i, j, len, newlen;
|
|
|
|
char *eol;
|
|
|
|
|
|
|
|
/* We may have to add a newline. */
|
|
|
|
strbuf_grow(sb, 1);
|
|
|
|
|
|
|
|
for (i = j = 0; i < sb->len; i += len, j += newlen) {
|
|
|
|
eol = memchr(sb->buf + i, '\n', sb->len - i);
|
|
|
|
len = eol ? eol - (sb->buf + i) + 1 : sb->len - i;
|
|
|
|
|
|
|
|
if (skip_comments && len && sb->buf[i] == comment_line_char) {
|
|
|
|
newlen = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
newlen = cleanup(sb->buf + i, len);
|
|
|
|
|
|
|
|
/* Not just an empty line? */
|
|
|
|
if (newlen) {
|
|
|
|
if (empties > 0 && j > 0)
|
|
|
|
sb->buf[j++] = '\n';
|
|
|
|
empties = 0;
|
|
|
|
memmove(sb->buf + j, sb->buf + i, newlen);
|
|
|
|
sb->buf[newlen + j++] = '\n';
|
|
|
|
} else {
|
|
|
|
empties++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_setlen(sb, j);
|
|
|
|
}
|
link_alt_odb_entry: handle normalize_path errors
When we add a new alternate to the list, we try to normalize
out any redundant "..", etc. However, we do not look at the
return value of normalize_path_copy(), and will happily
continue with a path that could not be normalized. Worse,
the normalizing process is done in-place, so we are left
with whatever half-finished working state the normalizing
function was in.
Fortunately, this cannot cause us to read past the end of
our buffer, as that working state will always leave the
NUL from the original path in place. And we do tend to
notice problems when we check is_directory() on the path.
But you can see the nonsense that we feed to is_directory
with an entry like:
this/../../is/../../way/../../too/../../deep/../../to/../../resolve
in your objects/info/alternates, which yields:
error: object directory
/to/e/deep/too/way//ects/this/../../is/../../way/../../too/../../deep/../../to/../../resolve
does not exist; check .git/objects/info/alternates.
We can easily fix this just by checking the return value.
But that makes it hard to generate a good error message,
since we're normalizing in-place and our input value has
been overwritten by cruft.
Instead, let's provide a strbuf helper that does an in-place
normalize, but restores the original contents on error. This
uses a second buffer under the hood, which is slightly less
efficient, but this is not a performance-critical code path.
The strbuf helper can also properly set the "len" parameter
of the strbuf before returning. Just doing:
normalize_path_copy(buf.buf, buf.buf);
will shorten the string, but leave buf.len at the original
length. That may be confusing to later code which uses the
strbuf.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-03 20:34:17 +00:00
|
|
|
|
|
|
|
int strbuf_normalize_path(struct strbuf *src)
|
|
|
|
{
|
|
|
|
struct strbuf dst = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_grow(&dst, src->len);
|
|
|
|
if (normalize_path_copy(dst.buf, src->buf) < 0) {
|
|
|
|
strbuf_release(&dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* normalize_path does not tell us the new length, so we have to
|
|
|
|
* compute it by looking for the new NUL it placed
|
|
|
|
*/
|
|
|
|
strbuf_setlen(&dst, strlen(dst.buf));
|
|
|
|
strbuf_swap(src, &dst);
|
|
|
|
strbuf_release(&dst);
|
|
|
|
return 0;
|
|
|
|
}
|
2019-12-13 08:08:00 +00:00
|
|
|
|
2022-12-22 15:14:14 +00:00
|
|
|
void strbuf_strip_file_from_path(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
char *path_sep = find_last_dir_sep(sb->buf);
|
|
|
|
strbuf_setlen(sb, path_sep ? path_sep - sb->buf + 1 : 0);
|
|
|
|
}
|