mirror of
https://github.com/git/git.git
synced 2024-12-07 00:45:16 +08:00
de1a2fdd38
The git-remote-curl backend detects if the remote server supports the git-receive-pack service, and if so, runs git-send-pack in a pipe to dump the command and pack data as a single POST request. The advertisements from the server that were obtained during the discovery are passed into git-send-pack before the POST request starts. This permits git-send-pack to operate largely unmodified. For smaller packs (those under 1 MiB) a HTTP/1.0 POST with a Content-Length is used, permitting interaction with any server. The 1 MiB limit is arbitrary, but is sufficent to fit most deltas created by human authors against text sources with the occasional small binary file (e.g. few KiB icon image). The configuration option http.postBuffer can be used to increase (or shink) this buffer if the default is not sufficient. For larger packs which cannot be spooled entirely into the helper's memory space (due to http.postBuffer being too small), the POST request requires HTTP/1.1 and sets "Transfer-Encoding: chunked". This permits the client to upload an unknown amount of data in one HTTP transaction without needing to pregenerate the entire pack file locally. Signed-off-by: Shawn O. Pearce <spearce@spearce.org> CC: Daniel Barkalow <barkalow@iabervon.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>
152 lines
3.4 KiB
C
152 lines
3.4 KiB
C
#include "pkt-line.h"
|
|
#include "sideband.h"
|
|
|
|
/*
|
|
* Receive multiplexed output stream over git native protocol.
|
|
* in_stream is the input stream from the remote, which carries data
|
|
* in pkt_line format with band designator. Demultiplex it into out
|
|
* and err and return error appropriately. Band #1 carries the
|
|
* primary payload. Things coming over band #2 is not necessarily
|
|
* error; they are usually informative message on the standard error
|
|
* stream, aka "verbose"). A message over band #3 is a signal that
|
|
* the remote died unexpectedly. A flush() concludes the stream.
|
|
*/
|
|
|
|
#define PREFIX "remote:"
|
|
|
|
#define ANSI_SUFFIX "\033[K"
|
|
#define DUMB_SUFFIX " "
|
|
|
|
#define FIX_SIZE 10 /* large enough for any of the above */
|
|
|
|
int recv_sideband(const char *me, int in_stream, int out)
|
|
{
|
|
unsigned pf = strlen(PREFIX);
|
|
unsigned sf;
|
|
char buf[LARGE_PACKET_MAX + 2*FIX_SIZE];
|
|
char *suffix, *term;
|
|
int skip_pf = 0;
|
|
|
|
memcpy(buf, PREFIX, pf);
|
|
term = getenv("TERM");
|
|
if (term && strcmp(term, "dumb"))
|
|
suffix = ANSI_SUFFIX;
|
|
else
|
|
suffix = DUMB_SUFFIX;
|
|
sf = strlen(suffix);
|
|
|
|
while (1) {
|
|
int band, len;
|
|
len = packet_read_line(in_stream, buf + pf, LARGE_PACKET_MAX);
|
|
if (len == 0)
|
|
break;
|
|
if (len < 1) {
|
|
fprintf(stderr, "%s: protocol error: no band designator\n", me);
|
|
return SIDEBAND_PROTOCOL_ERROR;
|
|
}
|
|
band = buf[pf] & 0xff;
|
|
len--;
|
|
switch (band) {
|
|
case 3:
|
|
buf[pf] = ' ';
|
|
buf[pf+1+len] = '\0';
|
|
fprintf(stderr, "%s\n", buf);
|
|
return SIDEBAND_REMOTE_ERROR;
|
|
case 2:
|
|
buf[pf] = ' ';
|
|
do {
|
|
char *b = buf;
|
|
int brk = 0;
|
|
|
|
/*
|
|
* If the last buffer didn't end with a line
|
|
* break then we should not print a prefix
|
|
* this time around.
|
|
*/
|
|
if (skip_pf) {
|
|
b += pf+1;
|
|
} else {
|
|
len += pf+1;
|
|
brk += pf+1;
|
|
}
|
|
|
|
/* Look for a line break. */
|
|
for (;;) {
|
|
brk++;
|
|
if (brk > len) {
|
|
brk = 0;
|
|
break;
|
|
}
|
|
if (b[brk-1] == '\n' ||
|
|
b[brk-1] == '\r')
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Let's insert a suffix to clear the end
|
|
* of the screen line if a line break was
|
|
* found. Also, if we don't skip the
|
|
* prefix, then a non-empty string must be
|
|
* present too.
|
|
*/
|
|
if (brk > (skip_pf ? 0 : (pf+1 + 1))) {
|
|
char save[FIX_SIZE];
|
|
memcpy(save, b + brk, sf);
|
|
b[brk + sf - 1] = b[brk - 1];
|
|
memcpy(b + brk - 1, suffix, sf);
|
|
fprintf(stderr, "%.*s", brk + sf, b);
|
|
memcpy(b + brk, save, sf);
|
|
len -= brk;
|
|
} else {
|
|
int l = brk ? brk : len;
|
|
fprintf(stderr, "%.*s", l, b);
|
|
len -= l;
|
|
}
|
|
|
|
skip_pf = !brk;
|
|
memmove(buf + pf+1, b + brk, len);
|
|
} while (len);
|
|
continue;
|
|
case 1:
|
|
safe_write(out, buf + pf+1, len);
|
|
continue;
|
|
default:
|
|
fprintf(stderr, "%s: protocol error: bad band #%d\n",
|
|
me, band);
|
|
return SIDEBAND_PROTOCOL_ERROR;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* fd is connected to the remote side; send the sideband data
|
|
* over multiplexed packet stream.
|
|
*/
|
|
ssize_t send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max)
|
|
{
|
|
ssize_t ssz = sz;
|
|
const char *p = data;
|
|
|
|
while (sz) {
|
|
unsigned n;
|
|
char hdr[5];
|
|
|
|
n = sz;
|
|
if (packet_max - 5 < n)
|
|
n = packet_max - 5;
|
|
if (0 <= band) {
|
|
sprintf(hdr, "%04x", n + 5);
|
|
hdr[4] = band;
|
|
safe_write(fd, hdr, 5);
|
|
} else {
|
|
sprintf(hdr, "%04x", n + 4);
|
|
safe_write(fd, hdr, 4);
|
|
}
|
|
safe_write(fd, p, n);
|
|
p += n;
|
|
sz -= n;
|
|
}
|
|
return ssz;
|
|
}
|