mirror of
https://github.com/git/git.git
synced 2026-08-08 17:11:48 +00:00
1a2aca2be4
subprocess_read_status() reads "status=<key>" packets up to a flush with
packet_read_line_gently(), which is gentle only about EOF. A malformed
length header still dies inside pkt-line, and an empty packet is
indistinguishable from the flush that ends the section. A protocol
violation in a status section therefore either kills the whole command
or silently truncates the section. That posture fits the filter
protocol's callers, which treat their process as required
infrastructure; the diff process consult added later in this series
treats its process as optional, and any protocol error must degrade to
the builtin diff rather than abort the command.
Add subprocess_read_status_gently(): the same status loop, reading
through packet_read_with_status() with the gentle options, returning
-1 on a truncated or malformed packet and on an empty packet where a
status line or the terminating flush belongs. subprocess_read_status()
and its callers are unchanged.
The handshake has its gentle counterpart in 061a68e443 (sub-process:
use gentle handshake to avoid die() on startup failure, 2026-06-01),
which turned truncated handshake reads into error returns for every
caller. This series' base includes that commit, so a process that
dies during the handshake feeds the same non-fatal fallback as a
status failure here, and an optional diff process degrades to the
builtin diff on either kind of protocol error.
Signed-off-by: Michael Montalbo <mmontalbo@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
115 lines
3.9 KiB
C
115 lines
3.9 KiB
C
#ifndef SUBPROCESS_H
|
|
#define SUBPROCESS_H
|
|
|
|
#include "hashmap.h"
|
|
#include "run-command.h"
|
|
|
|
/*
|
|
* The sub-process API makes it possible to run background sub-processes
|
|
* for the entire lifetime of a Git invocation. If Git needs to communicate
|
|
* with an external process multiple times, then this can reduces the process
|
|
* invocation overhead. Git and the sub-process communicate through stdin and
|
|
* stdout.
|
|
*
|
|
* The sub-processes are kept in a hashmap by command name and looked up
|
|
* via the subprocess_find_entry function. If an existing instance can not
|
|
* be found then a new process should be created and started. When the
|
|
* parent git command terminates, all sub-processes are also terminated.
|
|
*
|
|
* This API is based on the run-command API.
|
|
*/
|
|
|
|
/* data structures */
|
|
|
|
/* Members should not be accessed directly. */
|
|
struct subprocess_entry {
|
|
struct hashmap_entry ent;
|
|
const char *cmd;
|
|
struct child_process process;
|
|
};
|
|
|
|
struct subprocess_capability {
|
|
const char *name;
|
|
|
|
/*
|
|
* subprocess_handshake will "|=" this value to supported_capabilities
|
|
* if the server reports that it supports this capability.
|
|
*/
|
|
unsigned int flag;
|
|
};
|
|
|
|
/* subprocess functions */
|
|
|
|
/* Function to test two subprocess hashmap entries for equality. */
|
|
int cmd2process_cmp(const void *unused_cmp_data,
|
|
const struct hashmap_entry *e,
|
|
const struct hashmap_entry *entry_or_key,
|
|
const void *unused_keydata);
|
|
|
|
/*
|
|
* User-supplied function to initialize the sub-process. This is
|
|
* typically used to negotiate the interface version and capabilities.
|
|
*/
|
|
typedef int(*subprocess_start_fn)(struct subprocess_entry *entry);
|
|
|
|
/* Start a subprocess and run the startfn (typically handshake). */
|
|
int subprocess_start_command(struct subprocess_entry *entry, const char *cmd,
|
|
subprocess_start_fn startfn);
|
|
|
|
/* Start a subprocess, run startfn, and add it to the subprocess hashmap. */
|
|
int subprocess_start(struct hashmap *hashmap, struct subprocess_entry *entry, const char *cmd,
|
|
subprocess_start_fn startfn);
|
|
|
|
/* Kill a subprocess. */
|
|
void subprocess_stop_command(struct subprocess_entry *entry);
|
|
|
|
/* Kill a subprocess and remove it from the subprocess hashmap. */
|
|
void subprocess_stop(struct hashmap *hashmap, struct subprocess_entry *entry);
|
|
|
|
/* Find a subprocess in the subprocess hashmap. */
|
|
struct subprocess_entry *subprocess_find_entry(struct hashmap *hashmap, const char *cmd);
|
|
|
|
/* subprocess helper functions */
|
|
|
|
/* Get the underlying `struct child_process` from a subprocess. */
|
|
static inline struct child_process *subprocess_get_child_process(
|
|
struct subprocess_entry *entry)
|
|
{
|
|
return &entry->process;
|
|
}
|
|
|
|
/*
|
|
* Perform the version and capability negotiation as described in the
|
|
* "Handshake" section of long-running-process-protocol.adoc using the
|
|
* given requested versions and capabilities. The "versions" and "capabilities"
|
|
* parameters are arrays terminated by a 0 or blank struct.
|
|
*
|
|
* This function is typically called when a subprocess is started (as part of
|
|
* the "startfn" passed to subprocess_start).
|
|
*/
|
|
int subprocess_handshake(struct subprocess_entry *entry,
|
|
const char *welcome_prefix,
|
|
int *versions,
|
|
int *chosen_version,
|
|
struct subprocess_capability *capabilities,
|
|
unsigned int *supported_capabilities);
|
|
|
|
/*
|
|
* Helper function that will read packets looking for "status=<foo>"
|
|
* key/value pairs and return the value from the last "status" packet
|
|
*/
|
|
|
|
int subprocess_read_status(int fd, struct strbuf *status);
|
|
|
|
/*
|
|
* Like subprocess_read_status(), but a malformed status section fails
|
|
* instead of dying: a truncated or malformed packet, and an empty
|
|
* packet where a status line or the terminating flush belongs, return
|
|
* -1 and leave the stream unusable. subprocess_read_status() cannot
|
|
* tell an empty packet from the flush that ends the section, and dies
|
|
* on a framing error inside packet_read_line_gently().
|
|
*/
|
|
int subprocess_read_status_gently(int fd, struct strbuf *status);
|
|
|
|
#endif
|