6 #include "run-command.h"
11 #include "transport.h"
13 #include "sha1-array.h"
14 #include "gpg-interface.h"
16 static int feed_object(const unsigned char *sha1, int fd, int negative)
20 if (negative && !has_sha1_file(sha1))
23 memcpy(buf + negative, sha1_to_hex(sha1), 40);
26 buf[40 + negative] = '\n';
27 return write_or_whine(fd, buf, 41 + negative, "send-pack: send refs");
31 * Make a pack stream and spit it out into file descriptor fd
33 static int pack_objects(int fd, struct ref *refs, struct sha1_array *extra, struct send_pack_args *args)
36 * The child becomes pack-objects --revs; we feed
37 * the revision parameters to it via its stdin and
38 * let its stdout go back to the other end.
40 const char *argv[] = {
42 "--all-progress-implied",
52 struct child_process po = CHILD_PROCESS_INIT;
56 if (args->use_thin_pack)
58 if (args->use_ofs_delta)
59 argv[i++] = "--delta-base-offset";
60 if (args->quiet || !args->progress)
63 argv[i++] = "--progress";
64 if (is_repository_shallow())
65 argv[i++] = "--shallow";
68 po.out = args->stateless_rpc ? -1 : fd;
70 if (start_command(&po))
71 die_errno("git pack-objects failed");
74 * We feed the pack-objects we just spawned with revision
75 * parameters by writing to the pipe.
77 for (i = 0; i < extra->nr; i++)
78 if (!feed_object(extra->sha1[i], po.in, 1))
82 if (!is_null_sha1(refs->old_sha1) &&
83 !feed_object(refs->old_sha1, po.in, 1))
85 if (!is_null_sha1(refs->new_sha1) &&
86 !feed_object(refs->new_sha1, po.in, 0))
93 if (args->stateless_rpc) {
94 char *buf = xmalloc(LARGE_PACKET_MAX);
96 ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);
99 send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);
106 if (finish_command(&po))
111 static int receive_status(int in, struct ref *refs)
115 char *line = packet_read_line(in, NULL);
116 if (!starts_with(line, "unpack "))
117 return error("did not receive remote status");
118 if (strcmp(line, "unpack ok")) {
119 error("unpack failed: %s", line + 7);
126 line = packet_read_line(in, NULL);
129 if (!starts_with(line, "ok ") && !starts_with(line, "ng ")) {
130 error("invalid ref status from remote: %s", line);
136 msg = strchr(refname, ' ');
140 /* first try searching at our hint, falling back to all refs */
142 hint = find_ref_by_name(hint, refname);
144 hint = find_ref_by_name(refs, refname);
146 warning("remote reported status on unknown ref: %s",
150 if (hint->status != REF_STATUS_EXPECTING_REPORT) {
151 warning("remote reported status on unexpected ref: %s",
156 if (line[0] == 'o' && line[1] == 'k')
157 hint->status = REF_STATUS_OK;
159 hint->status = REF_STATUS_REMOTE_REJECT;
163 hint->remote_status = xstrdup(msg);
164 /* start our next search from the next ref */
170 static int sideband_demux(int in, int out, void *data)
176 ret = recv_sideband("send-pack", fd[0], out);
181 static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
183 struct strbuf *sb = cb;
184 if (graft->nr_parent == -1)
185 packet_buf_write(sb, "shallow %s\n", sha1_to_hex(graft->sha1));
189 static void advertise_shallow_grafts_buf(struct strbuf *sb)
191 if (!is_repository_shallow())
193 for_each_commit_graft(advertise_shallow_grafts_cb, sb);
196 static int ref_update_to_be_sent(const struct ref *ref, const struct send_pack_args *args)
198 if (!ref->peer_ref && !args->send_mirror)
201 /* Check for statuses set by set_ref_status_for_push() */
202 switch (ref->status) {
203 case REF_STATUS_REJECT_NONFASTFORWARD:
204 case REF_STATUS_REJECT_ALREADY_EXISTS:
205 case REF_STATUS_REJECT_FETCH_FIRST:
206 case REF_STATUS_REJECT_NEEDS_FORCE:
207 case REF_STATUS_REJECT_STALE:
208 case REF_STATUS_REJECT_NODELETE:
209 case REF_STATUS_UPTODATE:
217 * the beginning of the next line, or the end of buffer.
219 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
220 * convert many similar uses found by "git grep -A4 memchr".
222 static const char *next_line(const char *line, size_t len)
224 const char *nl = memchr(line, '\n', len);
226 return line + len; /* incomplete line */
230 static int generate_push_cert(struct strbuf *req_buf,
231 const struct ref *remote_refs,
232 struct send_pack_args *args,
233 const char *cap_string,
234 const char *push_cert_nonce)
236 const struct ref *ref;
237 char *signing_key = xstrdup(get_signing_key());
239 struct strbuf cert = STRBUF_INIT;
242 strbuf_addf(&cert, "certificate version 0.1\n");
243 strbuf_addf(&cert, "pusher %s ", signing_key);
245 strbuf_addch(&cert, '\n');
246 if (args->url && *args->url) {
247 char *anon_url = transport_anonymize_url(args->url);
248 strbuf_addf(&cert, "pushee %s\n", anon_url);
251 if (push_cert_nonce[0])
252 strbuf_addf(&cert, "nonce %s\n", push_cert_nonce);
253 strbuf_addstr(&cert, "\n");
255 for (ref = remote_refs; ref; ref = ref->next) {
256 if (!ref_update_to_be_sent(ref, args))
259 strbuf_addf(&cert, "%s %s %s\n",
260 sha1_to_hex(ref->old_sha1),
261 sha1_to_hex(ref->new_sha1),
267 if (sign_buffer(&cert, &cert, signing_key))
268 die(_("failed to sign the push certificate"));
270 packet_buf_write(req_buf, "push-cert%c%s", 0, cap_string);
271 for (cp = cert.buf; cp < cert.buf + cert.len; cp = np) {
272 np = next_line(cp, cert.buf + cert.len - cp);
273 packet_buf_write(req_buf,
274 "%.*s", (int)(np - cp), cp);
276 packet_buf_write(req_buf, "push-cert-end\n");
280 strbuf_release(&cert);
284 #define NONCE_LEN_LIMIT 256
286 static void reject_invalid_nonce(const char *nonce, int len)
290 if (NONCE_LEN_LIMIT <= len)
291 die("the receiving end asked to sign an invalid nonce <%.*s>",
294 for (i = 0; i < len; i++) {
295 int ch = nonce[i] & 0xFF;
297 ch == '-' || ch == '.' ||
298 ch == '/' || ch == '+' ||
299 ch == '=' || ch == '_')
301 die("the receiving end asked to sign an invalid nonce <%.*s>",
306 int send_pack(struct send_pack_args *args,
307 int fd[], struct child_process *conn,
308 struct ref *remote_refs,
309 struct sha1_array *extra_have)
313 struct strbuf req_buf = STRBUF_INIT;
314 struct strbuf cap_buf = STRBUF_INIT;
316 int need_pack_data = 0;
317 int allow_deleting_refs = 0;
318 int status_report = 0;
319 int use_sideband = 0;
320 int quiet_supported = 0;
321 int agent_supported = 0;
322 unsigned cmds_sent = 0;
325 const char *push_cert_nonce = NULL;
327 /* Does the other end support the reporting? */
328 if (server_supports("report-status"))
330 if (server_supports("delete-refs"))
331 allow_deleting_refs = 1;
332 if (server_supports("ofs-delta"))
333 args->use_ofs_delta = 1;
334 if (server_supports("side-band-64k"))
336 if (server_supports("quiet"))
338 if (server_supports("agent"))
340 if (server_supports("no-thin"))
341 args->use_thin_pack = 0;
342 if (args->push_cert) {
345 push_cert_nonce = server_feature_value("push-cert", &len);
346 if (!push_cert_nonce)
347 die(_("the receiving end does not support --signed push"));
348 reject_invalid_nonce(push_cert_nonce, len);
349 push_cert_nonce = xmemdupz(push_cert_nonce, len);
353 fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
354 "Perhaps you should specify a branch such as 'master'.\n");
359 strbuf_addstr(&cap_buf, " report-status");
361 strbuf_addstr(&cap_buf, " side-band-64k");
362 if (quiet_supported && (args->quiet || !args->progress))
363 strbuf_addstr(&cap_buf, " quiet");
365 strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());
368 * NEEDSWORK: why does delete-refs have to be so specific to
369 * send-pack machinery that set_ref_status_for_push() cannot
370 * set this bit for us???
372 for (ref = remote_refs; ref; ref = ref->next)
373 if (ref->deletion && !allow_deleting_refs)
374 ref->status = REF_STATUS_REJECT_NODELETE;
377 advertise_shallow_grafts_buf(&req_buf);
379 if (!args->dry_run && args->push_cert)
380 cmds_sent = generate_push_cert(&req_buf, remote_refs, args,
381 cap_buf.buf, push_cert_nonce);
384 * Clear the status for each ref and see if we need to send
387 for (ref = remote_refs; ref; ref = ref->next) {
388 if (!ref_update_to_be_sent(ref, args))
394 if (args->dry_run || !status_report)
395 ref->status = REF_STATUS_OK;
397 ref->status = REF_STATUS_EXPECTING_REPORT;
401 * Finally, tell the other end!
403 for (ref = remote_refs; ref; ref = ref->next) {
404 char *old_hex, *new_hex;
406 if (args->dry_run || args->push_cert)
409 if (!ref_update_to_be_sent(ref, args))
412 old_hex = sha1_to_hex(ref->old_sha1);
413 new_hex = sha1_to_hex(ref->new_sha1);
415 packet_buf_write(&req_buf,
417 old_hex, new_hex, ref->name, 0,
421 packet_buf_write(&req_buf, "%s %s %s",
422 old_hex, new_hex, ref->name);
426 if (args->stateless_rpc) {
427 if (!args->dry_run && (cmds_sent || is_repository_shallow())) {
428 packet_buf_flush(&req_buf);
429 send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);
432 write_or_die(out, req_buf.buf, req_buf.len);
435 strbuf_release(&req_buf);
436 strbuf_release(&cap_buf);
438 if (use_sideband && cmds_sent) {
439 memset(&demux, 0, sizeof(demux));
440 demux.proc = sideband_demux;
443 if (start_async(&demux))
444 die("send-pack: unable to fork off sideband demultiplexer");
448 if (need_pack_data && cmds_sent) {
449 if (pack_objects(out, remote_refs, extra_have, args) < 0) {
450 for (ref = remote_refs; ref; ref = ref->next)
451 ref->status = REF_STATUS_NONE;
452 if (args->stateless_rpc)
454 if (git_connection_is_socket(conn))
455 shutdown(fd[0], SHUT_WR);
457 finish_async(&demux);
461 if (!args->stateless_rpc)
462 /* Closed by pack_objects() via start_command() */
465 if (args->stateless_rpc && cmds_sent)
468 if (status_report && cmds_sent)
469 ret = receive_status(in, remote_refs);
472 if (args->stateless_rpc)
475 if (use_sideband && cmds_sent) {
476 if (finish_async(&demux)) {
477 error("error in sideband demultiplexer");
489 for (ref = remote_refs; ref; ref = ref->next) {
490 switch (ref->status) {
491 case REF_STATUS_NONE:
492 case REF_STATUS_UPTODATE: