blob: 83f3d2651ab3feee758178f86394627ffe4f76b0 [file] [log] [blame]
Elijah Newren5579f442023-04-11 00:41:48 -07001#include "git-compat-util.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -07002#include "config.h"
Elijah Newren32a8f512023-03-21 06:26:03 +00003#include "environment.h"
Elijah Newrenf394e092023-03-21 06:25:54 +00004#include "gettext.h"
Elijah Newren41771fa2023-02-24 00:09:27 +00005#include "hex.h"
Linus Torvaldsdef88e92005-07-04 13:26:53 -07006#include "refs.h"
7#include "pkt-line.h"
Junio C Hamano958c24b2006-09-10 03:20:24 -07008#include "sideband.h"
Stefan Beller109cd762018-06-28 18:21:51 -07009#include "repository.h"
Elijah Newrena034e912023-05-16 06:34:06 +000010#include "object-store-ll.h"
Elijah Newren6f2d7432023-04-11 03:00:42 +000011#include "oid-array.h"
Junio C Hamanof6b42a82005-10-13 18:57:40 -070012#include "tag.h"
13#include "object.h"
Johannes Schindelinf0243f22005-10-28 04:48:32 +020014#include "commit.h"
Johannes Schindelin9b8dc262006-10-30 20:08:43 +010015#include "diff.h"
16#include "revision.h"
17#include "list-objects.h"
Jeff Hostetler10ac85c2017-12-08 15:58:39 +000018#include "list-objects-filter.h"
19#include "list-objects-filter-options.h"
Johannes Sixtcc41fa82007-10-19 21:47:59 +020020#include "run-command.h"
Junio C Hamano47a59182013-07-08 13:56:53 -070021#include "connect.h"
Junio C Hamano051e4002011-08-05 13:54:06 -070022#include "sigchain.h"
Jeff Kingff5effd2012-08-03 12:19:16 -040023#include "version.h"
Junio C Hamanodaebaa72013-01-18 16:08:30 -080024#include "string-list.h"
Jeff Kingdbbcd442020-07-28 16:23:39 -040025#include "strvec.h"
Elijah Newren74ea5c92023-04-11 03:00:38 +000026#include "trace2.h"
Jeff King5411b102016-10-11 17:20:16 -040027#include "prio-queue.h"
Brandon Williamsaa9bab22017-10-16 10:55:26 -070028#include "protocol.h"
Jeff Hostetler10ac85c2017-12-08 15:58:39 +000029#include "quote.h"
Brandon Williamsa3d6b532018-03-14 11:31:41 -070030#include "upload-pack.h"
Brandon Williams3145ea92018-03-15 10:31:27 -070031#include "serve.h"
Derrick Stolee829a3212018-08-20 18:24:34 +000032#include "commit-graph.h"
Derrick Stoleeba3ca1e2018-07-20 16:33:13 +000033#include "commit-reach.h"
Taylor Blau120ad2b2020-04-30 13:48:50 -060034#include "shallow.h"
Elijah Newrend48be352023-03-21 06:26:07 +000035#include "write-or-die.h"
Linus Torvaldsdef88e92005-07-04 13:26:53 -070036
Nguyễn Thái Ngọc Duy208acbf2014-03-25 20:23:26 +070037/* Remember to update object flag allocation in object.h */
Junio C Hamano937a5152006-07-05 21:28:20 -070038#define THEY_HAVE (1u << 11)
39#define OUR_REF (1u << 12)
40#define WANTED (1u << 13)
41#define COMMON_KNOWN (1u << 14)
Junio C Hamano937a5152006-07-05 21:28:20 -070042
Johannes Schindelinf53514b2006-10-30 20:09:53 +010043#define SHALLOW (1u << 16)
44#define NOT_SHALLOW (1u << 17)
45#define CLIENT_SHALLOW (1u << 18)
Junio C Hamano390eb362013-01-28 21:49:57 -080046#define HIDDEN_REF (1u << 19)
Johannes Schindelinf53514b2006-10-30 20:09:53 +010047
Jonathan Tand1035ca2018-10-18 13:43:29 -070048#define ALL_FLAGS (THEY_HAVE | OUR_REF | WANTED | COMMON_KNOWN | SHALLOW | \
49 NOT_SHALLOW | CLIENT_SHALLOW | HIDDEN_REF)
50
Christian Couder629060d2020-06-11 14:05:12 +020051/* Enum for allowed unadvertised object request (UOR) */
52enum allow_uor {
53 /* Allow specifying sha1 if it is a ref tip. */
54 ALLOW_TIP_SHA1 = 0x01,
55 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
56 ALLOW_REACHABLE_SHA1 = 0x02,
57 /* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
58 ALLOW_ANY_SHA1 = 0x07
59};
H. Peter Anvin960decc2005-10-19 14:27:01 -070060
Christian Coudera8497282020-06-04 19:54:39 +020061/*
62 * Please annotate, and if possible group together, fields used only
63 * for protocol v0 or only for protocol v2.
64 */
Christian Coudere8498322020-05-15 12:04:44 +020065struct upload_pack_data {
Christian Coudera8497282020-06-04 19:54:39 +020066 struct string_list symref; /* v0 only */
Christian Coudere8498322020-05-15 12:04:44 +020067 struct object_array want_obj;
68 struct object_array have_obj;
Christian Coudera8497282020-06-04 19:54:39 +020069 struct oid_array haves; /* v2 only */
70 struct string_list wanted_refs; /* v2 only */
Taylor Blauc45841f2023-07-10 17:12:33 -040071 struct strvec hidden_refs;
Christian Coudere8498322020-05-15 12:04:44 +020072
73 struct object_array shallows;
74 struct string_list deepen_not;
Christian Couderde0e9f72020-06-11 14:05:10 +020075 struct object_array extra_edge_obj;
Christian Coudere8498322020-05-15 12:04:44 +020076 int depth;
77 timestamp_t deepen_since;
78 int deepen_rev_list;
79 int deepen_relative;
Christian Couderf203a882020-06-04 19:54:46 +020080 int keepalive;
Christian Couder35b43a12020-06-11 14:05:09 +020081 int shallow_nr;
Christian Couderf01c7912020-06-11 14:05:17 +020082 timestamp_t oldest_have;
Christian Coudere8498322020-05-15 12:04:44 +020083
Christian Couderd40f04e2020-06-04 19:54:40 +020084 unsigned int timeout; /* v0 only */
Christian Coudere9d882b2020-06-04 19:54:44 +020085 enum {
86 NO_MULTI_ACK = 0,
87 MULTI_ACK = 1,
88 MULTI_ACK_DETAILED = 2
89 } multi_ack; /* v0 only */
Christian Couderd40f04e2020-06-04 19:54:40 +020090
Christian Couderf8edd1c2020-06-04 19:54:41 +020091 /* 0 for no sideband, otherwise DEFAULT_PACKET_MAX or LARGE_PACKET_MAX */
92 int use_sideband;
93
Jonathan Tandd4b7322020-06-10 13:57:23 -070094 struct string_list uri_protocols;
Christian Couder629060d2020-06-11 14:05:12 +020095 enum allow_uor allow_uor;
Christian Couderf1514c62020-06-11 14:05:11 +020096
Christian Coudere8498322020-05-15 12:04:44 +020097 struct list_objects_filter_options filter_options;
Taylor Blau6dd34562020-08-03 14:00:10 -040098 struct string_list allowed_filters;
Christian Coudere8498322020-05-15 12:04:44 +020099
100 struct packet_writer writer;
101
Christian Couder339a9842020-06-04 19:54:50 +0200102 const char *pack_objects_hook;
103
Christian Coudera8497282020-06-04 19:54:39 +0200104 unsigned stateless_rpc : 1; /* v0 only */
Christian Couderd40f04e2020-06-04 19:54:40 +0200105 unsigned no_done : 1; /* v0 only */
106 unsigned daemon_mode : 1; /* v0 only */
Christian Couder59a90262020-06-04 19:54:42 +0200107 unsigned filter_capability_requested : 1; /* v0 only */
Christian Coudere8498322020-05-15 12:04:44 +0200108
109 unsigned use_thin_pack : 1;
110 unsigned use_ofs_delta : 1;
111 unsigned no_progress : 1;
112 unsigned use_include_tag : 1;
Jonathan Tan9c1e6572021-05-04 14:16:01 -0700113 unsigned wait_for_done : 1;
Christian Couder59abe192020-06-04 19:54:47 +0200114 unsigned allow_filter : 1;
Taylor Blau6dd34562020-08-03 14:00:10 -0400115 unsigned allow_filter_fallback : 1;
Taylor Blau5b01a4e2020-08-03 14:00:17 -0400116 unsigned long tree_filter_max_depth;
Christian Coudera8497282020-06-04 19:54:39 +0200117
118 unsigned done : 1; /* v2 only */
Christian Couderd1d7a942020-06-04 19:54:48 +0200119 unsigned allow_ref_in_want : 1; /* v2 only */
Christian Coudere3835cd2020-06-04 19:54:49 +0200120 unsigned allow_sideband_all : 1; /* v2 only */
Josh Steadmon791e1ad2020-11-11 15:29:27 -0800121 unsigned advertise_sid : 1;
brian m. carlson933e3a42023-05-17 19:24:43 +0000122 unsigned sent_capabilities : 1;
Christian Coudere8498322020-05-15 12:04:44 +0200123};
124
125static void upload_pack_data_init(struct upload_pack_data *data)
126{
Christian Couder438528f2020-05-15 12:04:49 +0200127 struct string_list symref = STRING_LIST_INIT_DUP;
Christian Coudere8498322020-05-15 12:04:44 +0200128 struct string_list wanted_refs = STRING_LIST_INIT_DUP;
Taylor Blauc45841f2023-07-10 17:12:33 -0400129 struct strvec hidden_refs = STRVEC_INIT;
Christian Coudere8498322020-05-15 12:04:44 +0200130 struct object_array want_obj = OBJECT_ARRAY_INIT;
131 struct object_array have_obj = OBJECT_ARRAY_INIT;
132 struct oid_array haves = OID_ARRAY_INIT;
133 struct object_array shallows = OBJECT_ARRAY_INIT;
134 struct string_list deepen_not = STRING_LIST_INIT_DUP;
Jonathan Tandd4b7322020-06-10 13:57:23 -0700135 struct string_list uri_protocols = STRING_LIST_INIT_DUP;
Christian Couderde0e9f72020-06-11 14:05:10 +0200136 struct object_array extra_edge_obj = OBJECT_ARRAY_INIT;
Taylor Blau6dd34562020-08-03 14:00:10 -0400137 struct string_list allowed_filters = STRING_LIST_INIT_DUP;
Christian Coudere8498322020-05-15 12:04:44 +0200138
139 memset(data, 0, sizeof(*data));
Christian Couder438528f2020-05-15 12:04:49 +0200140 data->symref = symref;
Christian Coudere8498322020-05-15 12:04:44 +0200141 data->wanted_refs = wanted_refs;
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +0100142 data->hidden_refs = hidden_refs;
Christian Coudere8498322020-05-15 12:04:44 +0200143 data->want_obj = want_obj;
144 data->have_obj = have_obj;
145 data->haves = haves;
146 data->shallows = shallows;
147 data->deepen_not = deepen_not;
Jonathan Tandd4b7322020-06-10 13:57:23 -0700148 data->uri_protocols = uri_protocols;
Christian Couderde0e9f72020-06-11 14:05:10 +0200149 data->extra_edge_obj = extra_edge_obj;
Taylor Blau6dd34562020-08-03 14:00:10 -0400150 data->allowed_filters = allowed_filters;
151 data->allow_filter_fallback = 1;
Taylor Blau5b01a4e2020-08-03 14:00:17 -0400152 data->tree_filter_max_depth = ULONG_MAX;
Christian Coudere8498322020-05-15 12:04:44 +0200153 packet_writer_init(&data->writer, 1);
Jeff King2a01bde2022-09-11 01:03:07 -0400154 list_objects_filter_init(&data->filter_options);
Christian Couderf203a882020-06-04 19:54:46 +0200155
156 data->keepalive = 5;
Josh Steadmon791e1ad2020-11-11 15:29:27 -0800157 data->advertise_sid = 0;
Christian Coudere8498322020-05-15 12:04:44 +0200158}
159
160static void upload_pack_data_clear(struct upload_pack_data *data)
161{
Christian Couder438528f2020-05-15 12:04:49 +0200162 string_list_clear(&data->symref, 1);
Christian Coudere8498322020-05-15 12:04:44 +0200163 string_list_clear(&data->wanted_refs, 1);
Taylor Blauc45841f2023-07-10 17:12:33 -0400164 strvec_clear(&data->hidden_refs);
Christian Coudere8498322020-05-15 12:04:44 +0200165 object_array_clear(&data->want_obj);
166 object_array_clear(&data->have_obj);
167 oid_array_clear(&data->haves);
168 object_array_clear(&data->shallows);
169 string_list_clear(&data->deepen_not, 0);
Christian Couderde0e9f72020-06-11 14:05:10 +0200170 object_array_clear(&data->extra_edge_obj);
Christian Coudere8498322020-05-15 12:04:44 +0200171 list_objects_filter_release(&data->filter_options);
Taylor Blau8d133f52020-12-03 13:55:18 -0500172 string_list_clear(&data->allowed_filters, 0);
Christian Couder339a9842020-06-04 19:54:50 +0200173
174 free((char *)data->pack_objects_hook);
Christian Coudere8498322020-05-15 12:04:44 +0200175}
176
Christian Couderd40f04e2020-06-04 19:54:40 +0200177static void reset_timeout(unsigned int timeout)
H. Peter Anvin960decc2005-10-19 14:27:01 -0700178{
179 alarm(timeout);
180}
Linus Torvaldsfb9040c2005-07-04 15:29:17 -0700181
Christian Couderf8edd1c2020-06-04 19:54:41 +0200182static void send_client_data(int fd, const char *data, ssize_t sz,
183 int use_sideband)
Junio C Hamano583b7ea2006-06-21 00:30:21 -0700184{
Lukas Fleischer4c4b7d12016-06-14 16:49:16 +0200185 if (use_sideband) {
186 send_sideband(1, fd, data, sz, use_sideband);
Lukas Fleischerfcf0fe92016-06-14 16:49:17 +0200187 return;
Lukas Fleischer4c4b7d12016-06-14 16:49:16 +0200188 }
Junio C Hamano958c24b2006-09-10 03:20:24 -0700189 if (fd == 3)
190 /* emergency quit */
191 fd = 2;
192 if (fd == 2) {
Andy Whitcroft93822c22007-01-08 15:58:23 +0000193 /* XXX: are we happy to lose stuff here? */
Junio C Hamano958c24b2006-09-10 03:20:24 -0700194 xwrite(fd, data, sz);
Lukas Fleischerfcf0fe92016-06-14 16:49:17 +0200195 return;
Junio C Hamano583b7ea2006-06-21 00:30:21 -0700196 }
Jeff Kingcdf4fb82013-02-20 15:01:56 -0500197 write_or_die(fd, data, sz);
Junio C Hamano583b7ea2006-06-21 00:30:21 -0700198}
199
Nguyễn Thái Ngọc Duyb790e0f2014-03-11 19:59:46 +0700200static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
201{
202 FILE *fp = cb_data;
203 if (graft->nr_parent == -1)
brian m. carlson7683e2e2015-03-13 23:39:34 +0000204 fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
Nguyễn Thái Ngọc Duyb790e0f2014-03-11 19:59:46 +0700205 return 0;
206}
207
Jonathan Tanacaaca72020-06-10 13:57:21 -0700208struct output_state {
Jacob Vosmaer55a96512021-12-14 20:46:26 +0100209 /*
210 * We do writes no bigger than LARGE_PACKET_DATA_MAX - 1, because with
211 * sideband-64k the band designator takes up 1 byte of space. Because
212 * relay_pack_data keeps the last byte to itself, we make the buffer 1
213 * byte bigger than the intended maximum write size.
214 */
215 char buffer[(LARGE_PACKET_DATA_MAX - 1) + 1];
Jonathan Tanacaaca72020-06-10 13:57:21 -0700216 int used;
Jonathan Tandd4b7322020-06-10 13:57:23 -0700217 unsigned packfile_uris_started : 1;
218 unsigned packfile_started : 1;
Jonathan Tanacaaca72020-06-10 13:57:21 -0700219};
220
221static int relay_pack_data(int pack_objects_out, struct output_state *os,
Jonathan Tandd4b7322020-06-10 13:57:23 -0700222 int use_sideband, int write_packfile_line)
Jonathan Tanacaaca72020-06-10 13:57:21 -0700223{
224 /*
225 * We keep the last byte to ourselves
226 * in case we detect broken rev-list, so that we
227 * can leave the stream corrupted. This is
228 * unfortunate -- unpack-objects would happily
229 * accept a valid packdata with trailing garbage,
230 * so appending garbage after we pass all the
231 * pack data is not good enough to signal
232 * breakage to downstream.
233 */
234 ssize_t readsz;
235
236 readsz = xread(pack_objects_out, os->buffer + os->used,
237 sizeof(os->buffer) - os->used);
238 if (readsz < 0) {
239 return readsz;
240 }
241 os->used += readsz;
242
Jonathan Tandd4b7322020-06-10 13:57:23 -0700243 while (!os->packfile_started) {
244 char *p;
245 if (os->used >= 4 && !memcmp(os->buffer, "PACK", 4)) {
246 os->packfile_started = 1;
247 if (write_packfile_line) {
248 if (os->packfile_uris_started)
249 packet_delim(1);
250 packet_write_fmt(1, "\1packfile\n");
251 }
252 break;
253 }
254 if ((p = memchr(os->buffer, '\n', os->used))) {
255 if (!os->packfile_uris_started) {
256 os->packfile_uris_started = 1;
257 if (!write_packfile_line)
258 BUG("packfile_uris requires sideband-all");
259 packet_write_fmt(1, "\1packfile-uris\n");
260 }
261 *p = '\0';
262 packet_write_fmt(1, "\1%s\n", os->buffer);
263
264 os->used -= p - os->buffer + 1;
265 memmove(os->buffer, p + 1, os->used);
266 } else {
267 /*
268 * Incomplete line.
269 */
270 return readsz;
271 }
272 }
273
Jonathan Tanacaaca72020-06-10 13:57:21 -0700274 if (os->used > 1) {
275 send_client_data(1, os->buffer, os->used - 1, use_sideband);
276 os->buffer[0] = os->buffer[os->used - 1];
277 os->used = 1;
278 } else {
279 send_client_data(1, os->buffer, os->used, use_sideband);
280 os->used = 0;
281 }
282
283 return readsz;
284}
285
Jonathan Tandd4b7322020-06-10 13:57:23 -0700286static void create_pack_file(struct upload_pack_data *pack_data,
287 const struct string_list *uri_protocols)
Linus Torvaldsfb9040c2005-07-04 15:29:17 -0700288{
René Scharfed3180272014-08-19 21:09:35 +0200289 struct child_process pack_objects = CHILD_PROCESS_INIT;
Jacob Vosmaer55a96512021-12-14 20:46:26 +0100290 struct output_state *output_state = xcalloc(1, sizeof(struct output_state));
Jonathan Tanacaaca72020-06-10 13:57:21 -0700291 char progress[128];
Junio C Hamano583b7ea2006-06-21 00:30:21 -0700292 char abort_msg[] = "aborting due to possible repository "
293 "corruption on the remote side.";
Junio C Hamano1456b042009-12-10 12:17:11 -0800294 ssize_t sz;
Michael Procter65a36292016-02-25 12:13:26 +0000295 int i;
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700296 FILE *pipe_fd;
Linus Torvalds75bfc6c2005-07-04 16:35:13 -0700297
Christian Couder339a9842020-06-04 19:54:50 +0200298 if (!pack_data->pack_objects_hook)
Jeff King20b20a22016-05-18 18:45:37 -0400299 pack_objects.git_cmd = 1;
300 else {
Jeff Kingc972bf42020-07-28 16:25:12 -0400301 strvec_push(&pack_objects.args, pack_data->pack_objects_hook);
302 strvec_push(&pack_objects.args, "git");
Jeff King20b20a22016-05-18 18:45:37 -0400303 pack_objects.use_shell = 1;
304 }
305
Christian Couder35b43a12020-06-11 14:05:09 +0200306 if (pack_data->shallow_nr) {
Jeff Kingc972bf42020-07-28 16:25:12 -0400307 strvec_push(&pack_objects.args, "--shallow-file");
308 strvec_push(&pack_objects.args, "");
Nick Edelenf0cea832009-06-10 01:50:18 +0200309 }
Jeff Kingc972bf42020-07-28 16:25:12 -0400310 strvec_push(&pack_objects.args, "pack-objects");
311 strvec_push(&pack_objects.args, "--revs");
Jeff Kingb5a20682020-06-04 19:54:38 +0200312 if (pack_data->use_thin_pack)
Jeff Kingc972bf42020-07-28 16:25:12 -0400313 strvec_push(&pack_objects.args, "--thin");
Linus Torvalds75bfc6c2005-07-04 16:35:13 -0700314
Jeff Kingc972bf42020-07-28 16:25:12 -0400315 strvec_push(&pack_objects.args, "--stdout");
Christian Couder35b43a12020-06-11 14:05:09 +0200316 if (pack_data->shallow_nr)
Jeff Kingc972bf42020-07-28 16:25:12 -0400317 strvec_push(&pack_objects.args, "--shallow");
Jeff Kingb5a20682020-06-04 19:54:38 +0200318 if (!pack_data->no_progress)
Jeff Kingc972bf42020-07-28 16:25:12 -0400319 strvec_push(&pack_objects.args, "--progress");
Jeff Kingb5a20682020-06-04 19:54:38 +0200320 if (pack_data->use_ofs_delta)
Jeff Kingc972bf42020-07-28 16:25:12 -0400321 strvec_push(&pack_objects.args, "--delta-base-offset");
Jeff Kingb5a20682020-06-04 19:54:38 +0200322 if (pack_data->use_include_tag)
Jeff Kingc972bf42020-07-28 16:25:12 -0400323 strvec_push(&pack_objects.args, "--include-tag");
Christian Couderc9f03252020-05-15 12:04:53 +0200324 if (pack_data->filter_options.choice) {
Matthew DeVorecf9ceb52019-06-27 15:54:10 -0700325 const char *spec =
Christian Couderc9f03252020-05-15 12:04:53 +0200326 expand_list_objects_filter_spec(&pack_data->filter_options);
Jacob Vosmaerad5df6b2021-01-28 17:04:53 +0100327 strvec_pushf(&pack_objects.args, "--filter=%s", spec);
Jeff Hostetler10ac85c2017-12-08 15:58:39 +0000328 }
Jonathan Tandd4b7322020-06-10 13:57:23 -0700329 if (uri_protocols) {
330 for (i = 0; i < uri_protocols->nr; i++)
Jeff Kingc972bf42020-07-28 16:25:12 -0400331 strvec_pushf(&pack_objects.args, "--uri-protocol=%s",
Jonathan Tandd4b7322020-06-10 13:57:23 -0700332 uri_protocols->items[i].string);
333 }
Johannes Sixtcc41fa82007-10-19 21:47:59 +0200334
Jeff Kingb9612192011-04-06 17:33:33 -0400335 pack_objects.in = -1;
Johannes Sixtcc41fa82007-10-19 21:47:59 +0200336 pack_objects.out = -1;
337 pack_objects.err = -1;
Jeff King309a4022020-12-01 07:15:13 -0500338 pack_objects.clean_on_exit = 1;
Johannes Sixt21edd3f2007-10-19 21:48:03 +0200339
Johannes Sixt4c324c02007-11-04 20:46:48 +0100340 if (start_command(&pack_objects))
Junio C Hamano7e44c932008-08-31 09:39:19 -0700341 die("git upload-pack: unable to fork git-pack-objects");
Johannes Schindelin83a5ad62007-02-20 03:01:44 +0100342
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700343 pipe_fd = xfdopen(pack_objects.in, "w");
Nick Edelenf0cea832009-06-10 01:50:18 +0200344
Christian Couder35b43a12020-06-11 14:05:09 +0200345 if (pack_data->shallow_nr)
Nguyễn Thái Ngọc Duyb790e0f2014-03-11 19:59:46 +0700346 for_each_commit_graft(write_one_shallow, pipe_fd);
347
Christian Couderc9f03252020-05-15 12:04:53 +0200348 for (i = 0; i < pack_data->want_obj.nr; i++)
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700349 fprintf(pipe_fd, "%s\n",
Christian Couderc9f03252020-05-15 12:04:53 +0200350 oid_to_hex(&pack_data->want_obj.objects[i].item->oid));
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700351 fprintf(pipe_fd, "--not\n");
Christian Couderc9f03252020-05-15 12:04:53 +0200352 for (i = 0; i < pack_data->have_obj.nr; i++)
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700353 fprintf(pipe_fd, "%s\n",
Christian Couderc9f03252020-05-15 12:04:53 +0200354 oid_to_hex(&pack_data->have_obj.objects[i].item->oid));
Christian Couderde0e9f72020-06-11 14:05:10 +0200355 for (i = 0; i < pack_data->extra_edge_obj.nr; i++)
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700356 fprintf(pipe_fd, "%s\n",
Christian Couderde0e9f72020-06-11 14:05:10 +0200357 oid_to_hex(&pack_data->extra_edge_obj.objects[i].item->oid));
Nguyễn Thái Ngọc Duycdab4852013-08-16 16:52:05 +0700358 fprintf(pipe_fd, "\n");
359 fflush(pipe_fd);
360 fclose(pipe_fd);
Nick Edelenf0cea832009-06-10 01:50:18 +0200361
Johannes Sixtcc41fa82007-10-19 21:47:59 +0200362 /* We read from pack_objects.err to capture stderr output for
363 * progress bar, and pack_objects.out to capture the pack data.
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700364 */
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700365
366 while (1) {
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700367 struct pollfd pfd[2];
Christian Couderf203a882020-06-04 19:54:46 +0200368 int pe, pu, pollsize, polltimeout;
Jeff King05e95152013-09-08 05:01:31 -0400369 int ret;
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700370
Christian Couderd40f04e2020-06-04 19:54:40 +0200371 reset_timeout(pack_data->timeout);
Matthias Lederhofer0d516ad2006-07-18 19:14:51 +0200372
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700373 pollsize = 0;
Junio C Hamano363b7812006-06-20 22:48:23 -0700374 pe = pu = -1;
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700375
Johannes Sixtcc41fa82007-10-19 21:47:59 +0200376 if (0 <= pack_objects.out) {
377 pfd[pollsize].fd = pack_objects.out;
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700378 pfd[pollsize].events = POLLIN;
379 pu = pollsize;
380 pollsize++;
381 }
Johannes Sixtcc41fa82007-10-19 21:47:59 +0200382 if (0 <= pack_objects.err) {
383 pfd[pollsize].fd = pack_objects.err;
Junio C Hamano363b7812006-06-20 22:48:23 -0700384 pfd[pollsize].events = POLLIN;
385 pe = pollsize;
386 pollsize++;
387 }
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700388
Johannes Sixt4c324c02007-11-04 20:46:48 +0100389 if (!pollsize)
390 break;
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700391
Christian Couderf203a882020-06-04 19:54:46 +0200392 polltimeout = pack_data->keepalive < 0
393 ? -1
394 : 1000 * pack_data->keepalive;
395
396 ret = poll(pfd, pollsize, polltimeout);
Edward Thomson6c71f8b2014-08-22 15:19:11 +0000397
Jeff King05e95152013-09-08 05:01:31 -0400398 if (ret < 0) {
Johannes Sixt4c324c02007-11-04 20:46:48 +0100399 if (errno != EINTR) {
Nguyễn Thái Ngọc Duyd2b6afa2016-05-08 16:47:59 +0700400 error_errno("poll failed, resuming");
Johannes Sixt4c324c02007-11-04 20:46:48 +0100401 sleep(1);
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700402 }
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700403 continue;
Johannes Sixt4c324c02007-11-04 20:46:48 +0100404 }
Nicolas Pitre6b59f512009-11-11 17:24:42 -0500405 if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
406 /* Status ready; we ship that in the side-band
407 * or dump to the standard error.
408 */
409 sz = xread(pack_objects.err, progress,
410 sizeof(progress));
411 if (0 < sz)
Christian Couderf8edd1c2020-06-04 19:54:41 +0200412 send_client_data(2, progress, sz,
413 pack_data->use_sideband);
Nicolas Pitre6b59f512009-11-11 17:24:42 -0500414 else if (sz == 0) {
415 close(pack_objects.err);
416 pack_objects.err = -1;
417 }
418 else
419 goto fail;
420 /* give priority to status messages */
421 continue;
422 }
Johannes Sixt4c324c02007-11-04 20:46:48 +0100423 if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
Jonathan Tanacaaca72020-06-10 13:57:21 -0700424 int result = relay_pack_data(pack_objects.out,
Jacob Vosmaer55a96512021-12-14 20:46:26 +0100425 output_state,
Jonathan Tandd4b7322020-06-10 13:57:23 -0700426 pack_data->use_sideband,
427 !!uri_protocols);
Jonathan Tanacaaca72020-06-10 13:57:21 -0700428
429 if (result == 0) {
Johannes Sixt4c324c02007-11-04 20:46:48 +0100430 close(pack_objects.out);
431 pack_objects.out = -1;
Jonathan Tanacaaca72020-06-10 13:57:21 -0700432 } else if (result < 0) {
Johannes Sixt4c324c02007-11-04 20:46:48 +0100433 goto fail;
Johannes Sixt4c324c02007-11-04 20:46:48 +0100434 }
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700435 }
Jeff King05e95152013-09-08 05:01:31 -0400436
437 /*
438 * We hit the keepalive timeout without saying anything; send
439 * an empty message on the data sideband just to let the other
440 * side know we're still working on it, but don't have any data
441 * yet.
442 *
443 * If we don't have a sideband channel, there's no room in the
444 * protocol to say anything, so those clients are just out of
445 * luck.
446 */
Christian Couderf8edd1c2020-06-04 19:54:41 +0200447 if (!ret && pack_data->use_sideband) {
Jeff King05e95152013-09-08 05:01:31 -0400448 static const char buf[] = "0005\1";
449 write_or_die(1, buf, 5);
450 }
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700451 }
Johannes Sixt4c324c02007-11-04 20:46:48 +0100452
453 if (finish_command(&pack_objects)) {
Junio C Hamano7e44c932008-08-31 09:39:19 -0700454 error("git upload-pack: git-pack-objects died with error.");
Johannes Sixt4c324c02007-11-04 20:46:48 +0100455 goto fail;
456 }
Johannes Sixt4c324c02007-11-04 20:46:48 +0100457
458 /* flush the data */
Jacob Vosmaer55a96512021-12-14 20:46:26 +0100459 if (output_state->used > 0) {
460 send_client_data(1, output_state->buffer, output_state->used,
Christian Couderf8edd1c2020-06-04 19:54:41 +0200461 pack_data->use_sideband);
Johannes Sixt4c324c02007-11-04 20:46:48 +0100462 fprintf(stderr, "flushed.\n");
463 }
Jacob Vosmaer55a96512021-12-14 20:46:26 +0100464 free(output_state);
Christian Couderf8edd1c2020-06-04 19:54:41 +0200465 if (pack_data->use_sideband)
Johannes Sixt4c324c02007-11-04 20:46:48 +0100466 packet_flush(1);
467 return;
468
Junio C Hamanob1c71b72006-06-20 18:26:34 -0700469 fail:
Ævar Arnfjörð Bjarmasonc68d5db2022-07-28 01:13:42 +0200470 free(output_state);
Christian Couderf8edd1c2020-06-04 19:54:41 +0200471 send_client_data(3, abort_msg, sizeof(abort_msg),
472 pack_data->use_sideband);
Junio C Hamano7e44c932008-08-31 09:39:19 -0700473 die("git upload-pack: %s", abort_msg);
Linus Torvaldsfb9040c2005-07-04 15:29:17 -0700474}
475
Christian Couderea2c6e62020-06-11 14:05:18 +0200476static int do_got_oid(struct upload_pack_data *data, const struct object_id *oid)
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700477{
Junio C Hamano937a5152006-07-05 21:28:20 -0700478 int we_knew_they_have = 0;
Christian Couderea2c6e62020-06-11 14:05:18 +0200479 struct object *o = parse_object(the_repository, oid);
Junio C Hamanob1e9fff2006-07-05 18:00:02 -0700480
Junio C Hamanob1e9fff2006-07-05 18:00:02 -0700481 if (!o)
brian m. carlsoncf939822017-05-06 22:10:28 +0000482 die("oops (%s)", oid_to_hex(oid));
Junio C Hamano182a8da2006-08-12 22:16:51 -0700483 if (o->type == OBJ_COMMIT) {
Junio C Hamanob1e9fff2006-07-05 18:00:02 -0700484 struct commit_list *parents;
Junio C Hamano937a5152006-07-05 21:28:20 -0700485 struct commit *commit = (struct commit *)o;
Junio C Hamanob1e9fff2006-07-05 18:00:02 -0700486 if (o->flags & THEY_HAVE)
Junio C Hamano937a5152006-07-05 21:28:20 -0700487 we_knew_they_have = 1;
488 else
489 o->flags |= THEY_HAVE;
Christian Couderf01c7912020-06-11 14:05:17 +0200490 if (!data->oldest_have || (commit->date < data->oldest_have))
491 data->oldest_have = commit->date;
Junio C Hamano937a5152006-07-05 21:28:20 -0700492 for (parents = commit->parents;
Junio C Hamanob1e9fff2006-07-05 18:00:02 -0700493 parents;
494 parents = parents->next)
495 parents->item->object.flags |= THEY_HAVE;
Linus Torvaldsfb9040c2005-07-04 15:29:17 -0700496 }
Junio C Hamano937a5152006-07-05 21:28:20 -0700497 if (!we_knew_they_have) {
Christian Couder460ed0d2020-06-11 14:05:16 +0200498 add_object_array(o, NULL, &data->have_obj);
Junio C Hamano937a5152006-07-05 21:28:20 -0700499 return 1;
500 }
501 return 0;
502}
503
Christian Couderea2c6e62020-06-11 14:05:18 +0200504static int got_oid(struct upload_pack_data *data,
505 const char *hex, struct object_id *oid)
506{
507 if (get_oid_hex(hex, oid))
508 die("git upload-pack: expected SHA1 object, got '%s'", hex);
Ævar Arnfjörð Bjarmasonbc726bd2023-03-28 15:58:50 +0200509 if (!repo_has_object_file_with_flags(the_repository, oid,
510 OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT))
Christian Couderea2c6e62020-06-11 14:05:18 +0200511 return -1;
512 return do_got_oid(data, oid);
513}
514
Christian Couder08667342020-06-11 14:05:15 +0200515static int ok_to_give_up(struct upload_pack_data *data)
Junio C Hamano937a5152006-07-05 21:28:20 -0700516{
Abhishek Kumard7f92782021-01-16 18:11:13 +0000517 timestamp_t min_generation = GENERATION_NUMBER_ZERO;
Junio C Hamano937a5152006-07-05 21:28:20 -0700518
Christian Couder08667342020-06-11 14:05:15 +0200519 if (!data->have_obj.nr)
Junio C Hamano937a5152006-07-05 21:28:20 -0700520 return 0;
521
Christian Couder08667342020-06-11 14:05:15 +0200522 return can_all_from_reach_with_flag(&data->want_obj, THEY_HAVE,
Christian Couderf01c7912020-06-11 14:05:17 +0200523 COMMON_KNOWN, data->oldest_have,
Derrick Stolee4fbcca42018-07-20 16:33:28 +0000524 min_generation);
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700525}
526
Christian Couder07977692020-05-15 12:04:46 +0200527static int get_common_commits(struct upload_pack_data *data,
528 struct packet_reader *reader)
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700529{
brian m. carlsoncf939822017-05-06 22:10:28 +0000530 struct object_id oid;
531 char last_hex[GIT_MAX_HEXSZ + 1];
Shawn O. Pearce49bee712011-03-14 16:48:39 -0700532 int got_common = 0;
533 int got_other = 0;
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700534 int sent_ready = 0;
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700535
Johannes Schindelinf0243f22005-10-28 04:48:32 +0200536 save_commit_buffer = 0;
537
Brian Gianforcaroeeefa7c2009-09-01 01:35:10 -0400538 for (;;) {
Nguyễn Thái Ngọc Duy8bf3b752016-06-12 17:53:49 +0700539 const char *arg;
540
Christian Couderd40f04e2020-06-04 19:54:40 +0200541 reset_timeout(data->timeout);
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700542
Masaya Suzuki01f9ec62018-12-29 13:19:14 -0800543 if (packet_reader_read(reader) != PACKET_READ_NORMAL) {
Christian Coudere9d882b2020-06-04 19:54:44 +0200544 if (data->multi_ack == MULTI_ACK_DETAILED
Christian Couder07977692020-05-15 12:04:46 +0200545 && got_common
546 && !got_other
Christian Couder08667342020-06-11 14:05:15 +0200547 && ok_to_give_up(data)) {
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700548 sent_ready = 1;
Lars Schneider81c634e2016-10-16 16:20:29 -0700549 packet_write_fmt(1, "ACK %s ready\n", last_hex);
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700550 }
Christian Couder53d69502020-06-04 19:54:43 +0200551 if (data->have_obj.nr == 0 || data->multi_ack)
Lars Schneider81c634e2016-10-16 16:20:29 -0700552 packet_write_fmt(1, "NAK\n");
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700553
Christian Couderd40f04e2020-06-04 19:54:40 +0200554 if (data->no_done && sent_ready) {
Lars Schneider81c634e2016-10-16 16:20:29 -0700555 packet_write_fmt(1, "ACK %s\n", last_hex);
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700556 return 0;
557 }
Christian Couderdf654ab2020-05-15 12:04:52 +0200558 if (data->stateless_rpc)
Shawn O. Pearce42526b42009-10-30 17:47:33 -0700559 exit(0);
Shawn O. Pearce49bee712011-03-14 16:48:39 -0700560 got_common = 0;
561 got_other = 0;
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700562 continue;
563 }
Masaya Suzuki01f9ec62018-12-29 13:19:14 -0800564 if (skip_prefix(reader->line, "have ", &arg)) {
Christian Couder460ed0d2020-06-11 14:05:16 +0200565 switch (got_oid(data, arg, &oid)) {
Junio C Hamano937a5152006-07-05 21:28:20 -0700566 case -1: /* they have what we do not */
Shawn O. Pearce49bee712011-03-14 16:48:39 -0700567 got_other = 1;
Christian Couder53d69502020-06-04 19:54:43 +0200568 if (data->multi_ack
Christian Couder08667342020-06-11 14:05:15 +0200569 && ok_to_give_up(data)) {
brian m. carlsoncf939822017-05-06 22:10:28 +0000570 const char *hex = oid_to_hex(&oid);
Christian Coudere9d882b2020-06-04 19:54:44 +0200571 if (data->multi_ack == MULTI_ACK_DETAILED) {
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700572 sent_ready = 1;
Lars Schneider81c634e2016-10-16 16:20:29 -0700573 packet_write_fmt(1, "ACK %s ready\n", hex);
Junio C Hamano4e10cf92011-03-29 12:29:10 -0700574 } else
Lars Schneider81c634e2016-10-16 16:20:29 -0700575 packet_write_fmt(1, "ACK %s continue\n", hex);
Shawn O. Pearce78affc42009-10-30 17:47:25 -0700576 }
Junio C Hamano937a5152006-07-05 21:28:20 -0700577 break;
578 default:
Shawn O. Pearce49bee712011-03-14 16:48:39 -0700579 got_common = 1;
brian m. carlson55dc2272018-05-02 00:25:51 +0000580 oid_to_hex_r(last_hex, &oid);
Christian Coudere9d882b2020-06-04 19:54:44 +0200581 if (data->multi_ack == MULTI_ACK_DETAILED)
Lars Schneider81c634e2016-10-16 16:20:29 -0700582 packet_write_fmt(1, "ACK %s common\n", last_hex);
Christian Couder53d69502020-06-04 19:54:43 +0200583 else if (data->multi_ack)
Lars Schneider81c634e2016-10-16 16:20:29 -0700584 packet_write_fmt(1, "ACK %s continue\n", last_hex);
Christian Couder07977692020-05-15 12:04:46 +0200585 else if (data->have_obj.nr == 1)
Lars Schneider81c634e2016-10-16 16:20:29 -0700586 packet_write_fmt(1, "ACK %s\n", last_hex);
Junio C Hamano937a5152006-07-05 21:28:20 -0700587 break;
Junio C Hamanoaf2d3aa2005-10-25 14:55:24 -0700588 }
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700589 continue;
590 }
Masaya Suzuki01f9ec62018-12-29 13:19:14 -0800591 if (!strcmp(reader->line, "done")) {
Christian Couder07977692020-05-15 12:04:46 +0200592 if (data->have_obj.nr > 0) {
Christian Couder53d69502020-06-04 19:54:43 +0200593 if (data->multi_ack)
Lars Schneider81c634e2016-10-16 16:20:29 -0700594 packet_write_fmt(1, "ACK %s\n", last_hex);
Johannes Schindelin1bd8c8f2005-10-28 04:49:16 +0200595 return 0;
596 }
Lars Schneider81c634e2016-10-16 16:20:29 -0700597 packet_write_fmt(1, "NAK\n");
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700598 return -1;
599 }
Masaya Suzuki01f9ec62018-12-29 13:19:14 -0800600 die("git upload-pack: expected SHA1 list, got '%s'", reader->line);
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700601 }
Linus Torvaldsdef88e92005-07-04 13:26:53 -0700602}
603
Taylor Blau18b6b1b2023-07-10 17:12:45 -0400604static int allow_hidden_refs(enum allow_uor allow_uor)
605{
606 if ((allow_uor & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1)
607 return 1;
608 return !(allow_uor & (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
609}
610
611static void for_each_namespaced_ref_1(each_ref_fn fn,
612 struct upload_pack_data *data)
613{
614 const char **excludes = NULL;
615 /*
616 * If `data->allow_uor` allows fetching hidden refs, we need to
617 * mark all references (including hidden ones), to check in
618 * `is_our_ref()` below.
619 *
620 * Otherwise, we only care about whether each reference's object
621 * has the OUR_REF bit set or not, so do not need to visit
622 * hidden references.
623 */
624 if (allow_hidden_refs(data->allow_uor))
625 excludes = hidden_refs_to_excludes(&data->hidden_refs);
626
627 for_each_namespaced_ref(excludes, fn, data);
628}
629
630
Christian Couder629060d2020-06-11 14:05:12 +0200631static int is_our_ref(struct object *o, enum allow_uor allow_uor)
Junio C Hamano390eb362013-01-28 21:49:57 -0800632{
Taylor Blau18b6b1b2023-07-10 17:12:45 -0400633 return o->flags & ((allow_hidden_refs(allow_uor) ? 0 : HIDDEN_REF) | OUR_REF);
Junio C Hamano390eb362013-01-28 21:49:57 -0800634}
635
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700636/*
637 * on successful case, it's up to the caller to close cmd->out
638 */
639static int do_reachable_revlist(struct child_process *cmd,
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700640 struct object_array *src,
Christian Couderf1514c62020-06-11 14:05:11 +0200641 struct object_array *reachable,
Christian Couder629060d2020-06-11 14:05:12 +0200642 enum allow_uor allow_uor)
Junio C Hamano051e4002011-08-05 13:54:06 -0700643{
Junio C Hamano051e4002011-08-05 13:54:06 -0700644 struct object *o;
René Scharfea698d672020-08-12 18:52:55 +0200645 FILE *cmd_in = NULL;
Junio C Hamano051e4002011-08-05 13:54:06 -0700646 int i;
647
Ævar Arnfjörð Bjarmason2b709892021-11-25 23:52:20 +0100648 strvec_pushl(&cmd->args, "rev-list", "--stdin", NULL);
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700649 cmd->git_cmd = 1;
650 cmd->no_stderr = 1;
651 cmd->in = -1;
652 cmd->out = -1;
Junio C Hamano051e4002011-08-05 13:54:06 -0700653
654 /*
Nguyễn Thái Ngọc Duy7fcbd372016-06-12 17:53:51 +0700655 * If the next rev-list --stdin encounters an unknown commit,
656 * it terminates, which will cause SIGPIPE in the write loop
Junio C Hamano051e4002011-08-05 13:54:06 -0700657 * below.
658 */
659 sigchain_push(SIGPIPE, SIG_IGN);
660
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700661 if (start_command(cmd))
Nguyễn Thái Ngọc Duy7fcbd372016-06-12 17:53:51 +0700662 goto error;
663
René Scharfea698d672020-08-12 18:52:55 +0200664 cmd_in = xfdopen(cmd->in, "w");
665
Junio C Hamano051e4002011-08-05 13:54:06 -0700666 for (i = get_max_object_index(); 0 < i; ) {
667 o = get_indexed_object(--i);
Brian Harring2a745322011-08-23 22:47:17 -0700668 if (!o)
669 continue;
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700670 if (reachable && o->type == OBJ_COMMIT)
671 o->flags &= ~TMP_MARK;
Christian Couder629060d2020-06-11 14:05:12 +0200672 if (!is_our_ref(o, allow_uor))
Junio C Hamano051e4002011-08-05 13:54:06 -0700673 continue;
René Scharfea698d672020-08-12 18:52:55 +0200674 if (fprintf(cmd_in, "^%s\n", oid_to_hex(&o->oid)) < 0)
Junio C Hamano051e4002011-08-05 13:54:06 -0700675 goto error;
676 }
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700677 for (i = 0; i < src->nr; i++) {
678 o = src->objects[i].item;
Christian Couder629060d2020-06-11 14:05:12 +0200679 if (is_our_ref(o, allow_uor)) {
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700680 if (reachable)
681 add_object_array(o, NULL, reachable);
Junio C Hamano051e4002011-08-05 13:54:06 -0700682 continue;
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700683 }
684 if (reachable && o->type == OBJ_COMMIT)
685 o->flags |= TMP_MARK;
René Scharfea698d672020-08-12 18:52:55 +0200686 if (fprintf(cmd_in, "%s\n", oid_to_hex(&o->oid)) < 0)
Junio C Hamano051e4002011-08-05 13:54:06 -0700687 goto error;
688 }
René Scharfea698d672020-08-12 18:52:55 +0200689 if (ferror(cmd_in) || fflush(cmd_in))
690 goto error;
691 fclose(cmd_in);
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700692 cmd->in = -1;
Junio C Hamano051e4002011-08-05 13:54:06 -0700693 sigchain_pop(SIGPIPE);
694
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700695 return 0;
696
697error:
698 sigchain_pop(SIGPIPE);
699
René Scharfea698d672020-08-12 18:52:55 +0200700 if (cmd_in)
701 fclose(cmd_in);
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700702 if (cmd->out >= 0)
703 close(cmd->out);
704 return -1;
705}
706
Christian Couderf1514c62020-06-11 14:05:11 +0200707static int get_reachable_list(struct upload_pack_data *data,
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700708 struct object_array *reachable)
709{
710 struct child_process cmd = CHILD_PROCESS_INIT;
711 int i;
712 struct object *o;
brian m. carlson55dc2272018-05-02 00:25:51 +0000713 char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
714 const unsigned hexsz = the_hash_algo->hexsz;
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700715
Christian Couderf1514c62020-06-11 14:05:11 +0200716 if (do_reachable_revlist(&cmd, &data->shallows, reachable,
Christian Couder629060d2020-06-11 14:05:12 +0200717 data->allow_uor) < 0)
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700718 return -1;
719
brian m. carlson55dc2272018-05-02 00:25:51 +0000720 while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
Jeff King62b89d42019-06-20 03:40:54 -0400721 struct object_id oid;
brian m. carlson55dc2272018-05-02 00:25:51 +0000722 const char *p;
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700723
Jeff King62b89d42019-06-20 03:40:54 -0400724 if (parse_oid_hex(namebuf, &oid, &p) || *p != '\n')
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700725 break;
726
Jeff Kingd0229ab2019-06-20 03:41:14 -0400727 o = lookup_object(the_repository, &oid);
Nguyễn Thái Ngọc Duy079aa972016-06-12 17:54:08 +0700728 if (o && o->type == OBJ_COMMIT) {
729 o->flags &= ~TMP_MARK;
730 }
731 }
732 for (i = get_max_object_index(); 0 < i; i--) {
733 o = get_indexed_object(i - 1);
734 if (o && o->type == OBJ_COMMIT &&
735 (o->flags & TMP_MARK)) {
736 add_object_array(o, NULL, reachable);
737 o->flags &= ~TMP_MARK;
738 }
739 }
740 close(cmd.out);
741
742 if (finish_command(&cmd))
743 return -1;
744
745 return 0;
746}
747
Christian Couder629060d2020-06-11 14:05:12 +0200748static int has_unreachable(struct object_array *src, enum allow_uor allow_uor)
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700749{
750 struct child_process cmd = CHILD_PROCESS_INIT;
751 char buf[1];
752 int i;
753
Christian Couder629060d2020-06-11 14:05:12 +0200754 if (do_reachable_revlist(&cmd, src, NULL, allow_uor) < 0)
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700755 return 1;
Junio C Hamano051e4002011-08-05 13:54:06 -0700756
757 /*
758 * The commits out of the rev-list are not ancestors of
759 * our ref.
760 */
Nguyễn Thái Ngọc Duy29971782016-06-12 17:54:07 +0700761 i = read_in_full(cmd.out, buf, 1);
Junio C Hamano051e4002011-08-05 13:54:06 -0700762 if (i)
763 goto error;
764 close(cmd.out);
Nguyễn Thái Ngọc Duy7fcbd372016-06-12 17:53:51 +0700765 cmd.out = -1;
Junio C Hamano051e4002011-08-05 13:54:06 -0700766
767 /*
768 * rev-list may have died by encountering a bad commit
769 * in the history, in which case we do want to bail out
770 * even when it showed no commit.
771 */
772 if (finish_command(&cmd))
773 goto error;
774
775 /* All the non-tip ones are ancestors of what we advertised */
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700776 return 0;
Junio C Hamano051e4002011-08-05 13:54:06 -0700777
778error:
Nguyễn Thái Ngọc Duy7fcbd372016-06-12 17:53:51 +0700779 if (cmd.out >= 0)
780 close(cmd.out);
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700781 return 1;
782}
Nguyễn Thái Ngọc Duy7fcbd372016-06-12 17:53:51 +0700783
Christian Couderb08c9742020-05-15 12:04:51 +0200784static void check_non_tip(struct upload_pack_data *data)
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700785{
786 int i;
787
788 /*
789 * In the normal in-process case without
790 * uploadpack.allowReachableSHA1InWant,
791 * non-tip requests can never happen.
792 */
Christian Couder629060d2020-06-11 14:05:12 +0200793 if (!data->stateless_rpc && !(data->allow_uor & ALLOW_REACHABLE_SHA1))
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700794 goto error;
Christian Couder629060d2020-06-11 14:05:12 +0200795 if (!has_unreachable(&data->want_obj, data->allow_uor))
Nguyễn Thái Ngọc Duy3f0f6622016-06-12 17:53:52 +0700796 /* All the non-tip ones are ancestors of what we advertised */
797 return;
Junio C Hamano051e4002011-08-05 13:54:06 -0700798
799error:
800 /* Pick one of them (we know there at least is one) */
Christian Couderb08c9742020-05-15 12:04:51 +0200801 for (i = 0; i < data->want_obj.nr; i++) {
802 struct object *o = data->want_obj.objects[i].item;
Christian Couder629060d2020-06-11 14:05:12 +0200803 if (!is_our_ref(o, data->allow_uor)) {
Derrick Stolee7ba7c522023-08-10 14:40:50 +0000804 error("git upload-pack: not our ref %s",
805 oid_to_hex(&o->oid));
Christian Couderb08c9742020-05-15 12:04:51 +0200806 packet_writer_error(&data->writer,
Jeff King014ade72019-04-13 01:53:34 -0400807 "upload-pack: not our ref %s",
808 oid_to_hex(&o->oid));
Patrick Steinhardt5f33a842023-08-16 08:06:59 +0200809 exit(128);
Jeff King014ade72019-04-13 01:53:34 -0400810 }
Junio C Hamano051e4002011-08-05 13:54:06 -0700811 }
812}
813
Christian Couder35b43a12020-06-11 14:05:09 +0200814static void send_shallow(struct upload_pack_data *data,
Jonathan Tanbc2e7952019-01-15 11:40:27 -0800815 struct commit_list *result)
Nguyễn Thái Ngọc Duy5c24cde2016-06-12 17:53:46 +0700816{
817 while (result) {
818 struct object *object = &result->item->object;
819 if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
Christian Couder35b43a12020-06-11 14:05:09 +0200820 packet_writer_write(&data->writer, "shallow %s",
Jonathan Tanbc2e7952019-01-15 11:40:27 -0800821 oid_to_hex(&object->oid));
Stefan Beller19143f12018-05-17 15:51:44 -0700822 register_shallow(the_repository, &object->oid);
Christian Couder35b43a12020-06-11 14:05:09 +0200823 data->shallow_nr++;
Nguyễn Thái Ngọc Duy5c24cde2016-06-12 17:53:46 +0700824 }
825 result = result->next;
826 }
827}
828
Christian Couder329f9962020-06-11 14:05:08 +0200829static void send_unshallow(struct upload_pack_data *data)
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700830{
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700831 int i;
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700832
Christian Couder329f9962020-06-11 14:05:08 +0200833 for (i = 0; i < data->shallows.nr; i++) {
834 struct object *object = data->shallows.objects[i].item;
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700835 if (object->flags & NOT_SHALLOW) {
836 struct commit_list *parents;
Christian Couder329f9962020-06-11 14:05:08 +0200837 packet_writer_write(&data->writer, "unshallow %s",
Jonathan Tanbc2e7952019-01-15 11:40:27 -0800838 oid_to_hex(&object->oid));
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700839 object->flags &= ~CLIENT_SHALLOW;
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700840 /*
841 * We want to _register_ "object" as shallow, but we
842 * also need to traverse object's parents to deepen a
843 * shallow clone. Unregister it for now so we can
844 * parse and add the parents to the want list, then
845 * re-register it.
846 */
brian m. carlsone92b8482017-05-06 22:10:06 +0000847 unregister_shallow(&object->oid);
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700848 object->parsed = 0;
849 parse_commit_or_die((struct commit *)object);
850 parents = ((struct commit *)object)->parents;
851 while (parents) {
852 add_object_array(&parents->item->object,
Christian Couder329f9962020-06-11 14:05:08 +0200853 NULL, &data->want_obj);
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700854 parents = parents->next;
855 }
Christian Couderde0e9f72020-06-11 14:05:10 +0200856 add_object_array(object, NULL, &data->extra_edge_obj);
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700857 }
858 /* make sure commit traversal conforms to client */
Stefan Beller19143f12018-05-17 15:51:44 -0700859 register_shallow(the_repository, &object->oid);
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700860 }
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700861}
862
Jonathan Tan5056cf42018-12-18 13:24:35 -0800863static int check_ref(const char *refname_full, const struct object_id *oid,
864 int flag, void *cb_data);
Christian Couderb1492f22020-06-11 14:05:06 +0200865static void deepen(struct upload_pack_data *data, int depth)
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700866{
Stefan Bellerc8813482018-05-17 15:51:46 -0700867 if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700868 int i;
869
Christian Couderb1492f22020-06-11 14:05:06 +0200870 for (i = 0; i < data->shallows.nr; i++) {
871 struct object *object = data->shallows.objects[i].item;
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700872 object->flags |= NOT_SHALLOW;
873 }
Christian Couderb1492f22020-06-11 14:05:06 +0200874 } else if (data->deepen_relative) {
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +0700875 struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
876 struct commit_list *result;
877
Jonathan Tan5056cf42018-12-18 13:24:35 -0800878 /*
879 * Checking for reachable shallows requires that our refs be
880 * marked with OUR_REF.
881 */
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +0100882 head_ref_namespaced(check_ref, data);
Taylor Blau18b6b1b2023-07-10 17:12:45 -0400883 for_each_namespaced_ref_1(check_ref, data);
Jonathan Tan5056cf42018-12-18 13:24:35 -0800884
Christian Couderf1514c62020-06-11 14:05:11 +0200885 get_reachable_list(data, &reachable_shallows);
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +0700886 result = get_shallow_commits(&reachable_shallows,
887 depth + 1,
888 SHALLOW, NOT_SHALLOW);
Christian Couder35b43a12020-06-11 14:05:09 +0200889 send_shallow(data, result);
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +0700890 free_commit_list(result);
891 object_array_clear(&reachable_shallows);
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700892 } else {
893 struct commit_list *result;
894
Christian Couderb1492f22020-06-11 14:05:06 +0200895 result = get_shallow_commits(&data->want_obj, depth,
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700896 SHALLOW, NOT_SHALLOW);
Christian Couder35b43a12020-06-11 14:05:09 +0200897 send_shallow(data, result);
Nguyễn Thái Ngọc Duy873700c2016-06-12 17:53:48 +0700898 free_commit_list(result);
899 }
900
Christian Couder329f9962020-06-11 14:05:08 +0200901 send_unshallow(data);
Nguyễn Thái Ngọc Duye8e44de2016-06-12 17:53:45 +0700902}
903
Christian Couder446e42c2020-06-11 14:05:07 +0200904static void deepen_by_rev_list(struct upload_pack_data *data,
905 int ac,
906 const char **av)
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +0700907{
908 struct commit_list *result;
909
Jeff King6abada12019-09-12 10:44:45 -0400910 disable_commit_graph(the_repository);
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +0700911 result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
Christian Couder35b43a12020-06-11 14:05:09 +0200912 send_shallow(data, result);
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +0700913 free_commit_list(result);
Christian Couder329f9962020-06-11 14:05:08 +0200914 send_unshallow(data);
Brandon Williams685fbd32018-03-15 10:31:28 -0700915}
916
917/* Returns 1 if a shallow list is sent or 0 otherwise */
Christian Couderee703c82020-06-11 14:05:05 +0200918static int send_shallow_list(struct upload_pack_data *data)
Brandon Williams685fbd32018-03-15 10:31:28 -0700919{
920 int ret = 0;
921
Christian Couderee703c82020-06-11 14:05:05 +0200922 if (data->depth > 0 && data->deepen_rev_list)
Brandon Williams685fbd32018-03-15 10:31:28 -0700923 die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
Christian Couderee703c82020-06-11 14:05:05 +0200924 if (data->depth > 0) {
Christian Couderb1492f22020-06-11 14:05:06 +0200925 deepen(data, data->depth);
Brandon Williams685fbd32018-03-15 10:31:28 -0700926 ret = 1;
Christian Couderee703c82020-06-11 14:05:05 +0200927 } else if (data->deepen_rev_list) {
Jeff Kingc972bf42020-07-28 16:25:12 -0400928 struct strvec av = STRVEC_INIT;
Brandon Williams685fbd32018-03-15 10:31:28 -0700929 int i;
930
Jeff Kingc972bf42020-07-28 16:25:12 -0400931 strvec_push(&av, "rev-list");
Christian Couderee703c82020-06-11 14:05:05 +0200932 if (data->deepen_since)
Jeff Kingc972bf42020-07-28 16:25:12 -0400933 strvec_pushf(&av, "--max-age=%"PRItime, data->deepen_since);
Christian Couderee703c82020-06-11 14:05:05 +0200934 if (data->deepen_not.nr) {
Jeff Kingc972bf42020-07-28 16:25:12 -0400935 strvec_push(&av, "--not");
Christian Couderee703c82020-06-11 14:05:05 +0200936 for (i = 0; i < data->deepen_not.nr; i++) {
937 struct string_list_item *s = data->deepen_not.items + i;
Jeff Kingc972bf42020-07-28 16:25:12 -0400938 strvec_push(&av, s->string);
Brandon Williams685fbd32018-03-15 10:31:28 -0700939 }
Jeff Kingc972bf42020-07-28 16:25:12 -0400940 strvec_push(&av, "--not");
Brandon Williams685fbd32018-03-15 10:31:28 -0700941 }
Christian Couderee703c82020-06-11 14:05:05 +0200942 for (i = 0; i < data->want_obj.nr; i++) {
943 struct object *o = data->want_obj.objects[i].item;
Jeff Kingc972bf42020-07-28 16:25:12 -0400944 strvec_push(&av, oid_to_hex(&o->oid));
Brandon Williams685fbd32018-03-15 10:31:28 -0700945 }
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400946 deepen_by_rev_list(data, av.nr, av.v);
Jeff Kingc972bf42020-07-28 16:25:12 -0400947 strvec_clear(&av);
Brandon Williams685fbd32018-03-15 10:31:28 -0700948 ret = 1;
949 } else {
Christian Couderee703c82020-06-11 14:05:05 +0200950 if (data->shallows.nr > 0) {
Brandon Williams685fbd32018-03-15 10:31:28 -0700951 int i;
Christian Couderee703c82020-06-11 14:05:05 +0200952 for (i = 0; i < data->shallows.nr; i++)
Junio C Hamano00624d62018-07-18 12:20:27 -0700953 register_shallow(the_repository,
Christian Couderee703c82020-06-11 14:05:05 +0200954 &data->shallows.objects[i].item->oid);
Brandon Williams685fbd32018-03-15 10:31:28 -0700955 }
956 }
957
Christian Couder35b43a12020-06-11 14:05:09 +0200958 data->shallow_nr += data->shallows.nr;
Brandon Williams685fbd32018-03-15 10:31:28 -0700959 return ret;
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +0700960}
961
Brandon Williamsae2948f2018-03-14 11:31:42 -0700962static int process_shallow(const char *line, struct object_array *shallows)
963{
964 const char *arg;
965 if (skip_prefix(line, "shallow ", &arg)) {
966 struct object_id oid;
967 struct object *object;
968 if (get_oid_hex(arg, &oid))
969 die("invalid shallow line: %s", line);
Stefan Beller109cd762018-06-28 18:21:51 -0700970 object = parse_object(the_repository, &oid);
Brandon Williamsae2948f2018-03-14 11:31:42 -0700971 if (!object)
972 return 1;
973 if (object->type != OBJ_COMMIT)
974 die("invalid shallow object %s", oid_to_hex(&oid));
975 if (!(object->flags & CLIENT_SHALLOW)) {
976 object->flags |= CLIENT_SHALLOW;
977 add_object_array(object, NULL, shallows);
978 }
979 return 1;
980 }
981
982 return 0;
983}
984
985static int process_deepen(const char *line, int *depth)
986{
987 const char *arg;
988 if (skip_prefix(line, "deepen ", &arg)) {
989 char *end = NULL;
990 *depth = (int)strtol(arg, &end, 0);
991 if (!end || *end || *depth <= 0)
992 die("Invalid deepen: %s", line);
993 return 1;
994 }
995
996 return 0;
997}
998
999static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
1000{
1001 const char *arg;
1002 if (skip_prefix(line, "deepen-since ", &arg)) {
1003 char *end = NULL;
1004 *deepen_since = parse_timestamp(arg, &end, 0);
1005 if (!end || *end || !deepen_since ||
1006 /* revisions.c's max_age -1 is special */
1007 *deepen_since == -1)
1008 die("Invalid deepen-since: %s", line);
1009 *deepen_rev_list = 1;
1010 return 1;
1011 }
1012 return 0;
1013}
1014
1015static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
1016{
1017 const char *arg;
1018 if (skip_prefix(line, "deepen-not ", &arg)) {
1019 char *ref = NULL;
1020 struct object_id oid;
Nguyễn Thái Ngọc Duy0b1dbf52019-04-06 18:34:27 +07001021 if (expand_ref(the_repository, arg, strlen(arg), &oid, &ref) != 1)
Brandon Williamsae2948f2018-03-14 11:31:42 -07001022 die("git upload-pack: ambiguous deepen-not: %s", line);
1023 string_list_append(deepen_not, ref);
1024 free(ref);
1025 *deepen_rev_list = 1;
1026 return 1;
1027 }
1028 return 0;
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001029}
1030
Taylor Blau6dd34562020-08-03 14:00:10 -04001031NORETURN __attribute__((format(printf,2,3)))
1032static void send_err_and_die(struct upload_pack_data *data,
1033 const char *fmt, ...)
1034{
1035 struct strbuf buf = STRBUF_INIT;
1036 va_list ap;
1037
1038 va_start(ap, fmt);
1039 strbuf_vaddf(&buf, fmt, ap);
1040 va_end(ap);
1041
1042 packet_writer_error(&data->writer, "%s", buf.buf);
1043 die("%s", buf.buf);
1044}
1045
1046static void check_one_filter(struct upload_pack_data *data,
1047 struct list_objects_filter_options *opts)
1048{
1049 const char *key = list_object_filter_config_name(opts->choice);
1050 struct string_list_item *item = string_list_lookup(&data->allowed_filters,
1051 key);
1052 int allowed;
1053
1054 if (item)
1055 allowed = (intptr_t)item->util;
1056 else
1057 allowed = data->allow_filter_fallback;
1058
1059 if (!allowed)
1060 send_err_and_die(data, "filter '%s' not supported", key);
Taylor Blau5b01a4e2020-08-03 14:00:17 -04001061
1062 if (opts->choice == LOFC_TREE_DEPTH &&
1063 opts->tree_exclude_depth > data->tree_filter_max_depth)
1064 send_err_and_die(data,
1065 "tree filter allows max depth %lu, but got %lu",
1066 data->tree_filter_max_depth,
1067 opts->tree_exclude_depth);
Taylor Blau6dd34562020-08-03 14:00:10 -04001068}
1069
1070static void check_filter_recurse(struct upload_pack_data *data,
1071 struct list_objects_filter_options *opts)
1072{
1073 size_t i;
1074
1075 check_one_filter(data, opts);
1076 if (opts->choice != LOFC_COMBINE)
1077 return;
1078
1079 for (i = 0; i < opts->sub_nr; i++)
1080 check_filter_recurse(data, &opts->sub[i]);
1081}
1082
1083static void die_if_using_banned_filter(struct upload_pack_data *data)
1084{
1085 check_filter_recurse(data, &data->filter_options);
1086}
1087
Christian Couderd92ae2c2020-05-15 12:04:47 +02001088static void receive_needs(struct upload_pack_data *data,
1089 struct packet_reader *reader)
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001090{
Junio C Hamano051e4002011-08-05 13:54:06 -07001091 int has_non_tip = 0;
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001092
Christian Couder35b43a12020-06-11 14:05:09 +02001093 data->shallow_nr = 0;
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001094 for (;;) {
Junio C Hamano565ebbf2005-10-24 18:59:18 -07001095 struct object *o;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001096 const char *features;
brian m. carlsoncf939822017-05-06 22:10:28 +00001097 struct object_id oid_buf;
Nguyễn Thái Ngọc Duy8bf3b752016-06-12 17:53:49 +07001098 const char *arg;
Jeff King7ce4c8f2023-04-14 17:25:20 -04001099 size_t feature_len;
Nguyễn Thái Ngọc Duy8bf3b752016-06-12 17:53:49 +07001100
Christian Couderd40f04e2020-06-04 19:54:40 +02001101 reset_timeout(data->timeout);
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001102 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
Johannes Schindelined09aef2006-10-30 20:09:06 +01001103 break;
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001104
Christian Couder7a516762020-05-15 12:04:54 +02001105 if (process_shallow(reader->line, &data->shallows))
Johannes Schindelined09aef2006-10-30 20:09:06 +01001106 continue;
Christian Couder7a516762020-05-15 12:04:54 +02001107 if (process_deepen(reader->line, &data->depth))
Johannes Schindelin016e6cc2006-10-30 20:09:29 +01001108 continue;
Christian Couder7a516762020-05-15 12:04:54 +02001109 if (process_deepen_since(reader->line, &data->deepen_since, &data->deepen_rev_list))
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +07001110 continue;
Christian Couder7a516762020-05-15 12:04:54 +02001111 if (process_deepen_not(reader->line, &data->deepen_not, &data->deepen_rev_list))
Nguyễn Thái Ngọc Duy269a7a82016-06-12 17:54:03 +07001112 continue;
Brandon Williamsae2948f2018-03-14 11:31:42 -07001113
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001114 if (skip_prefix(reader->line, "filter ", &arg)) {
Christian Couder59a90262020-06-04 19:54:42 +02001115 if (!data->filter_capability_requested)
Jeff Hostetler10ac85c2017-12-08 15:58:39 +00001116 die("git upload-pack: filtering capability not negotiated");
Christian Couderd92ae2c2020-05-15 12:04:47 +02001117 list_objects_filter_die_if_populated(&data->filter_options);
1118 parse_list_objects_filter(&data->filter_options, arg);
Taylor Blau6dd34562020-08-03 14:00:10 -04001119 die_if_using_banned_filter(data);
Jeff Hostetler10ac85c2017-12-08 15:58:39 +00001120 continue;
1121 }
Junio C Hamano9bfa0f92018-05-08 15:59:15 +09001122
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001123 if (!skip_prefix(reader->line, "want ", &arg) ||
brian m. carlson55dc2272018-05-02 00:25:51 +00001124 parse_oid_hex(arg, &oid_buf, &features))
Junio C Hamano7e44c932008-08-31 09:39:19 -07001125 die("git upload-pack: protocol error, "
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001126 "expected to get object ID, not '%s'", reader->line);
Junio C Hamanof47182c2012-01-08 22:06:19 +01001127
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +07001128 if (parse_feature_request(features, "deepen-relative"))
Christian Couder7a516762020-05-15 12:04:54 +02001129 data->deepen_relative = 1;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001130 if (parse_feature_request(features, "multi_ack_detailed"))
Christian Coudere9d882b2020-06-04 19:54:44 +02001131 data->multi_ack = MULTI_ACK_DETAILED;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001132 else if (parse_feature_request(features, "multi_ack"))
Christian Coudere9d882b2020-06-04 19:54:44 +02001133 data->multi_ack = MULTI_ACK;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001134 if (parse_feature_request(features, "no-done"))
Christian Couderd40f04e2020-06-04 19:54:40 +02001135 data->no_done = 1;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001136 if (parse_feature_request(features, "thin-pack"))
Jeff Kingb5a20682020-06-04 19:54:38 +02001137 data->use_thin_pack = 1;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001138 if (parse_feature_request(features, "ofs-delta"))
Jeff Kingb5a20682020-06-04 19:54:38 +02001139 data->use_ofs_delta = 1;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001140 if (parse_feature_request(features, "side-band-64k"))
Christian Couderf8edd1c2020-06-04 19:54:41 +02001141 data->use_sideband = LARGE_PACKET_MAX;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001142 else if (parse_feature_request(features, "side-band"))
Christian Couderf8edd1c2020-06-04 19:54:41 +02001143 data->use_sideband = DEFAULT_PACKET_MAX;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001144 if (parse_feature_request(features, "no-progress"))
Jeff Kingb5a20682020-06-04 19:54:38 +02001145 data->no_progress = 1;
Junio C Hamanof47182c2012-01-08 22:06:19 +01001146 if (parse_feature_request(features, "include-tag"))
Jeff Kingb5a20682020-06-04 19:54:38 +02001147 data->use_include_tag = 1;
Christian Couder59abe192020-06-04 19:54:47 +02001148 if (data->allow_filter &&
1149 parse_feature_request(features, "filter"))
Christian Couder59a90262020-06-04 19:54:42 +02001150 data->filter_capability_requested = 1;
Junio C Hamano565ebbf2005-10-24 18:59:18 -07001151
Josh Steadmon82959462020-11-11 15:29:32 -08001152 arg = parse_feature_value(features, "session-id", &feature_len, NULL);
1153 if (arg) {
1154 char *client_sid = xstrndup(arg, feature_len);
1155 trace2_data_string("transfer", NULL, "client-sid", client_sid);
1156 free(client_sid);
1157 }
1158
Stefan Beller109cd762018-06-28 18:21:51 -07001159 o = parse_object(the_repository, &oid_buf);
Jonathan Tanbdb31ea2017-02-23 10:43:03 -08001160 if (!o) {
Christian Couder4ace0282020-05-15 12:04:48 +02001161 packet_writer_error(&data->writer,
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001162 "upload-pack: not our ref %s",
1163 oid_to_hex(&oid_buf));
Elijah Newren9f9aa762010-07-31 14:11:46 -06001164 die("git upload-pack: not our ref %s",
brian m. carlsoncf939822017-05-06 22:10:28 +00001165 oid_to_hex(&oid_buf));
Jonathan Tanbdb31ea2017-02-23 10:43:03 -08001166 }
Junio C Hamano565ebbf2005-10-24 18:59:18 -07001167 if (!(o->flags & WANTED)) {
1168 o->flags |= WANTED;
Christian Couder629060d2020-06-11 14:05:12 +02001169 if (!((data->allow_uor & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
1170 || is_our_ref(o, data->allow_uor)))
Junio C Hamano051e4002011-08-05 13:54:06 -07001171 has_non_tip = 1;
Christian Couderd92ae2c2020-05-15 12:04:47 +02001172 add_object_array(o, NULL, &data->want_obj);
Junio C Hamano565ebbf2005-10-24 18:59:18 -07001173 }
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001174 }
Johannes Sixt9462e3f2009-06-16 20:41:16 +02001175
Junio C Hamano051e4002011-08-05 13:54:06 -07001176 /*
1177 * We have sent all our refs already, and the other end
1178 * should have chosen out of them. When we are operating
1179 * in the stateless RPC mode, however, their choice may
1180 * have been based on the set of older refs advertised
1181 * by another process that handled the initial request.
1182 */
1183 if (has_non_tip)
Christian Couderb08c9742020-05-15 12:04:51 +02001184 check_non_tip(data);
Junio C Hamano051e4002011-08-05 13:54:06 -07001185
Christian Couderf8edd1c2020-06-04 19:54:41 +02001186 if (!data->use_sideband && data->daemon_mode)
Jeff Kingb5a20682020-06-04 19:54:38 +02001187 data->no_progress = 1;
Johannes Sixt9462e3f2009-06-16 20:41:16 +02001188
Christian Couder7a516762020-05-15 12:04:54 +02001189 if (data->depth == 0 && !data->deepen_rev_list && data->shallows.nr == 0)
Johannes Schindelinf53514b2006-10-30 20:09:53 +01001190 return;
Nguyễn Thái Ngọc Duy569e5542016-06-12 17:53:58 +07001191
Christian Couderee703c82020-06-11 14:05:05 +02001192 if (send_shallow_list(data))
Brandon Williams685fbd32018-03-15 10:31:28 -07001193 packet_flush(1);
Linus Torvaldsfb9040c2005-07-04 15:29:17 -07001194}
1195
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001196/* return non-zero if the ref is hidden, otherwise 0 */
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001197static int mark_our_ref(const char *refname, const char *refname_full,
Taylor Blauc45841f2023-07-10 17:12:33 -04001198 const struct object_id *oid, const struct strvec *hidden_refs)
Junio C Hamanocbbe50d2013-01-18 15:48:49 -08001199{
Jeff King45a187c2021-04-13 03:16:36 -04001200 struct object *o = lookup_unknown_object(the_repository, oid);
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001201
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001202 if (ref_is_hidden(refname, refname_full, hidden_refs)) {
Junio C Hamano390eb362013-01-28 21:49:57 -08001203 o->flags |= HIDDEN_REF;
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001204 return 1;
Junio C Hamano390eb362013-01-28 21:49:57 -08001205 }
Junio C Hamano3f1da572013-01-28 20:45:43 -08001206 o->flags |= OUR_REF;
Junio C Hamanocbbe50d2013-01-18 15:48:49 -08001207 return 0;
1208}
1209
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001210static int check_ref(const char *refname_full, const struct object_id *oid,
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001211 int flag UNUSED, void *cb_data)
Jeff Kinge1727552015-03-13 00:42:12 -04001212{
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001213 const char *refname = strip_namespace(refname_full);
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001214 struct upload_pack_data *data = cb_data;
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001215
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001216 mark_our_ref(refname, refname_full, oid, &data->hidden_refs);
Jeff Kinge1727552015-03-13 00:42:12 -04001217 return 0;
1218}
1219
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001220static void format_symref_info(struct strbuf *buf, struct string_list *symref)
1221{
1222 struct string_list_item *item;
1223
1224 if (!symref->nr)
1225 return;
1226 for_each_string_list_item(item, symref)
1227 strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
1228}
1229
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001230static void format_session_id(struct strbuf *buf, struct upload_pack_data *d) {
1231 if (d->advertise_sid)
1232 strbuf_addf(buf, " session-id=%s", trace2_session_id());
1233}
1234
brian m. carlson933e3a42023-05-17 19:24:43 +00001235static void write_v0_ref(struct upload_pack_data *data,
1236 const char *refname, const char *refname_nons,
1237 const struct object_id *oid)
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001238{
Johannes Schindelined09aef2006-10-30 20:09:06 +01001239 static const char *capabilities = "multi_ack thin-pack side-band"
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +07001240 " side-band-64k ofs-delta shallow deepen-since deepen-not"
1241 " deepen-relative no-progress include-tag multi_ack_detailed";
Michael Haggerty21758af2015-05-25 18:39:13 +00001242 struct object_id peeled;
Carl Worthb5b16992006-02-17 16:14:52 -08001243
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001244 if (mark_our_ref(refname_nons, refname, oid, &data->hidden_refs))
brian m. carlson933e3a42023-05-17 19:24:43 +00001245 return;
Junio C Hamanocbbe50d2013-01-18 15:48:49 -08001246
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001247 if (capabilities) {
1248 struct strbuf symref_info = STRBUF_INIT;
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001249 struct strbuf session_id = STRBUF_INIT;
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001250
Christian Couder762f9272020-05-15 12:04:50 +02001251 format_symref_info(&symref_info, &data->symref);
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001252 format_session_id(&session_id, data);
Jacob Vosmaer70afef52021-09-01 14:54:42 +02001253 packet_fwrite_fmt(stdout, "%s %s%c%s%s%s%s%s%s%s object-format=%s agent=%s\n",
Michael Haggerty363e98b2015-05-25 18:39:12 +00001254 oid_to_hex(oid), refname_nons,
Junio C Hamanocf2ad8e2011-03-29 10:24:59 -07001255 0, capabilities,
Christian Couder629060d2020-06-11 14:05:12 +02001256 (data->allow_uor & ALLOW_TIP_SHA1) ?
Fredrik Medley7199c092015-05-21 22:23:38 +02001257 " allow-tip-sha1-in-want" : "",
Christian Couder629060d2020-06-11 14:05:12 +02001258 (data->allow_uor & ALLOW_REACHABLE_SHA1) ?
Fredrik Medley68ee6282015-05-21 22:23:39 +02001259 " allow-reachable-sha1-in-want" : "",
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001260 data->no_done ? " no-done" : "",
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001261 symref_info.buf,
Christian Couder59abe192020-06-04 19:54:47 +02001262 data->allow_filter ? " filter" : "",
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001263 session_id.buf,
brian m. carlsonbf30dbf2020-05-25 19:58:51 +00001264 the_hash_algo->name,
Jeff Kingff5effd2012-08-03 12:19:16 -04001265 git_user_agent_sanitized());
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001266 strbuf_release(&symref_info);
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001267 strbuf_release(&session_id);
brian m. carlson933e3a42023-05-17 19:24:43 +00001268 data->sent_capabilities = 1;
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001269 } else {
Jacob Vosmaer70afef52021-09-01 14:54:42 +02001270 packet_fwrite_fmt(stdout, "%s %s\n", oid_to_hex(oid), refname_nons);
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001271 }
Johannes Schindelin1f5881b2005-10-28 05:56:41 +02001272 capabilities = NULL;
Jeff King36a31792021-01-20 14:44:43 -05001273 if (!peel_iterated_oid(oid, &peeled))
Jacob Vosmaer70afef52021-09-01 14:54:42 +02001274 packet_fwrite_fmt(stdout, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
brian m. carlson933e3a42023-05-17 19:24:43 +00001275 return;
1276}
1277
1278static int send_ref(const char *refname, const struct object_id *oid,
1279 int flag UNUSED, void *cb_data)
1280{
1281 write_v0_ref(cb_data, refname, strip_namespace(refname), oid);
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001282 return 0;
1283}
1284
Jeff King63e14ee2022-08-19 06:08:32 -04001285static int find_symref(const char *refname,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001286 const struct object_id *oid UNUSED,
Michael Haggerty7dabd052015-05-25 18:39:10 +00001287 int flag, void *cb_data)
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001288{
1289 const char *symref_target;
1290 struct string_list_item *item;
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001291
1292 if ((flag & REF_ISSYMREF) == 0)
1293 return 0;
René Scharfe744c0402017-09-23 11:45:04 +02001294 symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001295 if (!symref_target || (flag & REF_ISSYMREF) == 0)
1296 die("'%s' is a symref but it is not?", refname);
Jeff King533e0882019-05-23 02:11:21 -04001297 item = string_list_append(cb_data, strip_namespace(refname));
1298 item->util = xstrdup(strip_namespace(symref_target));
Junio C Hamano7171d8c2013-09-17 16:17:33 -07001299 return 0;
1300}
1301
Taylor Blau6dd34562020-08-03 14:00:10 -04001302static int parse_object_filter_config(const char *var, const char *value,
Glen Choo8868b1e2023-06-28 19:26:27 +00001303 const struct key_value_info *kvi,
1304 struct upload_pack_data *data)
Taylor Blau6dd34562020-08-03 14:00:10 -04001305{
1306 struct strbuf buf = STRBUF_INIT;
1307 const char *sub, *key;
1308 size_t sub_len;
1309
1310 if (parse_config_key(var, "uploadpackfilter", &sub, &sub_len, &key))
1311 return 0;
1312
1313 if (!sub) {
1314 if (!strcmp(key, "allow"))
1315 data->allow_filter_fallback = git_config_bool(var, value);
1316 return 0;
1317 }
1318
1319 strbuf_add(&buf, sub, sub_len);
1320
1321 if (!strcmp(key, "allow"))
1322 string_list_insert(&data->allowed_filters, buf.buf)->util =
1323 (void *)(intptr_t)git_config_bool(var, value);
Taylor Blau5b01a4e2020-08-03 14:00:17 -04001324 else if (!strcmp(buf.buf, "tree") && !strcmp(key, "maxdepth")) {
1325 if (!value) {
1326 strbuf_release(&buf);
1327 return config_error_nonbool(var);
1328 }
1329 string_list_insert(&data->allowed_filters, buf.buf)->util =
1330 (void *)(intptr_t)1;
Glen Choo8868b1e2023-06-28 19:26:27 +00001331 data->tree_filter_max_depth = git_config_ulong(var, value,
1332 kvi);
Taylor Blau5b01a4e2020-08-03 14:00:17 -04001333 }
Taylor Blau6dd34562020-08-03 14:00:10 -04001334
1335 strbuf_release(&buf);
1336 return 0;
1337}
1338
Glen Chooa4e7e312023-06-28 19:26:22 +00001339static int upload_pack_config(const char *var, const char *value,
Glen Choo8868b1e2023-06-28 19:26:27 +00001340 const struct config_context *ctx,
Glen Chooa4e7e312023-06-28 19:26:22 +00001341 void *cb_data)
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001342{
Christian Couderf203a882020-06-04 19:54:46 +02001343 struct upload_pack_data *data = cb_data;
1344
Fredrik Medley7199c092015-05-21 22:23:38 +02001345 if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1346 if (git_config_bool(var, value))
Christian Couder629060d2020-06-11 14:05:12 +02001347 data->allow_uor |= ALLOW_TIP_SHA1;
Fredrik Medley7199c092015-05-21 22:23:38 +02001348 else
Christian Couder629060d2020-06-11 14:05:12 +02001349 data->allow_uor &= ~ALLOW_TIP_SHA1;
Fredrik Medley68ee6282015-05-21 22:23:39 +02001350 } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1351 if (git_config_bool(var, value))
Christian Couder629060d2020-06-11 14:05:12 +02001352 data->allow_uor |= ALLOW_REACHABLE_SHA1;
Fredrik Medley68ee6282015-05-21 22:23:39 +02001353 else
Christian Couder629060d2020-06-11 14:05:12 +02001354 data->allow_uor &= ~ALLOW_REACHABLE_SHA1;
David Turnerf8edeaa2016-11-11 12:23:48 -05001355 } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1356 if (git_config_bool(var, value))
Christian Couder629060d2020-06-11 14:05:12 +02001357 data->allow_uor |= ALLOW_ANY_SHA1;
David Turnerf8edeaa2016-11-11 12:23:48 -05001358 else
Christian Couder629060d2020-06-11 14:05:12 +02001359 data->allow_uor &= ~ALLOW_ANY_SHA1;
Fredrik Medley7199c092015-05-21 22:23:38 +02001360 } else if (!strcmp("uploadpack.keepalive", var)) {
Glen Choo8868b1e2023-06-28 19:26:27 +00001361 data->keepalive = git_config_int(var, value, ctx->kvi);
Christian Couderf203a882020-06-04 19:54:46 +02001362 if (!data->keepalive)
1363 data->keepalive = -1;
Jeff Hostetler10ac85c2017-12-08 15:58:39 +00001364 } else if (!strcmp("uploadpack.allowfilter", var)) {
Christian Couder59abe192020-06-04 19:54:47 +02001365 data->allow_filter = git_config_bool(var, value);
Brandon Williams516e2b72018-06-27 15:30:17 -07001366 } else if (!strcmp("uploadpack.allowrefinwant", var)) {
Christian Couderd1d7a942020-06-04 19:54:48 +02001367 data->allow_ref_in_want = git_config_bool(var, value);
Jonathan Tan0bbc0bc2019-01-16 11:28:14 -08001368 } else if (!strcmp("uploadpack.allowsidebandall", var)) {
Christian Coudere3835cd2020-06-04 19:54:49 +02001369 data->allow_sideband_all = git_config_bool(var, value);
Elijah Newren8e712ef2019-04-25 07:58:54 -07001370 } else if (!strcmp("core.precomposeunicode", var)) {
1371 precomposed_unicode = git_config_bool(var, value);
Josh Steadmon791e1ad2020-11-11 15:29:27 -08001372 } else if (!strcmp("transfer.advertisesid", var)) {
1373 data->advertise_sid = git_config_bool(var, value);
Jeff King05e95152013-09-08 05:01:31 -04001374 }
Jeff Kingaaaa8812018-10-24 03:27:52 -04001375
Glen Choo8868b1e2023-06-28 19:26:27 +00001376 if (parse_object_filter_config(var, value, ctx->kvi, data) < 0)
Jeff Kingd43a21b2020-12-03 03:09:42 -05001377 return -1;
Taylor Blau6dd34562020-08-03 14:00:10 -04001378
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001379 return parse_hide_refs_config(var, value, "uploadpack", &data->hidden_refs);
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001380}
1381
Glen Chooa4e7e312023-06-28 19:26:22 +00001382static int upload_pack_protected_config(const char *var, const char *value,
1383 const struct config_context *ctx UNUSED,
1384 void *cb_data)
Glen Choo5b3c6502022-07-14 21:27:59 +00001385{
1386 struct upload_pack_data *data = cb_data;
1387
1388 if (!strcmp("uploadpack.packobjectshook", var))
1389 return git_config_string(&data->pack_objects_hook, var, value);
1390 return 0;
1391}
1392
1393static void get_upload_pack_config(struct upload_pack_data *data)
1394{
1395 git_config(upload_pack_config, data);
1396 git_protected_config(upload_pack_protected_config, data);
1397}
1398
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001399void upload_pack(const int advertise_refs, const int stateless_rpc,
1400 const int timeout)
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001401{
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001402 struct packet_reader reader;
Christian Couderebf8ebc2020-05-15 12:04:45 +02001403 struct upload_pack_data data;
H. Peter Anvin960decc2005-10-19 14:27:01 -07001404
Christian Couderebf8ebc2020-05-15 12:04:45 +02001405 upload_pack_data_init(&data);
Glen Choo5b3c6502022-07-14 21:27:59 +00001406 get_upload_pack_config(&data);
Christian Couder8a0e6f12020-06-04 19:54:45 +02001407
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001408 data.stateless_rpc = stateless_rpc;
1409 data.timeout = timeout;
1410 if (data.timeout)
1411 data.daemon_mode = 1;
Christian Couderdf654ab2020-05-15 12:04:52 +02001412
Christian Couder438528f2020-05-15 12:04:49 +02001413 head_ref_namespaced(find_symref, &data.symref);
Brandon Williamsaa9bab22017-10-16 10:55:26 -07001414
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001415 if (advertise_refs || !data.stateless_rpc) {
Christian Couderd40f04e2020-06-04 19:54:40 +02001416 reset_timeout(data.timeout);
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001417 if (advertise_refs)
1418 data.no_done = 1;
Christian Couder762f9272020-05-15 12:04:50 +02001419 head_ref_namespaced(send_ref, &data);
Taylor Blau18b6b1b2023-07-10 17:12:45 -04001420 for_each_namespaced_ref_1(send_ref, &data);
brian m. carlson933e3a42023-05-17 19:24:43 +00001421 if (!data.sent_capabilities) {
1422 const char *refname = "capabilities^{}";
1423 write_v0_ref(&data, refname, refname, null_oid());
1424 }
Jacob Vosmaer70afef52021-09-01 14:54:42 +02001425 /*
1426 * fflush stdout before calling advertise_shallow_grafts because send_ref
1427 * uses stdio.
1428 */
1429 fflush_or_die(stdout);
Brandon Williamsa3d6b532018-03-14 11:31:41 -07001430 advertise_shallow_grafts(1);
1431 packet_flush(1);
1432 } else {
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001433 head_ref_namespaced(check_ref, &data);
Taylor Blau18b6b1b2023-07-10 17:12:45 -04001434 for_each_namespaced_ref_1(check_ref, &data);
Brandon Williamsaa9bab22017-10-16 10:55:26 -07001435 }
1436
Ævar Arnfjörð Bjarmasonf234da82021-08-05 03:25:42 +02001437 if (!advertise_refs) {
Christian Couderebf8ebc2020-05-15 12:04:45 +02001438 packet_reader_init(&reader, 0, NULL, 0,
1439 PACKET_READ_CHOMP_NEWLINE |
1440 PACKET_READ_DIE_ON_ERR_PACKET);
Masaya Suzuki01f9ec62018-12-29 13:19:14 -08001441
Christian Couderd92ae2c2020-05-15 12:04:47 +02001442 receive_needs(&data, &reader);
Daniel Duvallfb3d1a02020-10-30 19:39:02 -07001443
1444 /*
1445 * An EOF at this exact point in negotiation should be
1446 * acceptable from stateless clients as they will consume the
1447 * shallow list before doing subsequent rpc with haves/etc.
1448 */
1449 if (data.stateless_rpc)
1450 reader.options |= PACKET_READ_GENTLE_ON_EOF;
1451
1452 if (data.want_obj.nr &&
1453 packet_reader_peek(&reader) != PACKET_READ_EOF) {
1454 reader.options &= ~PACKET_READ_GENTLE_ON_EOF;
Christian Couder07977692020-05-15 12:04:46 +02001455 get_common_commits(&data, &reader);
Ramsay Jonescae2ee12020-06-16 00:00:20 +01001456 create_pack_file(&data, NULL);
Christian Couderebf8ebc2020-05-15 12:04:45 +02001457 }
Brandon Williamsa3d6b532018-03-14 11:31:41 -07001458 }
Christian Couder08450ef2020-05-08 10:01:15 +02001459
Christian Couderebf8ebc2020-05-15 12:04:45 +02001460 upload_pack_data_clear(&data);
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001461}
Brandon Williams3145ea92018-03-15 10:31:27 -07001462
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001463static int parse_want(struct packet_writer *writer, const char *line,
1464 struct object_array *want_obj)
Brandon Williams3145ea92018-03-15 10:31:27 -07001465{
1466 const char *arg;
1467 if (skip_prefix(line, "want ", &arg)) {
1468 struct object_id oid;
1469 struct object *o;
1470
1471 if (get_oid_hex(arg, &oid))
1472 die("git upload-pack: protocol error, "
1473 "expected to get oid, not '%s'", line);
1474
Jeff King9a8c3c42022-09-06 19:06:25 -04001475 o = parse_object_with_flags(the_repository, &oid,
1476 PARSE_OBJECT_SKIP_HASH_CHECK);
Patrick Steinhardt4de65622022-03-01 10:33:37 +01001477
Brandon Williams3145ea92018-03-15 10:31:27 -07001478 if (!o) {
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001479 packet_writer_error(writer,
1480 "upload-pack: not our ref %s",
1481 oid_to_hex(&oid));
Brandon Williams3145ea92018-03-15 10:31:27 -07001482 die("git upload-pack: not our ref %s",
1483 oid_to_hex(&oid));
1484 }
1485
1486 if (!(o->flags & WANTED)) {
1487 o->flags |= WANTED;
Jonathan Tan1d1243f2018-10-18 13:43:28 -07001488 add_object_array(o, NULL, want_obj);
Brandon Williams3145ea92018-03-15 10:31:27 -07001489 }
1490
1491 return 1;
Linus Torvaldsdef88e92005-07-04 13:26:53 -07001492 }
1493
1494 return 0;
1495}
Brandon Williams3145ea92018-03-15 10:31:27 -07001496
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001497static int parse_want_ref(struct packet_writer *writer, const char *line,
1498 struct string_list *wanted_refs,
Taylor Blauc45841f2023-07-10 17:12:33 -04001499 struct strvec *hidden_refs,
Jonathan Tan1d1243f2018-10-18 13:43:28 -07001500 struct object_array *want_obj)
Brandon Williams516e2b72018-06-27 15:30:17 -07001501{
Kim Altintop39551402021-08-13 06:23:50 +00001502 const char *refname_nons;
1503 if (skip_prefix(line, "want-ref ", &refname_nons)) {
Brandon Williams516e2b72018-06-27 15:30:17 -07001504 struct object_id oid;
1505 struct string_list_item *item;
Patrick Steinhardt4de65622022-03-01 10:33:37 +01001506 struct object *o = NULL;
Kim Altintop39551402021-08-13 06:23:50 +00001507 struct strbuf refname = STRBUF_INIT;
Brandon Williams516e2b72018-06-27 15:30:17 -07001508
Kim Altintop39551402021-08-13 06:23:50 +00001509 strbuf_addf(&refname, "%s%s", get_git_namespace(), refname_nons);
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001510 if (ref_is_hidden(refname_nons, refname.buf, hidden_refs) ||
Kim Altintop39551402021-08-13 06:23:50 +00001511 read_ref(refname.buf, &oid)) {
1512 packet_writer_error(writer, "unknown ref %s", refname_nons);
1513 die("unknown ref %s", refname_nons);
Brandon Williams516e2b72018-06-27 15:30:17 -07001514 }
Kim Altintop39551402021-08-13 06:23:50 +00001515 strbuf_release(&refname);
Brandon Williams516e2b72018-06-27 15:30:17 -07001516
Kim Altintop39551402021-08-13 06:23:50 +00001517 item = string_list_append(wanted_refs, refname_nons);
Brandon Williams516e2b72018-06-27 15:30:17 -07001518 item->util = oiddup(&oid);
1519
Patrick Steinhardt4de65622022-03-01 10:33:37 +01001520 if (!starts_with(refname_nons, "refs/tags/")) {
1521 struct commit *commit = lookup_commit_in_graph(the_repository, &oid);
1522 if (commit)
1523 o = &commit->object;
1524 }
1525
1526 if (!o)
1527 o = parse_object_or_die(&oid, refname_nons);
1528
Brandon Williams516e2b72018-06-27 15:30:17 -07001529 if (!(o->flags & WANTED)) {
1530 o->flags |= WANTED;
Jonathan Tan1d1243f2018-10-18 13:43:28 -07001531 add_object_array(o, NULL, want_obj);
Brandon Williams516e2b72018-06-27 15:30:17 -07001532 }
1533
1534 return 1;
1535 }
1536
1537 return 0;
1538}
1539
Brandon Williams3145ea92018-03-15 10:31:27 -07001540static int parse_have(const char *line, struct oid_array *haves)
1541{
1542 const char *arg;
1543 if (skip_prefix(line, "have ", &arg)) {
1544 struct object_id oid;
1545
1546 if (get_oid_hex(arg, &oid))
1547 die("git upload-pack: expected SHA1 object, got '%s'", arg);
1548 oid_array_append(haves, &oid);
1549 return 1;
1550 }
1551
1552 return 0;
1553}
1554
1555static void process_args(struct packet_reader *request,
Christian Couder389f1612020-05-15 12:04:43 +02001556 struct upload_pack_data *data)
Brandon Williams3145ea92018-03-15 10:31:27 -07001557{
Jeff King4845b772020-03-27 04:03:38 -04001558 while (packet_reader_read(request) == PACKET_READ_NORMAL) {
Brandon Williams3145ea92018-03-15 10:31:27 -07001559 const char *arg = request->line;
Jonathan Tanba957102018-05-03 16:46:56 -07001560 const char *p;
Brandon Williams3145ea92018-03-15 10:31:27 -07001561
1562 /* process want */
Christian Couder389f1612020-05-15 12:04:43 +02001563 if (parse_want(&data->writer, arg, &data->want_obj))
Brandon Williams3145ea92018-03-15 10:31:27 -07001564 continue;
Christian Couderd1d7a942020-06-04 19:54:48 +02001565 if (data->allow_ref_in_want &&
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001566 parse_want_ref(&data->writer, arg, &data->wanted_refs,
Patrick Steinhardt9b67eb62022-11-17 06:46:43 +01001567 &data->hidden_refs, &data->want_obj))
Brandon Williams516e2b72018-06-27 15:30:17 -07001568 continue;
Brandon Williams3145ea92018-03-15 10:31:27 -07001569 /* process have line */
1570 if (parse_have(arg, &data->haves))
1571 continue;
1572
1573 /* process args like thin-pack */
1574 if (!strcmp(arg, "thin-pack")) {
Jeff Kingb5a20682020-06-04 19:54:38 +02001575 data->use_thin_pack = 1;
Brandon Williams3145ea92018-03-15 10:31:27 -07001576 continue;
1577 }
1578 if (!strcmp(arg, "ofs-delta")) {
Jeff Kingb5a20682020-06-04 19:54:38 +02001579 data->use_ofs_delta = 1;
Brandon Williams3145ea92018-03-15 10:31:27 -07001580 continue;
1581 }
1582 if (!strcmp(arg, "no-progress")) {
Jeff Kingb5a20682020-06-04 19:54:38 +02001583 data->no_progress = 1;
Brandon Williams3145ea92018-03-15 10:31:27 -07001584 continue;
1585 }
1586 if (!strcmp(arg, "include-tag")) {
Jeff Kingb5a20682020-06-04 19:54:38 +02001587 data->use_include_tag = 1;
Brandon Williams3145ea92018-03-15 10:31:27 -07001588 continue;
1589 }
1590 if (!strcmp(arg, "done")) {
1591 data->done = 1;
1592 continue;
1593 }
Jonathan Tan9c1e6572021-05-04 14:16:01 -07001594 if (!strcmp(arg, "wait-for-done")) {
1595 data->wait_for_done = 1;
1596 continue;
1597 }
Brandon Williams3145ea92018-03-15 10:31:27 -07001598
Brandon Williams685fbd32018-03-15 10:31:28 -07001599 /* Shallow related arguments */
1600 if (process_shallow(arg, &data->shallows))
1601 continue;
1602 if (process_deepen(arg, &data->depth))
1603 continue;
1604 if (process_deepen_since(arg, &data->deepen_since,
1605 &data->deepen_rev_list))
1606 continue;
1607 if (process_deepen_not(arg, &data->deepen_not,
1608 &data->deepen_rev_list))
1609 continue;
1610 if (!strcmp(arg, "deepen-relative")) {
1611 data->deepen_relative = 1;
1612 continue;
1613 }
1614
Christian Couder59abe192020-06-04 19:54:47 +02001615 if (data->allow_filter && skip_prefix(arg, "filter ", &p)) {
Christian Couder08450ef2020-05-08 10:01:15 +02001616 list_objects_filter_die_if_populated(&data->filter_options);
1617 parse_list_objects_filter(&data->filter_options, p);
Taylor Blau6dd34562020-08-03 14:00:10 -04001618 die_if_using_banned_filter(data);
Jonathan Tanba957102018-05-03 16:46:56 -07001619 continue;
1620 }
1621
Jonathan Tan07c3c2a2019-01-16 11:28:15 -08001622 if ((git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
Christian Coudere3835cd2020-06-04 19:54:49 +02001623 data->allow_sideband_all) &&
Jonathan Tan07c3c2a2019-01-16 11:28:15 -08001624 !strcmp(arg, "sideband-all")) {
Jonathan Tan0bbc0bc2019-01-16 11:28:14 -08001625 data->writer.use_sideband = 1;
1626 continue;
1627 }
1628
Jonathan Tandd4b7322020-06-10 13:57:23 -07001629 if (skip_prefix(arg, "packfile-uris ", &p)) {
1630 string_list_split(&data->uri_protocols, p, ',', -1);
1631 continue;
1632 }
1633
Brandon Williams3145ea92018-03-15 10:31:27 -07001634 /* ignore unknown lines maybe? */
Jonathan Tan7cc6ed22018-05-01 17:31:29 -07001635 die("unexpected line: '%s'", arg);
Brandon Williams3145ea92018-03-15 10:31:27 -07001636 }
Jeff King4845b772020-03-27 04:03:38 -04001637
Jonathan Tandd4b7322020-06-10 13:57:23 -07001638 if (data->uri_protocols.nr && !data->writer.use_sideband)
1639 string_list_clear(&data->uri_protocols, 0);
1640
Jeff King4845b772020-03-27 04:03:38 -04001641 if (request->status != PACKET_READ_FLUSH)
1642 die(_("expected flush after fetch arguments"));
Brandon Williams3145ea92018-03-15 10:31:27 -07001643}
1644
Christian Couder8dcf2272020-06-11 14:05:13 +02001645static int process_haves(struct upload_pack_data *data, struct oid_array *common)
Brandon Williams3145ea92018-03-15 10:31:27 -07001646{
1647 int i;
1648
1649 /* Process haves */
Christian Couder8dcf2272020-06-11 14:05:13 +02001650 for (i = 0; i < data->haves.nr; i++) {
1651 const struct object_id *oid = &data->haves.oid[i];
Brandon Williams3145ea92018-03-15 10:31:27 -07001652
Ævar Arnfjörð Bjarmasonbc726bd2023-03-28 15:58:50 +02001653 if (!repo_has_object_file_with_flags(the_repository, oid,
1654 OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT))
Brandon Williams3145ea92018-03-15 10:31:27 -07001655 continue;
1656
1657 oid_array_append(common, oid);
1658
Christian Couderea2c6e62020-06-11 14:05:18 +02001659 do_got_oid(data, oid);
Brandon Williams3145ea92018-03-15 10:31:27 -07001660 }
1661
1662 return 0;
1663}
1664
Christian Couder6fbbc432020-06-11 14:05:14 +02001665static int send_acks(struct upload_pack_data *data, struct oid_array *acks)
Brandon Williams3145ea92018-03-15 10:31:27 -07001666{
1667 int i;
1668
Christian Couder6fbbc432020-06-11 14:05:14 +02001669 packet_writer_write(&data->writer, "acknowledgments\n");
Brandon Williams3145ea92018-03-15 10:31:27 -07001670
1671 /* Send Acks */
1672 if (!acks->nr)
Christian Couder6fbbc432020-06-11 14:05:14 +02001673 packet_writer_write(&data->writer, "NAK\n");
Brandon Williams3145ea92018-03-15 10:31:27 -07001674
1675 for (i = 0; i < acks->nr; i++) {
Christian Couder6fbbc432020-06-11 14:05:14 +02001676 packet_writer_write(&data->writer, "ACK %s\n",
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001677 oid_to_hex(&acks->oid[i]));
Brandon Williams3145ea92018-03-15 10:31:27 -07001678 }
1679
Jonathan Tan9c1e6572021-05-04 14:16:01 -07001680 if (!data->wait_for_done && ok_to_give_up(data)) {
Brandon Williams3145ea92018-03-15 10:31:27 -07001681 /* Send Ready */
Christian Couder6fbbc432020-06-11 14:05:14 +02001682 packet_writer_write(&data->writer, "ready\n");
Brandon Williams3145ea92018-03-15 10:31:27 -07001683 return 1;
1684 }
1685
1686 return 0;
1687}
1688
Christian Couder389f1612020-05-15 12:04:43 +02001689static int process_haves_and_send_acks(struct upload_pack_data *data)
Brandon Williams3145ea92018-03-15 10:31:27 -07001690{
1691 struct oid_array common = OID_ARRAY_INIT;
Brandon Williams3145ea92018-03-15 10:31:27 -07001692 int ret = 0;
1693
Christian Couder8dcf2272020-06-11 14:05:13 +02001694 process_haves(data, &common);
Brandon Williams3145ea92018-03-15 10:31:27 -07001695 if (data->done) {
1696 ret = 1;
Christian Couder6fbbc432020-06-11 14:05:14 +02001697 } else if (send_acks(data, &common)) {
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001698 packet_writer_delim(&data->writer);
Brandon Williams3145ea92018-03-15 10:31:27 -07001699 ret = 1;
1700 } else {
1701 /* Add Flush */
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001702 packet_writer_flush(&data->writer);
Brandon Williams3145ea92018-03-15 10:31:27 -07001703 ret = 0;
1704 }
1705
Brandon Williams3145ea92018-03-15 10:31:27 -07001706 oid_array_clear(&data->haves);
1707 oid_array_clear(&common);
1708 return ret;
1709}
1710
Brandon Williams516e2b72018-06-27 15:30:17 -07001711static void send_wanted_ref_info(struct upload_pack_data *data)
1712{
1713 const struct string_list_item *item;
1714
1715 if (!data->wanted_refs.nr)
1716 return;
1717
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001718 packet_writer_write(&data->writer, "wanted-refs\n");
Brandon Williams516e2b72018-06-27 15:30:17 -07001719
1720 for_each_string_list_item(item, &data->wanted_refs) {
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001721 packet_writer_write(&data->writer, "%s %s\n",
1722 oid_to_hex(item->util),
1723 item->string);
Brandon Williams516e2b72018-06-27 15:30:17 -07001724 }
1725
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001726 packet_writer_delim(&data->writer);
Brandon Williams516e2b72018-06-27 15:30:17 -07001727}
1728
Christian Couder389f1612020-05-15 12:04:43 +02001729static void send_shallow_info(struct upload_pack_data *data)
Brandon Williams685fbd32018-03-15 10:31:28 -07001730{
1731 /* No shallow info needs to be sent */
1732 if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
Junio C Hamano00624d62018-07-18 12:20:27 -07001733 !is_repository_shallow(the_repository))
Brandon Williams685fbd32018-03-15 10:31:28 -07001734 return;
1735
Jonathan Tanbc2e7952019-01-15 11:40:27 -08001736 packet_writer_write(&data->writer, "shallow-info\n");
Brandon Williams685fbd32018-03-15 10:31:28 -07001737
Christian Couderee703c82020-06-11 14:05:05 +02001738 if (!send_shallow_list(data) &&
Junio C Hamano00624d62018-07-18 12:20:27 -07001739 is_repository_shallow(the_repository))
Christian Couderb1492f22020-06-11 14:05:06 +02001740 deepen(data, INFINITE_DEPTH);
Brandon Williams685fbd32018-03-15 10:31:28 -07001741
1742 packet_delim(1);
1743}
1744
Brandon Williams3145ea92018-03-15 10:31:27 -07001745enum fetch_state {
1746 FETCH_PROCESS_ARGS = 0,
1747 FETCH_SEND_ACKS,
1748 FETCH_SEND_PACK,
1749 FETCH_DONE,
1750};
1751
Jeff King74595cc2023-02-24 01:38:23 -05001752int upload_pack_v2(struct repository *r UNUSED, struct packet_reader *request)
Brandon Williams3145ea92018-03-15 10:31:27 -07001753{
1754 enum fetch_state state = FETCH_PROCESS_ARGS;
1755 struct upload_pack_data data;
Jonathan Tand1035ca2018-10-18 13:43:29 -07001756
1757 clear_object_flags(ALL_FLAGS);
Brandon Williams3145ea92018-03-15 10:31:27 -07001758
1759 upload_pack_data_init(&data);
Christian Couderf8edd1c2020-06-04 19:54:41 +02001760 data.use_sideband = LARGE_PACKET_MAX;
Glen Choo5b3c6502022-07-14 21:27:59 +00001761 get_upload_pack_config(&data);
Christian Couder8a0e6f12020-06-04 19:54:45 +02001762
Brandon Williams3145ea92018-03-15 10:31:27 -07001763 while (state != FETCH_DONE) {
1764 switch (state) {
1765 case FETCH_PROCESS_ARGS:
Christian Couder389f1612020-05-15 12:04:43 +02001766 process_args(request, &data);
Brandon Williams3145ea92018-03-15 10:31:27 -07001767
Jonathan Tan9c1e6572021-05-04 14:16:01 -07001768 if (!data.want_obj.nr && !data.wait_for_done) {
Brandon Williams3145ea92018-03-15 10:31:27 -07001769 /*
Jonathan Tan9c1e6572021-05-04 14:16:01 -07001770 * Request didn't contain any 'want' lines (and
1771 * the request does not contain
1772 * "wait-for-done", in which it is reasonable
1773 * to just send 'have's without 'want's); guess
1774 * they didn't want anything.
Brandon Williams3145ea92018-03-15 10:31:27 -07001775 */
1776 state = FETCH_DONE;
1777 } else if (data.haves.nr) {
1778 /*
1779 * Request had 'have' lines, so lets ACK them.
1780 */
1781 state = FETCH_SEND_ACKS;
1782 } else {
1783 /*
1784 * Request had 'want's but no 'have's so we can
1785 * immedietly go to construct and send a pack.
1786 */
1787 state = FETCH_SEND_PACK;
1788 }
1789 break;
1790 case FETCH_SEND_ACKS:
Christian Couder389f1612020-05-15 12:04:43 +02001791 if (process_haves_and_send_acks(&data))
Brandon Williams3145ea92018-03-15 10:31:27 -07001792 state = FETCH_SEND_PACK;
1793 else
1794 state = FETCH_DONE;
1795 break;
1796 case FETCH_SEND_PACK:
Brandon Williams516e2b72018-06-27 15:30:17 -07001797 send_wanted_ref_info(&data);
Christian Couder389f1612020-05-15 12:04:43 +02001798 send_shallow_info(&data);
Brandon Williams685fbd32018-03-15 10:31:28 -07001799
Jonathan Tandd4b7322020-06-10 13:57:23 -07001800 if (data.uri_protocols.nr) {
1801 create_pack_file(&data, &data.uri_protocols);
1802 } else {
1803 packet_writer_write(&data.writer, "packfile\n");
1804 create_pack_file(&data, NULL);
1805 }
Brandon Williams3145ea92018-03-15 10:31:27 -07001806 state = FETCH_DONE;
1807 break;
1808 case FETCH_DONE:
1809 continue;
1810 }
1811 }
1812
1813 upload_pack_data_clear(&data);
1814 return 0;
1815}
Brandon Williams685fbd32018-03-15 10:31:28 -07001816
1817int upload_pack_advertise(struct repository *r,
1818 struct strbuf *value)
1819{
Jonathan Tanba957102018-05-03 16:46:56 -07001820 if (value) {
1821 int allow_filter_value;
Brandon Williams516e2b72018-06-27 15:30:17 -07001822 int allow_ref_in_want;
Jonathan Tan0bbc0bc2019-01-16 11:28:14 -08001823 int allow_sideband_all_value;
Jonathan Tandd4b7322020-06-10 13:57:23 -07001824 char *str = NULL;
Brandon Williams516e2b72018-06-27 15:30:17 -07001825
Jonathan Tan9c1e6572021-05-04 14:16:01 -07001826 strbuf_addstr(value, "shallow wait-for-done");
Brandon Williams516e2b72018-06-27 15:30:17 -07001827
Jeff King4b4e75d2023-02-24 01:38:10 -05001828 if (!repo_config_get_bool(r,
Jonathan Tanba957102018-05-03 16:46:56 -07001829 "uploadpack.allowfilter",
1830 &allow_filter_value) &&
1831 allow_filter_value)
1832 strbuf_addstr(value, " filter");
Brandon Williams516e2b72018-06-27 15:30:17 -07001833
Jeff King4b4e75d2023-02-24 01:38:10 -05001834 if (!repo_config_get_bool(r,
Brandon Williams516e2b72018-06-27 15:30:17 -07001835 "uploadpack.allowrefinwant",
1836 &allow_ref_in_want) &&
1837 allow_ref_in_want)
1838 strbuf_addstr(value, " ref-in-want");
Jonathan Tan0bbc0bc2019-01-16 11:28:14 -08001839
Jonathan Tan07c3c2a2019-01-16 11:28:15 -08001840 if (git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
Jeff King4b4e75d2023-02-24 01:38:10 -05001841 (!repo_config_get_bool(r,
Jonathan Tan07c3c2a2019-01-16 11:28:15 -08001842 "uploadpack.allowsidebandall",
1843 &allow_sideband_all_value) &&
1844 allow_sideband_all_value))
Jonathan Tan0bbc0bc2019-01-16 11:28:14 -08001845 strbuf_addstr(value, " sideband-all");
Jonathan Tandd4b7322020-06-10 13:57:23 -07001846
Jeff King4b4e75d2023-02-24 01:38:10 -05001847 if (!repo_config_get_string(r,
Jonathan Tandd4b7322020-06-10 13:57:23 -07001848 "uploadpack.blobpackfileuri",
1849 &str) &&
1850 str) {
1851 strbuf_addstr(value, " packfile-uris");
1852 free(str);
1853 }
Jonathan Tanba957102018-05-03 16:46:56 -07001854 }
Brandon Williams516e2b72018-06-27 15:30:17 -07001855
Brandon Williams685fbd32018-03-15 10:31:28 -07001856 return 1;
1857}