thodg/libgit2/src/buffer.c

• Show log

  Commit

• Hash : caab22c0
  Author :
  Date : 2015-06-23T15:41:58
  

  buffer: don't allow growing borrowed buffers When we don't own a buffer (asize=0) we currently allow the usage of grow to copy the memory into a buffer we do own. This muddles the meaning of grow, and lets us be a bit cavalier with ownership semantics. Don't allow this any more. Usage of grow should be restricted to buffers which we know own their own memory. If unsure, we must not attempt to modify it.

Download

• src/buffer.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  #include "buffer.h"
  #include "posix.h"
  #include "git2/buffer.h"
  #include "buf_text.h"
  #include <ctype.h>
  
  /* 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.
   */
  char git_buf__initbuf[1];
  
  char git_buf__oom[1];
  
  #define ENSURE_SIZE(b, d) \
  	if ((d) > buf->asize && git_buf_grow(b, (d)) < 0)\
  		return -1;
  
  
  void git_buf_init(git_buf *buf, size_t initial_size)
  {
  	buf->asize = 0;
  	buf->size = 0;
  	buf->ptr = git_buf__initbuf;
  
  	if (initial_size)
  		git_buf_grow(buf, initial_size);
  }
  
  int git_buf_try_grow(
  	git_buf *buf, size_t target_size, bool mark_oom)
  {
  	char *new_ptr;
  	size_t new_size;
  
  	if (buf->ptr == git_buf__oom)
  		return -1;
  
  	if (buf->asize == 0 && buf->size != 0)
  		return GIT_EINVALIDSPEC;
  
  	if (!target_size)
  		target_size = buf->size;
  
  	if (target_size <= buf->asize)
  		return 0;
  
  	if (buf->asize == 0) {
  		new_size = target_size;
  		new_ptr = NULL;
  	} else {
  		new_size = buf->asize;
  		new_ptr = buf->ptr;
  	}
  
  	/* grow the buffer size by 1.5, until it's big enough
  	 * to fit our target size */
  	while (new_size < target_size)
  		new_size = (new_size << 1) - (new_size >> 1);
  
  	/* round allocation up to multiple of 8 */
  	new_size = (new_size + 7) & ~7;
  
  	if (new_size < buf->size) {
  		if (mark_oom)
  			buf->ptr = git_buf__oom;
  
  		giterr_set_oom();
  		return -1;
  	}
  
  	new_ptr = git__realloc(new_ptr, new_size);
  
  	if (!new_ptr) {
  		if (mark_oom) {
  			if (buf->ptr && (buf->ptr != git_buf__initbuf))
  				git__free(buf->ptr);
  			buf->ptr = git_buf__oom;
  		}
  		return -1;
  	}
  
  	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';
  
  	return 0;
  }
  
  int git_buf_grow(git_buf *buffer, size_t target_size)
  {
  	return git_buf_try_grow(buffer, target_size, true);
  }
  
  int git_buf_grow_by(git_buf *buffer, size_t additional_size)
  {
  	size_t newsize;
  
  	if (GIT_ADD_SIZET_OVERFLOW(&newsize, buffer->size, additional_size)) {
  		buffer->ptr = git_buf__oom;
  		return -1;
  	}
  
  	return git_buf_try_grow(buffer, newsize, true);
  }
  
  void git_buf_free(git_buf *buf)
  {
  	if (!buf) return;
  
  	if (buf->asize > 0 && buf->ptr != NULL && buf->ptr != git_buf__oom)
  		git__free(buf->ptr);
  
  	git_buf_init(buf, 0);
  }
  
  void git_buf_sanitize(git_buf *buf)
  {
  	if (buf->ptr == NULL) {
  		assert(buf->size == 0 && buf->asize == 0);
  		buf->ptr = git_buf__initbuf;
  	} else if (buf->asize > buf->size)
  		buf->ptr[buf->size] = '\0';
  }
  
  void git_buf_clear(git_buf *buf)
  {
  	buf->size = 0;
  
  	if (!buf->ptr) {
  		buf->ptr = git_buf__initbuf;
  		buf->asize = 0;
  	}
  
  	if (buf->asize > 0)
  		buf->ptr[0] = '\0';
  }
  
  int git_buf_set(git_buf *buf, const void *data, size_t len)
  {
  	size_t alloclen;
  
  	if (len == 0 || data == NULL) {
  		git_buf_clear(buf);
  	} else {
  		if (data != buf->ptr) {
  			GITERR_CHECK_ALLOC_ADD(&alloclen, len, 1);
  			ENSURE_SIZE(buf, alloclen);
  			memmove(buf->ptr, data, len);
  		}
  
  		buf->size = len;
  		if (buf->asize > buf->size)
  			buf->ptr[buf->size] = '\0';
  
  	}
  	return 0;
  }
  
  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);
  }
  
  int git_buf_sets(git_buf *buf, const char *string)
  {
  	return git_buf_set(buf, string, string ? strlen(string) : 0);
  }
  
  int git_buf_putc(git_buf *buf, char c)
  {
  	size_t new_size;
  	GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, 2);
  	ENSURE_SIZE(buf, new_size);
  	buf->ptr[buf->size++] = c;
  	buf->ptr[buf->size] = '\0';
  	return 0;
  }
  
  int git_buf_putcn(git_buf *buf, char c, size_t len)
  {
  	size_t new_size;
  	GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
  	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
  	ENSURE_SIZE(buf, new_size);
  	memset(buf->ptr + buf->size, c, len);
  	buf->size += len;
  	buf->ptr[buf->size] = '\0';
  	return 0;
  }
  
  int git_buf_put(git_buf *buf, const char *data, size_t len)
  {
  	if (len) {
  		size_t new_size;
  
  		assert(data);
  		
  		GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
  		GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
  		ENSURE_SIZE(buf, new_size);
  		memmove(buf->ptr + buf->size, data, len);
  		buf->size += len;
  		buf->ptr[buf->size] = '\0';
  	}
  	return 0;
  }
  
  int git_buf_puts(git_buf *buf, const char *string)
  {
  	assert(string);
  	return git_buf_put(buf, string, strlen(string));
  }
  
  static const char base64_encode[] =
  	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  
  int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
  {
  	size_t extra = len % 3;
  	uint8_t *write, a, b, c;
  	const uint8_t *read = (const uint8_t *)data;
  	size_t blocks = (len / 3) + !!extra, alloclen;
  
  	GITERR_CHECK_ALLOC_ADD(&blocks, blocks, 1);
  	GITERR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 4);
  	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
  
  	ENSURE_SIZE(buf, alloclen);
  	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++;
  
  		*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];
  	}
  
  	if (extra > 0) {
  		a = *read++;
  		b = (extra > 1) ? *read++ : 0;
  
  		*write++ = base64_encode[a >> 2];
  		*write++ = base64_encode[(a & 0x03) << 4 | b >> 4];
  		*write++ = (extra > 1) ? base64_encode[(b & 0x0f) << 2] : '=';
  		*write++ = '=';
  	}
  
  	buf->size = ((char *)write) - buf->ptr;
  	buf->ptr[buf->size] = '\0';
  
  	return 0;
  }
  
  /* 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, new_size;
  
  	assert(len % 4 == 0);
  	GITERR_CHECK_ALLOC_ADD(&new_size, (len / 4 * 3), buf->size);
  	GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
  	ENSURE_SIZE(buf, new_size);
  
  	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;
  }
  
  static const char b85str[] =
  	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
  
  int git_buf_encode_base85(git_buf *buf, const char *data, size_t len)
  {
  	size_t blocks = (len / 4) + !!(len % 4), alloclen;
  
  	GITERR_CHECK_ALLOC_MULTIPLY(&alloclen, blocks, 5);
  	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, buf->size);
  	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
  
  	ENSURE_SIZE(buf, alloclen);
  
  	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;
  }
  
  int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
  {
  	size_t expected_size, new_size;
  	int len;
  
  	GITERR_CHECK_ALLOC_MULTIPLY(&expected_size, strlen(format), 2);
  	GITERR_CHECK_ALLOC_ADD(&expected_size, expected_size, buf->size);
  	ENSURE_SIZE(buf, expected_size);
  
  	while (1) {
  		va_list args;
  		va_copy(args, ap);
  
  		len = p_vsnprintf(
  			buf->ptr + buf->size,
  			buf->asize - buf->size,
  			format, args
  		);
  
  		va_end(args);
  
  		if (len < 0) {
  			git__free(buf->ptr);
  			buf->ptr = git_buf__oom;
  			return -1;
  		}
  
  		if ((size_t)len + 1 <= buf->asize - buf->size) {
  			buf->size += len;
  			break;
  		}
  
  		GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, len);
  		GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
  		ENSURE_SIZE(buf, new_size);
  	}
  
  	return 0;
  }
  
  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;
  }
  
  void git_buf_copy_cstr(char *data, size_t datasize, const git_buf *buf)
  {
  	size_t copylen;
  
  	assert(data && datasize && buf);
  
  	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';
  }
  
  void git_buf_consume(git_buf *buf, const char *end)
  {
  	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;
  		buf->ptr[buf->size] = '\0';
  	}
  }
  
  void git_buf_truncate(git_buf *buf, size_t len)
  {
  	if (len >= buf->size)
  		return;
  
  	buf->size = len;
  	if (buf->size < buf->asize)
  		buf->ptr[buf->size] = '\0';
  }
  
  void git_buf_shorten(git_buf *buf, size_t amount)
  {
  	if (buf->size > amount)
  		git_buf_truncate(buf, buf->size - amount);
  	else
  		git_buf_clear(buf);
  }
  
  void git_buf_rtruncate_at_char(git_buf *buf, char separator)
  {
  	ssize_t idx = git_buf_rfind_next(buf, separator);
  	git_buf_truncate(buf, idx < 0 ? 0 : (size_t)idx);
  }
  
  void git_buf_swap(git_buf *buf_a, git_buf *buf_b)
  {
  	git_buf t = *buf_a;
  	*buf_a = *buf_b;
  	*buf_b = t;
  }
  
  char *git_buf_detach(git_buf *buf)
  {
  	char *data = buf->ptr;
  
  	if (buf->asize == 0 || buf->ptr == git_buf__oom)
  		return NULL;
  
  	git_buf_init(buf, 0);
  
  	return data;
  }
  
  void git_buf_attach(git_buf *buf, char *ptr, size_t asize)
  {
  	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);
  	}
  }
  
  void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size)
  {
  	if (git_buf_is_allocated(buf))
  		git_buf_free(buf);
  
  	if (!size) {
  		git_buf_init(buf, 0);
  	} else {
  		buf->ptr = (char *)ptr;
  		buf->asize = 0;
  		buf->size = size;
  	}
  }
  
  int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...)
  {
  	va_list ap;
  	int i;
  	size_t total_size = 0, original_size = buf->size;
  	char *out, *original = buf->ptr;
  
  	if (buf->size > 0 && buf->ptr[buf->size - 1] != separator)
  		++total_size; /* space for initial separator */
  
  	/* Make two passes to avoid multiple reallocation */
  
  	va_start(ap, nbuf);
  	for (i = 0; i < nbuf; ++i) {
  		const char* segment;
  		size_t segment_len;
  
  		segment = va_arg(ap, const char *);
  		if (!segment)
  			continue;
  
  		segment_len = strlen(segment);
  
  		GITERR_CHECK_ALLOC_ADD(&total_size, total_size, segment_len);
  
  		if (segment_len == 0 || segment[segment_len - 1] != separator)
  			GITERR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
  	}
  	va_end(ap);
  
  	/* expand buffer if needed */
  	if (total_size == 0)
  		return 0;
  
  	GITERR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
  	if (git_buf_grow_by(buf, total_size) < 0)
  		return -1;
  
  	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;
  		size_t segment_len;
  
  		segment = va_arg(ap, const char *);
  		if (!segment)
  			continue;
  
  		/* 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);
  		}
  
  		/* skip leading separators */
  		if (out > buf->ptr && out[-1] == separator)
  			while (segment_len > 0 && *segment == separator) {
  				segment++;
  				segment_len--;
  			}
  
  		/* 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;
  	buf->ptr[buf->size] = '\0';
  
  	return 0;
  }
  
  int git_buf_join(
  	git_buf *buf,
  	char separator,
  	const char *str_a,
  	const char *str_b)
  {
  	size_t strlen_a = str_a ? strlen(str_a) : 0;
  	size_t strlen_b = strlen(str_b);
  	size_t alloc_len;
  	int need_sep = 0;
  	ssize_t offset_a = -1;
  
  	/* not safe to have str_b point internally to the buffer */
  	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
  
  	/* 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;
  	}
  
  	/* 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;
  
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, strlen_a, strlen_b);
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, need_sep);
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 1);
  	if (git_buf_grow(buf, alloc_len) < 0)
  		return -1;
  	assert(buf->ptr);
  
  	/* fix up internal pointers */
  	if (offset_a >= 0)
  		str_a = buf->ptr + offset_a;
  
  	/* do the actual copying */
  	if (offset_a != 0 && str_a)
  		memmove(buf->ptr, str_a, strlen_a);
  	if (need_sep)
  		buf->ptr[strlen_a] = separator;
  	memcpy(buf->ptr + strlen_a + need_sep, str_b, strlen_b);
  
  	buf->size = strlen_a + strlen_b + need_sep;
  	buf->ptr[buf->size] = '\0';
  
  	return 0;
  }
  
  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),
  		len_total;
  	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);
  	}
  
  	GITERR_CHECK_ALLOC_ADD(&len_total, len_a, sep_a);
  	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, len_b);
  	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, sep_b);
  	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, len_c);
  	GITERR_CHECK_ALLOC_ADD(&len_total, len_total, 1);
  	if (git_buf_grow(buf, len_total) < 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;
  }
  
  void git_buf_rtrim(git_buf *buf)
  {
  	while (buf->size > 0) {
  		if (!git__isspace(buf->ptr[buf->size - 1]))
  			break;
  
  		buf->size--;
  	}
  
  	if (buf->asize > buf->size)
  		buf->ptr[buf->size] = '\0';
  }
  
  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;
  }
  
  int git_buf_splice(
  	git_buf *buf,
  	size_t where,
  	size_t nb_to_remove,
  	const char *data,
  	size_t nb_to_insert)
  {
  	char *splice_loc;
  	size_t new_size, alloc_size;
  
  	assert(buf && where <= buf->size && nb_to_remove <= buf->size - where);
  
  	splice_loc = buf->ptr + where;
  
  	/* Ported from git.git
  	 * https://github.com/git/git/blob/16eed7c/strbuf.c#L159-176
  	 */
  	GITERR_CHECK_ALLOC_ADD(&new_size, (buf->size - nb_to_remove), nb_to_insert);
  	GITERR_CHECK_ALLOC_ADD(&alloc_size, new_size, 1);
  	ENSURE_SIZE(buf, alloc_size);
  
  	memmove(splice_loc + nb_to_insert,
  		splice_loc + nb_to_remove,
  		buf->size - where - nb_to_remove);
  
  	memcpy(splice_loc, data, nb_to_insert);
  
  	buf->size = new_size;
  	buf->ptr[buf->size] = '\0';
  	return 0;
  }
  

Download