git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "config.h"
5
#include "commit.h"
6
#include "date.h"
7
#include "gettext.h"
8
#include "hex.h"
9
#include "object-store-ll.h"
10
#include "pkt-line.h"
11
#include "sideband.h"
12
#include "run-command.h"
13
#include "remote.h"
14
#include "connect.h"
15
#include "send-pack.h"
16
#include "transport.h"
17
#include "version.h"
18
#include "oid-array.h"
19
#include "gpg-interface.h"
20
#include "shallow.h"
21
#include "parse-options.h"
22
#include "trace2.h"
23
#include "write-or-die.h"
24

25
int option_parse_push_signed(const struct option *opt,
26
			     const char *arg, int unset)
27
{
28
	if (unset) {
29
		*(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
30
		return 0;
31
	}
32
	switch (git_parse_maybe_bool(arg)) {
33
	case 1:
34
		*(int *)(opt->value) = SEND_PACK_PUSH_CERT_ALWAYS;
35
		return 0;
36
	case 0:
37
		*(int *)(opt->value) = SEND_PACK_PUSH_CERT_NEVER;
38
		return 0;
39
	}
40
	if (!strcasecmp("if-asked", arg)) {
41
		*(int *)(opt->value) = SEND_PACK_PUSH_CERT_IF_ASKED;
42
		return 0;
43
	}
44
	die("bad %s argument: %s", opt->long_name, arg);
45
}
46

47
static void feed_object(const struct object_id *oid, FILE *fh, int negative)
48
{
49
	if (negative &&
50
	    !repo_has_object_file_with_flags(the_repository, oid,
51
					     OBJECT_INFO_SKIP_FETCH_OBJECT |
52
					     OBJECT_INFO_QUICK))
53
		return;
54

55
	if (negative)
56
		putc('^', fh);
57
	fputs(oid_to_hex(oid), fh);
58
	putc('\n', fh);
59
}
60

61
/*
62
 * Make a pack stream and spit it out into file descriptor fd
63
 */
64
static int pack_objects(int fd, struct ref *refs, struct oid_array *advertised,
65
			struct oid_array *negotiated,
66
			struct send_pack_args *args)
67
{
68
	/*
69
	 * The child becomes pack-objects --revs; we feed
70
	 * the revision parameters to it via its stdin and
71
	 * let its stdout go back to the other end.
72
	 */
73
	struct child_process po = CHILD_PROCESS_INIT;
74
	FILE *po_in;
75
	int i;
76
	int rc;
77

78
	strvec_push(&po.args, "pack-objects");
79
	strvec_push(&po.args, "--all-progress-implied");
80
	strvec_push(&po.args, "--revs");
81
	strvec_push(&po.args, "--stdout");
82
	if (args->use_thin_pack)
83
		strvec_push(&po.args, "--thin");
84
	if (args->use_ofs_delta)
85
		strvec_push(&po.args, "--delta-base-offset");
86
	if (args->quiet || !args->progress)
87
		strvec_push(&po.args, "-q");
88
	if (args->progress)
89
		strvec_push(&po.args, "--progress");
90
	if (is_repository_shallow(the_repository))
91
		strvec_push(&po.args, "--shallow");
92
	if (args->disable_bitmaps)
93
		strvec_push(&po.args, "--no-use-bitmap-index");
94
	po.in = -1;
95
	po.out = args->stateless_rpc ? -1 : fd;
96
	po.git_cmd = 1;
97
	po.clean_on_exit = 1;
98
	if (start_command(&po))
99
		die_errno("git pack-objects failed");
100

101
	/*
102
	 * We feed the pack-objects we just spawned with revision
103
	 * parameters by writing to the pipe.
104
	 */
105
	po_in = xfdopen(po.in, "w");
106
	for (i = 0; i < advertised->nr; i++)
107
		feed_object(&advertised->oid[i], po_in, 1);
108
	for (i = 0; i < negotiated->nr; i++)
109
		feed_object(&negotiated->oid[i], po_in, 1);
110

111
	while (refs) {
112
		if (!is_null_oid(&refs->old_oid))
113
			feed_object(&refs->old_oid, po_in, 1);
114
		if (!is_null_oid(&refs->new_oid))
115
			feed_object(&refs->new_oid, po_in, 0);
116
		refs = refs->next;
117
	}
118

119
	fflush(po_in);
120
	if (ferror(po_in))
121
		die_errno("error writing to pack-objects");
122
	fclose(po_in);
123

124
	if (args->stateless_rpc) {
125
		char *buf = xmalloc(LARGE_PACKET_MAX);
126
		while (1) {
127
			ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);
128
			if (n <= 0)
129
				break;
130
			send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);
131
		}
132
		free(buf);
133
		close(po.out);
134
		po.out = -1;
135
	}
136

137
	rc = finish_command(&po);
138
	if (rc) {
139
		/*
140
		 * For a normal non-zero exit, we assume pack-objects wrote
141
		 * something useful to stderr. For death by signal, though,
142
		 * we should mention it to the user. The exception is SIGPIPE
143
		 * (141), because that's a normal occurrence if the remote end
144
		 * hangs up (and we'll report that by trying to read the unpack
145
		 * status).
146
		 */
147
		if (rc > 128 && rc != 141)
148
			error("pack-objects died of signal %d", rc - 128);
149
		return -1;
150
	}
151
	return 0;
152
}
153

154
static int receive_unpack_status(struct packet_reader *reader)
155
{
156
	if (packet_reader_read(reader) != PACKET_READ_NORMAL)
157
		return error(_("unexpected flush packet while reading remote unpack status"));
158
	if (!skip_prefix(reader->line, "unpack ", &reader->line))
159
		return error(_("unable to parse remote unpack status: %s"), reader->line);
160
	if (strcmp(reader->line, "ok"))
161
		return error(_("remote unpack failed: %s"), reader->line);
162
	return 0;
163
}
164

165
static int receive_status(struct packet_reader *reader, struct ref *refs)
166
{
167
	struct ref *hint;
168
	int ret;
169
	struct ref_push_report *report = NULL;
170
	int new_report = 0;
171
	int once = 0;
172

173
	hint = NULL;
174
	ret = receive_unpack_status(reader);
175
	while (1) {
176
		struct object_id old_oid, new_oid;
177
		const char *head;
178
		const char *refname;
179
		char *p;
180
		if (packet_reader_read(reader) != PACKET_READ_NORMAL)
181
			break;
182
		head = reader->line;
183
		p = strchr(head, ' ');
184
		if (!p) {
185
			error("invalid status line from remote: %s", reader->line);
186
			ret = -1;
187
			break;
188
		}
189
		*p++ = '\0';
190

191
		if (!strcmp(head, "option")) {
192
			const char *key, *val;
193

194
			if (!hint || !(report || new_report)) {
195
				if (!once++)
196
					error("'option' without a matching 'ok/ng' directive");
197
				ret = -1;
198
				continue;
199
			}
200
			if (new_report) {
201
				if (!hint->report) {
202
					CALLOC_ARRAY(hint->report, 1);
203
					report = hint->report;
204
				} else {
205
					report = hint->report;
206
					while (report->next)
207
						report = report->next;
208
					CALLOC_ARRAY(report->next, 1);
209
					report = report->next;
210
				}
211
				new_report = 0;
212
			}
213
			key = p;
214
			p = strchr(key, ' ');
215
			if (p)
216
				*p++ = '\0';
217
			val = p;
218
			if (!strcmp(key, "refname"))
219
				report->ref_name = xstrdup_or_null(val);
220
			else if (!strcmp(key, "old-oid") && val &&
221
				 !parse_oid_hex(val, &old_oid, &val))
222
				report->old_oid = oiddup(&old_oid);
223
			else if (!strcmp(key, "new-oid") && val &&
224
				 !parse_oid_hex(val, &new_oid, &val))
225
				report->new_oid = oiddup(&new_oid);
226
			else if (!strcmp(key, "forced-update"))
227
				report->forced_update = 1;
228
			continue;
229
		}
230

231
		report = NULL;
232
		new_report = 0;
233
		if (strcmp(head, "ok") && strcmp(head, "ng")) {
234
			error("invalid ref status from remote: %s", head);
235
			ret = -1;
236
			break;
237
		}
238
		refname = p;
239
		p = strchr(refname, ' ');
240
		if (p)
241
			*p++ = '\0';
242
		/* first try searching at our hint, falling back to all refs */
243
		if (hint)
244
			hint = find_ref_by_name(hint, refname);
245
		if (!hint)
246
			hint = find_ref_by_name(refs, refname);
247
		if (!hint) {
248
			warning("remote reported status on unknown ref: %s",
249
				refname);
250
			continue;
251
		}
252
		if (hint->status != REF_STATUS_EXPECTING_REPORT &&
253
		    hint->status != REF_STATUS_OK &&
254
		    hint->status != REF_STATUS_REMOTE_REJECT) {
255
			warning("remote reported status on unexpected ref: %s",
256
				refname);
257
			continue;
258
		}
259
		if (!strcmp(head, "ng")) {
260
			hint->status = REF_STATUS_REMOTE_REJECT;
261
			if (p)
262
				hint->remote_status = xstrdup(p);
263
			else
264
				hint->remote_status = xstrdup("failed");
265
		} else {
266
			hint->status = REF_STATUS_OK;
267
			hint->remote_status = xstrdup_or_null(p);
268
			new_report = 1;
269
		}
270
	}
271
	return ret;
272
}
273

274
static int sideband_demux(int in UNUSED, int out, void *data)
275
{
276
	int *fd = data, ret;
277
	if (async_with_fork())
278
		close(fd[1]);
279
	ret = recv_sideband("send-pack", fd[0], out);
280
	close(out);
281
	return ret;
282
}
283

284
static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
285
{
286
	struct strbuf *sb = cb;
287
	if (graft->nr_parent == -1)
288
		packet_buf_write(sb, "shallow %s\n", oid_to_hex(&graft->oid));
289
	return 0;
290
}
291

292
static void advertise_shallow_grafts_buf(struct strbuf *sb)
293
{
294
	if (!is_repository_shallow(the_repository))
295
		return;
296
	for_each_commit_graft(advertise_shallow_grafts_cb, sb);
297
}
298

299
#define CHECK_REF_NO_PUSH -1
300
#define CHECK_REF_STATUS_REJECTED -2
301
#define CHECK_REF_UPTODATE -3
302
static int check_to_send_update(const struct ref *ref, const struct send_pack_args *args)
303
{
304
	if (!ref->peer_ref && !args->send_mirror)
305
		return CHECK_REF_NO_PUSH;
306

307
	/* Check for statuses set by set_ref_status_for_push() */
308
	switch (ref->status) {
309
	case REF_STATUS_REJECT_NONFASTFORWARD:
310
	case REF_STATUS_REJECT_ALREADY_EXISTS:
311
	case REF_STATUS_REJECT_FETCH_FIRST:
312
	case REF_STATUS_REJECT_NEEDS_FORCE:
313
	case REF_STATUS_REJECT_STALE:
314
	case REF_STATUS_REJECT_REMOTE_UPDATED:
315
	case REF_STATUS_REJECT_NODELETE:
316
		return CHECK_REF_STATUS_REJECTED;
317
	case REF_STATUS_UPTODATE:
318
		return CHECK_REF_UPTODATE;
319

320
	default:
321
	case REF_STATUS_EXPECTING_REPORT:
322
		/* already passed checks on the local side */
323
	case REF_STATUS_OK:
324
		/* of course this is OK */
325
		return 0;
326
	}
327
}
328

329
/*
330
 * the beginning of the next line, or the end of buffer.
331
 *
332
 * NEEDSWORK: perhaps move this to git-compat-util.h or somewhere and
333
 * convert many similar uses found by "git grep -A4 memchr".
334
 */
335
static const char *next_line(const char *line, size_t len)
336
{
337
	const char *nl = memchr(line, '\n', len);
338
	if (!nl)
339
		return line + len; /* incomplete line */
340
	return nl + 1;
341
}
342

343
static int generate_push_cert(struct strbuf *req_buf,
344
			      const struct ref *remote_refs,
345
			      struct send_pack_args *args,
346
			      const char *cap_string,
347
			      const char *push_cert_nonce)
348
{
349
	const struct ref *ref;
350
	struct string_list_item *item;
351
	char *signing_key_id = xstrdup(get_signing_key_id());
352
	const char *cp, *np;
353
	struct strbuf cert = STRBUF_INIT;
354
	int update_seen = 0;
355

356
	strbuf_addstr(&cert, "certificate version 0.1\n");
357
	strbuf_addf(&cert, "pusher %s ", signing_key_id);
358
	datestamp(&cert);
359
	strbuf_addch(&cert, '\n');
360
	if (args->url && *args->url) {
361
		char *anon_url = transport_anonymize_url(args->url);
362
		strbuf_addf(&cert, "pushee %s\n", anon_url);
363
		free(anon_url);
364
	}
365
	if (push_cert_nonce[0])
366
		strbuf_addf(&cert, "nonce %s\n", push_cert_nonce);
367
	if (args->push_options)
368
		for_each_string_list_item(item, args->push_options)
369
			strbuf_addf(&cert, "push-option %s\n", item->string);
370
	strbuf_addstr(&cert, "\n");
371

372
	for (ref = remote_refs; ref; ref = ref->next) {
373
		if (check_to_send_update(ref, args) < 0)
374
			continue;
375
		update_seen = 1;
376
		strbuf_addf(&cert, "%s %s %s\n",
377
			    oid_to_hex(&ref->old_oid),
378
			    oid_to_hex(&ref->new_oid),
379
			    ref->name);
380
	}
381
	if (!update_seen)
382
		goto free_return;
383

384
	if (sign_buffer(&cert, &cert, get_signing_key()))
385
		die(_("failed to sign the push certificate"));
386

387
	packet_buf_write(req_buf, "push-cert%c%s", 0, cap_string);
388
	for (cp = cert.buf; cp < cert.buf + cert.len; cp = np) {
389
		np = next_line(cp, cert.buf + cert.len - cp);
390
		packet_buf_write(req_buf,
391
				 "%.*s", (int)(np - cp), cp);
392
	}
393
	packet_buf_write(req_buf, "push-cert-end\n");
394

395
free_return:
396
	free(signing_key_id);
397
	strbuf_release(&cert);
398
	return update_seen;
399
}
400

401
#define NONCE_LEN_LIMIT 256
402

403
static void reject_invalid_nonce(const char *nonce, int len)
404
{
405
	int i = 0;
406

407
	if (NONCE_LEN_LIMIT <= len)
408
		die("the receiving end asked to sign an invalid nonce <%.*s>",
409
		    len, nonce);
410

411
	for (i = 0; i < len; i++) {
412
		int ch = nonce[i] & 0xFF;
413
		if (isalnum(ch) ||
414
		    ch == '-' || ch == '.' ||
415
		    ch == '/' || ch == '+' ||
416
		    ch == '=' || ch == '_')
417
			continue;
418
		die("the receiving end asked to sign an invalid nonce <%.*s>",
419
		    len, nonce);
420
	}
421
}
422

423
static void get_commons_through_negotiation(const char *url,
424
					    const struct ref *remote_refs,
425
					    struct oid_array *commons)
426
{
427
	struct child_process child = CHILD_PROCESS_INIT;
428
	const struct ref *ref;
429
	int len = the_hash_algo->hexsz + 1; /* hash + NL */
430
	int nr_negotiation_tip = 0;
431

432
	child.git_cmd = 1;
433
	child.no_stdin = 1;
434
	child.out = -1;
435
	strvec_pushl(&child.args, "fetch", "--negotiate-only", NULL);
436
	for (ref = remote_refs; ref; ref = ref->next) {
437
		if (!is_null_oid(&ref->new_oid)) {
438
			strvec_pushf(&child.args, "--negotiation-tip=%s",
439
				     oid_to_hex(&ref->new_oid));
440
			nr_negotiation_tip++;
441
		}
442
	}
443
	strvec_push(&child.args, url);
444

445
	if (!nr_negotiation_tip) {
446
		child_process_clear(&child);
447
		return;
448
	}
449

450
	if (start_command(&child))
451
		die(_("send-pack: unable to fork off fetch subprocess"));
452

453
	do {
454
		char hex_hash[GIT_MAX_HEXSZ + 1];
455
		int read_len = read_in_full(child.out, hex_hash, len);
456
		struct object_id oid;
457
		const char *end;
458

459
		if (!read_len)
460
			break;
461
		if (read_len != len)
462
			die("invalid length read %d", read_len);
463
		if (parse_oid_hex(hex_hash, &oid, &end) || *end != '\n')
464
			die("invalid hash");
465
		oid_array_append(commons, &oid);
466
	} while (1);
467

468
	if (finish_command(&child)) {
469
		/*
470
		 * The information that push negotiation provides is useful but
471
		 * not mandatory.
472
		 */
473
		warning(_("push negotiation failed; proceeding anyway with push"));
474
	}
475
}
476

477
int send_pack(struct send_pack_args *args,
478
	      int fd[], struct child_process *conn,
479
	      struct ref *remote_refs,
480
	      struct oid_array *extra_have)
481
{
482
	struct oid_array commons = OID_ARRAY_INIT;
483
	int in = fd[0];
484
	int out = fd[1];
485
	struct strbuf req_buf = STRBUF_INIT;
486
	struct strbuf cap_buf = STRBUF_INIT;
487
	struct ref *ref;
488
	int need_pack_data = 0;
489
	int allow_deleting_refs = 0;
490
	int status_report = 0;
491
	int use_sideband = 0;
492
	int quiet_supported = 0;
493
	int agent_supported = 0;
494
	int advertise_sid = 0;
495
	int push_negotiate = 0;
496
	int use_atomic = 0;
497
	int atomic_supported = 0;
498
	int use_push_options = 0;
499
	int push_options_supported = 0;
500
	int object_format_supported = 0;
501
	unsigned cmds_sent = 0;
502
	int ret;
503
	struct async demux;
504
	const char *push_cert_nonce = NULL;
505
	struct packet_reader reader;
506
	int use_bitmaps;
507

508
	if (!remote_refs) {
509
		fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
510
			"Perhaps you should specify a branch.\n");
511
		return 0;
512
	}
513

514
	git_config_get_bool("push.negotiate", &push_negotiate);
515
	if (push_negotiate)
516
		get_commons_through_negotiation(args->url, remote_refs, &commons);
517

518
	if (!git_config_get_bool("push.usebitmaps", &use_bitmaps))
519
		args->disable_bitmaps = !use_bitmaps;
520

521
	git_config_get_bool("transfer.advertisesid", &advertise_sid);
522

523
	/* Does the other end support the reporting? */
524
	if (server_supports("report-status-v2"))
525
		status_report = 2;
526
	else if (server_supports("report-status"))
527
		status_report = 1;
528
	if (server_supports("delete-refs"))
529
		allow_deleting_refs = 1;
530
	if (server_supports("ofs-delta"))
531
		args->use_ofs_delta = 1;
532
	if (server_supports("side-band-64k"))
533
		use_sideband = 1;
534
	if (server_supports("quiet"))
535
		quiet_supported = 1;
536
	if (server_supports("agent"))
537
		agent_supported = 1;
538
	if (!server_supports("session-id"))
539
		advertise_sid = 0;
540
	if (server_supports("no-thin"))
541
		args->use_thin_pack = 0;
542
	if (server_supports("atomic"))
543
		atomic_supported = 1;
544
	if (server_supports("push-options"))
545
		push_options_supported = 1;
546

547
	if (!server_supports_hash(the_hash_algo->name, &object_format_supported))
548
		die(_("the receiving end does not support this repository's hash algorithm"));
549

550
	if (args->push_cert != SEND_PACK_PUSH_CERT_NEVER) {
551
		size_t len;
552
		push_cert_nonce = server_feature_value("push-cert", &len);
553
		if (push_cert_nonce) {
554
			reject_invalid_nonce(push_cert_nonce, len);
555
			push_cert_nonce = xmemdupz(push_cert_nonce, len);
556
		} else if (args->push_cert == SEND_PACK_PUSH_CERT_ALWAYS) {
557
			die(_("the receiving end does not support --signed push"));
558
		} else if (args->push_cert == SEND_PACK_PUSH_CERT_IF_ASKED) {
559
			warning(_("not sending a push certificate since the"
560
				  " receiving end does not support --signed"
561
				  " push"));
562
		}
563
	}
564

565
	if (args->atomic && !atomic_supported)
566
		die(_("the receiving end does not support --atomic push"));
567

568
	use_atomic = atomic_supported && args->atomic;
569

570
	if (args->push_options && !push_options_supported)
571
		die(_("the receiving end does not support push options"));
572

573
	use_push_options = push_options_supported && args->push_options;
574

575
	if (status_report == 1)
576
		strbuf_addstr(&cap_buf, " report-status");
577
	else if (status_report == 2)
578
		strbuf_addstr(&cap_buf, " report-status-v2");
579
	if (use_sideband)
580
		strbuf_addstr(&cap_buf, " side-band-64k");
581
	if (quiet_supported && (args->quiet || !args->progress))
582
		strbuf_addstr(&cap_buf, " quiet");
583
	if (use_atomic)
584
		strbuf_addstr(&cap_buf, " atomic");
585
	if (use_push_options)
586
		strbuf_addstr(&cap_buf, " push-options");
587
	if (object_format_supported)
588
		strbuf_addf(&cap_buf, " object-format=%s", the_hash_algo->name);
589
	if (agent_supported)
590
		strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());
591
	if (advertise_sid)
592
		strbuf_addf(&cap_buf, " session-id=%s", trace2_session_id());
593

594
	/*
595
	 * NEEDSWORK: why does delete-refs have to be so specific to
596
	 * send-pack machinery that set_ref_status_for_push() cannot
597
	 * set this bit for us???
598
	 */
599
	for (ref = remote_refs; ref; ref = ref->next)
600
		if (ref->deletion && !allow_deleting_refs)
601
			ref->status = REF_STATUS_REJECT_NODELETE;
602

603
	/*
604
	 * Clear the status for each ref and see if we need to send
605
	 * the pack data.
606
	 */
607
	for (ref = remote_refs; ref; ref = ref->next) {
608
		switch (check_to_send_update(ref, args)) {
609
		case 0: /* no error */
610
			break;
611
		case CHECK_REF_STATUS_REJECTED:
612
			/*
613
			 * When we know the server would reject a ref update if
614
			 * we were to send it and we're trying to send the refs
615
			 * atomically, abort the whole operation.
616
			 */
617
			if (use_atomic) {
618
				strbuf_release(&req_buf);
619
				strbuf_release(&cap_buf);
620
				reject_atomic_push(remote_refs, args->send_mirror);
621
				error("atomic push failed for ref %s. status: %d\n",
622
				      ref->name, ref->status);
623
				return args->porcelain ? 0 : -1;
624
			}
625
			/* else fallthrough */
626
		default:
627
			continue;
628
		}
629
		if (!ref->deletion)
630
			need_pack_data = 1;
631

632
		if (args->dry_run || !status_report)
633
			ref->status = REF_STATUS_OK;
634
		else
635
			ref->status = REF_STATUS_EXPECTING_REPORT;
636
	}
637

638
	if (!args->dry_run)
639
		advertise_shallow_grafts_buf(&req_buf);
640

641
	/*
642
	 * Finally, tell the other end!
643
	 */
644
	if (!args->dry_run && push_cert_nonce)
645
		cmds_sent = generate_push_cert(&req_buf, remote_refs, args,
646
					       cap_buf.buf, push_cert_nonce);
647
	else if (!args->dry_run)
648
		for (ref = remote_refs; ref; ref = ref->next) {
649
			char *old_hex, *new_hex;
650

651
			if (check_to_send_update(ref, args) < 0)
652
				continue;
653

654
			old_hex = oid_to_hex(&ref->old_oid);
655
			new_hex = oid_to_hex(&ref->new_oid);
656
			if (!cmds_sent) {
657
				packet_buf_write(&req_buf,
658
						 "%s %s %s%c%s",
659
						 old_hex, new_hex, ref->name, 0,
660
						 cap_buf.buf);
661
				cmds_sent = 1;
662
			} else {
663
				packet_buf_write(&req_buf, "%s %s %s",
664
						 old_hex, new_hex, ref->name);
665
			}
666
		}
667

668
	if (use_push_options) {
669
		struct string_list_item *item;
670

671
		packet_buf_flush(&req_buf);
672
		for_each_string_list_item(item, args->push_options)
673
			packet_buf_write(&req_buf, "%s", item->string);
674
	}
675

676
	if (args->stateless_rpc) {
677
		if (!args->dry_run && (cmds_sent || is_repository_shallow(the_repository))) {
678
			packet_buf_flush(&req_buf);
679
			send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);
680
		}
681
	} else {
682
		write_or_die(out, req_buf.buf, req_buf.len);
683
		packet_flush(out);
684
	}
685
	strbuf_release(&req_buf);
686
	strbuf_release(&cap_buf);
687

688
	if (use_sideband && cmds_sent) {
689
		memset(&demux, 0, sizeof(demux));
690
		demux.proc = sideband_demux;
691
		demux.data = fd;
692
		demux.out = -1;
693
		demux.isolate_sigpipe = 1;
694
		if (start_async(&demux))
695
			die("send-pack: unable to fork off sideband demultiplexer");
696
		in = demux.out;
697
	}
698

699
	packet_reader_init(&reader, in, NULL, 0,
700
			   PACKET_READ_CHOMP_NEWLINE |
701
			   PACKET_READ_DIE_ON_ERR_PACKET);
702

703
	if (need_pack_data && cmds_sent) {
704
		if (pack_objects(out, remote_refs, extra_have, &commons, args) < 0) {
705
			if (args->stateless_rpc)
706
				close(out);
707
			if (git_connection_is_socket(conn))
708
				shutdown(fd[0], SHUT_WR);
709

710
			/*
711
			 * Do not even bother with the return value; we know we
712
			 * are failing, and just want the error() side effects,
713
			 * as well as marking refs with their remote status (if
714
			 * we get one).
715
			 */
716
			if (status_report)
717
				receive_status(&reader, remote_refs);
718

719
			if (use_sideband) {
720
				close(demux.out);
721
				finish_async(&demux);
722
			}
723
			fd[1] = -1;
724
			return -1;
725
		}
726
		if (!args->stateless_rpc)
727
			/* Closed by pack_objects() via start_command() */
728
			fd[1] = -1;
729
	}
730
	if (args->stateless_rpc && cmds_sent)
731
		packet_flush(out);
732

733
	if (status_report && cmds_sent)
734
		ret = receive_status(&reader, remote_refs);
735
	else
736
		ret = 0;
737
	if (args->stateless_rpc)
738
		packet_flush(out);
739

740
	if (use_sideband && cmds_sent) {
741
		close(demux.out);
742
		if (finish_async(&demux)) {
743
			error("error in sideband demultiplexer");
744
			ret = -1;
745
		}
746
	}
747

748
	if (ret < 0)
749
		return ret;
750

751
	if (args->porcelain)
752
		return 0;
753

754
	for (ref = remote_refs; ref; ref = ref->next) {
755
		switch (ref->status) {
756
		case REF_STATUS_NONE:
757
		case REF_STATUS_UPTODATE:
758
		case REF_STATUS_OK:
759
			break;
760
		default:
761
			return -1;
762
		}
763
	}
764
	return 0;
765
}
766