summaryrefslogtreecommitdiff
path: root/sideband.c
blob: 58edea68ee225e22d69a7e4aeada26b9d5cbf1f9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#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 SUFFIX "\e[K"  /* change to "        " if ANSI sequences don't work */
 
int recv_sideband(const char *me, int in_stream, int out, int err)
{
	unsigned pf = strlen(PREFIX);
	unsigned sf = strlen(SUFFIX);
	char buf[pf + LARGE_PACKET_MAX + sf + 1];
	memcpy(buf, PREFIX, pf);
	while (1) {
		int band, len;
		len = packet_read_line(in_stream, buf + pf, LARGE_PACKET_MAX);
		if (len == 0)
			break;
		if (len < 1) {
			len = sprintf(buf, "%s: protocol error: no band designator\n", me);
			safe_write(err, buf, len);
			return SIDEBAND_PROTOCOL_ERROR;
		}
		band = buf[pf] & 0xff;
		len--;
		switch (band) {
		case 3:
			buf[pf] = ' ';
			buf[pf+1+len] = '\n';
			safe_write(err, buf, pf+1+len+1);
			return SIDEBAND_REMOTE_ERROR;
		case 2:
			buf[pf] = ' ';
			len += pf+1;
			while (1) {
				int brk = pf+1;
 
				/* Break the buffer into separate lines. */
				while (brk < len) {
					brk++;
					if (buf[brk-1] == '\n' ||
					    buf[brk-1] == '\r')
						break;
				}
 
				/*
				 * Let's insert a suffix to clear the end
				 * of the screen line, but only if current
				 * line data actually contains something.
				 */
				if (brk > pf+1 + 1) {
					char save[sf];
					memcpy(save, buf + brk, sf);
					buf[brk + sf - 1] = buf[brk - 1];
					memcpy(buf + brk - 1, SUFFIX, sf);
					safe_write(err, buf, brk + sf);
					memcpy(buf + brk, save, sf);
				} else
					safe_write(err, buf, brk);
 
				if (brk < len) {
					memmove(buf + pf+1, buf + brk, len - brk);
					len = len - brk + pf+1;
				} else
					break;
			}
			continue;
		case 1:
			safe_write(out, buf + pf+1, len);
			continue;
		default:
			len = sprintf(buf,
				      "%s: protocol error: bad band #%d\n",
				      me, band);
			safe_write(err, buf, len);
			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;
		sprintf(hdr, "%04x", n + 5);
		hdr[4] = band;
		safe_write(fd, hdr, 5);
		safe_write(fd, p, n);
		p += n;
		sz -= n;
	}
	return ssz;
}