rugged 1.9.0 → 1.9.4

data/vendor/libgit2/src/libgit2/transports/credential.c

@@ -161,7 +161,7 @@ static void ssh_custom_free(struct git_credential *cred)
 
 	if (c->publickey) {
 		/* Zero the memory which previously held the publickey */
-		size_t key_len = strlen(c->publickey);
+		size_t key_len = c->publickey_len;
 		git__memzero(c->publickey, key_len);
 		git__free(c->publickey);
 	}

data/vendor/libgit2/src/libgit2/transports/git.c

@@ -39,7 +39,7 @@ typedef struct {
  */
 static int gen_proto(git_str *request, const char *cmd, const char *url)
 {
-	char *delim, *repo;
+	const char *delim, *repo;
 	char host[] = "host=";
 	size_t len;
 

data/vendor/libgit2/src/libgit2/transports/httpclient.c

@@ -379,7 +379,7 @@ static int on_headers_complete(git_http_parser *parser)
 	ctx->response->resend_credentials = resend_needed(ctx->client,
 	                                                  ctx->response);
 
-	if (ctx->response->content_type || ctx->response->chunked)
+	if (ctx->response->content_length || ctx->response->chunked)
 		ctx->client->state = READING_BODY;
 	else
 		ctx->client->state = DONE;
@@ -553,7 +553,7 @@ static int apply_credentials(
 {
 	git_http_auth_context *auth = server->auth_context;
 	git_vector *challenges = &server->auth_challenges;
-	const char *challenge;
+	const char *challenge = NULL;
 	git_str token = GIT_STR_INIT;
 	int error = 0;
 
@@ -1243,13 +1243,16 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 }
 
 /*
- * See if we've consumed the entire response body.  If the client was
- * reading the body but did not consume it entirely, it's possible that
- * they knew that the stream had finished (in a git response, seeing a
- * final flush) and stopped reading.  But if the response was chunked,
- * we may have not consumed the final chunk marker.  Consume it to
- * ensure that we don't have it waiting in our socket.  If there's
- * more than just a chunk marker, close the connection.
+ * Try to consume any remaining response body. The client may have
+ * decided that it did not need to consume the entire response body.
+ * For example, the client saw a redirect in the header and ignored
+ * the body. Or the client saw a particular sequence (like a final
+ * flush in a git response) and stopped reading (but there were
+ * additional response bytes, perhaps because the response was chunked).
+ * Do one more read to try to clear this out; this takes care of small
+ * remainders, like a chunk response or a small redirect message. If
+ * there is too much data, we'll just leave it and close the
+ * connection.
  */
 static void complete_response_body(git_http_client *client)
 {

data/vendor/libgit2/src/libgit2/transports/local.c

@@ -41,6 +41,9 @@ typedef struct {
 	git_vector refs;
 	unsigned connected : 1,
 		have_refs : 1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type;
+#endif
 } transport_local;
 
 static void free_head(git_remote_head *head)
@@ -231,6 +234,10 @@ static int local_connect(
 
 	t->repo = repo;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	t->oid_type = repo->oid_type;
+#endif
+
 	if (store_refs(t) < 0)
 		return -1;
 
@@ -267,7 +274,7 @@ static int local_oid_type(git_oid_t *out, git_transport *transport)
 {
 	transport_local *t = (transport_local *)transport;
 
-	*out = t->repo->oid_type;
+	*out = t->oid_type;
 
 	return 0;
 }

data/vendor/libgit2/src/libgit2/transports/smart.c

@@ -64,13 +64,13 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp
 
 		if (t->wrapped->close(t->wrapped) < 0)
 			return -1;
-	}
 
-	git__free(t->caps.object_format);
-	t->caps.object_format = NULL;
+		git__free(t->caps.object_format);
+		t->caps.object_format = NULL;
 
-	git__free(t->caps.agent);
-	t->caps.agent = NULL;
+		git__free(t->caps.agent);
+		t->caps.agent = NULL;
+	}
 
 	return 0;
 }

data/vendor/libgit2/src/libgit2/transports/smart_pkt.c

@@ -238,13 +238,13 @@ static int set_data(
 
 		if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0)
 			format_str = caps + CONST_STRLEN("object-format=");
-		else if ((format_str = strstr(caps, " object-format=")) != NULL)
+		else if ((format_str = git__memmem(caps, len - (caps - line), " object-format=", CONST_STRLEN(" object-format="))) != NULL)
 			format_str += CONST_STRLEN(" object-format=");
 	}
 
 	if (format_str) {
-		if ((eos = strchr(format_str, ' ')) == NULL)
-			eos = strchr(format_str, '\0');
+		if ((eos = memchr(format_str, ' ', len - (format_str - line))) == NULL)
+			eos = memchr(format_str, '\0', len - (format_str - line));
 
 		GIT_ASSERT(eos);
 

data/vendor/libgit2/src/libgit2/transports/ssh_exec.c

@@ -120,7 +120,8 @@ GIT_INLINE(int) ensure_transport_state(
 }
 
 static int get_ssh_cmdline(
-	git_str *out,
+	git_vector *args,
+	bool *use_shell,
 	ssh_exec_subtransport *transport,
 	git_net_url *url,
 	const char *command)
@@ -128,7 +129,8 @@ static int get_ssh_cmdline(
 	git_remote *remote = ((transport_smart *)transport->owner)->owner;
 	git_repository *repo = remote->repo;
 	git_config *cfg;
-	git_str ssh_cmd = GIT_STR_INIT;
+	git_str ssh_cmd = GIT_STR_INIT, url_and_host = GIT_STR_INIT,
+		remote_cmd = GIT_STR_INIT;
 	const char *default_ssh_cmd = "ssh";
 	int error;
 
@@ -151,25 +153,57 @@ static int get_ssh_cmdline(
 	if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
 		return error;
 
-	if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0)
-		;
+	if ((error = git__getenv(&ssh_cmd, "GIT_SSH_COMMAND")) == 0)
+		*use_shell = true;
+	else if (error != GIT_ENOTFOUND)
+		goto done;
+	else if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0)
+		*use_shell = false;
 	else if (error != GIT_ENOTFOUND)
 		goto done;
 	else if ((error = git_config__get_string_buf(&ssh_cmd, cfg, "core.sshcommand")) < 0 && error != GIT_ENOTFOUND)
 		goto done;
 
-	error = git_str_printf(out, "%s %s %s \"%s%s%s\" \"%s\" \"%s\"",
-		ssh_cmd.size > 0 ? ssh_cmd.ptr : default_ssh_cmd,
-		url->port_specified ? "-p" : "",
-		url->port_specified ? url->port : "",
-		url->username ? url->username : "",
-		url->username ? "@" : "",
-		url->host,
-		command,
-		url->path);
+	git_error_clear();
+
+	if (!ssh_cmd.size &&
+	    git_str_puts(&ssh_cmd, default_ssh_cmd) < 0)
+		goto done;
+
+	if ((error = git_vector_insert(args, git_str_detach(&ssh_cmd))) < 0)
+		goto done;
+
+	if (url->port_specified) {
+		char *p = git__strdup("-p");
+		char *port = git__strdup(url->port);
+
+		if (!p || !port ||
+		    (error = git_vector_insert(args, p)) < 0 ||
+		    (error = git_vector_insert(args, port)) < 0)
+			goto done;
+	}
+
+	if (url->username) {
+		if ((error = git_str_puts(&url_and_host, url->username)) < 0 ||
+		    (error = git_str_putc(&url_and_host, '@')) < 0)
+			goto done;
+	}
+
+	if ((error = git_str_puts(&url_and_host, url->host)) < 0 ||
+	    (error = git_vector_insert(args, git_str_detach(&url_and_host))) < 0)
+		goto done;
+
+	if ((error = git_str_puts(&remote_cmd, command)) < 0 ||
+	    (error = git_str_puts(&remote_cmd, " '")) < 0 ||
+	    (error = git_str_puts_escaped(&remote_cmd, url->path, "'!", "'\\", "'")) < 0 ||
+	    (error = git_str_puts(&remote_cmd, "'")) < 0 ||
+	    (error = git_vector_insert(args, git_str_detach(&remote_cmd))) < 0)
+		goto done;
 
 done:
 	git_str_dispose(&ssh_cmd);
+	git_str_dispose(&url_and_host);
+	git_str_dispose(&remote_cmd);
 	git_config_free(cfg);
 	return error;
 }
@@ -183,7 +217,8 @@ static int start_ssh(
 
 	git_process_options process_opts = GIT_PROCESS_OPTIONS_INIT;
 	git_net_url url = GIT_NET_URL_INIT;
-	git_str ssh_cmdline = GIT_STR_INIT;
+	git_vector args = GIT_VECTOR_INIT;
+	bool use_shell = false;
 	const char *command;
 	int error;
 
@@ -214,11 +249,15 @@ static int start_ssh(
 	if (error < 0)
 		goto done;
 
-	if ((error = get_ssh_cmdline(&ssh_cmdline, transport, &url, command)) < 0)
+	if ((error = get_ssh_cmdline(&args, &use_shell,
+			transport, &url, command)) < 0)
 		goto done;
 
-	if ((error = git_process_new_from_cmdline(&transport->process,
-	     ssh_cmdline.ptr, env, ARRAY_SIZE(env), &process_opts)) < 0 ||
+	process_opts.use_shell = use_shell;
+
+	if ((error = git_process_new(&transport->process,
+	     (const char **)args.contents, args.length,
+	     env, ARRAY_SIZE(env), &process_opts)) < 0 ||
 	    (error = git_process_start(transport->process)) < 0) {
 		git_process_free(transport->process);
 		transport->process = NULL;
@@ -226,7 +265,7 @@ static int start_ssh(
 	}
 
 done:
-	git_str_dispose(&ssh_cmdline);
+	git_vector_dispose_deep(&args);
 	git_net_url_dispose(&url);
 	return error;
 }

data/vendor/libgit2/src/libgit2/transports/ssh_libssh2.c

@@ -366,7 +366,7 @@ static int _git_ssh_authenticate_session(
 		default:
 			rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
 		}
-	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+	} while (LIBSSH2_ERROR_EAGAIN == rc);
 
 	if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED ||
 		rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED ||
@@ -556,7 +556,7 @@ static int _git_ssh_session_create(
 	if (git_str_len(&prefs) > 0) {
 		do {
 			rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs));
-		} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+		} while (LIBSSH2_ERROR_EAGAIN == rc);
 		if (rc != LIBSSH2_ERROR_NONE) {
 			ssh_error(s, "failed to set hostkey preference");
 			goto on_error;
@@ -566,7 +566,7 @@ static int _git_ssh_session_create(
 
 	do {
 		rc = libssh2_session_handshake(s, socket->s);
-	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+	} while (LIBSSH2_ERROR_EAGAIN == rc);
 
 	if (rc != LIBSSH2_ERROR_NONE) {
 		ssh_error(s, "failed to start SSH session");

data/vendor/libgit2/src/util/CMakeLists.txt

@@ -2,13 +2,12 @@
 
 add_library(util OBJECT)
 
-configure_file(git2_features.h.in git2_features.h)
+configure_file(git2_features.h.in "${PROJECT_BINARY_DIR}/gen_headers/git2_features.h")
 
 set(UTIL_INCLUDES
-	"${PROJECT_BINARY_DIR}/src/util"
-	"${PROJECT_BINARY_DIR}/include"
 	"${PROJECT_SOURCE_DIR}/src/util"
-	"${PROJECT_SOURCE_DIR}/include")
+	"${PROJECT_SOURCE_DIR}/include"
+	"${PROJECT_BINARY_DIR}/gen_headers")
 
 file(GLOB UTIL_SRC *.c *.h allocators/*.c allocators/*.h hash.h)
 list(SORT UTIL_SRC)

data/vendor/libgit2/src/util/fs_path.c

@@ -611,6 +611,37 @@ bool git_fs_path_isfile(const char *path)
 	return S_ISREG(st.st_mode) != 0;
 }
 
+#ifdef GIT_WIN32
+
+bool git_fs_path_isexecutable(const char *path)
+{
+	struct stat st;
+
+	GIT_ASSERT_ARG_WITH_RETVAL(path, false);
+
+	if (git__suffixcmp_icase(path, ".exe") != 0 &&
+	    git__suffixcmp_icase(path, ".cmd") != 0)
+		return false;
+
+	return (p_stat(path, &st) == 0);
+}
+
+#else
+
+bool git_fs_path_isexecutable(const char *path)
+{
+	struct stat st;
+
+	GIT_ASSERT_ARG_WITH_RETVAL(path, false);
+	if (p_stat(path, &st) < 0)
+		return false;
+
+	return S_ISREG(st.st_mode) != 0 &&
+	       ((st.st_mode & S_IXUSR) != 0);
+}
+
+#endif
+
 bool git_fs_path_islink(const char *path)
 {
 	struct stat st;
@@ -2020,9 +2051,10 @@ int git_fs_path_owner_is_system(bool *out, const char *path)
 	return git_fs_path_owner_is(out, path, GIT_FS_PATH_OWNER_ADMINISTRATOR);
 }
 
-int git_fs_path_find_executable(git_str *fullpath, const char *executable)
-{
 #ifdef GIT_WIN32
+
+static int find_executable(git_str *fullpath, const char *executable)
+{
 	git_win32_path fullpath_w, executable_w;
 	int error;
 
@@ -2035,9 +2067,15 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 		error = git_str_put_w(fullpath, fullpath_w, wcslen(fullpath_w));
 
 	return error;
+}
+
 #else
+
+static int find_executable(git_str *fullpath, const char *executable)
+{
 	git_str path = GIT_STR_INIT;
 	const char *current_dir, *term;
+	size_t current_dirlen;
 	bool found = false;
 
 	if (git__getenv(&path, "PATH") < 0)
@@ -2049,20 +2087,28 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 		if (! (term = strchr(current_dir, GIT_PATH_LIST_SEPARATOR)))
 			term = strchr(current_dir, '\0');
 
+		current_dirlen = term - current_dir;
 		git_str_clear(fullpath);
-		if (git_str_put(fullpath, current_dir, (term - current_dir)) < 0 ||
-		    git_str_putc(fullpath, '/') < 0 ||
+
+		/* An empty path segment is treated as '.' */
+		if (current_dirlen == 0 && git_str_putc(fullpath, '.'))
+			return -1;
+		else if (current_dirlen != 0 &&
+		         git_str_put(fullpath, current_dir, current_dirlen) < 0)
+			return -1;
+
+		if (git_str_putc(fullpath, '/') < 0 ||
 		    git_str_puts(fullpath, executable) < 0)
 			return -1;
 
-		if (git_fs_path_isfile(fullpath->ptr)) {
+		if (git_fs_path_isexecutable(fullpath->ptr)) {
 			found = true;
 			break;
 		}
 
 		current_dir = term;
 
-		while (*current_dir == GIT_PATH_LIST_SEPARATOR)
+		if (*current_dir == GIT_PATH_LIST_SEPARATOR)
 			current_dir++;
 	}
 
@@ -2073,5 +2119,19 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 
 	git_str_clear(fullpath);
 	return GIT_ENOTFOUND;
+}
+
 #endif
+
+int git_fs_path_find_executable(git_str *fullpath, const char *executable)
+{
+	/* For qualified paths we do not look in PATH */
+	if (strchr(executable, '/') != NULL) {
+		if (!git_fs_path_isexecutable(executable))
+			return GIT_ENOTFOUND;
+
+		return git_str_puts(fullpath, executable);
+	}
+
+	return find_executable(fullpath, executable);
 }

data/vendor/libgit2/src/util/fs_path.h

@@ -204,6 +204,12 @@ extern bool git_fs_path_isdir(const char *path);
  */
 extern bool git_fs_path_isfile(const char *path);
 
+/**
+ * Check if the given path points to an executable.
+ * @return true or false
+ */
+extern bool git_fs_path_isexecutable(const char *path);
+
 /**
  * Check if the given path points to a symbolic link.
  * @return true or false

data/vendor/libgit2/src/util/futils.h

@@ -32,9 +32,17 @@ extern int git_futils_readbuffer_fd(git_str *obj, git_file fd, size_t len);
 
 /* Additional constants for `git_futils_writebuffer`'s `open_flags`.  We
  * support these internally and they will be removed before the `open` call.
- */
-#ifndef O_FSYNC
-# define O_FSYNC (1 << 31)
+ *
+ * Not all platforms define O_FSYNC.  Fall back to O_SYNC (the POSIX
+ * standard name; O_FSYNC is a non-standard alias) when available,
+ * otherwise use a sentinel value that won't collide with real open
+ * flags.  Avoid (1 << 31) since left-shifting into the sign bit of
+ * a signed int is undefined behavior.
+ */
+#if !defined(O_FSYNC) && defined(O_SYNC)
+# define O_FSYNC O_SYNC
+#elif !defined(O_FSYNC)
+# define O_FSYNC (1 << 30)
 #endif
 
 extern int git_futils_writebuffer(

data/vendor/libgit2/src/util/hash/builtin.c

@@ -32,13 +32,23 @@ int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
 	return 0;
 }
 
-int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
+int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *_data, size_t len)
 {
+	const unsigned char *data = _data;
 	GIT_ASSERT_ARG(ctx);
-	if (SHA256Input(&ctx->c, data, len)) {
-		git_error_set(GIT_ERROR_SHA, "SHA256 error");
-		return -1;
+
+	while (len > 0) {
+		unsigned int chunk = (len > UINT_MAX) ? UINT_MAX : (unsigned int)len;
+
+		if (SHA256Input(&ctx->c, data, chunk)) {
+			git_error_set(GIT_ERROR_SHA, "SHA256 error");
+			return -1;
+		}
+
+		data += chunk;
+		len -= chunk;
 	}
+
 	return 0;
 }
 

data/vendor/libgit2/src/util/hash/openssl.c

@@ -189,8 +189,6 @@ int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 		return -1;
 	}
 
-	ctx->c = NULL;
-
 	return 0;
 }
 
@@ -339,8 +337,6 @@ int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
 		return -1;
 	}
 
-	ctx->c = NULL;
-
 	return 0;
 }
 

data/vendor/libgit2/src/util/hash/rfc6234/sha224-256.c

@@ -83,12 +83,14 @@
  * Add "length" to the length.
  * Set Corrupted when overflow has occurred.
  */
-static uint32_t addTemp;
-#define SHA224_256AddLength(context, length)               \
-  (addTemp = (context)->Length_Low, (context)->Corrupted = \
-    (((context)->Length_Low += (length)) < addTemp) &&     \
-    (++(context)->Length_High == 0) ? shaInputTooLong :    \
-                                      (context)->Corrupted )
+static int SHA224_256AddLength(SHA256Context *context, unsigned int length)
+{
+  uint32_t addTemp = context->Length_Low;
+  context->Length_Low += length;
+  if (context->Length_Low < addTemp && ++context->Length_High == 0)
+    context->Corrupted = shaInputTooLong;
+  return context->Corrupted;
+}
 
 /* Local Function Prototypes */
 static int SHA224_256Reset(SHA256Context *context, uint32_t *H0);

data/vendor/libgit2/src/util/hashmap.h

@@ -107,6 +107,7 @@ typedef uint32_t git_hashmap_iter_t;
 	} \
 	GIT_INLINE(int) name##__idx(uint32_t *out, name *h, key_t key) \
 	{ \
+		*out = UINT32_MAX; \
 		if (h->n_buckets) { \
 			uint32_t k, i, last, mask, step = 0; \
 			GIT_ASSERT((h)->flags); \

data/vendor/libgit2/src/util/net.c

@@ -184,8 +184,8 @@ static int url_parse_authority(
 	const char *authority,
 	size_t len)
 {
-	const char *c, *hostport_end, *host_end = NULL,
-	           *userpass_end, *user_end = NULL;
+	const char *c, *hostport_end = NULL, *host_end = NULL,
+	           *userpass_end = NULL, *user_end = NULL;
 
 	enum {
 		HOSTPORT, HOST, IPV6, HOST_END, USERPASS, USER
@@ -464,7 +464,7 @@ done:
 int git_net_url_parse(git_net_url *url, const char *given)
 {
 	git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
-	const char *c, *authority, *path;
+	const char *c, *authority = NULL, *path = NULL;
 	size_t authority_len = 0, path_len = 0;
 	int error = 0;
 
@@ -574,7 +574,7 @@ int git_net_url_parse_http(
 	const char *given)
 {
 	git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
-	const char *c, *authority, *path = NULL;
+	const char *c = NULL, *authority = NULL, *path = NULL;
 	size_t authority_len = 0, path_len = 0;
 	int error;
 
@@ -661,7 +661,7 @@ static bool has_at(const char *str)
 int git_net_url_parse_scp(git_net_url *url, const char *given)
 {
 	const char *default_port = default_port_for_scheme("ssh");
-	const char *c, *user, *host, *port = NULL, *path = NULL;
+	const char *c, *user = NULL, *host = NULL, *port = NULL, *path = NULL;
 	size_t user_len = 0, host_len = 0, port_len = 0;
 	unsigned short bracket = 0;
 

data/vendor/libgit2/src/util/process.h

@@ -11,7 +11,8 @@
 typedef struct git_process git_process;
 
 typedef struct {
-	unsigned int capture_in  : 1,
+	unsigned int use_shell   : 1,
+	             capture_in  : 1,
 	             capture_out : 1,
 	             capture_err : 1,
 	             exclude_env : 1;

data/vendor/libgit2/src/util/runtime.c

@@ -16,7 +16,7 @@ static git_atomic32 init_count;
 static int init_common(git_runtime_init_fn init_fns[], size_t cnt)
 {
 	size_t i;
-	int ret;
+	int ret = 0;
 
 	/* Initialize subsystems that have global state */
 	for (i = 0; i < cnt; i++) {
@@ -110,7 +110,7 @@ GIT_INLINE(int) init_unlock(void)
 
 int git_runtime_init(git_runtime_init_fn init_fns[], size_t cnt)
 {
-	int ret;
+	int ret = 0;
 
 	if (init_lock() < 0)
 		return -1;

data/vendor/libgit2/src/util/str.c

@@ -1065,10 +1065,13 @@ int git_str_puts_escaped(
 	git_str *buf,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with)
+	const char *esc_prefix,
+	const char *esc_suffix)
 {
 	const char *scan;
-	size_t total = 0, esc_len = strlen(esc_with), count, alloclen;
+	size_t total = 0, count, alloclen;
+	size_t esc_prefix_len = esc_prefix ? strlen(esc_prefix) : 0;
+	size_t esc_suffix_len = esc_suffix ? strlen(esc_suffix) : 0;
 
 	if (!string)
 		return 0;
@@ -1080,7 +1083,7 @@ int git_str_puts_escaped(
 		scan += count;
 		/* count run of escaped characters */
 		count = strspn(scan, esc_chars);
-		total += count * (esc_len + 1);
+		total += count * (esc_prefix_len + esc_suffix_len + 1);
 		scan += count;
 	}
 
@@ -1096,13 +1099,22 @@ int git_str_puts_escaped(
 		buf->size += count;
 
 		for (count = strspn(scan, esc_chars); count > 0; --count) {
-			/* copy escape sequence */
-			memmove(buf->ptr + buf->size, esc_with, esc_len);
-			buf->size += esc_len;
+			/* copy escape prefix sequence */
+			if (esc_prefix) {
+				memmove(buf->ptr + buf->size, esc_prefix, esc_prefix_len);
+				buf->size += esc_prefix_len;
+			}
+
 			/* copy character to be escaped */
 			buf->ptr[buf->size] = *scan;
 			buf->size++;
 			scan++;
+
+			/* copy escape suffix sequence */
+			if (esc_suffix) {
+				memmove(buf->ptr + buf->size, esc_suffix, esc_suffix_len);
+				buf->size += esc_suffix_len;
+			}
 		}
 	}