buffer.c 14.4 KB
Newer Older
Vicent Marti committed
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
Vicent Marti committed
3 4 5 6
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
7 8
#include "buffer.h"
#include "posix.h"
9
#include "git2/buffer.h"
joshaber committed
10
#include "buf_text.h"
11
#include <ctype.h>
12

13 14 15
/* Used as default value for git_buf->ptr so that people can always
 * assume ptr is non-NULL and zero terminated even for new git_bufs.
 */
16
char git_buf__initbuf[1];
17

18
char git_buf__oom[1];
19

20
#define ENSURE_SIZE(b, d) \
21 22
	if ((d) > buf->asize && git_buf_grow(b, (d)) < 0)\
		return -1;
23

24

25 26 27 28
void git_buf_init(git_buf *buf, size_t initial_size)
{
	buf->asize = 0;
	buf->size = 0;
29
	buf->ptr = git_buf__initbuf;
30 31 32 33 34

	if (initial_size)
		git_buf_grow(buf, initial_size);
}

35 36
int git_buf_try_grow(
	git_buf *buf, size_t target_size, bool mark_oom, bool preserve_external)
37
{
38
	char *new_ptr;
39
	size_t new_size;
40

41
	if (buf->ptr == git_buf__oom)
42
		return -1;
43

44 45 46
	if (!target_size)
		target_size = buf->size;

47
	if (target_size <= buf->asize)
48
		return 0;
49

50 51 52 53
	if (buf->asize == 0) {
		new_size = target_size;
		new_ptr = NULL;
	} else {
54
		new_size = buf->asize;
55 56
		new_ptr = buf->ptr;
	}
57 58 59

	/* grow the buffer size by 1.5, until it's big enough
	 * to fit our target size */
60 61
	while (new_size < target_size)
		new_size = (new_size << 1) - (new_size >> 1);
62

63
	/* round allocation up to multiple of 8 */
64
	new_size = (new_size + 7) & ~7;
65

66
	new_ptr = git__realloc(new_ptr, new_size);
67 68

	if (!new_ptr) {
69
		if (mark_oom) {
70 71
			if (buf->ptr && (buf->ptr != git_buf__initbuf))
				git__free(buf->ptr);
72
			buf->ptr = git_buf__oom;
73
		}
74
		return -1;
75
	}
76

77 78 79
	if (preserve_external && !buf->asize && buf->ptr != NULL && buf->size > 0)
		memcpy(new_ptr, buf->ptr, min(buf->size, new_size));

80 81 82 83 84 85 86 87
	buf->asize = new_size;
	buf->ptr   = new_ptr;

	/* truncate the existing buffer size if necessary */
	if (buf->size >= buf->asize)
		buf->size = buf->asize - 1;
	buf->ptr[buf->size] = '\0';

88
	return 0;
89 90
}

91 92 93 94 95
int git_buf_grow(git_buf *buffer, size_t target_size)
{
	return git_buf_try_grow(buffer, target_size, true, true);
}

96 97 98 99
void git_buf_free(git_buf *buf)
{
	if (!buf) return;

100
	if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_buf__oom)
101 102 103 104 105
		git__free(buf->ptr);

	git_buf_init(buf, 0);
}

106 107 108
void git_buf_sanitize(git_buf *buf)
{
	if (buf->ptr == NULL) {
109
		assert(buf->size == 0 && buf->asize == 0);
110
		buf->ptr = git_buf__initbuf;
111 112
	} else if (buf->asize > buf->size)
		buf->ptr[buf->size] = '\0';
113 114
}

115 116 117
void git_buf_clear(git_buf *buf)
{
	buf->size = 0;
118

119
	if (!buf->ptr) {
120
		buf->ptr = git_buf__initbuf;
121 122
		buf->asize = 0;
	}
123

124 125 126 127
	if (buf->asize > 0)
		buf->ptr[0] = '\0';
}

128
int git_buf_set(git_buf *buf, const void *data, size_t len)
129 130 131 132
{
	if (len == 0 || data == NULL) {
		git_buf_clear(buf);
	} else {
133 134 135 136
		if (data != buf->ptr) {
			ENSURE_SIZE(buf, len + 1);
			memmove(buf->ptr, data, len);
		}
137

138
		buf->size = len;
139 140 141
		if (buf->asize > buf->size)
			buf->ptr[buf->size] = '\0';

142
	}
143
	return 0;
144 145
}

joshaber committed
146 147 148 149 150 151 152 153 154 155
int git_buf_is_binary(const git_buf *buf)
{
	return git_buf_text_is_binary(buf);
}

int git_buf_contains_nul(const git_buf *buf)
{
	return git_buf_text_contains_nul(buf);
}

156
int git_buf_sets(git_buf *buf, const char *string)
157
{
158
	return git_buf_set(buf, string, string ? strlen(string) : 0);
159 160
}

161
int git_buf_putc(git_buf *buf, char c)
162
{
163
	ENSURE_SIZE(buf, buf->size + 2);
164
	buf->ptr[buf->size++] = c;
165
	buf->ptr[buf->size] = '\0';
166
	return 0;
167 168
}

169 170 171 172 173 174 175 176 177
int git_buf_putcn(git_buf *buf, char c, size_t len)
{
	ENSURE_SIZE(buf, buf->size + len + 1);
	memset(buf->ptr + buf->size, c, len);
	buf->size += len;
	buf->ptr[buf->size] = '\0';
	return 0;
}

178
int git_buf_put(git_buf *buf, const char *data, size_t len)
179
{
180 181 182 183 184 185 186
	if (len) {
		assert(data);
		ENSURE_SIZE(buf, buf->size + len + 1);
		memmove(buf->ptr + buf->size, data, len);
		buf->size += len;
		buf->ptr[buf->size] = '\0';
	}
187
	return 0;
188 189
}

190
int git_buf_puts(git_buf *buf, const char *string)
191
{
192
	assert(string);
193
	return git_buf_put(buf, string, strlen(string));
194 195
}

196
static const char base64_encode[] =
197 198
	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

199
int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
200 201 202 203 204
{
	size_t extra = len % 3;
	uint8_t *write, a, b, c;
	const uint8_t *read = (const uint8_t *)data;

205
	ENSURE_SIZE(buf, buf->size + 4 * ((len / 3) + !!extra) + 1);
206 207 208 209 210 211 212 213
	write = (uint8_t *)&buf->ptr[buf->size];

	/* convert each run of 3 bytes into 4 output bytes */
	for (len -= extra; len > 0; len -= 3) {
		a = *read++;
		b = *read++;
		c = *read++;

214 215 216 217
		*write++ = base64_encode[a >> 2];
		*write++ = base64_encode[(a & 0x03) << 4 | b >> 4];
		*write++ = base64_encode[(b & 0x0f) << 2 | c >> 6];
		*write++ = base64_encode[c & 0x3f];
218 219 220 221 222 223
	}

	if (extra > 0) {
		a = *read++;
		b = (extra > 1) ? *read++ : 0;

224 225 226
		*write++ = base64_encode[a >> 2];
		*write++ = base64_encode[(a & 0x03) << 4 | b >> 4];
		*write++ = (extra > 1) ? base64_encode[(b & 0x0f) << 2] : '=';
227 228 229 230 231 232 233 234 235
		*write++ = '=';
	}

	buf->size = ((char *)write) - buf->ptr;
	buf->ptr[buf->size] = '\0';

	return 0;
}

236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
/* The inverse of base64_encode, offset by '+' == 43. */
static const int8_t base64_decode[] = {
	62,
	-1, -1, -1,
	63,
	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	-1, -1, -1, 0, -1, -1, -1,
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
	13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	-1, -1, -1, -1, -1, -1,
	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
	39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
};

#define BASE64_DECODE_VALUE(c) (((c) < 43 || (c) > 122) ? -1 : base64_decode[c - 43])

int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
{
	size_t i;
	int8_t a, b, c, d;
	size_t orig_size = buf->size;

	assert(len % 4 == 0);
	ENSURE_SIZE(buf, buf->size + (len / 4 * 3) + 1);

	for (i = 0; i < len; i += 4) {
		if ((a = BASE64_DECODE_VALUE(base64[i])) < 0 ||
			(b = BASE64_DECODE_VALUE(base64[i+1])) < 0 ||
			(c = BASE64_DECODE_VALUE(base64[i+2])) < 0 ||
			(d = BASE64_DECODE_VALUE(base64[i+3])) < 0) {
			buf->size = orig_size;
			buf->ptr[buf->size] = '\0';

			giterr_set(GITERR_INVALID, "Invalid base64 input");
			return -1;
		}

		buf->ptr[buf->size++] = ((a << 2) | (b & 0x30) >> 4);
		buf->ptr[buf->size++] = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
		buf->ptr[buf->size++] = (c & 0x03) << 6 | (d & 0x3f);
	}

	buf->ptr[buf->size] = '\0';
	return 0;
}

282 283 284
static const char b85str[] =
	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";

285
int git_buf_encode_base85(git_buf *buf, const char *data, size_t len)
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
{
	ENSURE_SIZE(buf, buf->size + (5 * ((len / 4) + !!(len % 4))) + 1);

	while (len) {
		uint32_t acc = 0;
		char b85[5];
		int i;

		for (i = 24; i >= 0; i -= 8) {
			uint8_t ch = *data++;
			acc |= ch << i;

			if (--len == 0)
				break;
		}

		for (i = 4; i >= 0; i--) {
			int val = acc % 85;
			acc /= 85;

			b85[i] = b85str[val];
		}

		for (i = 0; i < 5; i++)
			buf->ptr[buf->size++] = b85[i];
	}

	buf->ptr[buf->size] = '\0';

	return 0;
}

318
int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
319 320
{
	int len;
321
	const size_t expected_size = buf->size + (strlen(format) * 2);
322

323
	ENSURE_SIZE(buf, expected_size);
324 325

	while (1) {
326 327 328 329 330 331 332 333
		va_list args;
		va_copy(args, ap);

		len = p_vsnprintf(
			buf->ptr + buf->size,
			buf->asize - buf->size,
			format, args
		);
334

335 336
		va_end(args);

337
		if (len < 0) {
338
			git__free(buf->ptr);
339
			buf->ptr = git_buf__oom;
340
			return -1;
341 342
		}

343
		if ((size_t)len + 1 <= buf->asize - buf->size) {
344
			buf->size += len;
345
			break;
346 347 348 349
		}

		ENSURE_SIZE(buf, buf->size + len + 1);
	}
350

351
	return 0;
352 353
}

354 355 356 357 358 359 360 361 362 363 364 365
int git_buf_printf(git_buf *buf, const char *format, ...)
{
	int r;
	va_list ap;

	va_start(ap, format);
	r = git_buf_vprintf(buf, format, ap);
	va_end(ap);

	return r;
}

366
void git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf)
367 368 369
{
	size_t copylen;

370
	assert(data && datasize && buf);
371 372 373 374 375 376 377 378 379 380 381

	data[0] = '\0';

	if (buf->size == 0 || buf->asize <= 0)
		return;

	copylen = buf->size;
	if (copylen > datasize - 1)
		copylen = datasize - 1;
	memmove(data, buf->ptr, copylen);
	data[copylen] = '\0';
382 383
}

384 385
void git_buf_consume(git_buf *buf, const char *end)
{
386 387 388 389
	if (end > buf->ptr && end <= buf->ptr + buf->size) {
		size_t consumed = end - buf->ptr;
		memmove(buf->ptr, end, buf->size - consumed);
		buf->size -= consumed;
390
		buf->ptr[buf->size] = '\0';
391 392 393
	}
}

394
void git_buf_truncate(git_buf *buf, size_t len)
395
{
396 397 398 399 400
	if (len >= buf->size)
		return;

	buf->size = len;
	if (buf->size < buf->asize)
401 402 403
		buf->ptr[buf->size] = '\0';
}

404 405
void git_buf_shorten(git_buf *buf, size_t amount)
{
406 407 408 409
	if (buf->size > amount)
		git_buf_truncate(buf, buf->size - amount);
	else
		git_buf_clear(buf);
410 411
}

412 413
void git_buf_rtruncate_at_char(git_buf *buf, char separator)
{
414 415
	ssize_t idx = git_buf_rfind_next(buf, separator);
	git_buf_truncate(buf, idx < 0 ? 0 : (size_t)idx);
416 417
}

418 419 420 421 422
void git_buf_swap(git_buf *buf_a, git_buf *buf_b)
{
	git_buf t = *buf_a;
	*buf_a = *buf_b;
	*buf_b = t;
423
}
424

425
char *git_buf_detach(git_buf *buf)
426
{
427
	char *data = buf->ptr;
428

429
	if (buf->asize == 0 || buf->ptr == git_buf__oom)
430 431
		return NULL;

432
	git_buf_init(buf, 0);
433 434 435 436

	return data;
}

437
void git_buf_attach(git_buf *buf, char *ptr, size_t asize)
438
{
439 440 441 442 443 444 445 446 447 448 449 450 451
	git_buf_free(buf);

	if (ptr) {
		buf->ptr = ptr;
		buf->size = strlen(ptr);
		if (asize)
			buf->asize = (asize < buf->size) ? buf->size + 1 : asize;
		else /* pass 0 to fall back on strlen + 1 */
			buf->asize = buf->size + 1;
	} else {
		git_buf_grow(buf, asize);
	}
}
452

453 454
int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
{
455
	va_list ap;
456
	int i;
457 458
	size_t total_size = 0, original_size = buf->size;
	char *out, *original = buf->ptr;
459 460 461 462

	if (buf->size > 0 && buf->ptr[buf->size - 1] != separator)
		++total_size; /* space for initial separator */

463 464
	/* Make two passes to avoid multiple reallocation */

465 466 467
	va_start(ap, nbuf);
	for (i = 0; i < nbuf; ++i) {
		const char* segment;
468
		size_t segment_len;
469 470 471 472 473 474 475 476 477 478 479 480

		segment = va_arg(ap, const char *);
		if (!segment)
			continue;

		segment_len = strlen(segment);
		total_size += segment_len;
		if (segment_len == 0 || segment[segment_len - 1] != separator)
			++total_size; /* space for separator */
	}
	va_end(ap);

481
	/* expand buffer if needed */
482 483 484
	if (total_size == 0)
		return 0;
	if (git_buf_grow(buf, buf->size + total_size + 1) < 0)
485
		return -1;
486 487 488 489 490 491 492 493 494 495

	out = buf->ptr + buf->size;

	/* append separator to existing buf if needed */
	if (buf->size > 0 && out[-1] != separator)
		*out++ = separator;

	va_start(ap, nbuf);
	for (i = 0; i < nbuf; ++i) {
		const char* segment;
496
		size_t segment_len;
497 498 499 500 501

		segment = va_arg(ap, const char *);
		if (!segment)
			continue;

502 503 504 505 506 507 508 509 510
		/* deal with join that references buffer's original content */
		if (segment >= original && segment < original + original_size) {
			size_t offset = (segment - original);
			segment = buf->ptr + offset;
			segment_len = original_size - offset;
		} else {
			segment_len = strlen(segment);
		}

511 512
		/* skip leading separators */
		if (out > buf->ptr && out[-1] == separator)
513 514 515 516
			while (segment_len > 0 && *segment == separator) {
				segment++;
				segment_len--;
			}
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

		/* copy over next buffer */
		if (segment_len > 0) {
			memmove(out, segment, segment_len);
			out += segment_len;
		}

		/* append trailing separator (except for last item) */
		if (i < nbuf - 1 && out > buf->ptr && out[-1] != separator)
			*out++ = separator;
	}
	va_end(ap);

	/* set size based on num characters actually written */
	buf->size = out - buf->ptr;
532
	buf->ptr[buf->size] = '\0';
533

534
	return 0;
535 536
}

537
int git_buf_join(
538 539 540 541 542
	git_buf *buf,
	char separator,
	const char *str_a,
	const char *str_b)
{
543
	size_t strlen_a = str_a ? strlen(str_a) : 0;
544 545
	size_t strlen_b = strlen(str_b);
	int need_sep = 0;
546 547 548
	ssize_t offset_a = -1;

	/* not safe to have str_b point internally to the buffer */
549
	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
550 551 552 553 554 555

	/* figure out if we need to insert a separator */
	if (separator && strlen_a) {
		while (*str_b == separator) { str_b++; strlen_b--; }
		if (str_a[strlen_a - 1] != separator)
			need_sep = 1;
556 557
	}

558 559 560 561
	/* str_a could be part of the buffer */
	if (str_a >= buf->ptr && str_a < buf->ptr + buf->size)
		offset_a = str_a - buf->ptr;

562 563
	if (git_buf_grow(buf, strlen_a + strlen_b + need_sep + 1) < 0)
		return -1;
564
	assert(buf->ptr);
565

566 567 568 569 570
	/* fix up internal pointers */
	if (offset_a >= 0)
		str_a = buf->ptr + offset_a;

	/* do the actual copying */
571
	if (offset_a != 0 && str_a)
572
		memmove(buf->ptr, str_a, strlen_a);
573 574
	if (need_sep)
		buf->ptr[strlen_a] = separator;
575
	memcpy(buf->ptr + strlen_a + need_sep, str_b, strlen_b);
576

577
	buf->size = strlen_a + strlen_b + need_sep;
578
	buf->ptr[buf->size] = '\0';
579

580
	return 0;
581
}
582

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
int git_buf_join3(
	git_buf *buf,
	char separator,
	const char *str_a,
	const char *str_b,
	const char *str_c)
{
	size_t len_a = strlen(str_a), len_b = strlen(str_b), len_c = strlen(str_c);
	int sep_a = 0, sep_b = 0;
	char *tgt;

	/* for this function, disallow pointers into the existing buffer */
	assert(str_a < buf->ptr || str_a >= buf->ptr + buf->size);
	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
	assert(str_c < buf->ptr || str_c >= buf->ptr + buf->size);

	if (separator) {
		if (len_a > 0) {
			while (*str_b == separator) { str_b++; len_b--; }
			sep_a = (str_a[len_a - 1] != separator);
		}
		if (len_a > 0 || len_b > 0)
			while (*str_c == separator) { str_c++; len_c--; }
		if (len_b > 0)
			sep_b = (str_b[len_b - 1] != separator);
	}

	if (git_buf_grow(buf, len_a + sep_a + len_b + sep_b + len_c + 1) < 0)
		return -1;

	tgt = buf->ptr;

	if (len_a) {
		memcpy(tgt, str_a, len_a);
		tgt += len_a;
	}
	if (sep_a)
		*tgt++ = separator;
	if (len_b) {
		memcpy(tgt, str_b, len_b);
		tgt += len_b;
	}
	if (sep_b)
		*tgt++ = separator;
	if (len_c)
		memcpy(tgt, str_c, len_c);

	buf->size = len_a + sep_a + len_b + sep_b + len_c;
	buf->ptr[buf->size] = '\0';

	return 0;
}

636 637 638
void git_buf_rtrim(git_buf *buf)
{
	while (buf->size > 0) {
639
		if (!git__isspace(buf->ptr[buf->size - 1]))
640 641 642 643
			break;

		buf->size--;
	}
644

645 646
	if (buf->asize > buf->size)
		buf->ptr[buf->size] = '\0';
647
}
648 649 650 651 652 653 654

int git_buf_cmp(const git_buf *a, const git_buf *b)
{
	int result = memcmp(a->ptr, b->ptr, min(a->size, b->size));
	return (result != 0) ? result :
		(a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
}
655

656 657 658 659 660 661 662 663 664 665 666 667 668 669
int git_buf_splice(
	git_buf *buf,
	size_t where,
	size_t nb_to_remove,
	const char *data,
	size_t nb_to_insert)
{
	assert(buf &&
		where <= git_buf_len(buf) &&
		where + nb_to_remove <= git_buf_len(buf));

	/* Ported from git.git
	 * https://github.com/git/git/blob/16eed7c/strbuf.c#L159-176
	 */
670
	ENSURE_SIZE(buf, buf->size + nb_to_insert - nb_to_insert + 1);
671 672 673 674 675 676 677 678 679 680 681

	memmove(buf->ptr + where + nb_to_insert,
			buf->ptr + where + nb_to_remove,
			buf->size - where - nb_to_remove);

	memcpy(buf->ptr + where, data, nb_to_insert);

	buf->size = buf->size + nb_to_insert - nb_to_remove;
	buf->ptr[buf->size] = '\0';
	return 0;
}