sideband.c

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