2013-02-20 20:01:56 +00:00
|
|
|
#include "cache.h"
|
2006-09-10 08:06:33 +00:00
|
|
|
#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.
|
|
|
|
*/
|
2007-11-04 04:22:42 +00:00
|
|
|
|
|
|
|
#define PREFIX "remote:"
|
2008-01-08 16:24:53 +00:00
|
|
|
|
|
|
|
#define ANSI_SUFFIX "\033[K"
|
|
|
|
#define DUMB_SUFFIX " "
|
|
|
|
|
|
|
|
#define FIX_SIZE 10 /* large enough for any of the above */
|
2007-11-04 04:22:42 +00:00
|
|
|
|
2009-03-10 21:54:17 +00:00
|
|
|
int recv_sideband(const char *me, int in_stream, int out)
|
2006-09-10 08:06:33 +00:00
|
|
|
{
|
2007-11-04 04:22:42 +00:00
|
|
|
unsigned pf = strlen(PREFIX);
|
2008-01-08 16:24:53 +00:00
|
|
|
unsigned sf;
|
|
|
|
char buf[LARGE_PACKET_MAX + 2*FIX_SIZE];
|
|
|
|
char *suffix, *term;
|
2008-09-03 19:13:42 +00:00
|
|
|
int skip_pf = 0;
|
2008-01-08 16:24:53 +00:00
|
|
|
|
2007-11-04 04:22:42 +00:00
|
|
|
memcpy(buf, PREFIX, pf);
|
2008-01-08 16:24:53 +00:00
|
|
|
term = getenv("TERM");
|
2014-05-28 03:12:15 +00:00
|
|
|
if (isatty(2) && term && strcmp(term, "dumb"))
|
2008-01-08 16:24:53 +00:00
|
|
|
suffix = ANSI_SUFFIX;
|
|
|
|
else
|
|
|
|
suffix = DUMB_SUFFIX;
|
|
|
|
sf = strlen(suffix);
|
|
|
|
|
2006-09-10 08:06:33 +00:00
|
|
|
while (1) {
|
2006-10-11 15:49:15 +00:00
|
|
|
int band, len;
|
pkt-line: share buffer/descriptor reading implementation
The packet_read function reads from a descriptor. The
packet_get_line function is similar, but reads from an
in-memory buffer, and uses a completely separate
implementation. This patch teaches the generic packet_read
function to accept either source, and we can do away with
packet_get_line's implementation.
There are two other differences to account for between the
old and new functions. The first is that we used to read
into a strbuf, but now read into a fixed size buffer. The
only two callers are fine with that, and in fact it
simplifies their code, since they can use the same
static-buffer interface as the rest of the packet_read_line
callers (and we provide a similar convenience wrapper for
reading from a buffer rather than a descriptor).
This is technically an externally-visible behavior change in
that we used to accept arbitrary sized packets up to 65532
bytes, and now cap out at LARGE_PACKET_MAX, 65520. In
practice this doesn't matter, as we use it only for parsing
smart-http headers (of which there is exactly one defined,
and it is small and fixed-size). And any extension headers
would be breaking the protocol to go over LARGE_PACKET_MAX
anyway.
The other difference is that packet_get_line would return
on error rather than dying. However, both callers of
packet_get_line are actually improved by dying.
The first caller does its own error checking, but we can
drop that; as a result, we'll actually get more specific
reporting about protocol breakage when packet_read dies
internally. The only downside is that packet_read will not
print the smart-http URL that failed, but that's not a big
deal; anybody not debugging can already see the remote's URL
already, and anybody debugging would want to run with
GIT_CURL_VERBOSE anyway to see way more information.
The second caller, which is just trying to skip past any
extra smart-http headers (of which there are none defined,
but which we allow to keep room for future expansion), did
not error check at all. As a result, it would treat an error
just like a flush packet. The resulting mess would generally
cause an error later in get_remote_heads, but now we get
error reporting much closer to the source of the problem.
Brown-paper-bag-fixes-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-23 22:31:34 +00:00
|
|
|
len = packet_read(in_stream, NULL, NULL, buf + pf, LARGE_PACKET_MAX, 0);
|
2006-09-10 08:06:33 +00:00
|
|
|
if (len == 0)
|
|
|
|
break;
|
|
|
|
if (len < 1) {
|
2009-03-10 21:54:17 +00:00
|
|
|
fprintf(stderr, "%s: protocol error: no band designator\n", me);
|
2006-09-10 08:06:33 +00:00
|
|
|
return SIDEBAND_PROTOCOL_ERROR;
|
|
|
|
}
|
2007-11-04 04:22:42 +00:00
|
|
|
band = buf[pf] & 0xff;
|
2006-09-10 08:06:33 +00:00
|
|
|
len--;
|
2006-10-11 15:49:15 +00:00
|
|
|
switch (band) {
|
2006-09-10 08:06:33 +00:00
|
|
|
case 3:
|
2007-11-04 04:22:42 +00:00
|
|
|
buf[pf] = ' ';
|
2009-03-10 21:54:17 +00:00
|
|
|
buf[pf+1+len] = '\0';
|
|
|
|
fprintf(stderr, "%s\n", buf);
|
2006-09-10 08:06:33 +00:00
|
|
|
return SIDEBAND_REMOTE_ERROR;
|
|
|
|
case 2:
|
2007-11-04 04:22:42 +00:00
|
|
|
buf[pf] = ' ';
|
2008-09-03 19:13:42 +00:00
|
|
|
do {
|
|
|
|
char *b = buf;
|
|
|
|
int brk = 0;
|
2007-11-04 04:22:42 +00:00
|
|
|
|
2008-09-03 19:13:42 +00:00
|
|
|
/*
|
|
|
|
* 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 (;;) {
|
2007-10-17 01:55:46 +00:00
|
|
|
brk++;
|
2008-09-03 19:13:42 +00:00
|
|
|
if (brk > len) {
|
|
|
|
brk = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (b[brk-1] == '\n' ||
|
|
|
|
b[brk-1] == '\r')
|
2007-10-17 01:55:46 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-11-04 04:22:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's insert a suffix to clear the end
|
2008-09-03 19:13:42 +00:00
|
|
|
* 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.
|
2007-11-04 04:22:42 +00:00
|
|
|
*/
|
2008-09-03 19:13:42 +00:00
|
|
|
if (brk > (skip_pf ? 0 : (pf+1 + 1))) {
|
2008-01-08 16:24:53 +00:00
|
|
|
char save[FIX_SIZE];
|
2008-09-03 19:13:42 +00:00
|
|
|
memcpy(save, b + brk, sf);
|
|
|
|
b[brk + sf - 1] = b[brk - 1];
|
|
|
|
memcpy(b + brk - 1, suffix, sf);
|
2009-03-10 21:54:17 +00:00
|
|
|
fprintf(stderr, "%.*s", brk + sf, b);
|
2008-09-03 19:13:42 +00:00
|
|
|
memcpy(b + brk, save, sf);
|
|
|
|
len -= brk;
|
|
|
|
} else {
|
|
|
|
int l = brk ? brk : len;
|
2009-03-10 21:54:17 +00:00
|
|
|
fprintf(stderr, "%.*s", l, b);
|
2008-09-03 19:13:42 +00:00
|
|
|
len -= l;
|
|
|
|
}
|
2007-11-04 04:22:42 +00:00
|
|
|
|
2008-09-03 19:13:42 +00:00
|
|
|
skip_pf = !brk;
|
|
|
|
memmove(buf + pf+1, b + brk, len);
|
|
|
|
} while (len);
|
2006-09-10 08:06:33 +00:00
|
|
|
continue;
|
|
|
|
case 1:
|
2013-02-20 20:01:56 +00:00
|
|
|
write_or_die(out, buf + pf+1, len);
|
2006-09-10 08:06:33 +00:00
|
|
|
continue;
|
|
|
|
default:
|
2009-03-10 21:54:17 +00:00
|
|
|
fprintf(stderr, "%s: protocol error: bad band #%d\n",
|
|
|
|
me, band);
|
2006-09-10 08:06:33 +00:00
|
|
|
return SIDEBAND_PROTOCOL_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2006-09-10 10:20:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* fd is connected to the remote side; send the sideband data
|
|
|
|
* over multiplexed packet stream.
|
|
|
|
*/
|
2016-06-14 14:49:16 +00:00
|
|
|
void send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max)
|
2006-09-10 10:20:24 +00:00
|
|
|
{
|
|
|
|
const char *p = data;
|
|
|
|
|
|
|
|
while (sz) {
|
|
|
|
unsigned n;
|
|
|
|
char hdr[5];
|
|
|
|
|
|
|
|
n = sz;
|
|
|
|
if (packet_max - 5 < n)
|
|
|
|
n = packet_max - 5;
|
2009-10-31 00:47:41 +00:00
|
|
|
if (0 <= band) {
|
2015-09-24 21:06:08 +00:00
|
|
|
xsnprintf(hdr, sizeof(hdr), "%04x", n + 5);
|
2009-10-31 00:47:41 +00:00
|
|
|
hdr[4] = band;
|
2013-02-20 20:01:56 +00:00
|
|
|
write_or_die(fd, hdr, 5);
|
2009-10-31 00:47:41 +00:00
|
|
|
} else {
|
2015-09-24 21:06:08 +00:00
|
|
|
xsnprintf(hdr, sizeof(hdr), "%04x", n + 4);
|
2013-02-20 20:01:56 +00:00
|
|
|
write_or_die(fd, hdr, 4);
|
2009-10-31 00:47:41 +00:00
|
|
|
}
|
2013-02-20 20:01:56 +00:00
|
|
|
write_or_die(fd, p, n);
|
2006-09-10 10:20:24 +00:00
|
|
|
p += n;
|
|
|
|
sz -= n;
|
|
|
|
}
|
|
|
|
}
|