Codebergdnkl

foot

master
ply5 git calls636 ms42 KiB3 cachedprotocol v2
2271 lines75 KiBRaw
1#include "csi.h"
3#include <stdlib.h>
4#include <string.h>
5#include <unistd.h>
7#if defined(_DEBUG)
8 #include <stdio.h>
9#endif
11#include <sys/timerfd.h>
13#define LOG_MODULE "csi"
14#define LOG_ENABLE_DBG 0
15#include "log.h"
16#include "char32.h"
17#include "config.h"
18#include "debug.h"
19#include "grid.h"
20#include "selection.h"
21#include "sixel.h"
22#include "util.h"
23#include "version.h"
24#include "vt.h"
25#include "xmalloc.h"
26#include "xsnprintf.h"
28#define UNHANDLED() LOG_DBG("unhandled: %s", csi_as_string(term, final, -1))
29#define UNHANDLED_SGR(idx) LOG_DBG("unhandled: %s", csi_as_string(term, 'm', idx))
31static void
32sgr_reset(struct terminal *term)
34 term->vt.attrs = (struct attributes){0};
35 term->vt.underline = (struct underline_range_data){0};
37 term->bits_affecting_ascii_printer.underline_style = false;
38 term->bits_affecting_ascii_printer.underline_color = false;
39 term_update_ascii_printer(term);
42static const char *
43csi_as_string(struct terminal *term, uint8_t final, int idx)
45 static char msg[1024];
46 int c = snprintf(msg, sizeof(msg), "CSI: ");
48 for (size_t i = idx >= 0 ? idx : 0;
49 i < (idx >= 0 ? idx + 1 : term->vt.params.idx);
50 i++)
51 {
52 c += snprintf(&msg[c], sizeof(msg) - c, "%u",
53 term->vt.params.v[i].value);
55 for (size_t j = 0; j < term->vt.params.v[i].sub.idx; j++) {
56 c += snprintf(&msg[c], sizeof(msg) - c, ":%u",
57 term->vt.params.v[i].sub.value[j]);
58 }
60 c += snprintf(&msg[c], sizeof(msg) - c, "%s",
61 i == term->vt.params.idx - 1 ? "" : ";");
62 }
64 for (size_t i = 0; i < sizeof(term->vt.private); i++) {
65 char value = (term->vt.private >> (i * 8)) & 0xff;
66 if (value == 0)
67 break;
68 c += snprintf(&msg[c], sizeof(msg) - c, "%c", value);
69 }
71 snprintf(&msg[c], sizeof(msg) - c, "%c (%u parameters)",
72 final, idx >= 0 ? 1 : term->vt.params.idx);
73 return msg;
76static void
77csi_sgr(struct terminal *term)
79 if (term->vt.params.idx == 0) {
80 sgr_reset(term);
81 return;
82 }
84 for (size_t i = 0; i < term->vt.params.idx; i++) {
85 const int param = term->vt.params.v[i].value;
87 switch (param) {
88 case 0:
89 sgr_reset(term);
90 break;
92 case 1: term->vt.attrs.bold = true; break;
93 case 2: term->vt.attrs.dim = true; break;
94 case 3: term->vt.attrs.italic = true; break;
95 case 4: {
96 term->vt.attrs.underline = true;
97 term->vt.underline.style = UNDERLINE_SINGLE;
99 if (unlikely(term->vt.params.v[i].sub.idx == 1)) {
100 enum underline_style style = term->vt.params.v[i].sub.value[0];
102 switch (style) {
103 default:
104 case UNDERLINE_NONE:
105 term->vt.attrs.underline = false;
106 term->vt.underline.style = UNDERLINE_NONE;
107 term->bits_affecting_ascii_printer.underline_style = false;
108 break;
110 case UNDERLINE_SINGLE:
111 case UNDERLINE_DOUBLE:
112 case UNDERLINE_CURLY:
113 case UNDERLINE_DOTTED:
114 case UNDERLINE_DASHED:
115 term->vt.underline.style = style;
116 term->bits_affecting_ascii_printer.underline_style =
117 style > UNDERLINE_SINGLE;
118 break;
119 }
120 } else
121 term->bits_affecting_ascii_printer.underline_style = false;
122 term_update_ascii_printer(term);
123 break;
124 }
125 case 5: term->vt.attrs.blink = true; break;
126 case 6: LOG_WARN("ignored: rapid blink"); break;
127 case 7: term->vt.attrs.reverse = true; break;
128 case 8: term->vt.attrs.conceal = true; break;
129 case 9: term->vt.attrs.strikethrough = true; break;
131 case 21:
132 term->vt.attrs.underline = true;
133 term->vt.underline.style = UNDERLINE_DOUBLE;
134 term->bits_affecting_ascii_printer.underline_style = true;
135 term_update_ascii_printer(term);
136 break;
138 case 22: term->vt.attrs.bold = term->vt.attrs.dim = false; break;
139 case 23: term->vt.attrs.italic = false; break;
140 case 24: {
141 term->vt.attrs.underline = false;
142 term->vt.underline.style = UNDERLINE_NONE;
143 term->bits_affecting_ascii_printer.underline_style = false;
144 term_update_ascii_printer(term);
145 break;
146 }
147 case 25: term->vt.attrs.blink = false; break;
148 case 26: break; /* rapid blink, ignored */
149 case 27: term->vt.attrs.reverse = false; break;
150 case 28: term->vt.attrs.conceal = false; break;
151 case 29: term->vt.attrs.strikethrough = false; break;
153 /* Regular foreground colors */
154 case 30:
155 case 31:
156 case 32:
157 case 33:
158 case 34:
159 case 35:
160 case 36:
161 case 37:
162 term->vt.attrs.fg_src = COLOR_BASE16;
163 term->vt.attrs.fg = param - 30;
164 break;
166 case 38:
167 case 48:
168 case 58: {
169 uint32_t color;
170 enum color_source src;
172 /* Indexed: 38;5;<idx> */
173 if (term->vt.params.idx - i - 1 >= 2 &&
174 term->vt.params.v[i + 1].value == 5)
175 {
176 src = COLOR_BASE256;
177 color = min(term->vt.params.v[i + 2].value,
178 ALEN(term->colors.table) - 1);
179 i += 2;
180 }
182 /* RGB: 38;2;<r>;<g>;<b> */
183 else if (term->vt.params.idx - i - 1 >= 4 &&
184 term->vt.params.v[i + 1].value == 2)
185 {
186 uint8_t r = term->vt.params.v[i + 2].value;
187 uint8_t g = term->vt.params.v[i + 3].value;
188 uint8_t b = term->vt.params.v[i + 4].value;
189 src = COLOR_RGB;
190 color = r << 16 | g << 8 | b;
191 i += 4;
192 }
194 /* Indexed: 38:5:<idx> */
195 else if (term->vt.params.v[i].sub.idx >= 2 &&
196 term->vt.params.v[i].sub.value[0] == 5)
197 {
198 src = COLOR_BASE256;
199 color = min(term->vt.params.v[i].sub.value[1],
200 ALEN(term->colors.table) - 1);
201 }
203 /*
204 * RGB: 38:2:<color-space>:r:g:b[:ignored:tolerance:tolerance-color-space]
205 * RGB: 38:2:r:g:b
206 *
207 * The second version is a "bastard" version - many
208 * programs "forget" the color space ID
209 * parameter... *sigh*
210 */
211 else if (term->vt.params.v[i].sub.idx >= 4 &&
212 term->vt.params.v[i].sub.value[0] == 2)
213 {
214 const struct vt_param *param = &term->vt.params.v[i];
215 bool have_color_space_id = param->sub.idx >= 5;
217 /* 0 - color space (ignored) */
218 int r_idx = 2 - !have_color_space_id;
219 int g_idx = 3 - !have_color_space_id;
220 int b_idx = 4 - !have_color_space_id;
221 /* 5 - unused */
222 /* 6 - CS tolerance */
223 /* 7 - color space associated with tolerance */
225 uint8_t r = param->sub.value[r_idx];
226 uint8_t g = param->sub.value[g_idx];
227 uint8_t b = param->sub.value[b_idx];
229 src = COLOR_RGB;
230 color = r << 16 | g << 8 | b;
231 }
233 /* Transparent: 38:1 */
234 /* CMY: 38:3:<color-space>:c:m:y[:tolerance:tolerance-color-space] */
235 /* CMYK: 38:4:<color-space>:c:m:y:k[:tolerance:tolerance-color-space] */
237 /* Unrecognized */
238 else {
239 UNHANDLED_SGR(i);
240 break;
241 }
243 if (unlikely(param == 58)) {
244 term->vt.underline.color_src = src;
245 term->vt.underline.color = color;
246 term->bits_affecting_ascii_printer.underline_color = true;
247 term_update_ascii_printer(term);
248 } else if (param == 38) {
249 term->vt.attrs.fg_src = src;
250 term->vt.attrs.fg = color;
251 } else {
252 xassert(param == 48);
253 term->vt.attrs.bg_src = src;
254 term->vt.attrs.bg = color;
255 }
256 break;
257 }
259 case 39:
260 term->vt.attrs.fg_src = COLOR_DEFAULT;
261 break;
263 /* Regular background colors */
264 case 40:
265 case 41:
266 case 42:
267 case 43:
268 case 44:
269 case 45:
270 case 46:
271 case 47:
272 term->vt.attrs.bg_src = COLOR_BASE16;
273 term->vt.attrs.bg = param - 40;
274 break;
276 case 49:
277 term->vt.attrs.bg_src = COLOR_DEFAULT;
278 break;
280 case 59:
281 term->vt.underline.color_src = COLOR_DEFAULT;
282 term->vt.underline.color = 0;
283 term->bits_affecting_ascii_printer.underline_color = false;
284 term_update_ascii_printer(term);
285 break;
287 /* Bright foreground colors */
288 case 90:
289 case 91:
290 case 92:
291 case 93:
292 case 94:
293 case 95:
294 case 96:
295 case 97:
296 term->vt.attrs.fg_src = COLOR_BASE16;
297 term->vt.attrs.fg = param - 90 + 8;
298 break;
300 /* Bright background colors */
301 case 100:
302 case 101:
303 case 102:
304 case 103:
305 case 104:
306 case 105:
307 case 106:
308 case 107:
309 term->vt.attrs.bg_src = COLOR_BASE16;
310 term->vt.attrs.bg = param - 100 + 8;
311 break;
313 default:
314 UNHANDLED_SGR(i);
315 break;
316 }
317 }
320static void
321decset_decrst(struct terminal *term, unsigned param, bool enable)
323#if defined(_DEBUG)
324 /* For UNHANDLED() */
325 int UNUSED final = enable ? 'h' : 'l';
326#endif
328 /* Note: update XTSAVE/XTRESTORE if adding/removing things here */
330 switch (param) {
331 case 1:
332 /* DECCKM */
333 term->cursor_keys_mode =
334 enable ? CURSOR_KEYS_APPLICATION : CURSOR_KEYS_NORMAL;
335 break;
337 case 5:
338 /* DECSCNM */
339 term->reverse = enable;
340 term_damage_all(term);
341 term_damage_margins(term);
342 break;
344 case 6: {
345 /* DECOM */
346 term->origin = enable ? ORIGIN_RELATIVE : ORIGIN_ABSOLUTE;
347 term_cursor_home(term);
348 break;
349 }
351 case 7:
352 /* DECAWM */
353 term->auto_margin = enable;
354 term->grid->cursor.lcf = false;
355 break;
357 case 9:
358 if (enable)
359 LOG_WARN("unimplemented: X10 mouse tracking mode");
360#if 0
361 else if (term->mouse_tracking == MOUSE_X10)
362 term->mouse_tracking = MOUSE_NONE;
363#endif
364 break;
366 case 12:
367 term->cursor_blink.decset = enable;
368 term_cursor_blink_update(term);
369 break;
371 case 25:
372 /* DECTCEM */
373 term->hide_cursor = !enable;
374 break;
376 case 45:
377 term->reverse_wrap = enable;
378 break;
380 case 66:
381 /* DECNKM */
382 term->keypad_keys_mode = enable ? KEYPAD_APPLICATION : KEYPAD_NUMERICAL;
383 break;
385 case 67:
386 if (enable)
387 LOG_WARN("unimplemented: DECBKM");
388 break;
390 case 80:
391 term->sixel.scrolling = !enable;
392 break;
394 case 1000:
395 if (enable)
396 term->mouse_tracking = MOUSE_CLICK;
397 else if (term->mouse_tracking == MOUSE_CLICK)
398 term->mouse_tracking = MOUSE_NONE;
399 term_xcursor_update(term);
400 break;
402 case 1001:
403 if (enable)
404 LOG_WARN("unimplemented: highlight mouse tracking");
405 break;
407 case 1002:
408 if (enable)
409 term->mouse_tracking = MOUSE_DRAG;
410 else if (term->mouse_tracking == MOUSE_DRAG)
411 term->mouse_tracking = MOUSE_NONE;
412 term_xcursor_update(term);
413 break;
415 case 1003:
416 if (enable)
417 term->mouse_tracking = MOUSE_MOTION;
418 else if (term->mouse_tracking == MOUSE_MOTION)
419 term->mouse_tracking = MOUSE_NONE;
420 term_xcursor_update(term);
421 break;
423 case 1004:
424 term->focus_events = enable;
425 if (enable)
426 term_to_slave(term, term->kbd_focus ? "\033[I" : "\033[O", 3);
427 break;
429 case 1005:
430 if (enable)
431 LOG_WARN("unimplemented: mouse reporting mode: UTF-8");
432#if 0
433 else if (term->mouse_reporting == MOUSE_UTF8)
434 term->mouse_reporting = MOUSE_NONE;
435#endif
436 break;
438 case 1006:
439 if (enable)
440 term->mouse_reporting = MOUSE_SGR;
441 else if (term->mouse_reporting == MOUSE_SGR)
442 term->mouse_reporting = MOUSE_NORMAL;
443 break;
445 case 1007:
446 term->alt_scrolling = enable;
447 break;
449 case 1015:
450 if (enable)
451 term->mouse_reporting = MOUSE_URXVT;
452 else if (term->mouse_reporting == MOUSE_URXVT)
453 term->mouse_reporting = MOUSE_NORMAL;
454 break;
456 case 1016:
457 if (enable)
458 term->mouse_reporting = MOUSE_SGR_PIXELS;
459 else if (term->mouse_reporting == MOUSE_SGR_PIXELS)
460 term->mouse_reporting = MOUSE_NORMAL;
461 break;
463 case 1034:
464 /* smm */
465 LOG_DBG("%s 8-bit meta mode", enable ? "enabling" : "disabling");
466 term->meta.eight_bit = enable;
467 break;
469 case 1035:
470 /* numLock */
471 LOG_DBG("%s Num Lock modifier", enable ? "enabling" : "disabling");
472 term->num_lock_modifier = enable;
473 break;
475 case 1036:
476 /* metaSendsEscape */
477 LOG_DBG("%s meta-sends-escape", enable ? "enabling" : "disabling");
478 term->meta.esc_prefix = enable;
479 break;
481 case 1042:
482 term->bell_action_enabled = enable;
483 break;
485#if 0
486 case 1043:
487 LOG_WARN("unimplemented: raise window on ctrl-g");
488 break;
489#endif
491 case 1048:
492 if (enable)
493 term_save_cursor(term);
494 else
495 term_restore_cursor(term, &term->grid->saved_cursor);
496 break;
498 case 47:
499 case 1047:
500 case 1049:
501 if (enable && term->grid != &term->alt) {
502 selection_cancel(term);
504 if (param == 1049)
505 term_save_cursor(term);
507 term->grid = &term->alt;
509 /* Cursor retains its position from the normal grid */
510 term_cursor_to(
511 term,
512 min(term->normal.cursor.point.row, term->rows - 1),
513 min(term->normal.cursor.point.col, term->cols - 1));
515 tll_free(term->normal.scroll_damage);
516 term_erase(term, 0, 0, term->rows - 1, term->cols - 1);
517 }
519 else if (!enable && term->grid == &term->alt) {
520 selection_cancel(term);
522 term->grid = &term->normal;
524 /* Cursor retains its position from the alt grid */
525 term_cursor_to(
526 term, min(term->alt.cursor.point.row, term->rows - 1),
527 min(term->alt.cursor.point.col, term->cols - 1));
529 if (param == 1049)
530 term_restore_cursor(term, &term->grid->saved_cursor);
532 /* Delete all sixel images on the alt screen */
533 tll_foreach(term->alt.sixel_images, it) {
534 sixel_destroy(&it->item);
535 tll_remove(term->alt.sixel_images, it);
536 }
538 tll_free(term->alt.scroll_damage);
539 term_damage_view(term);
540 }
542 term->bits_affecting_ascii_printer.sixels =
543 tll_length(term->grid->sixel_images) > 0;
544 term_update_ascii_printer(term);
545 break;
547 case 1070:
548 term->sixel.use_private_palette = enable;
549 break;
551 case 2004:
552 term->bracketed_paste = enable;
553 break;
555 case 2026:
556 if (enable)
557 term_enable_app_sync_updates(term);
558 else
559 term_disable_app_sync_updates(term);
560 break;
562 case 2027:
563#if defined(FOOT_GRAPHEME_CLUSTERING)
564 term->grapheme_shaping = enable;
565#endif
566 break;
568 case 2031:
569 term->report_theme_changes = enable;
570 break;
572 case 2033:
573 term->visibility_reports = enable;
574 if (enable)
575 term_send_visibility_report(term);
576 break;
578 case 2048:
579 if (enable)
580 term_enable_size_notifications(term);
581 else
582 term_disable_size_notifications(term);
583 break;
585 case 8452:
586 term->sixel.cursor_right_of_graphics = enable;
587 break;
589 case 737769:
590 if (enable)
591 term_ime_enable(term);
592 else {
593 term_ime_disable(term);
594 term->url.ime_reenable_after_url_mode = false;
595 }
596 break;
598 default:
599 UNHANDLED();
600 break;
601 }
604static void
605decset(struct terminal *term, unsigned param)
607 decset_decrst(term, param, true);
610static void
611decrst(struct terminal *term, unsigned param)
613 decset_decrst(term, param, false);
616/*
617 * These values represent the current state of a DEC private mode,
618 * as returned in the DECRPM reply to a DECRQM query.
619 */
620enum decrpm_status {
621 DECRPM_NOT_RECOGNIZED = 0,
622 DECRPM_SET = 1,
623 DECRPM_RESET = 2,
624 DECRPM_PERMANENTLY_SET = 3,
625 DECRPM_PERMANENTLY_RESET = 4,
626};
628static enum decrpm_status
629decrpm(bool enabled)
631 return enabled ? DECRPM_SET : DECRPM_RESET;
634static enum decrpm_status
635decrqm(const struct terminal *term, unsigned param)
637 switch (param) {
638 case 1: return decrpm(term->cursor_keys_mode == CURSOR_KEYS_APPLICATION);
639 case 5: return decrpm(term->reverse);
640 case 6: return decrpm(term->origin);
641 case 7: return decrpm(term->auto_margin);
642 case 9: return DECRPM_PERMANENTLY_RESET; /* term->mouse_tracking == MOUSE_X10; */
643 case 12: return decrpm(term->cursor_blink.decset);
644 case 25: return decrpm(!term->hide_cursor);
645 case 45: return decrpm(term->reverse_wrap);
646 case 66: return decrpm(term->keypad_keys_mode == KEYPAD_APPLICATION);
647 case 67: return DECRPM_PERMANENTLY_RESET; /* https://vt100.net/docs/vt510-rm/DECBKM */
648 case 80: return decrpm(!term->sixel.scrolling);
649 case 1000: return decrpm(term->mouse_tracking == MOUSE_CLICK);
650 case 1001: return DECRPM_PERMANENTLY_RESET;
651 case 1002: return decrpm(term->mouse_tracking == MOUSE_DRAG);
652 case 1003: return decrpm(term->mouse_tracking == MOUSE_MOTION);
653 case 1004: return decrpm(term->focus_events);
654 case 1005: return DECRPM_PERMANENTLY_RESET; /* term->mouse_reporting == MOUSE_UTF8; */
655 case 1006: return decrpm(term->mouse_reporting == MOUSE_SGR);
656 case 1007: return decrpm(term->alt_scrolling);
657 case 1015: return decrpm(term->mouse_reporting == MOUSE_URXVT);
658 case 1016: return decrpm(term->mouse_reporting == MOUSE_SGR_PIXELS);
659 case 1034: return decrpm(term->meta.eight_bit);
660 case 1035: return decrpm(term->num_lock_modifier);
661 case 1036: return decrpm(term->meta.esc_prefix);
662 case 1042: return decrpm(term->bell_action_enabled);
663 case 47: /* FALLTHROUGH */
664 case 1047: /* FALLTHROUGH */
665 case 1049: return decrpm(term->grid == &term->alt);
666 case 1070: return decrpm(term->sixel.use_private_palette);
667 case 2004: return decrpm(term->bracketed_paste);
668 case 2026: return decrpm(term->render.app_sync_updates.enabled);
669 case 2027: return term->conf->tweak.grapheme_width_method != GRAPHEME_WIDTH_DOUBLE
670 ? DECRPM_PERMANENTLY_RESET
671 : decrpm(term->grapheme_shaping);
672 case 2031: return decrpm(term->report_theme_changes);
673 case 2033: return decrpm(term->visibility_reports);
674 case 2048: return decrpm(term->size_notifications);
675 case 8452: return decrpm(term->sixel.cursor_right_of_graphics);
676 case 737769: return decrpm(term_ime_is_enabled(term));
677 }
679 return DECRPM_NOT_RECOGNIZED;
682static void
683xtsave(struct terminal *term, unsigned param)
685 switch (param) {
686 case 1: term->xtsave.application_cursor_keys = term->cursor_keys_mode == CURSOR_KEYS_APPLICATION; break;
687 case 5: term->xtsave.reverse = term->reverse; break;
688 case 6: term->xtsave.origin = term->origin; break;
689 case 7: term->xtsave.auto_margin = term->auto_margin; break;
690 case 9: /* term->xtsave.mouse_x10 = term->mouse_tracking == MOUSE_X10; */ break;
691 case 12: term->xtsave.cursor_blink = term->cursor_blink.decset; break;
692 case 25: term->xtsave.show_cursor = !term->hide_cursor; break;
693 case 45: term->xtsave.reverse_wrap = term->reverse_wrap; break;
694 case 47: term->xtsave.alt_screen = term->grid == &term->alt; break;
695 case 66: term->xtsave.application_keypad_keys = term->keypad_keys_mode == KEYPAD_APPLICATION; break;
696 case 67: break;
697 case 80: term->xtsave.sixel_display_mode = !term->sixel.scrolling; break;
698 case 1000: term->xtsave.mouse_click = term->mouse_tracking == MOUSE_CLICK; break;
699 case 1001: break;
700 case 1002: term->xtsave.mouse_drag = term->mouse_tracking == MOUSE_DRAG; break;
701 case 1003: term->xtsave.mouse_motion = term->mouse_tracking == MOUSE_MOTION; break;
702 case 1004: term->xtsave.focus_events = term->focus_events; break;
703 case 1005: /* term->xtsave.mouse_utf8 = term->mouse_reporting == MOUSE_UTF8; */ break;
704 case 1006: term->xtsave.mouse_sgr = term->mouse_reporting == MOUSE_SGR; break;
705 case 1007: term->xtsave.alt_scrolling = term->alt_scrolling; break;
706 case 1015: term->xtsave.mouse_urxvt = term->mouse_reporting == MOUSE_URXVT; break;
707 case 1016: term->xtsave.mouse_sgr_pixels = term->mouse_reporting == MOUSE_SGR_PIXELS; break;
708 case 1034: term->xtsave.meta_eight_bit = term->meta.eight_bit; break;
709 case 1035: term->xtsave.num_lock_modifier = term->num_lock_modifier; break;
710 case 1036: term->xtsave.meta_esc_prefix = term->meta.esc_prefix; break;
711 case 1042: term->xtsave.bell_action_enabled = term->bell_action_enabled; break;
712 case 1047: term->xtsave.alt_screen = term->grid == &term->alt; break;
713 case 1048: term_save_cursor(term); break;
714 case 1049: term->xtsave.alt_screen = term->grid == &term->alt; break;
715 case 1070: term->xtsave.sixel_private_palette = term->sixel.use_private_palette; break;
716 case 2004: term->xtsave.bracketed_paste = term->bracketed_paste; break;
717 case 2026: term->xtsave.app_sync_updates = term->render.app_sync_updates.enabled; break;
718 case 2027: term->xtsave.grapheme_shaping = term->grapheme_shaping; break;
719 case 2031: term->xtsave.report_theme_changes = term->report_theme_changes; break;
720 case 2033: term->xtsave.visibility_reports = term->visibility_reports; break;
721 case 2048: term->xtsave.size_notifications = term->size_notifications; break;
722 case 8452: term->xtsave.sixel_cursor_right_of_graphics = term->sixel.cursor_right_of_graphics; break;
723 case 737769: term->xtsave.ime = term_ime_is_enabled(term); break;
724 }
727static void
728xtrestore(struct terminal *term, unsigned param)
730 bool enable;
731 switch (param) {
732 case 1: enable = term->xtsave.application_cursor_keys; break;
733 case 5: enable = term->xtsave.reverse; break;
734 case 6: enable = term->xtsave.origin; break;
735 case 7: enable = term->xtsave.auto_margin; break;
736 case 9: /* enable = term->xtsave.mouse_x10; break; */ return;
737 case 12: enable = term->xtsave.cursor_blink; break;
738 case 25: enable = term->xtsave.show_cursor; break;
739 case 45: enable = term->xtsave.reverse_wrap; break;
740 case 47: enable = term->xtsave.alt_screen; break;
741 case 66: enable = term->xtsave.application_keypad_keys; break;
742 case 67: return;
743 case 80: enable = term->xtsave.sixel_display_mode; break;
744 case 1000: enable = term->xtsave.mouse_click; break;
745 case 1001: return;
746 case 1002: enable = term->xtsave.mouse_drag; break;
747 case 1003: enable = term->xtsave.mouse_motion; break;
748 case 1004: enable = term->xtsave.focus_events; break;
749 case 1005: /* enable = term->xtsave.mouse_utf8; break; */ return;
750 case 1006: enable = term->xtsave.mouse_sgr; break;
751 case 1007: enable = term->xtsave.alt_scrolling; break;
752 case 1015: enable = term->xtsave.mouse_urxvt; break;
753 case 1016: enable = term->xtsave.mouse_sgr_pixels; break;
754 case 1034: enable = term->xtsave.meta_eight_bit; break;
755 case 1035: enable = term->xtsave.num_lock_modifier; break;
756 case 1036: enable = term->xtsave.meta_esc_prefix; break;
757 case 1042: enable = term->xtsave.bell_action_enabled; break;
758 case 1047: enable = term->xtsave.alt_screen; break;
759 case 1048: enable = true; break;
760 case 1049: enable = term->xtsave.alt_screen; break;
761 case 1070: enable = term->xtsave.sixel_private_palette; break;
762 case 2004: enable = term->xtsave.bracketed_paste; break;
763 case 2026: enable = term->xtsave.app_sync_updates; break;
764 case 2027: enable = term->xtsave.grapheme_shaping; break;
765 case 2031: enable = term->xtsave.report_theme_changes; break;
766 case 2033: enable = term->xtsave.visibility_reports; break;
767 case 2048: enable = term->xtsave.size_notifications; break;
768 case 8452: enable = term->xtsave.sixel_cursor_right_of_graphics; break;
769 case 737769: enable = term->xtsave.ime; break;
771 default: return;
772 }
774 decset_decrst(term, param, enable);
777static bool
778params_to_rectangular_area(const struct terminal *term, int first_idx,
779 int *top, int *left, int *bottom, int *right)
781 int rel_top = vt_param_get(term, first_idx + 0, 1) - 1;
782 *left = min(vt_param_get(term, first_idx + 1, 1) - 1, term->cols - 1);
783 int rel_bottom = vt_param_get(term, first_idx + 2, term->rows) - 1;
784 *right = min(vt_param_get(term, first_idx + 3, term->cols) - 1, term->cols - 1);
786 if (unlikely(rel_top > rel_bottom || *left > *right))
787 return false;
789 *top = term_row_rel_to_abs(term, rel_top);
790 *bottom = term_row_rel_to_abs(term, rel_bottom);
792 return true;
795void
796csi_dispatch(struct terminal *term, uint8_t final)
798 LOG_DBG("%s (%08x)", csi_as_string(term, final, -1), term->vt.private);
800 switch (term->vt.private) {
801 case 0: {
802 switch (final) {
803 case 'b':
804 if (term->vt.last_printed != 0) {
805 /*
806 * Note: we never reset 'last-printed'. According to
807 * ECMA-48, the behaviour is undefined if REP was
808 * _not_ preceded by a graphical character.
809 */
810 const size_t max_count = term->grid->num_rows * term->cols;
811 int count = min(vt_param_get(term, 0, 1), max_count);
812 LOG_DBG("REP: '%lc' %d times", (wint_t)term->vt.last_printed, count);
814 int width;
816 if (term->vt.last_printed >= CELL_COMB_CHARS_LO) {
817 const struct composed *comp = composed_lookup(
818 term->composed, term->vt.last_printed - CELL_COMB_CHARS_LO);
820 xassert(comp != NULL);
821 width = comp->forced_width > 0 ? comp->forced_width : comp->width;
822 } else
823 width = c32width(term->vt.last_printed);
825 if (width > 0) {
826 for (int i = 0; i < count; i++)
827 term_print(term, term->vt.last_printed, width, false);
828 }
829 }
830 break;
832 case 'c': {
833 if (vt_param_get(term, 0, 0) != 0) {
834 UNHANDLED();
835 break;
836 }
838 /* Send Device Attributes (Primary DA) */
840 /*
841 * Responses:
842 * - CSI?1;2c vt100 with advanced video option
843 * - CSI?1;0c vt101 with no options
844 * - CSI?6c vt102
845 * - CSI?62;<Ps>c vt220
846 * - CSI?63;<Ps>c vt320
847 * - CSI?64;<Ps>c vt420
848 *
849 * Ps (response may contain multiple):
850 * - 1 132 columns
851 * - 2 Printer.
852 * - 3 ReGIS graphics.
853 * - 4 Sixel graphics.
854 * - 6 Selective erase.
855 * - 8 User-defined keys.
856 * - 9 National Replacement Character sets.
857 * - 15 Technical characters.
858 * - 16 Locator port.
859 * - 17 Terminal state interrogation.
860 * - 18 User windows.
861 * - 21 Horizontal scrolling.
862 * - 22 ANSI color, e.g., VT525.
863 * - 28 Rectangular editing.
864 * - 29 ANSI text locator (i.e., DEC Locator mode).
865 * - 52 Clipboard access
866 *
867 * Note: we report ourselves as a VT220, mainly to be able
868 * to pass parameters, to indicate we support sixel, and
869 * ANSI colors.
870 *
871 * The VT level must be synchronized with the secondary DA
872 * response.
873 *
874 * Note: tertiary DA responds with "FOOT".
875 */
876 char reply[32];
878 int len = snprintf(
879 reply, sizeof(reply), "\033[?62%s;22;28%sc",
880 term->conf->tweak.sixel ? ";4" : "",
881 (term->conf->security.osc52 == OSC52_ENABLED ||
882 term->conf->security.osc52 == OSC52_COPY_ENABLED ? ";52" : ""));
884 term_to_slave(term, reply, len);
885 break;
886 }
888 case 'd': {
889 /* VPA - vertical line position absolute */
890 int rel_row = vt_param_get(term, 0, 1) - 1;
891 int row = term_row_rel_to_abs(term, rel_row);
892 term_cursor_to(term, row, term->grid->cursor.point.col);
893 break;
894 }
896 case 'm':
897 csi_sgr(term);
898 break;
900 case 'A':
901 term_cursor_up(term, vt_param_get(term, 0, 1));
902 break;
904 case 'e':
905 case 'B':
906 term_cursor_down(term, vt_param_get(term, 0, 1));
907 break;
909 case 'a':
910 case 'C':
911 term_cursor_right(term, vt_param_get(term, 0, 1));
912 break;
914 case 'D':
915 term_cursor_left(term, vt_param_get(term, 0, 1));
916 break;
918 case 'E':
919 /* CNL - Cursor Next Line */
920 term_cursor_down(term, vt_param_get(term, 0, 1));
921 term_cursor_left(term, term->grid->cursor.point.col);
922 break;
924 case 'F':
925 /* CPL - Cursor Previous Line */
926 term_cursor_up(term, vt_param_get(term, 0, 1));
927 term_cursor_left(term, term->grid->cursor.point.col);
928 break;
930 case 'g': {
931 int param = vt_param_get(term, 0, 0);
932 switch (param) {
933 case 0:
934 /* Clear tab stop at *current* column */
935 tll_foreach(term->tab_stops, it) {
936 if (it->item == term->grid->cursor.point.col)
937 tll_remove(term->tab_stops, it);
938 else if (it->item > term->grid->cursor.point.col)
939 break;
940 }
942 break;
944 case 3:
945 /* Clear *all* tabs */
946 tll_free(term->tab_stops);
947 break;
949 default:
950 UNHANDLED();
951 break;
952 }
953 break;
954 }
956 case '`':
957 case 'G': {
958 /* Cursor horizontal absolute */
959 int col = min(vt_param_get(term, 0, 1), term->cols) - 1;
960 term_cursor_col(term, col);
961 break;
962 }
964 case 'f':
965 case 'H': {
966 /* Move cursor */
967 int rel_row = vt_param_get(term, 0, 1) - 1;
968 int row = term_row_rel_to_abs(term, rel_row);
969 int col = min(vt_param_get(term, 1, 1), term->cols) - 1;
970 term_cursor_to(term, row, col);
971 break;
972 }
974 case 'J': {
975 /* Erase screen */
977 int param = vt_param_get(term, 0, 0);
978 switch (param) {
979 case 0: {
980 /* From cursor to end of screen */
981 const struct coord *cursor = &term->grid->cursor.point;
982 term_erase(
983 term,
984 cursor->row, cursor->col,
985 term->rows - 1, term->cols - 1);
986 term->grid->cursor.lcf = false;
987 break;
988 }
990 case 1: {
991 /* From start of screen to cursor */
992 const struct coord *cursor = &term->grid->cursor.point;
993 term_erase(term, 0, 0, cursor->row, cursor->col);
994 term->grid->cursor.lcf = false;
995 break;
996 }
998 case 2:
999 /* Erase entire screen */
1000 term_erase(term, 0, 0, term->rows - 1, term->cols - 1);
1001 term->grid->cursor.lcf = false;
1002 break;
1004 case 3: {
1005 /* Erase scrollback */
1006 term_erase_scrollback(term);
1007 break;
1010 default:
1011 UNHANDLED();
1012 break;
1014 break;
1017 case 'K': {
1018 /* Erase line */
1020 int param = vt_param_get(term, 0, 0);
1021 switch (param) {
1022 case 0: {
1023 /* From cursor to end of line */
1024 const struct coord *cursor = &term->grid->cursor.point;
1025 term_erase(
1026 term,
1027 cursor->row, cursor->col,
1028 cursor->row, term->cols - 1);
1029 term->grid->cursor.lcf = false;
1030 break;
1033 case 1: {
1034 /* From start of line to cursor */
1035 const struct coord *cursor = &term->grid->cursor.point;
1036 term_erase(term, cursor->row, 0, cursor->row, cursor->col);
1037 term->grid->cursor.lcf = false;
1038 break;
1041 case 2: {
1042 /* Entire line */
1043 const struct coord *cursor = &term->grid->cursor.point;
1044 term_erase(term, cursor->row, 0, cursor->row, term->cols - 1);
1045 term->grid->cursor.lcf = false;
1046 break;
1049 default:
1050 UNHANDLED();
1051 break;
1054 break;
1057 case 'L': { /* IL */
1058 if (term->grid->cursor.point.row < term->scroll_region.start ||
1059 term->grid->cursor.point.row >= term->scroll_region.end)
1060 break;
1062 int count = min(
1063 vt_param_get(term, 0, 1),
1064 term->scroll_region.end - term->grid->cursor.point.row);
1066 term_scroll_reverse_partial(
1067 term,
1068 (struct scroll_region){
1069 .start = term->grid->cursor.point.row,
1070 .end = term->scroll_region.end},
1071 count);
1072 term->grid->cursor.lcf = false;
1073 term->grid->cursor.point.col = 0;
1074 break;
1077 case 'M': { /* DL */
1078 if (term->grid->cursor.point.row < term->scroll_region.start ||
1079 term->grid->cursor.point.row >= term->scroll_region.end)
1080 break;
1082 int count = min(
1083 vt_param_get(term, 0, 1),
1084 term->scroll_region.end - term->grid->cursor.point.row);
1086 term_scroll_partial(
1087 term,
1088 (struct scroll_region){
1089 .start = term->grid->cursor.point.row,
1090 .end = term->scroll_region.end},
1091 count);
1092 term->grid->cursor.lcf = false;
1093 term->grid->cursor.point.col = 0;
1094 break;
1097 case 'P': {
1098 /* DCH: Delete character(s) */
1100 /* Number of characters to delete */
1101 int count = min(
1102 vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
1104 /* Number of characters left after deletion (on current line) */
1105 int remaining = term->cols - (term->grid->cursor.point.col + count);
1107 /* 'Delete' characters by moving the remaining ones */
1108 memmove(&term->grid->cur_row->cells[term->grid->cursor.point.col],
1109 &term->grid->cur_row->cells[term->grid->cursor.point.col + count],
1110 remaining * sizeof(term->grid->cur_row->cells[0]));
1112 for (size_t c = 0; c < remaining; c++)
1113 term->grid->cur_row->cells[term->grid->cursor.point.col + c].attrs.clean = 0;
1114 term->grid->cur_row->dirty = true;
1116 /* Erase the remainder of the line */
1117 const struct coord *cursor = &term->grid->cursor.point;
1118 term_erase(
1119 term,
1120 cursor->row, cursor->col + remaining,
1121 cursor->row, term->cols - 1);
1122 term->grid->cursor.lcf = false;
1123 break;
1126 case '@': {
1127 /* ICH: insert character(s) */
1129 /* Number of characters to insert */
1130 int count = min(
1131 vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
1133 /* Characters to move */
1134 int remaining = term->cols - (term->grid->cursor.point.col + count);
1136 /* Push existing characters */
1137 memmove(&term->grid->cur_row->cells[term->grid->cursor.point.col + count],
1138 &term->grid->cur_row->cells[term->grid->cursor.point.col],
1139 remaining * sizeof(term->grid->cur_row->cells[0]));
1140 for (size_t c = 0; c < remaining; c++)
1141 term->grid->cur_row->cells[term->grid->cursor.point.col + count + c].attrs.clean = 0;
1142 term->grid->cur_row->dirty = true;
1144 /* Erase (insert space characters) */
1145 const struct coord *cursor = &term->grid->cursor.point;
1146 term_erase(
1147 term,
1148 cursor->row, cursor->col,
1149 cursor->row, cursor->col + count - 1);
1150 term->grid->cursor.lcf = false;
1151 break;
1154 case 'S': {
1155 const struct scroll_region *r = &term->scroll_region;
1156 int amount = min(vt_param_get(term, 0, 1), r->end - r->start);
1157 term_scroll(term, amount);
1158 break;
1161 case 'T': {
1162 const struct scroll_region *r = &term->scroll_region;
1163 int amount = min(vt_param_get(term, 0, 1), r->end - r->start);
1164 term_scroll_reverse(term, amount);
1165 break;
1168 case 'X': {
1169 /* Erase chars */
1170 int count = min(
1171 vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
1173 const struct coord *cursor = &term->grid->cursor.point;
1174 term_erase(
1175 term,
1176 cursor->row, cursor->col,
1177 cursor->row, cursor->col + count - 1);
1178 term->grid->cursor.lcf = false;
1179 break;
1182 case 'I': {
1183 /* CHT - Tab Forward (param is number of tab stops to move through) */
1184 int count = vt_param_get(term, 0, 1);
1185 int new_col = term->grid->cursor.point.col;
1186 tll_foreach(term->tab_stops, it) {
1187 if (it->item > new_col) {
1188 if (--count < 0) {
1189 break;
1191 new_col = it->item;
1194 xassert(new_col >= term->grid->cursor.point.col);
1196 bool lcf = term->grid->cursor.lcf;
1197 term_cursor_right(term, new_col - term->grid->cursor.point.col);
1198 term->grid->cursor.lcf = lcf;
1199 break;
1202 case 'Z': {
1203 /* CBT - Back tab (param is number of tab stops to move back through) */
1204 int count = vt_param_get(term, 0, 1);
1205 int new_col = term->grid->cursor.point.col;
1206 tll_rforeach(term->tab_stops, it) {
1207 if (it->item < new_col) {
1208 if (--count < 0) {
1209 break;
1211 new_col = it->item;
1214 xassert(term->grid->cursor.point.col >= new_col);
1215 term_cursor_left(term, term->grid->cursor.point.col - new_col);
1216 break;
1219 case 'h':
1220 case 'l': {
1221 /* Set/Reset Mode (SM/RM) */
1222 int param = vt_param_get(term, 0, 0);
1223 bool sm = final == 'h';
1224 if (param == 4) {
1225 /* Insertion Replacement Mode (IRM) */
1226 term->insert_mode = sm;
1227 term->bits_affecting_ascii_printer.insert_mode = sm;
1228 term_update_ascii_printer(term);
1229 break;
1232 /*
1233 * ECMA-48 defines modes 1-22, all of which were optional
1234 * (§7.1; "may have one state only") and are considered
1235 * deprecated (§7.1) in the latest (5th) edition. xterm only
1236 * documents modes 2, 4, 12 and 20, the last of which was
1237 * outright removed (§8.3.106) in 5th edition ECMA-48.
1238 */
1239 if (sm) {
1240 LOG_WARN("SM with unimplemented mode: %d", param);
1242 break;
1245 case 'r': {
1246 int start = vt_param_get(term, 0, 1);
1247 int end = min(vt_param_get(term, 1, term->rows), term->rows);
1249 if (end > start) {
1251 /* 1-based */
1252 term->scroll_region.start = start - 1;
1253 term->scroll_region.end = end;
1254 term_cursor_home(term);
1256 LOG_DBG("scroll region: %d-%d",
1257 term->scroll_region.start,
1258 term->scroll_region.end);
1260 break;
1263 case 's':
1264 term_save_cursor(term);
1265 break;
1267 case 'u':
1268 term_restore_cursor(term, &term->grid->saved_cursor);
1269 break;
1271 case 't': {
1272 /*
1273 * Window operations
1274 */
1276 const unsigned param = vt_param_get(term, 0, 0);
1278 switch (param) {
1279 case 1: LOG_WARN("unimplemented: de-iconify"); break;
1280 case 2: LOG_WARN("unimplemented: iconify"); break;
1281 case 3: LOG_WARN("unimplemented: move window to pixel position"); break;
1282 case 4: LOG_WARN("unimplemented: resize window in pixels"); break;
1283 case 5: LOG_WARN("unimplemented: raise window to front of stack"); break;
1284 case 6: LOG_WARN("unimplemented: raise window to back of stack"); break;
1285 case 7: LOG_WARN("unimplemented: refresh window"); break;
1286 case 8: LOG_WARN("unimplemented: resize window in chars"); break;
1287 case 9: LOG_WARN("unimplemented: maximize/unmaximize window"); break;
1288 case 10: LOG_WARN("unimplemented: to/from full screen"); break;
1289 case 20: LOG_WARN("unimplemented: report icon label"); break;
1290 case 24: LOG_WARN("unimplemented: resize window (DECSLPP)"); break;
1292 case 11: /* report if window is iconified */
1293 /* We don't know - always report *not* iconified */
1294 /* 1=not iconified, 2=iconified */
1295 term_to_slave(term, "\033[1t", 4);
1296 break;
1298 case 13: { /* report window position */
1299 /* We don't know our position - always report (0,0) */
1300 static const char reply[] = "\033[3;0;0t";
1301 switch (vt_param_get(term, 1, 0)) {
1302 case 0: /* window position */
1303 case 2: /* text area position */
1304 term_to_slave(term, reply, sizeof(reply) - 1);
1305 break;
1307 default:
1308 UNHANDLED();
1309 break;
1312 break;
1315 case 14: { /* report window size in pixels */
1316 int width = -1;
1317 int height = -1;
1319 switch (vt_param_get(term, 1, 0)) {
1320 case 0:
1321 /* text area size */
1322 width = term->width - term->margins.left - term->margins.right;
1323 height = term->height - term->margins.top - term->margins.bottom;
1324 break;
1326 case 2:
1327 /* window size */
1328 width = term->width;
1329 height = term->height;
1330 break;
1332 default:
1333 UNHANDLED();
1334 break;
1337 if (width >= 0 && height >= 0) {
1338 char reply[64];
1339 size_t n = xsnprintf(
1340 reply, sizeof(reply), "\033[4;%d;%dt", height, width);
1341 term_to_slave(term, reply, n);
1343 break;
1346 case 15: /* report screen size in pixels */
1347 tll_foreach(term->window->on_outputs, it) {
1348 char reply[64];
1349 size_t n = xsnprintf(reply, sizeof(reply), "\033[5;%d;%dt",
1350 it->item->dim.px_real.height,
1351 it->item->dim.px_real.width);
1352 term_to_slave(term, reply, n);
1353 break;
1356 if (tll_length(term->window->on_outputs) == 0)
1357 term_to_slave(term, "\033[5;0;0t", 8);
1358 break;
1360 case 16: { /* report cell size in pixels */
1361 char reply[64];
1362 size_t n = xsnprintf(
1363 reply, sizeof(reply), "\033[6;%d;%dt",
1364 term->cell_height, term->cell_width);
1365 term_to_slave(term, reply, n);
1366 break;
1369 case 18: { /* text area size in chars */
1370 char reply[64];
1371 size_t n = xsnprintf(reply, sizeof(reply), "\033[8;%d;%dt",
1372 term->rows, term->cols);
1373 term_to_slave(term, reply, n);
1374 break;
1377 case 19: { /* report screen size in chars */
1378 tll_foreach(term->window->on_outputs, it) {
1379 char reply[64];
1380 size_t n = xsnprintf(
1381 reply, sizeof(reply), "\033[9;%d;%dt",
1382 it->item->dim.px_real.height / term->cell_height,
1383 it->item->dim.px_real.width / term->cell_width);
1384 term_to_slave(term, reply, n);
1385 break;
1388 if (tll_length(term->window->on_outputs) == 0)
1389 term_to_slave(term, "\033[9;0;0t", 8);
1390 break;
1393 case 21: {
1394#if 0 /* Disabled for now, see #1894 */
1395 char reply[3 + strlen(term->window_title) + 2 + 1];
1396 int chars = xsnprintf(
1397 reply, sizeof(reply), "\033]l%s\033\\", term->window_title);
1398 term_to_slave(term, reply, chars);
1399#else
1400 LOG_WARN("CSI 21 t (report window title) ignored");
1401#endif
1402 break;
1405 case 22: { /* push window title */
1406 /* 0 - icon + title, 1 - icon, 2 - title */
1407 unsigned what = vt_param_get(term, 1, 0);
1408 if (what == 0 || what == 2) {
1409 if (tll_length(term->window_title_stack) < 128)
1410 tll_push_back(
1411 term->window_title_stack, xstrdup(term->window_title));
1412 else
1413 LOG_WARN("window title stack depth capped at 128 entries");
1415 break;
1418 case 23: { /* pop window title */
1419 /* 0 - icon + title, 1 - icon, 2 - title */
1420 unsigned what = vt_param_get(term, 1, 0);
1421 if (what == 0 || what == 2) {
1422 if (tll_length(term->window_title_stack) > 0) {
1423 char *title = tll_pop_back(term->window_title_stack);
1424 term_set_window_title(term, title);
1425 free(title);
1428 break;
1431 case 1001: {
1434 default:
1435 LOG_DBG("ignoring %s", csi_as_string(term, final, -1));
1436 break;
1438 break;
1441 case 'n': {
1442 if (term->vt.params.idx > 0) {
1443 int param = vt_param_get(term, 0, 0);
1444 switch (param) {
1445 case 5:
1446 /* Query device status */
1447 term_to_slave(term, "\x1b[0n", 4); /* "Device OK" */
1448 break;
1450 case 6: {
1451 /* u7 - cursor position query */
1453 int row = term->origin == ORIGIN_ABSOLUTE
1454 ? term->grid->cursor.point.row
1455 : term->grid->cursor.point.row - term->scroll_region.start;
1457 /* TODO: we use 0-based position, while the xterm
1458 * terminfo says the receiver of the reply should
1459 * decrement, hence we must add 1 */
1460 char reply[64];
1461 size_t n = xsnprintf(reply, sizeof(reply), "\x1b[%d;%dR",
1462 row + 1, term->grid->cursor.point.col + 1);
1463 term_to_slave(term, reply, n);
1464 break;
1467 default:
1468 UNHANDLED();
1469 break;
1471 } else
1472 UNHANDLED();
1474 break;
1477 default:
1478 UNHANDLED();
1479 break;
1482 break; /* private[0] == 0 */
1485 case '?': {
1486 switch (final) {
1487 case 'h':
1488 /* DECSET - DEC private mode set */
1489 for (size_t i = 0; i < term->vt.params.idx; i++)
1490 decset(term, term->vt.params.v[i].value);
1491 break;
1493 case 'l':
1494 /* DECRST - DEC private mode reset */
1495 for (size_t i = 0; i < term->vt.params.idx; i++)
1496 decrst(term, term->vt.params.v[i].value);
1497 break;
1499 case 's':
1500 for (size_t i = 0; i < term->vt.params.idx; i++)
1501 xtsave(term, term->vt.params.v[i].value);
1502 break;
1504 case 'r':
1505 for (size_t i = 0; i < term->vt.params.idx; i++)
1506 xtrestore(term, term->vt.params.v[i].value);
1507 break;
1509 case 'S': {
1510 if (!term->conf->tweak.sixel) {
1511 UNHANDLED();
1512 break;
1515 unsigned target = vt_param_get(term, 0, 0);
1516 unsigned operation = vt_param_get(term, 1, 0);
1518 switch (target) {
1519 case 1:
1520 switch (operation) {
1521 case 1: sixel_colors_report_current(term); break;
1522 case 2: sixel_colors_reset(term); break;
1523 case 3: sixel_colors_set(term, vt_param_get(term, 2, 0)); break;
1524 case 4: sixel_colors_report_max(term); break;
1525 default: UNHANDLED(); break;
1527 break;
1529 case 2:
1530 switch (operation) {
1531 case 1: sixel_geometry_report_current(term); break;
1532 case 2: sixel_geometry_reset(term); break;
1533 case 3: sixel_geometry_set(term, vt_param_get(term, 2, 0), vt_param_get(term, 3, 0)); break;
1534 case 4: sixel_geometry_report_max(term); break;
1535 default: UNHANDLED(); break;
1537 break;
1539 default:
1540 UNHANDLED();
1541 break;
1544 break;
1547 case 'm': {
1548 int resource = vt_param_get(term, 0, 0);
1549 int value = -1;
1551 switch (resource) {
1552 case 0: /* modifyKeyboard */
1553 value = 0;
1554 break;
1556 case 1: /* modifyCursorKeys */
1557 case 2: /* modifyFunctionKeys */
1558 value = 1;
1559 break;
1561 case 4: /* modifyOtherKeys */
1562 value = term->modify_other_keys_2 ? 2 : 1;
1563 break;
1565 default:
1566 LOG_WARN("XTQMODKEYS: invalid resource '%d' in '%s'",
1567 resource, csi_as_string(term, final, -1));
1568 break;
1571 if (value >= 0) {
1572 char reply[16] = {0};
1573 int chars = snprintf(reply, sizeof(reply),
1574 "\033[>%d;%dm", resource, value);
1575 term_to_slave(term, reply, chars);
1577 break;
1580 case 'n': {
1581 const int param = vt_param_get(term, 0, 0);
1583 switch (param) {
1584 case 996: { /* Query current theme mode (see private mode 2031) */
1585 /*
1586 * 1 - dark mode
1587 * 2 - light mode
1589 * In foot, the themes aren't necessarily light/dark,
1590 * but by convention, the primary theme is dark, and
1591 * the alternative theme is light.
1592 */
1593 char reply[16] = {0};
1594 int chars = snprintf(
1595 reply, sizeof(reply),
1596 "\033[?997;%dn",
1597 term->colors.active_theme == COLOR_THEME_DARK ? 1 : 2);
1599 term_to_slave(term, reply, chars);
1600 break;
1603 case 998:
1604 term_send_visibility_report(term);
1605 break;
1607 break;
1610 case 'p': {
1611 /*
1612 * Request status of ECMA-48/"ANSI" private mode (DECRQM
1613 * for SM/RM modes; see private="?$" case further below for
1614 * DECSET/DECRST modes)
1615 */
1616 unsigned param = vt_param_get(term, 0, 0);
1617 unsigned status = DECRPM_NOT_RECOGNIZED;
1618 if (param == 4) {
1619 status = decrpm(term->insert_mode);
1621 char reply[32];
1622 size_t n = xsnprintf(reply, sizeof(reply), "\033[%u;%u$y", param, status);
1623 term_to_slave(term, reply, n);
1624 break;
1627 case 'u': {
1628 enum kitty_kbd_flags flags =
1629 term->grid->kitty_kbd.flags[term->grid->kitty_kbd.idx];
1631 char reply[8];
1632 int chars = snprintf(reply, sizeof(reply), "\033[?%uu", flags);
1633 term_to_slave(term, reply, chars);
1634 break;
1637 default:
1638 UNHANDLED();
1639 break;
1642 break; /* private[0] == '?' */
1645 case '>': {
1646 switch (final) {
1647 case 'c':
1648 /* Send Device Attributes (Secondary DA) */
1649 if (vt_param_get(term, 0, 0) != 0) {
1650 UNHANDLED();
1651 break;
1654 /*
1655 * Param 1 - terminal type:
1656 * 0 - vt100
1657 * 1 - vt220
1658 * 2 - vt240
1659 * 18 - vt330
1660 * 19 - vt340
1661 * 24 - vt320
1662 * 41 - vt420
1663 * 61 - vt510
1664 * 64 - vt520
1665 * 65 - vt525
1667 * Param 2 - firmware version xterm uses its version
1668 * number. We do to, in the format "MAJORMINORPATCH",
1669 * where all three version numbers are always two
1670 * digits. So e.g. 1.25.0 is reported as 012500.
1672 * We report ourselves as a VT220. This must be
1673 * synchronized with the primary DA response.
1675 * Note: tertiary DA replies with "FOOT".
1676 */
1678 static_assert(FOOT_MAJOR < 100, "Major version must not exceed 99");
1679 static_assert(FOOT_MINOR < 100, "Minor version must not exceed 99");
1680 static_assert(FOOT_PATCH < 100, "Patch version must not exceed 99");
1682 char reply[64];
1683 size_t n = xsnprintf(reply, sizeof(reply), "\033[>1;%02u%02u%02u;0c",
1684 FOOT_MAJOR, FOOT_MINOR, FOOT_PATCH);
1686 term_to_slave(term, reply, n);
1687 break;
1689 case 'm':
1690 if (term->vt.params.idx == 0) {
1691 /* Reset all */
1692 } else {
1693 int resource = vt_param_get(term, 0, 0);
1694 int value = vt_param_get(term, 1, -1);
1696 switch (resource) {
1697 case 0: /* modifyKeyboard */
1698 break;
1700 case 1: /* modifyCursorKeys */
1701 case 2: /* modifyFunctionKeys */
1702 /* Ignored, we always report modifiers */
1703 if (value != 2 && value != -1) {
1704 LOG_WARN(
1705 "unimplemented: %s = %d",
1706 resource == 1 ? "modifyCursorKeys" :
1707 resource == 2 ? "modifyFunctionKeys" : "<invalid>",
1708 value);
1710 break;
1712 case 4: /* modifyOtherKeys */
1713 term->modify_other_keys_2 = value == 2;
1714 LOG_DBG("modifyOtherKeys=%d", value);
1715 break;
1717 default:
1718 LOG_WARN("XTMODKEYS: invalid resource '%d' in '%s'",
1719 resource, csi_as_string(term, final, -1));
1720 break;
1723 break; /* final == 'm' */
1725 case 'n': {
1726 int resource = vt_param_get(term, 0, 2); /* Default is modifyFunctionKeys */
1727 switch (resource) {
1728 case 0: /* modifyKeyboard */
1729 case 1: /* modifyCursorKeys */
1730 case 2: /* modifyFunctionKeys */
1731 break;
1733 case 4: /* modifyOtherKeys */
1734 /* We don't support fully disabling modifyOtherKeys,
1735 * but simply revert back to mode '1' */
1736 term->modify_other_keys_2 = false;
1737 LOG_DBG("modifyOtherKeys=1");
1738 break;
1740 break;
1743 case 'u': {
1744 int flags = vt_param_get(term, 0, 0) & KITTY_KBD_SUPPORTED;
1746 struct grid *grid = term->grid;
1747 uint8_t idx = grid->kitty_kbd.idx;
1749 if (idx + 1 >= ALEN(grid->kitty_kbd.flags)) {
1750 /* Stack full, evict oldest by wrapping around */
1751 idx = 0;
1752 } else
1753 idx++;
1755 grid->kitty_kbd.flags[idx] = flags;
1756 grid->kitty_kbd.idx = idx;
1758 LOG_DBG("kitty kbd: pushed new flags: 0x%03x", flags);
1759 break;
1762 case 'q': {
1763 /* XTVERSION */
1764 if (vt_param_get(term, 0, 0) != 0) {
1765 UNHANDLED();
1766 break;
1769 char reply[64];
1770 size_t n = xsnprintf(
1771 reply, sizeof(reply), "\033P>|foot(%u.%u.%u%s%s)\033\\",
1772 FOOT_MAJOR, FOOT_MINOR, FOOT_PATCH,
1773 FOOT_EXTRA[0] != '\0' ? "-" : "", FOOT_EXTRA);
1774 term_to_slave(term, reply, n);
1775 break;
1778 default:
1779 UNHANDLED();
1780 break;
1783 break; /* private[0] == '>' */
1786 case '<': {
1787 switch (final) {
1788 case 'u': {
1789 struct grid *grid = term->grid;
1790 int count = min(vt_param_get(term, 0, 1), ALEN(grid->kitty_kbd.flags));
1791 LOG_DBG("kitty kbd: popping %d levels of flags", count);
1793 uint8_t idx = grid->kitty_kbd.idx;
1795 for (int i = 0; i < count; i++) {
1796 /* Reset flags. This ensures we get flags=0 when
1797 * over-popping */
1798 grid->kitty_kbd.flags[idx] = 0;
1800 if (idx == 0)
1801 idx = ALEN(grid->kitty_kbd.flags) - 1;
1802 else
1803 idx--;
1806 grid->kitty_kbd.idx = idx;
1808 LOG_DBG("kitty kbd: flags after pop: 0x%03x",
1809 term->grid->kitty_kbd.flags[idx]);
1810 break;
1813 break; /* private[0] == '<' */
1816 case ' ': {
1817 switch (final) {
1818 case 'q': {
1819 int param = vt_param_get(term, 0, 0);
1820 switch (param) {
1821 case 0: /* blinking block, but we use it to reset to configured default */
1822 term->cursor_style = term->conf->cursor.style;
1823 term->cursor_blink.deccsusr = term->conf->cursor.blink.enabled;
1824 term_cursor_blink_update(term);
1825 break;
1827 case 1: /* blinking block */
1828 case 2: /* steady block */
1829 term->cursor_style = term->conf->cursor.style == CURSOR_HOLLOW
1830 ? CURSOR_HOLLOW : CURSOR_BLOCK;
1831 break;
1833 case 3: /* blinking underline */
1834 case 4: /* steady underline */
1835 term->cursor_style = CURSOR_UNDERLINE;
1836 break;
1838 case 5: /* blinking bar */
1839 case 6: /* steady bar */
1840 term->cursor_style = CURSOR_BEAM;
1841 break;
1843 default:
1844 UNHANDLED();
1845 break;
1848 if (param > 0 && param <= 6) {
1849 term->cursor_blink.deccsusr = param & 1;
1850 term_cursor_blink_update(term);
1852 break;
1855 default:
1856 UNHANDLED();
1857 break;
1859 break; /* private[0] == ' ' */
1862 case '!': {
1863 if (final == 'p') {
1864 term_reset(term, false);
1865 break;
1868 UNHANDLED();
1869 break; /* private[0] == '!' */
1872 case '=': {
1873 switch (final) {
1874 case 'c':
1875 if (vt_param_get(term, 0, 0) != 0) {
1876 UNHANDLED();
1877 break;
1880 /*
1881 * Send Device Attributes (Tertiary DA)
1883 * Reply format is "DCS ! | DDDDDDDD ST"
1885 * D..D is the unit ID of the terminal, consisting of four
1886 * hexadecimal pairs. The first pair represents the
1887 * manufacturing site code. This code can be any
1888 * hexadecimal value from 00 through FF.
1889 */
1891 term_to_slave(term, "\033P!|464f4f54\033\\", 14); /* FOOT */
1892 break;
1894 case 'u': {
1895 int flag_set = vt_param_get(term, 0, 0) & KITTY_KBD_SUPPORTED;
1896 int mode = vt_param_get(term, 1, 1);
1898 struct grid *grid = term->grid;
1899 uint8_t idx = grid->kitty_kbd.idx;
1901 switch (mode) {
1902 case 1:
1903 /* set bits are set, unset bits are reset */
1904 grid->kitty_kbd.flags[idx] = flag_set;
1905 break;
1907 case 2:
1908 /* set bits are set, unset bits are left unchanged */
1909 grid->kitty_kbd.flags[idx] |= flag_set;
1910 break;
1912 case 3:
1913 /* set bits are reset, unset bits are left unchanged */
1914 grid->kitty_kbd.flags[idx] &= ~flag_set;
1915 break;
1917 default:
1918 UNHANDLED();
1919 break;
1922 LOG_DBG("kitty kbd: flags after update: 0x%03x",
1923 grid->kitty_kbd.flags[idx]);
1924 break;
1927 default:
1928 UNHANDLED();
1929 break;
1931 break; /* private[0] == '=' */
1934 case '$': {
1935 switch (final) {
1936 case 'r': { /* DECCARA */
1937 int top, left, bottom, right;
1938 if (!params_to_rectangular_area(
1939 term, 0, &top, &left, &bottom, &right))
1941 break;
1944 for (int r = top; r <= bottom; r++) {
1945 struct row *row = grid_row(term->grid, r);
1946 row->dirty = true;
1948 for (int c = left; c <= right; c++) {
1949 struct attributes *a = &row->cells[c].attrs;
1950 a->clean = 0;
1952 for (size_t i = 4; i < term->vt.params.idx; i++) {
1953 const int param = term->vt.params.v[i].value;
1955 /* DECCARA only supports a sub-set of SGR parameters */
1956 switch (param) {
1957 case 0:
1958 a->bold = false;
1959 a->underline = false;
1960 a->blink = false;
1961 a->reverse = false;
1962 break;
1964 case 1: a->bold = true; break;
1965 case 4: a->underline = true; break;
1966 case 5: a->blink = true; break;
1967 case 7: a->reverse = true; break;
1969 case 22: a->bold = false; break;
1970 case 24: a->underline = false; break;
1971 case 25: a->blink = false; break;
1972 case 27: a->reverse = false; break;
1977 break;
1980 case 't': { /* DECRARA */
1981 int top, left, bottom, right;
1982 if (!params_to_rectangular_area(
1983 term, 0, &top, &left, &bottom, &right))
1985 break;
1988 for (int r = top; r <= bottom; r++) {
1989 struct row *row = grid_row(term->grid, r);
1990 row->dirty = true;
1992 for (int c = left; c <= right; c++) {
1993 struct attributes *a = &row->cells[c].attrs;
1994 a->clean = 0;
1996 for (size_t i = 4; i < term->vt.params.idx; i++) {
1997 const int param = term->vt.params.v[i].value;
1999 /* DECRARA only supports a sub-set of SGR parameters */
2000 switch (param) {
2001 case 0:
2002 a->bold = !a->bold;
2003 a->underline = !a->underline;
2004 a->blink = !a->blink;
2005 a->reverse = !a->reverse;
2006 break;
2008 case 1: a->bold = !a->bold; break;
2009 case 4: a->underline = !a->underline; break;
2010 case 5: a->blink = !a->blink; break;
2011 case 7: a->reverse = !a->reverse; break;
2016 break;
2019 case 'v': { /* DECCRA */
2020 int src_top, src_left, src_bottom, src_right;
2021 if (!params_to_rectangular_area(
2022 term, 0, &src_top, &src_left, &src_bottom, &src_right))
2024 break;
2027 int src_page = vt_param_get(term, 4, 1);
2028 int dst_rel_top = vt_param_get(term, 5, 1) - 1;
2029 int dst_left = min(vt_param_get(term, 6, 1) - 1, term->cols - 1);
2030 int dst_page = vt_param_get(term, 7, 1);
2032 if (unlikely(src_page != 1 || dst_page != 1)) {
2033 /* We don’t support “pages” */
2034 break;
2037 int dst_rel_bottom = dst_rel_top + (src_bottom - src_top);
2038 int dst_right = min(dst_left + (src_right - src_left), term->cols - 1);
2040 int dst_top = term_row_rel_to_abs(term, dst_rel_top);
2041 int dst_bottom = term_row_rel_to_abs(term, dst_rel_bottom);
2043 if (unlikely(dst_left > dst_right || dst_top > dst_bottom))
2044 break;
2046 /*
2047 * src validated by params_to_rectangular_area()
2048 * dst validated above
2049 */
2050 xassert(src_bottom - src_top >= 0);
2051 xassert(dst_bottom - dst_top >= 0);
2052 xassert(src_right - src_left >= 0);
2053 xassert(dst_right - dst_left >= 0);
2055 /* Target area outside the screen is clipped */
2056 const size_t row_count = min(src_bottom - src_top,
2057 dst_bottom - dst_top) + 1;
2058 const size_t cell_count = min(src_right - src_left,
2059 dst_right - dst_left) + 1;
2061 sixel_overwrite_by_rectangle(
2062 term, dst_top, dst_left, row_count, cell_count);
2064 /*
2065 * Copy source area
2067 * Note: since source and destination may overlap, we need
2068 * to copy out the entire source region first, and _then_
2069 * write the destination. I.e. this is similar to how
2070 * memmove() behaves, but adapted to our row/cell
2071 * structure.
2072 */
2073 struct cell **copy = xmalloc(row_count * sizeof(copy[0]));
2074 for (int r = 0; r < row_count; r++) {
2075 copy[r] = xmalloc(cell_count * sizeof(copy[r][0]));
2077 const struct row *row = grid_row(term->grid, src_top + r);
2078 const struct cell *cell = &row->cells[src_left];
2079 memcpy(copy[r], cell, cell_count * sizeof(copy[r][0]));
2082 /* Paste into destination area */
2083 for (int r = 0; r < row_count; r++) {
2084 struct row *row = grid_row(term->grid, dst_top + r);
2085 row->dirty = true;
2087 struct cell *cell = &row->cells[dst_left];
2088 memcpy(cell, copy[r], cell_count * sizeof(copy[r][0]));
2089 free(copy[r]);
2091 for (;cell < &row->cells[dst_left + cell_count]; cell++)
2092 cell->attrs.clean = 0;
2094 if (unlikely(row->extra != NULL)) {
2095 /* TODO: technically, we should copy the source URIs... */
2096 grid_row_uri_range_erase(row, dst_left, dst_right);
2099 free(copy);
2100 break;
2103 case 'x': { /* DECFRA */
2104 const uint8_t c = vt_param_get(term, 0, 0);
2106 if (unlikely(!((c >= 32 && c < 126) || c >= 160)))
2107 break;
2109 int top, left, bottom, right;
2110 if (!params_to_rectangular_area(
2111 term, 1, &top, &left, &bottom, &right))
2113 break;
2116 /* Erase the entire region at once (MUCH cheaper than
2117 * doing it row by row, or even character by
2118 * character). */
2119 sixel_overwrite_by_rectangle(
2120 term, top, left, bottom - top + 1, right - left + 1);
2122 for (int r = top; r <= bottom; r++)
2123 term_fill(term, r, left, c, right - left + 1, true);
2125 break;
2128 case 'z': { /* DECERA */
2129 int top, left, bottom, right;
2130 if (!params_to_rectangular_area(
2131 term, 0, &top, &left, &bottom, &right))
2133 break;
2136 /*
2137 * Note: term_erase() _also_ erases sixels, but since
2138 * we’re forced to erase one row at a time, erasing the
2139 * entire sixel here is more efficient.
2140 */
2141 sixel_overwrite_by_rectangle(
2142 term, top, left, bottom - top + 1, right - left + 1);
2144 for (int r = top; r <= bottom; r++)
2145 term_erase(term, r, left, r, right);
2146 break;
2150 break; /* private[0] == ‘$’ */
2153 case '#': {
2154 switch (final) {
2155 case 'P': { /* XTPUSHCOLORS */
2156 int slot = vt_param_get(term, 0, 0);
2158 /* Pm == 0, "push" (what xterm does is take take the
2159 *current* slot + 1, even if that's in the middle of the
2160 stack, and overwrites whatever is already in that
2161 slot) */
2162 if (slot == 0)
2163 slot = term->color_stack.idx + 1;
2165 const size_t max_slot = 128;
2166 if (slot > max_slot) {
2167 LOG_WARN("XTPUSHCOLORS slot index capped to 128");
2168 slot = max_slot;
2171 if (term->color_stack.size < slot) {
2172 const size_t new_size = slot;
2173 term->color_stack.stack = xrealloc(
2174 term->color_stack.stack,
2175 new_size * sizeof(term->color_stack.stack[0]));
2177 /* Initialize new slots (except the selected slot,
2178 which is done below) */
2179 xassert(new_size > 0);
2180 for (size_t i = term->color_stack.size; i < new_size - 1; i++) {
2181 memcpy(&term->color_stack.stack[i], &term->colors,
2182 sizeof(term->colors));
2184 term->color_stack.size = new_size;
2187 xassert(slot > 0);
2188 xassert(slot <= term->color_stack.size);
2189 term->color_stack.idx = slot;
2190 memcpy(&term->color_stack.stack[slot - 1], &term->colors,
2191 sizeof(term->colors));
2192 break;
2195 case 'Q': { /* XTPOPCOLORS */
2196 int slot = vt_param_get(term, 0, 0);
2198 /* Pm == 0, "pop" (what xterm does is copy colors from the
2199 *current* slot, *and* decrease the current slot index,
2200 even if that's in the middle of the stack) */
2201 if (slot == 0)
2202 slot = term->color_stack.idx;
2204 if (slot > 0 && slot <= term->color_stack.size) {
2205 memcpy(&term->colors, &term->color_stack.stack[slot - 1],
2206 sizeof(term->colors));
2207 term->color_stack.idx = slot - 1;
2209 /* Assume a full palette switch *will* affect almost
2210 all cells. The alternative is to call
2211 term_damage_color() for all 256 palette entries
2212 *and* the default fg/bg (256 + 2 calls in total) */
2213 term_damage_view(term);
2214 term_damage_margins(term);
2215 } else if (slot == 0) {
2216 LOG_ERR("XTPOPCOLORS: cannot pop beyond the first element");
2217 } else {
2218 LOG_ERR(
2219 "XTPOPCOLORS: invalid color slot: %d "
2220 "(stack has %zu slots, current slot is %zu)",
2221 vt_param_get(term, 0, 0),
2222 term->color_stack.size, term->color_stack.idx);
2224 break;
2227 case 'R': { /* XTREPORTCOLORS */
2228 char reply[64];
2229 size_t n = xsnprintf(reply, sizeof(reply), "\033[?%zu;%zu#Q",
2230 term->color_stack.idx, term->color_stack.size);
2231 term_to_slave(term, reply, n);
2232 break;
2235 break; /* private[0] == '#' */
2238 case 0x243f: /* ?$ */
2239 switch (final) {
2240 case 'p': {
2241 unsigned param = vt_param_get(term, 0, 0);
2243 /*
2244 * Request DEC private mode (DECRQM)
2245 * Reply:
2246 * 0 - not recognized
2247 * 1 - set
2248 * 2 - reset
2249 * 3 - permanently set
2250 * 4 - permantently reset
2251 */
2252 unsigned status = decrqm(term, param);
2253 char reply[32];
2254 size_t n = xsnprintf(reply, sizeof(reply), "\033[?%u;%u$y", param, status);
2255 term_to_slave(term, reply, n);
2256 break;
2260 default:
2261 UNHANDLED();
2262 break;
2265 break; /* private[0] == '?' && private[1] == '$' */
2267 default:
2268 UNHANDLED();
2269 break;
Diagnostics5 git calls · 636 ms
CallStatusSizeTime0636 ms
discover200178 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=178
git.server.agent=git/2.56.1-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=178
git.pkt.payload.max=35
ls-refs20010 KiB582 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=577
git.response.bytes=10322
git.response.cache=EXPIRED
git.response.duration_ms=582
git.protocol.version=2
git.pkt.frames=108
git.pkt.data=107
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=10322
git.pkt.payload.max=106
git.ls_refs.count=107
git.ls_refs.head=refs/heads/master
fetchtree:0 · deepen 102009.3 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=9489
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=9489
git.pkt.payload.max=9389
git.sideband.band1.bytes=9389
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=10
git.pack.bytes=9389
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=de930681b6073ba5b599a0f956bfbd114762ad5a
git.pack.full=10
Open pack map
fetchcombine:blob:none+tree:2 · deepen 12008.6 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=8830
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=8830
git.pkt.payload.max=8730
git.sideband.band1.bytes=8730
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=14
git.pack.bytes=8730
git.fetch.wide.objects=14
git.fetch.wide.extra_bytes=9909
git.fetch.wide.blobs=0
fetch20014 KiB · hit51 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=51
git.response.bytes=14220
git.response.cache=HIT
git.response.duration_ms=51
git.fetch.wants=c1738cf7c04df5e576154b8e70d1e733729946d4
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=14220
git.pkt.payload.max=14193
git.sideband.band1.bytes=14193
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://codeberg.org/dnkl/foot
Ref
refs/heads/master
Commit
c0d2c3e95d74cb60526ff28aec9f34ee3df545e0
cf-ray
a5e21db08ca8a87d
Request
4304ad27…
Protocol
v2 · sha1
Agent
git/2.56.1-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format