Codebergdnkl
foot
master
1#include "server.h"
3#include <string.h>
4#include <fcntl.h>
5#include <unistd.h>
6#include <errno.h>
7#include <limits.h>
9#include <sys/types.h>
10#include <sys/socket.h>
11#include <sys/epoll.h>
13#include <sys/un.h>
15#include <tllist.h>
17#define LOG_MODULE "server"
18#define LOG_ENABLE_DBG 0
19#include "log.h"
21#include "client-protocol.h"
22#include "terminal.h"
23#include "util.h"
24#include "wayland.h"
25#include "xmalloc.h"
27#define NON_ZERO_OPT (INT_MIN / 7)
29struct client;
30struct terminal_instance;
32struct server {
33 struct config *conf;
34 struct fdm *fdm;
35 struct reaper *reaper;
36 struct wayland *wayl;
38 int fd;
39 const char *sock_path;
41 tll(struct client *) clients;
42 tll(struct terminal_instance *) terminals;
43};
45struct client {
46 struct server *server;
47 int fd;
49 struct {
50 uint8_t *data;
51 size_t left;
52 size_t idx;
53 } buffer;
55 struct terminal_instance *instance;
56};
57static void client_destroy(struct client *client);
59struct terminal_instance {
60 struct terminal *terminal;
61 struct server *server;
62 struct client *client;
63 struct config *conf;
64};
65static void instance_destroy(struct terminal_instance *instance, int exit_code);
67static void
68client_destroy(struct client *client)
69{
70 if (client == NULL)
71 return;
73 if (client->instance != NULL) {
74 LOG_WARN("client FD=%d: terminal still alive", client->fd);
75 client->instance->client = NULL;
76 instance_destroy(client->instance, 1);
77 }
79 if (client->fd != -1) {
80 LOG_DBG("client FD=%d: disconnected", client->fd);
81 fdm_del(client->server->fdm, client->fd);
82 }
84 tll_foreach(client->server->clients, it) {
85 if (it->item == client) {
86 tll_remove(client->server->clients, it);
87 break;
88 }
89 }
91 free(client->buffer.data);
92 free(client);
93}
95static void
96client_send_exit_code(struct client *client, int exit_code)
97{
98 if (client->fd == -1)
99 return;
101 if (write(client->fd, &exit_code, sizeof(exit_code)) != sizeof(exit_code))
102 LOG_ERRNO("failed to write slave exit code to client");
103}
105static void
106instance_destroy(struct terminal_instance *instance, int exit_code)
107{
108 if (instance->terminal != NULL)
109 term_destroy(instance->terminal);
111 tll_foreach(instance->server->terminals, it) {
112 if (it->item == instance) {
113 tll_remove(instance->server->terminals, it);
114 break;
115 }
116 }
118 if (instance->client != NULL) {
119 instance->client->instance = NULL;
120 client_send_exit_code(instance->client, exit_code);
121 client_destroy(instance->client);
122 }
124 /* TODO: clone server conf completely, so that we can just call
125 * conf_destroy() here */
126 if (instance->conf != NULL) {
127 config_free(instance->conf);
128 free(instance->conf);
129 }
130 free(instance);
132}
134static void
135term_shutdown_handler(void *data, int exit_code)
136{
137 struct terminal_instance *instance = data;
139 instance->terminal = NULL;
140 instance_destroy(instance, exit_code);
141}
143static bool
144fdm_client(struct fdm *fdm, int fd, int events, void *data)
145{
146 struct client *client = data;
147 struct server *server = client->server;
149 char **argv = NULL;
150 config_override_t overrides = tll_init();
151 char **envp = NULL;
153 if (events & EPOLLHUP)
154 goto shutdown;
156 xassert(events & EPOLLIN);
158 if (client->instance != NULL) {
159 struct client_ipc_hdr ipc_hdr;
160 ssize_t count = read(fd, &ipc_hdr, sizeof(ipc_hdr));
162 if (count != sizeof(ipc_hdr)) {
163 LOG_WARN("client unexpectedly sent %zd bytes", count);
164 return true; /* TODO: shutdown instead? */
165 }
167 switch (ipc_hdr.ipc_code) {
168 case FOOT_IPC_SIGUSR: {
169 xassert(ipc_hdr.size == sizeof(struct client_ipc_sigusr));
171 struct client_ipc_sigusr sigusr;
172 count = read(fd, &sigusr, sizeof(sigusr));
173 if (count < 0) {
174 LOG_ERRNO("failed to read SIGUSR IPC data from client");
175 return true; /* TODO: shutdown instead? */
176 }
178 if ((size_t)count != sizeof(sigusr)) {
179 LOG_ERR("failed to read SIGUSR IPC data from client");
180 return true; /* TODO: shutdown instead? */
181 }
183 switch (sigusr.signo) {
184 case SIGUSR1:
185 term_theme_switch_to_dark(client->instance->terminal);
186 break;
188 case SIGUSR2:
189 term_theme_switch_to_light(client->instance->terminal);
190 break;
192 default:
193 LOG_ERR(
194 "client sent bad SIGUSR number: %d "
195 "(expected SIGUSR1=%d or SIGUSR2=%d)",
196 sigusr.signo, SIGUSR1, SIGUSR2);
197 break;
198 }
200 return true;
201 }
203 default:
204 LOG_WARN(
205 "client sent unrecognized IPC (0x%04x), ignoring %hhu bytes",
206 ipc_hdr.ipc_code, ipc_hdr.size);
208 /* TODO: slightly broken, since not all data is guaranteed
209 to be readable yet */
210 uint8_t dummy[ipc_hdr.size];
211 (void)!!read(fd, dummy, ipc_hdr.size);
212 return true;
213 }
214 }
216 if (client->buffer.data == NULL) {
217 /*
218 * We haven't received any data yet - the first thing the
219 * client sends is the total size of the initialization
220 * data.
221 */
222 uint32_t total_len;
223 ssize_t count = recv(fd, &total_len, sizeof(total_len), 0);
224 if (count < 0) {
225 LOG_ERRNO("failed to read total length");
226 goto shutdown;
227 }
229 if (count != sizeof(total_len)) {
230 LOG_ERR("client did not send setup packet size");
231 goto shutdown;
232 }
234 const uint32_t max_size = 128 * 1024;
235 if (total_len > max_size) {
236 LOG_ERR("client wants to send too large setup packet (%u > %u)",
237 total_len, max_size);
238 goto shutdown;
239 }
241 LOG_DBG("total len: %u", total_len);
242 client->buffer.data = xmalloc(total_len + 1);
243 client->buffer.left = total_len;
244 client->buffer.idx = 0;
246 /* Prevent our strlen() calls to run outside */
247 client->buffer.data[total_len] = '\0';
248 return true; /* Let FDM trigger again when we have more data */
249 }
251 /* Keep filling our buffer of initialization data */
252 ssize_t count = recv(
253 fd, &client->buffer.data[client->buffer.idx], client->buffer.left, 0);
255 if (count < 0) {
256 LOG_ERRNO("failed to read");
257 goto shutdown;
258 }
260 client->buffer.idx += count;
261 client->buffer.left -= count;
263 if (client->buffer.left > 0) {
264 /* Not done yet */
265 return true;
266 }
268 if (tll_length(server->wayl->monitors) == 0) {
269 LOG_ERR("no monitors available for new terminal");
270 client_send_exit_code(client, -26);
271 goto shutdown;
272 }
274 /* All initialization data received - time to instantiate a terminal! */
276 xassert(client->instance == NULL);
277 xassert(client->buffer.data != NULL);
278 xassert(client->buffer.left == 0);
280 /*
281 * Parse the received buffer, verifying lengths etc
282 */
284#define CHECK_BUF(sz) do { \
285 if (p + (sz) > end) \
286 goto shutdown; \
287 } while (0)
289#define CHECK_BUF_AND_NULL(sz) do { \
290 CHECK_BUF(sz); \
291 if (sz == 0) \
292 goto shutdown; \
293 if (p[sz - 1] != '\0') \
294 goto shutdown; \
295 } while (0)
297 uint8_t *p = client->buffer.data;
298 const uint8_t *end = &client->buffer.data[client->buffer.idx];
300 struct client_data cdata;
301 CHECK_BUF(sizeof(cdata));
302 memcpy(&cdata, p, sizeof(cdata));
303 p += sizeof(cdata);
305 CHECK_BUF_AND_NULL(cdata.cwd_len);
306 const char *cwd = (const char *)p; p += cdata.cwd_len;
307 LOG_DBG("CWD = %.*s", cdata.cwd_len, cwd);
309 /* XDGA token */
310 const char *token = NULL;
311 if (cdata.xdga_token) {
313 CHECK_BUF_AND_NULL(cdata.token_len);
314 token = (const char *)p; p += cdata.token_len;
315 LOG_DBG("XDGA = %.*s", cdata.token_len, token);
316 } else {
317 LOG_DBG("No XDGA token");
318 }
320 /* Overrides */
321 for (uint16_t i = 0; i < cdata.override_count; i++) {
322 struct client_string arg;
323 CHECK_BUF(sizeof(arg));
324 memcpy(&arg, p, sizeof(arg)); p += sizeof(arg);
326 CHECK_BUF_AND_NULL(arg.len);
327 const char *str = (const char *)p;
328 p += arg.len;
330 tll_push_back(overrides, xstrdup(str));
331 }
333 /* argv */
334 argv = xcalloc(cdata.argc + 1, sizeof(argv[0]));
335 for (uint16_t i = 0; i < cdata.argc; i++) {
336 struct client_string arg;
337 CHECK_BUF(sizeof(arg));
338 memcpy(&arg, p, sizeof(arg)); p += sizeof(arg);
340 CHECK_BUF_AND_NULL(arg.len);
341 argv[i] = (char *)p; p += arg.len;
342 LOG_DBG("argv[%hu] = %.*s", i, arg.len, argv[i]);
343 }
345 /* envp */
346 envp = cdata.env_count != 0
347 ? xcalloc(cdata.env_count + 1, sizeof(envp[0]))
348 : NULL;
350 for (uint16_t i = 0; i < cdata.env_count; i++) {
351 struct client_string e;
352 CHECK_BUF(sizeof(e));
353 memcpy(&e, p, sizeof(e)); p += sizeof(e);
355 CHECK_BUF_AND_NULL(e.len);
356 envp[i] = (char *)p; p += e.len;
357 LOG_DBG("env[%hu] = %.*s", i, e.len, envp[i]);
358 }
360#undef CHECK_BUF_AND_NULL
361#undef CHECK_BUF
363 struct terminal_instance *instance = xmalloc(sizeof(struct terminal_instance));
365 const bool need_to_clone_conf =
366 tll_length(overrides)> 0 ||
367 cdata.hold != server->conf->hold_at_exit;
369 struct config *conf = NULL;
370 if (need_to_clone_conf) {
371 conf = config_clone(server->conf);
373 if (cdata.hold != server->conf->hold_at_exit)
374 conf->hold_at_exit = cdata.hold;
376 config_override_apply(conf, &overrides, false);
378 if (conf->tweak.font_monospace_warn && conf->fonts[0].count > 0) {
379 check_if_font_is_monospaced(
380 conf->fonts[0].arr[0].pattern,
381 &conf->notifications);
382 }
383 }
385 *instance = (struct terminal_instance) {
386 .client = NULL,
387 .server = server,
388 .conf = conf,
389 };
391 instance->terminal = term_init(
392 conf != NULL ? conf : server->conf,
393 server->fdm, server->reaper, server->wayl, "footclient", cwd, token,
394 NULL, cdata.argc, argv, (const char *const *)envp,
395 &term_shutdown_handler, instance);
397 if (instance->terminal == NULL) {
398 LOG_ERR("failed to instantiate new terminal");
399 client_send_exit_code(client, -26);
400 instance_destroy(instance, -1);
401 goto shutdown;
402 }
404 if (cdata.no_wait) {
405 // the server owns the instance
406 tll_push_back(server->terminals, instance);
407 client_send_exit_code(client, 0);
408 goto shutdown;
409 } else {
410 // the instance is attached to the client
411 instance->client = client;
412 client->instance = instance;
413 free(argv);
414 free(envp);
415 tll_free_and_free(overrides, free);
416 }
418 return true;
420shutdown:
421 LOG_DBG("client FD=%d: disconnected", client->fd);
423 free(argv);
424 free(envp);
425 tll_free_and_free(overrides, free);
426 fdm_del(fdm, fd);
427 client->fd = -1;
429 if (client->instance != NULL)
430 term_shutdown(client->instance->terminal);
431 else
432 client_destroy(client);
434 return true;
435}
437static bool
438fdm_server(struct fdm *fdm, int fd, int events, void *data)
439{
440 if (events & EPOLLHUP)
441 return false;
443 struct server *server = data;
445 struct sockaddr_un addr;
446 socklen_t addr_size = sizeof(addr);
447 int client_fd = accept4(
448 server->fd, (struct sockaddr *)&addr, &addr_size, SOCK_CLOEXEC | SOCK_NONBLOCK);
450 if (client_fd == -1) {
451 LOG_ERRNO("failed to accept client connection");
452 return false;
453 }
455 struct client *client = xmalloc(sizeof(*client));
456 *client = (struct client) {
457 .server = server,
458 .fd = client_fd,
459 };
461 if (!fdm_add(server->fdm, client_fd, EPOLLIN, &fdm_client, client)) {
462 close(client_fd);
463 free(client);
464 return false;
465 }
467 LOG_DBG("client FD=%d: connected", client_fd);
468 tll_push_back(server->clients, client);
469 return true;
470}
472enum connect_status {CONNECT_ERR, CONNECT_FAIL, CONNECT_SUCCESS};
474static enum connect_status
475try_connect(const char *sock_path)
476{
477 enum connect_status ret = CONNECT_ERR;
479 int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
480 if (fd == -1) {
481 LOG_ERRNO("failed to create UNIX socket");
482 goto err;
483 }
485 struct sockaddr_un addr = {.sun_family = AF_UNIX};
486 strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1);
488 switch (connect(fd, (struct sockaddr *)&addr, sizeof(addr))) {
489 case 0:
490 ret = CONNECT_SUCCESS;
491 break;
493 case -1:
494 LOG_DBG("connect() failed: %s", strerror(errno));
495 ret = CONNECT_FAIL;
496 break;
497 }
499err:
500 if (fd != -1)
501 close(fd);
502 return ret;
503}
505static bool
506prepare_socket(int fd)
507{
508 int flags = fcntl(fd, F_GETFD);
509 if (flags < 0) {
510 LOG_ERRNO("failed to get file descriptors flag for passed socket");
511 return false;
512 }
513 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
514 LOG_ERRNO("failed to set FD_CLOEXEC for passed socket");
515 return false;
516 }
518 flags = fcntl(fd, F_GETFL);
519 if (flags < 0) {
520 LOG_ERRNO("failed to get file status flags for passed socket");
521 return false;
522 }
523 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
524 LOG_ERRNO("failed to set non-blocking mode on passed socket");
525 return false;
526 }
528 int const socket_options[] = { SO_DOMAIN, SO_ACCEPTCONN, SO_TYPE };
529 int const socket_options_values[] = { AF_UNIX, NON_ZERO_OPT, SOCK_STREAM};
530 char const * const socket_options_names[] = { "SO_DOMAIN", "SO_ACCEPTCONN", "SO_TYPE" };
532 xassert(ALEN(socket_options) == ALEN(socket_options_values));
533 xassert(ALEN(socket_options) == ALEN(socket_options_names));
535 int socket_option = 0;
536 socklen_t len;
537 for (size_t i = 0; i < ALEN(socket_options) ; i++) {
538 len = sizeof(socket_option);
539 if (getsockopt(fd, SOL_SOCKET, socket_options[i], &socket_option, &len) == -1 ||
540 len != sizeof(socket_option)) {
541 LOG_ERRNO("failed to read socket option from passed file descriptor");
542 return false;
543 }
544 if (socket_options_values[i] == NON_ZERO_OPT && socket_option)
545 socket_option = NON_ZERO_OPT;
546 if (socket_option != socket_options_values[i]) {
547 LOG_ERR("wrong socket value for socket option '%s' on passed file descriptor",
548 socket_options_names[i]);
549 return false;
550 }
551 }
553 return true;
554}
556struct server *
557server_init(struct config *conf, struct fdm *fdm, struct reaper *reaper,
558 struct wayland *wayl)
559{
560 int fd;
561 struct server *server = NULL;
562 const char *sock_path = conf->server_socket_path;
563 char *end;
565 errno = 0;
566 fd = strtol(sock_path, &end, 10);
567 if (*end == '\0' && *sock_path != '\0')
568 {
569 if (!prepare_socket(fd))
570 goto err;
571 LOG_DBG("we've been started by socket activation, using passed socket");
572 sock_path = NULL;
573 }
574 else {
575 LOG_DBG("no suitable pre-existing socket found, creating our own");
576 fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
577 if (fd == -1) {
578 LOG_ERRNO("failed to create UNIX socket");
579 return NULL;
580 }
582 switch (try_connect(sock_path)) {
583 case CONNECT_FAIL:
584 break;
586 case CONNECT_SUCCESS:
587 LOG_ERR("%s is already accepting connections; is 'foot --server' already running", sock_path);
588 /* FALLTHROUGH */
590 case CONNECT_ERR:
591 goto err;
592 }
594 unlink(sock_path);
596 struct sockaddr_un addr = {.sun_family = AF_UNIX};
597 strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1);
599 if (bind(fd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
600 LOG_ERRNO("%s: failed to bind", addr.sun_path);
601 goto err;
602 }
604 if (listen(fd, 0) < 0) {
605 LOG_ERRNO("%s: failed to listen", addr.sun_path);
606 goto err;
607 }
608 }
610 server = malloc(sizeof(*server));
611 if (unlikely(server == NULL)) {
612 LOG_ERRNO("malloc() failed");
613 goto err;
614 }
616 *server = (struct server) {
617 .conf = conf,
618 .fdm = fdm,
619 .reaper = reaper,
620 .wayl = wayl,
622 .fd = fd,
623 .sock_path = sock_path,
625 .clients = tll_init(),
626 .terminals = tll_init(),
627 };
629 if (!fdm_add(fdm, fd, EPOLLIN, &fdm_server, server))
630 goto err;
632 LOG_INFO("accepting connections on %s", sock_path != NULL ? sock_path : "socket provided through socket activation");
634 return server;
636err:
637 free(server);
638 if (fd != -1)
639 close(fd);
640 return NULL;
641}
643void
644server_destroy(struct server *server)
645{
646 if (server == NULL)
647 return;
649 LOG_DBG("server destroy, %zu clients still alive",
650 tll_length(server->clients));
652 tll_foreach(server->clients, it) {
653 client_send_exit_code(it->item, -26);
654 client_destroy(it->item);
655 }
657 tll_free(server->clients);
659 tll_foreach(server->terminals, it)
660 instance_destroy(it->item, 1);
662 tll_free(server->terminals);
664 fdm_del(server->fdm, server->fd);
665 if (server->sock_path != NULL)
666 unlink(server->sock_path);
667 free(server);
668}
670void
671server_global_theme_switch_to_dark(struct server *server)
672{
673 server->conf->initial_color_theme = COLOR_THEME_DARK;
674 tll_foreach(server->clients, it)
675 term_theme_switch_to_dark(it->item->instance->terminal);
676 tll_foreach(server->terminals, it)
677 term_theme_switch_to_dark(it->item->terminal);
678}
680void
681server_global_theme_switch_to_light(struct server *server)
682{
683 server->conf->initial_color_theme = COLOR_THEME_LIGHT;
684 tll_foreach(server->clients, it)
685 term_theme_switch_to_light(it->item->instance->terminal);
686 tll_foreach(server->terminals, it)
687 term_theme_switch_to_light(it->item->terminal);
688}
Diagnostics5 git calls · 665 ms
CallStatusSizeTime0665 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 KiB638 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=636 git.response.bytes=10322 git.response.cache=EXPIRED git.response.duration_ms=638 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
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
fetchtree:0 · deepen 102009.3 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=9489 git.response.cache=HIT git.response.duration_ms=3 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=10Open pack map
fetch2004.7 KiB · hit24 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=24 git.response.bytes=4791 git.response.cache=HIT git.response.duration_ms=24 git.fetch.wants=46560d5cb8438075ea7392f52087256dae21393a 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=4791 git.pkt.payload.max=4764 git.sideband.band1.bytes=4764 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
- a5e201a6799e70b8
- Request
- 87624ac6…
- 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