mirror of
https://github.com/git/git
synced 2024-10-30 03:13:24 +00:00
af22a63c39
In demultiplex_sideband(), there are two oddities when we check an
incoming packet:
- if it has zero length, then we assume it's a flush packet. This
means we fail to notice the difference between a real flush and a
true zero-length packet that's missing its sideband designator. It's
not a huge problem in practice because we'd never send a zero-length
data packet (even our keepalives are otherwise-empty sideband-1
packets).
But it would be nice to detect and report the error, since it's
likely to cause other confusion (we think the other side flushed,
but they do not).
- we try to detect packets missing their designator by checking for
"if (len < 1)". But this will never trigger for "len == 0"; we've
already detected that and left the function before then.
It _could_ detect a negative "len" parameter. But in that case, the
error message is wrong. The issue is not "no sideband" but rather
"eof while reading the packet". However, this can't actually be
triggered in practice, because neither of the two callers uses
pkt_read's GENTLE_ON_EOF flag. Which means they'd die with "the
remote end hung up unexpectedly" before we even get here.
So this truly is dead code.
We can improve these cases by passing in a pkt-line status to the
demultiplexer, and by having recv_sideband() use GENTLE_ON_EOF. This
gives us two improvements:
- we can now reliably detect flush packets, and will report a normal
packet missing its sideband designator as an error
- we'll report an eof with a more detailed "protocol error: eof while
reading sideband packet", rather than the generic "the remote end
hung up unexpectedly"
- when we see an eof, we'll flush the sideband scratch buffer, which
may provide some hints from the remote about why they hung up
(though note we already flush on newlines, so it's likely that most
such messages already made it through)
In some sense this patch goes against fbd76cd450 (sideband: reverse its
dependency on pkt-line, 2019-01-16), which caused the sideband code not
to depend on the pkt-line code. But that commit was really just trying
to deal with the circular header dependency. The two modules are
conceptually interlinked, and it was just trying to keep things
compiling. And indeed, there's a sticking point in this patch: because
pkt-line.h includes sideband.h, we can't add the reverse include we need
for the sideband code to have an "enum packet_read_status" parameter.
Nor can we forward declare it, because you can't forward declare an enum
in C. However, C does guarantee that enums fit in an int, so we can just
use that type.
One alternative would be for the callers to check themselves that they
got something sane from the pkt-line code. But besides duplicating
logic, this gets quite tricky. Any error condition requires flushing the
sideband #2 scratch buffer, which only demultiplex_sideband() knows how
to do.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
33 lines
1 KiB
C
33 lines
1 KiB
C
#ifndef SIDEBAND_H
|
|
#define SIDEBAND_H
|
|
|
|
enum sideband_type {
|
|
SIDEBAND_PROTOCOL_ERROR = -2,
|
|
SIDEBAND_REMOTE_ERROR = -1,
|
|
SIDEBAND_FLUSH = 0,
|
|
SIDEBAND_PRIMARY = 1
|
|
};
|
|
|
|
/*
|
|
* Inspects a multiplexed packet read from the remote. If this packet is a
|
|
* progress packet and thus should not be processed by the caller, returns 0.
|
|
* Otherwise, returns 1, releases scratch, and sets sideband_type.
|
|
*
|
|
* If this packet is SIDEBAND_PROTOCOL_ERROR, SIDEBAND_REMOTE_ERROR, or a
|
|
* progress packet, also prints a message to stderr.
|
|
*
|
|
* scratch must be a struct strbuf allocated by the caller. It is used to store
|
|
* progress messages split across multiple packets.
|
|
*
|
|
* The "status" parameter is a pkt-line response as returned by
|
|
* packet_read_with_status() (e.g., PACKET_READ_NORMAL).
|
|
*/
|
|
int demultiplex_sideband(const char *me, int status,
|
|
char *buf, int len,
|
|
int die_on_error,
|
|
struct strbuf *scratch,
|
|
enum sideband_type *sideband_type);
|
|
|
|
void send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max);
|
|
|
|
#endif
|