archive: stop passing "stage" through read_tree_recursive()
[git] / sideband.c
1 #include "cache.h"
2 #include "color.h"
3 #include "config.h"
4 #include "sideband.h"
5 #include "help.h"
6 #include "pkt-line.h"
7
8 struct keyword_entry {
9         /*
10          * We use keyword as config key so it should be a single alphanumeric word.
11          */
12         const char *keyword;
13         char color[COLOR_MAXLEN];
14 };
15
16 static struct keyword_entry keywords[] = {
17         { "hint",       GIT_COLOR_YELLOW },
18         { "warning",    GIT_COLOR_BOLD_YELLOW },
19         { "success",    GIT_COLOR_BOLD_GREEN },
20         { "error",      GIT_COLOR_BOLD_RED },
21 };
22
23 /* Returns a color setting (GIT_COLOR_NEVER, etc). */
24 static int use_sideband_colors(void)
25 {
26         static int use_sideband_colors_cached = -1;
27
28         const char *key = "color.remote";
29         struct strbuf sb = STRBUF_INIT;
30         char *value;
31         int i;
32
33         if (use_sideband_colors_cached >= 0)
34                 return use_sideband_colors_cached;
35
36         if (!git_config_get_string(key, &value)) {
37                 use_sideband_colors_cached = git_config_colorbool(key, value);
38         } else if (!git_config_get_string("color.ui", &value)) {
39                 use_sideband_colors_cached = git_config_colorbool("color.ui", value);
40         } else {
41                 use_sideband_colors_cached = GIT_COLOR_AUTO;
42         }
43
44         for (i = 0; i < ARRAY_SIZE(keywords); i++) {
45                 strbuf_reset(&sb);
46                 strbuf_addf(&sb, "%s.%s", key, keywords[i].keyword);
47                 if (git_config_get_string(sb.buf, &value))
48                         continue;
49                 if (color_parse(value, keywords[i].color))
50                         continue;
51         }
52         strbuf_release(&sb);
53         return use_sideband_colors_cached;
54 }
55
56 void list_config_color_sideband_slots(struct string_list *list, const char *prefix)
57 {
58         int i;
59
60         for (i = 0; i < ARRAY_SIZE(keywords); i++)
61                 list_config_item(list, prefix, keywords[i].keyword);
62 }
63
64 /*
65  * Optionally highlight one keyword in remote output if it appears at the start
66  * of the line. This should be called for a single line only, which is
67  * passed as the first N characters of the SRC array.
68  *
69  * NEEDSWORK: use "size_t n" instead for clarity.
70  */
71 static void maybe_colorize_sideband(struct strbuf *dest, const char *src, int n)
72 {
73         int i;
74
75         if (!want_color_stderr(use_sideband_colors())) {
76                 strbuf_add(dest, src, n);
77                 return;
78         }
79
80         while (0 < n && isspace(*src)) {
81                 strbuf_addch(dest, *src);
82                 src++;
83                 n--;
84         }
85
86         for (i = 0; i < ARRAY_SIZE(keywords); i++) {
87                 struct keyword_entry *p = keywords + i;
88                 int len = strlen(p->keyword);
89
90                 if (n < len)
91                         continue;
92                 /*
93                  * Match case insensitively, so we colorize output from existing
94                  * servers regardless of the case that they use for their
95                  * messages. We only highlight the word precisely, so
96                  * "successful" stays uncolored.
97                  */
98                 if (!strncasecmp(p->keyword, src, len) &&
99                     (len == n || !isalnum(src[len]))) {
100                         strbuf_addstr(dest, p->color);
101                         strbuf_add(dest, src, len);
102                         strbuf_addstr(dest, GIT_COLOR_RESET);
103                         n -= len;
104                         src += len;
105                         break;
106                 }
107         }
108
109         strbuf_add(dest, src, n);
110 }
111
112
113 #define DISPLAY_PREFIX "remote: "
114
115 #define ANSI_SUFFIX "\033[K"
116 #define DUMB_SUFFIX "        "
117
118 int demultiplex_sideband(const char *me, int status,
119                          char *buf, int len,
120                          int die_on_error,
121                          struct strbuf *scratch,
122                          enum sideband_type *sideband_type)
123 {
124         static const char *suffix;
125         const char *b, *brk;
126         int band;
127
128         if (!suffix) {
129                 if (isatty(2) && !is_terminal_dumb())
130                         suffix = ANSI_SUFFIX;
131                 else
132                         suffix = DUMB_SUFFIX;
133         }
134
135         if (status == PACKET_READ_EOF) {
136                 strbuf_addf(scratch,
137                             "%s%s: unexpected disconnect while reading sideband packet",
138                             scratch->len ? "\n" : "", me);
139                 *sideband_type = SIDEBAND_PROTOCOL_ERROR;
140                 goto cleanup;
141         }
142
143         if (len < 0)
144                 BUG("negative length on non-eof packet read");
145
146         if (len == 0) {
147                 if (status == PACKET_READ_NORMAL) {
148                         strbuf_addf(scratch,
149                                     "%s%s: protocol error: missing sideband designator",
150                                     scratch->len ? "\n" : "", me);
151                         *sideband_type = SIDEBAND_PROTOCOL_ERROR;
152                 } else {
153                         /* covers flush, delim, etc */
154                         *sideband_type = SIDEBAND_FLUSH;
155                 }
156                 goto cleanup;
157         }
158
159         band = buf[0] & 0xff;
160         buf[len] = '\0';
161         len--;
162         switch (band) {
163         case 3:
164                 if (die_on_error)
165                         die(_("remote error: %s"), buf + 1);
166                 strbuf_addf(scratch, "%s%s", scratch->len ? "\n" : "",
167                             DISPLAY_PREFIX);
168                 maybe_colorize_sideband(scratch, buf + 1, len);
169
170                 *sideband_type = SIDEBAND_REMOTE_ERROR;
171                 break;
172         case 2:
173                 b = buf + 1;
174
175                 /*
176                  * Append a suffix to each nonempty line to clear the
177                  * end of the screen line.
178                  *
179                  * The output is accumulated in a buffer and
180                  * each line is printed to stderr using
181                  * write(2) to ensure inter-process atomicity.
182                  */
183                 while ((brk = strpbrk(b, "\n\r"))) {
184                         int linelen = brk - b;
185
186                         if (!scratch->len)
187                                 strbuf_addstr(scratch, DISPLAY_PREFIX);
188                         if (linelen > 0) {
189                                 maybe_colorize_sideband(scratch, b, linelen);
190                                 strbuf_addstr(scratch, suffix);
191                         }
192
193                         strbuf_addch(scratch, *brk);
194                         xwrite(2, scratch->buf, scratch->len);
195                         strbuf_reset(scratch);
196
197                         b = brk + 1;
198                 }
199
200                 if (*b) {
201                         strbuf_addstr(scratch, scratch->len ?
202                                     "" : DISPLAY_PREFIX);
203                         maybe_colorize_sideband(scratch, b, strlen(b));
204                 }
205                 return 0;
206         case 1:
207                 *sideband_type = SIDEBAND_PRIMARY;
208                 return 1;
209         default:
210                 strbuf_addf(scratch, "%s%s: protocol error: bad band #%d",
211                             scratch->len ? "\n" : "", me, band);
212                 *sideband_type = SIDEBAND_PROTOCOL_ERROR;
213                 break;
214         }
215
216 cleanup:
217         if (die_on_error && *sideband_type == SIDEBAND_PROTOCOL_ERROR)
218                 die("%s", scratch->buf);
219         if (scratch->len) {
220                 strbuf_addch(scratch, '\n');
221                 xwrite(2, scratch->buf, scratch->len);
222         }
223         strbuf_release(scratch);
224         return 1;
225 }
226
227 /*
228  * fd is connected to the remote side; send the sideband data
229  * over multiplexed packet stream.
230  */
231 void send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max)
232 {
233         const char *p = data;
234
235         while (sz) {
236                 unsigned n;
237                 char hdr[5];
238
239                 n = sz;
240                 if (packet_max - 5 < n)
241                         n = packet_max - 5;
242                 if (0 <= band) {
243                         xsnprintf(hdr, sizeof(hdr), "%04x", n + 5);
244                         hdr[4] = band;
245                         write_or_die(fd, hdr, 5);
246                 } else {
247                         xsnprintf(hdr, sizeof(hdr), "%04x", n + 4);
248                         write_or_die(fd, hdr, 4);
249                 }
250                 write_or_die(fd, p, n);
251                 p += n;
252                 sz -= n;
253         }
254 }