refs/reftable: print errors on compaction failure
[alt-git.git] / bundle-uri.c
blobca32050a78fd7570adea76db264c5600339caf82
1 #include "git-compat-util.h"
2 #include "bundle-uri.h"
3 #include "bundle.h"
4 #include "copy.h"
5 #include "environment.h"
6 #include "gettext.h"
7 #include "refs.h"
8 #include "run-command.h"
9 #include "hashmap.h"
10 #include "pkt-line.h"
11 #include "config.h"
12 #include "remote.h"
14 static struct {
15 enum bundle_list_heuristic heuristic;
16 const char *name;
17 } heuristics[BUNDLE_HEURISTIC__COUNT] = {
18 { BUNDLE_HEURISTIC_NONE, ""},
19 { BUNDLE_HEURISTIC_CREATIONTOKEN, "creationToken" },
22 static int compare_bundles(const void *hashmap_cmp_fn_data UNUSED,
23 const struct hashmap_entry *he1,
24 const struct hashmap_entry *he2,
25 const void *id)
27 const struct remote_bundle_info *e1 =
28 container_of(he1, const struct remote_bundle_info, ent);
29 const struct remote_bundle_info *e2 =
30 container_of(he2, const struct remote_bundle_info, ent);
32 return strcmp(e1->id, id ? (const char *)id : e2->id);
35 void init_bundle_list(struct bundle_list *list)
37 memset(list, 0, sizeof(*list));
39 /* Implied defaults. */
40 list->mode = BUNDLE_MODE_ALL;
41 list->version = 1;
43 hashmap_init(&list->bundles, compare_bundles, NULL, 0);
46 static int clear_remote_bundle_info(struct remote_bundle_info *bundle,
47 void *data UNUSED)
49 FREE_AND_NULL(bundle->id);
50 FREE_AND_NULL(bundle->uri);
51 FREE_AND_NULL(bundle->file);
52 bundle->unbundled = 0;
53 return 0;
56 void clear_bundle_list(struct bundle_list *list)
58 if (!list)
59 return;
61 for_all_bundles_in_list(list, clear_remote_bundle_info, NULL);
62 hashmap_clear_and_free(&list->bundles, struct remote_bundle_info, ent);
63 free(list->baseURI);
66 int for_all_bundles_in_list(struct bundle_list *list,
67 bundle_iterator iter,
68 void *data)
70 struct remote_bundle_info *info;
71 struct hashmap_iter i;
73 hashmap_for_each_entry(&list->bundles, &i, info, ent) {
74 int result = iter(info, data);
76 if (result)
77 return result;
80 return 0;
83 static int summarize_bundle(struct remote_bundle_info *info, void *data)
85 FILE *fp = data;
86 fprintf(fp, "[bundle \"%s\"]\n", info->id);
87 fprintf(fp, "\turi = %s\n", info->uri);
89 if (info->creationToken)
90 fprintf(fp, "\tcreationToken = %"PRIu64"\n", info->creationToken);
91 return 0;
94 void print_bundle_list(FILE *fp, struct bundle_list *list)
96 const char *mode;
98 switch (list->mode) {
99 case BUNDLE_MODE_ALL:
100 mode = "all";
101 break;
103 case BUNDLE_MODE_ANY:
104 mode = "any";
105 break;
107 case BUNDLE_MODE_NONE:
108 default:
109 mode = "<unknown>";
112 fprintf(fp, "[bundle]\n");
113 fprintf(fp, "\tversion = %d\n", list->version);
114 fprintf(fp, "\tmode = %s\n", mode);
116 if (list->heuristic) {
117 int i;
118 for (i = 0; i < BUNDLE_HEURISTIC__COUNT; i++) {
119 if (heuristics[i].heuristic == list->heuristic) {
120 printf("\theuristic = %s\n",
121 heuristics[list->heuristic].name);
122 break;
127 for_all_bundles_in_list(list, summarize_bundle, fp);
131 * Given a key-value pair, update the state of the given bundle list.
132 * Returns 0 if the key-value pair is understood. Returns -1 if the key
133 * is not understood or the value is malformed.
135 static int bundle_list_update(const char *key, const char *value,
136 struct bundle_list *list)
138 struct strbuf id = STRBUF_INIT;
139 struct remote_bundle_info lookup = REMOTE_BUNDLE_INFO_INIT;
140 struct remote_bundle_info *bundle;
141 const char *subsection, *subkey;
142 size_t subsection_len;
144 if (parse_config_key(key, "bundle", &subsection, &subsection_len, &subkey))
145 return -1;
147 if (!subsection_len) {
148 if (!strcmp(subkey, "version")) {
149 int version;
150 if (!git_parse_int(value, &version))
151 return -1;
152 if (version != 1)
153 return -1;
155 list->version = version;
156 return 0;
159 if (!strcmp(subkey, "mode")) {
160 if (!strcmp(value, "all"))
161 list->mode = BUNDLE_MODE_ALL;
162 else if (!strcmp(value, "any"))
163 list->mode = BUNDLE_MODE_ANY;
164 else
165 return -1;
166 return 0;
169 if (!strcmp(subkey, "heuristic")) {
170 int i;
171 for (i = 0; i < BUNDLE_HEURISTIC__COUNT; i++) {
172 if (heuristics[i].heuristic &&
173 heuristics[i].name &&
174 !strcmp(value, heuristics[i].name)) {
175 list->heuristic = heuristics[i].heuristic;
176 return 0;
180 /* Ignore unknown heuristics. */
181 return 0;
184 /* Ignore other unknown global keys. */
185 return 0;
188 strbuf_add(&id, subsection, subsection_len);
191 * Check for an existing bundle with this <id>, or create one
192 * if necessary.
194 lookup.id = id.buf;
195 hashmap_entry_init(&lookup.ent, strhash(lookup.id));
196 if (!(bundle = hashmap_get_entry(&list->bundles, &lookup, ent, NULL))) {
197 CALLOC_ARRAY(bundle, 1);
198 bundle->id = strbuf_detach(&id, NULL);
199 hashmap_entry_init(&bundle->ent, strhash(bundle->id));
200 hashmap_add(&list->bundles, &bundle->ent);
202 strbuf_release(&id);
204 if (!strcmp(subkey, "uri")) {
205 if (bundle->uri)
206 return -1;
207 bundle->uri = relative_url(list->baseURI, value, NULL);
208 return 0;
211 if (!strcmp(subkey, "creationtoken")) {
212 if (sscanf(value, "%"PRIu64, &bundle->creationToken) != 1)
213 warning(_("could not parse bundle list key %s with value '%s'"),
214 "creationToken", value);
215 return 0;
219 * At this point, we ignore any information that we don't
220 * understand, assuming it to be hints for a heuristic the client
221 * does not currently understand.
223 return 0;
226 static int config_to_bundle_list(const char *key, const char *value,
227 const struct config_context *ctx UNUSED,
228 void *data)
230 struct bundle_list *list = data;
231 return bundle_list_update(key, value, list);
234 int bundle_uri_parse_config_format(const char *uri,
235 const char *filename,
236 struct bundle_list *list)
238 int result;
239 struct config_options opts = {
240 .error_action = CONFIG_ERROR_ERROR,
243 if (!list->baseURI) {
244 struct strbuf baseURI = STRBUF_INIT;
245 strbuf_addstr(&baseURI, uri);
248 * If the URI does not end with a trailing slash, then
249 * remove the filename portion of the path. This is
250 * important for relative URIs.
252 strbuf_strip_file_from_path(&baseURI);
253 list->baseURI = strbuf_detach(&baseURI, NULL);
255 result = git_config_from_file_with_options(config_to_bundle_list,
256 filename, list,
257 CONFIG_SCOPE_UNKNOWN,
258 &opts);
260 if (!result && list->mode == BUNDLE_MODE_NONE) {
261 warning(_("bundle list at '%s' has no mode"), uri);
262 result = 1;
265 return result;
268 static char *find_temp_filename(void)
270 int fd;
271 struct strbuf name = STRBUF_INIT;
273 * Find a temporary filename that is available. This is briefly
274 * racy, but unlikely to collide.
276 fd = odb_mkstemp(&name, "bundles/tmp_uri_XXXXXX");
277 if (fd < 0) {
278 warning(_("failed to create temporary file"));
279 return NULL;
282 close(fd);
283 unlink(name.buf);
284 return strbuf_detach(&name, NULL);
287 static int download_https_uri_to_file(const char *file, const char *uri)
289 int result = 0;
290 struct child_process cp = CHILD_PROCESS_INIT;
291 FILE *child_in = NULL, *child_out = NULL;
292 struct strbuf line = STRBUF_INIT;
293 int found_get = 0;
295 strvec_pushl(&cp.args, "git-remote-https", uri, NULL);
296 cp.err = -1;
297 cp.in = -1;
298 cp.out = -1;
300 if (start_command(&cp))
301 return 1;
303 child_in = fdopen(cp.in, "w");
304 if (!child_in) {
305 result = 1;
306 goto cleanup;
309 child_out = fdopen(cp.out, "r");
310 if (!child_out) {
311 result = 1;
312 goto cleanup;
315 fprintf(child_in, "capabilities\n");
316 fflush(child_in);
318 while (!strbuf_getline(&line, child_out)) {
319 if (!line.len)
320 break;
321 if (!strcmp(line.buf, "get"))
322 found_get = 1;
324 strbuf_release(&line);
326 if (!found_get) {
327 result = error(_("insufficient capabilities"));
328 goto cleanup;
331 fprintf(child_in, "get %s %s\n\n", uri, file);
333 cleanup:
334 if (child_in)
335 fclose(child_in);
336 if (finish_command(&cp))
337 return 1;
338 if (child_out)
339 fclose(child_out);
340 return result;
343 static int copy_uri_to_file(const char *filename, const char *uri)
345 const char *out;
347 if (starts_with(uri, "https:") ||
348 starts_with(uri, "http:"))
349 return download_https_uri_to_file(filename, uri);
351 if (skip_prefix(uri, "file://", &out))
352 uri = out;
354 /* Copy as a file */
355 return copy_file(filename, uri, 0);
358 static int unbundle_from_file(struct repository *r, const char *file)
360 int result = 0;
361 int bundle_fd;
362 struct bundle_header header = BUNDLE_HEADER_INIT;
363 struct string_list_item *refname;
364 struct strbuf bundle_ref = STRBUF_INIT;
365 size_t bundle_prefix_len;
367 if ((bundle_fd = read_bundle_header(file, &header)) < 0)
368 return 1;
371 * Skip the reachability walk here, since we will be adding
372 * a reachable ref pointing to the new tips, which will reach
373 * the prerequisite commits.
375 if ((result = unbundle(r, &header, bundle_fd, NULL,
376 VERIFY_BUNDLE_QUIET)))
377 return 1;
380 * Convert all refs/heads/ from the bundle into refs/bundles/
381 * in the local repository.
383 strbuf_addstr(&bundle_ref, "refs/bundles/");
384 bundle_prefix_len = bundle_ref.len;
386 for_each_string_list_item(refname, &header.references) {
387 struct object_id *oid = refname->util;
388 struct object_id old_oid;
389 const char *branch_name;
390 int has_old;
392 if (!skip_prefix(refname->string, "refs/heads/", &branch_name))
393 continue;
395 strbuf_setlen(&bundle_ref, bundle_prefix_len);
396 strbuf_addstr(&bundle_ref, branch_name);
398 has_old = !read_ref(bundle_ref.buf, &old_oid);
399 update_ref("fetched bundle", bundle_ref.buf, oid,
400 has_old ? &old_oid : NULL,
401 REF_SKIP_OID_VERIFICATION,
402 UPDATE_REFS_MSG_ON_ERR);
405 bundle_header_release(&header);
406 return result;
409 struct bundle_list_context {
410 struct repository *r;
411 struct bundle_list *list;
412 enum bundle_list_mode mode;
413 int count;
414 int depth;
418 * This early definition is necessary because we use indirect recursion:
420 * While iterating through a bundle list that was downloaded as part
421 * of fetch_bundle_uri_internal(), iterator methods eventually call it
422 * again, but with depth + 1.
424 static int fetch_bundle_uri_internal(struct repository *r,
425 struct remote_bundle_info *bundle,
426 int depth,
427 struct bundle_list *list);
429 static int download_bundle_to_file(struct remote_bundle_info *bundle, void *data)
431 int res;
432 struct bundle_list_context *ctx = data;
434 if (ctx->mode == BUNDLE_MODE_ANY && ctx->count)
435 return 0;
437 res = fetch_bundle_uri_internal(ctx->r, bundle, ctx->depth + 1, ctx->list);
440 * Only increment count if the download succeeded. If our mode is
441 * BUNDLE_MODE_ANY, then we will want to try other URIs in the
442 * list in case they work instead.
444 if (!res)
445 ctx->count++;
448 * To be opportunistic as possible, we continue iterating and
449 * download as many bundles as we can, so we can apply the ones
450 * that work, even in BUNDLE_MODE_ALL mode.
452 return 0;
455 struct bundles_for_sorting {
456 struct remote_bundle_info **items;
457 size_t alloc;
458 size_t nr;
461 static int append_bundle(struct remote_bundle_info *bundle, void *data)
463 struct bundles_for_sorting *list = data;
464 list->items[list->nr++] = bundle;
465 return 0;
469 * For use in QSORT() to get a list sorted by creationToken
470 * in decreasing order.
472 static int compare_creation_token_decreasing(const void *va, const void *vb)
474 const struct remote_bundle_info * const *a = va;
475 const struct remote_bundle_info * const *b = vb;
477 if ((*a)->creationToken > (*b)->creationToken)
478 return -1;
479 if ((*a)->creationToken < (*b)->creationToken)
480 return 1;
481 return 0;
484 static int fetch_bundles_by_token(struct repository *r,
485 struct bundle_list *list)
487 int cur;
488 int move_direction = 0;
489 const char *creationTokenStr;
490 uint64_t maxCreationToken = 0, newMaxCreationToken = 0;
491 struct bundle_list_context ctx = {
492 .r = r,
493 .list = list,
494 .mode = list->mode,
496 struct bundles_for_sorting bundles = {
497 .alloc = hashmap_get_size(&list->bundles),
500 ALLOC_ARRAY(bundles.items, bundles.alloc);
502 for_all_bundles_in_list(list, append_bundle, &bundles);
504 if (!bundles.nr) {
505 free(bundles.items);
506 return 0;
509 QSORT(bundles.items, bundles.nr, compare_creation_token_decreasing);
512 * If fetch.bundleCreationToken exists, parses to a uint64t, and
513 * is not strictly smaller than the maximum creation token in the
514 * bundle list, then do not download any bundles.
516 if (!repo_config_get_value(r,
517 "fetch.bundlecreationtoken",
518 &creationTokenStr) &&
519 sscanf(creationTokenStr, "%"PRIu64, &maxCreationToken) == 1 &&
520 bundles.items[0]->creationToken <= maxCreationToken) {
521 free(bundles.items);
522 return 0;
526 * Attempt to download and unbundle the minimum number of bundles by
527 * creationToken in decreasing order. If we fail to unbundle (after
528 * a successful download) then move to the next non-downloaded bundle
529 * and attempt downloading. Once we succeed in applying a bundle,
530 * move to the previous unapplied bundle and attempt to unbundle it
531 * again.
533 * In the case of a fresh clone, we will likely download all of the
534 * bundles before successfully unbundling the oldest one, then the
535 * rest of the bundles unbundle successfully in increasing order
536 * of creationToken.
538 * If there are existing objects, then this process may terminate
539 * early when all required commits from "new" bundles exist in the
540 * repo's object store.
542 cur = 0;
543 while (cur >= 0 && cur < bundles.nr) {
544 struct remote_bundle_info *bundle = bundles.items[cur];
547 * If we need to dig into bundles below the previous
548 * creation token value, then likely we are in an erroneous
549 * state due to missing or invalid bundles. Halt the process
550 * instead of continuing to download extra data.
552 if (bundle->creationToken <= maxCreationToken)
553 break;
555 if (!bundle->file) {
557 * Not downloaded yet. Try downloading.
559 * Note that bundle->file is non-NULL if a download
560 * was attempted, even if it failed to download.
562 if (fetch_bundle_uri_internal(ctx.r, bundle, ctx.depth + 1, ctx.list)) {
563 /* Mark as unbundled so we do not retry. */
564 bundle->unbundled = 1;
566 /* Try looking deeper in the list. */
567 move_direction = 1;
568 goto move;
571 /* We expect bundles when using creationTokens. */
572 if (!is_bundle(bundle->file, 1)) {
573 warning(_("file downloaded from '%s' is not a bundle"),
574 bundle->uri);
575 break;
579 if (bundle->file && !bundle->unbundled) {
581 * This was downloaded, but not successfully
582 * unbundled. Try unbundling again.
584 if (unbundle_from_file(ctx.r, bundle->file)) {
585 /* Try looking deeper in the list. */
586 move_direction = 1;
587 } else {
589 * Succeeded in unbundle. Retry bundles
590 * that previously failed to unbundle.
592 move_direction = -1;
593 bundle->unbundled = 1;
595 if (bundle->creationToken > newMaxCreationToken)
596 newMaxCreationToken = bundle->creationToken;
601 * Else case: downloaded and unbundled successfully.
602 * Skip this by moving in the same direction as the
603 * previous step.
606 move:
607 /* Move in the specified direction and repeat. */
608 cur += move_direction;
612 * We succeed if the loop terminates because 'cur' drops below
613 * zero. The other case is that we terminate because 'cur'
614 * reaches the end of the list, so we have a failure no matter
615 * which bundles we apply from the list.
617 if (cur < 0) {
618 struct strbuf value = STRBUF_INIT;
619 strbuf_addf(&value, "%"PRIu64"", newMaxCreationToken);
620 if (repo_config_set_multivar_gently(ctx.r,
621 "fetch.bundleCreationToken",
622 value.buf, NULL, 0))
623 warning(_("failed to store maximum creation token"));
625 strbuf_release(&value);
628 free(bundles.items);
629 return cur >= 0;
632 static int download_bundle_list(struct repository *r,
633 struct bundle_list *local_list,
634 struct bundle_list *global_list,
635 int depth)
637 struct bundle_list_context ctx = {
638 .r = r,
639 .list = global_list,
640 .depth = depth + 1,
641 .mode = local_list->mode,
644 return for_all_bundles_in_list(local_list, download_bundle_to_file, &ctx);
647 static int fetch_bundle_list_in_config_format(struct repository *r,
648 struct bundle_list *global_list,
649 struct remote_bundle_info *bundle,
650 int depth)
652 int result;
653 struct bundle_list list_from_bundle;
655 init_bundle_list(&list_from_bundle);
657 if ((result = bundle_uri_parse_config_format(bundle->uri,
658 bundle->file,
659 &list_from_bundle)))
660 goto cleanup;
662 if (list_from_bundle.mode == BUNDLE_MODE_NONE) {
663 warning(_("unrecognized bundle mode from URI '%s'"),
664 bundle->uri);
665 result = -1;
666 goto cleanup;
670 * If this list uses the creationToken heuristic, then the URIs
671 * it advertises are expected to be bundles, not nested lists.
672 * We can drop 'global_list' and 'depth'.
674 if (list_from_bundle.heuristic == BUNDLE_HEURISTIC_CREATIONTOKEN) {
675 result = fetch_bundles_by_token(r, &list_from_bundle);
676 global_list->heuristic = BUNDLE_HEURISTIC_CREATIONTOKEN;
677 } else if ((result = download_bundle_list(r, &list_from_bundle,
678 global_list, depth)))
679 goto cleanup;
681 cleanup:
682 clear_bundle_list(&list_from_bundle);
683 return result;
687 * This limits the recursion on fetch_bundle_uri_internal() when following
688 * bundle lists.
690 static int max_bundle_uri_depth = 4;
693 * Recursively download all bundles advertised at the given URI
694 * to files. If the file is a bundle, then add it to the given
695 * 'list'. Otherwise, expect a bundle list and recurse on the
696 * URIs in that list according to the list mode (ANY or ALL).
698 static int fetch_bundle_uri_internal(struct repository *r,
699 struct remote_bundle_info *bundle,
700 int depth,
701 struct bundle_list *list)
703 int result = 0;
704 struct remote_bundle_info *bcopy;
706 if (depth >= max_bundle_uri_depth) {
707 warning(_("exceeded bundle URI recursion limit (%d)"),
708 max_bundle_uri_depth);
709 return -1;
712 if (!bundle->file &&
713 !(bundle->file = find_temp_filename())) {
714 result = -1;
715 goto cleanup;
718 if ((result = copy_uri_to_file(bundle->file, bundle->uri))) {
719 warning(_("failed to download bundle from URI '%s'"), bundle->uri);
720 goto cleanup;
723 if ((result = !is_bundle(bundle->file, 1))) {
724 result = fetch_bundle_list_in_config_format(
725 r, list, bundle, depth);
726 if (result)
727 warning(_("file at URI '%s' is not a bundle or bundle list"),
728 bundle->uri);
729 goto cleanup;
732 /* Copy the bundle and insert it into the global list. */
733 CALLOC_ARRAY(bcopy, 1);
734 bcopy->id = xstrdup(bundle->id);
735 bcopy->file = xstrdup(bundle->file);
736 hashmap_entry_init(&bcopy->ent, strhash(bcopy->id));
737 hashmap_add(&list->bundles, &bcopy->ent);
739 cleanup:
740 if (result && bundle->file)
741 unlink(bundle->file);
742 return result;
746 * This loop iterator breaks the loop with nonzero return code on the
747 * first successful unbundling of a bundle.
749 static int attempt_unbundle(struct remote_bundle_info *info, void *data)
751 struct repository *r = data;
753 if (!info->file || info->unbundled)
754 return 0;
756 if (!unbundle_from_file(r, info->file)) {
757 info->unbundled = 1;
758 return 1;
761 return 0;
764 static int unbundle_all_bundles(struct repository *r,
765 struct bundle_list *list)
768 * Iterate through all bundles looking for ones that can
769 * successfully unbundle. If any succeed, then perhaps another
770 * will succeed in the next attempt.
772 * Keep in mind that a non-zero result for the loop here means
773 * the loop terminated early on a successful unbundling, which
774 * signals that we can try again.
776 while (for_all_bundles_in_list(list, attempt_unbundle, r)) ;
778 return 0;
781 static int unlink_bundle(struct remote_bundle_info *info, void *data UNUSED)
783 if (info->file)
784 unlink_or_warn(info->file);
785 return 0;
788 int fetch_bundle_uri(struct repository *r, const char *uri,
789 int *has_heuristic)
791 int result;
792 struct bundle_list list;
793 struct remote_bundle_info bundle = {
794 .uri = xstrdup(uri),
795 .id = xstrdup(""),
798 init_bundle_list(&list);
801 * Do not fetch an empty bundle URI. An empty bundle URI
802 * could signal that a configured bundle URI has been disabled.
804 if (!*uri) {
805 result = 0;
806 goto cleanup;
809 /* If a bundle is added to this global list, then it is required. */
810 list.mode = BUNDLE_MODE_ALL;
812 if ((result = fetch_bundle_uri_internal(r, &bundle, 0, &list)))
813 goto cleanup;
815 result = unbundle_all_bundles(r, &list);
817 cleanup:
818 if (has_heuristic)
819 *has_heuristic = (list.heuristic != BUNDLE_HEURISTIC_NONE);
820 for_all_bundles_in_list(&list, unlink_bundle, NULL);
821 clear_bundle_list(&list);
822 clear_remote_bundle_info(&bundle, NULL);
823 return result;
826 int fetch_bundle_list(struct repository *r, struct bundle_list *list)
828 int result;
829 struct bundle_list global_list;
832 * If the creationToken heuristic is used, then the URIs
833 * advertised by 'list' are not nested lists and instead
834 * direct bundles. We do not need to use global_list.
836 if (list->heuristic == BUNDLE_HEURISTIC_CREATIONTOKEN)
837 return fetch_bundles_by_token(r, list);
839 init_bundle_list(&global_list);
841 /* If a bundle is added to this global list, then it is required. */
842 global_list.mode = BUNDLE_MODE_ALL;
844 if ((result = download_bundle_list(r, list, &global_list, 0)))
845 goto cleanup;
847 if (list->heuristic == BUNDLE_HEURISTIC_CREATIONTOKEN)
848 result = fetch_bundles_by_token(r, list);
849 else
850 result = unbundle_all_bundles(r, &global_list);
852 cleanup:
853 for_all_bundles_in_list(&global_list, unlink_bundle, NULL);
854 clear_bundle_list(&global_list);
855 return result;
859 * API for serve.c.
862 int bundle_uri_advertise(struct repository *r, struct strbuf *value UNUSED)
864 static int advertise_bundle_uri = -1;
866 if (advertise_bundle_uri != -1)
867 goto cached;
869 advertise_bundle_uri = 0;
870 repo_config_get_maybe_bool(r, "uploadpack.advertisebundleuris", &advertise_bundle_uri);
872 cached:
873 return advertise_bundle_uri;
876 static int config_to_packet_line(const char *key, const char *value,
877 const struct config_context *ctx UNUSED,
878 void *data)
880 struct packet_reader *writer = data;
882 if (starts_with(key, "bundle."))
883 packet_write_fmt(writer->fd, "%s=%s", key, value);
885 return 0;
888 int bundle_uri_command(struct repository *r,
889 struct packet_reader *request)
891 struct packet_writer writer;
892 packet_writer_init(&writer, 1);
894 while (packet_reader_read(request) == PACKET_READ_NORMAL)
895 die(_("bundle-uri: unexpected argument: '%s'"), request->line);
896 if (request->status != PACKET_READ_FLUSH)
897 die(_("bundle-uri: expected flush after arguments"));
900 * Read all "bundle.*" config lines to the client as key=value
901 * packet lines.
903 repo_config(r, config_to_packet_line, &writer);
905 packet_writer_flush(&writer);
907 return 0;
911 * General API for {transport,connect}.c etc.
913 int bundle_uri_parse_line(struct bundle_list *list, const char *line)
915 int result;
916 const char *equals;
917 struct strbuf key = STRBUF_INIT;
919 if (!strlen(line))
920 return error(_("bundle-uri: got an empty line"));
922 equals = strchr(line, '=');
924 if (!equals)
925 return error(_("bundle-uri: line is not of the form 'key=value'"));
926 if (line == equals || !*(equals + 1))
927 return error(_("bundle-uri: line has empty key or value"));
929 strbuf_add(&key, line, equals - line);
930 result = bundle_list_update(key.buf, equals + 1, list);
931 strbuf_release(&key);
933 return result;