🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v1.5.3 / . / send-pack.c
blob: 9fc8a812f4c526d61e3acb8183b8b8da0e36895c [file] [log] [blame]
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]1#include "cache.h"
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]2#include "commit.h"
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]3#include "tag.h"
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]4#include "refs.h"
Linus Torvaldsf3a32142005-06-30 03:50:15[diff] [blame]5#include "pkt-line.h"
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]6#include "run-command.h"
Daniel Barkalow6b628162007-05-12 15:45:59[diff] [blame]7#include "remote.h"
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]8
Junio C Hamano2a245012005-07-14 07:10:05[diff] [blame]9static const char send_pack_usage[] =
Uwe Kleine-Königd23842f2007-01-19 12:49:27[diff] [blame]10"git-send-pack [--all] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
Uwe Kleine-König18bd8822007-01-19 12:43:00[diff] [blame]11" --all and explicit <ref> specification are mutually exclusive.";
Uwe Kleine-Königd23842f2007-01-19 12:49:27[diff] [blame]12static const char *receivepack = "git-receive-pack";
David Rientjes96f1e582006-08-15 17:23:48[diff] [blame]13static int verbose;
14static int send_all;
15static int force_update;
16static int use_thin_pack;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]17
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]18/*
Junio C Hamano0ae5f982006-12-31 09:26:53[diff] [blame]19 * Make a pack stream and spit it out into file descriptor fd
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]20 */
Junio C Hamano0ae5f982006-12-31 09:26:53[diff] [blame]21static int pack_objects(int fd, struct ref *refs)
Linus Torvalds94fdb7a2005-06-30 17:17:39[diff] [blame]22{
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]23 /*
24 * The child becomes pack-objects --revs; we feed
25 * the revision parameters to it via its stdin and
26 * let its stdout go back to the other end.
27 */
28 const char *args[] = {
29 "pack-objects",
30 "--all-progress",
31 "--revs",
32 "--stdout",
33 NULL,
34 NULL,
35 };
36 struct child_process po;
Linus Torvalds94fdb7a2005-06-30 17:17:39[diff] [blame]37
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]38 if (use_thin_pack)
39 args[4] = "--thin";
40 memset(&po, 0, sizeof(po));
41 po.argv = args;
42 po.in = -1;
43 po.out = fd;
44 po.git_cmd = 1;
45 if (start_command(&po))
46 die("git-pack-objects failed (%s)", strerror(errno));
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]47
Junio C Hamano0ae5f982006-12-31 09:26:53[diff] [blame]48 /*
49 * We feed the pack-objects we just spawned with revision
50 * parameters by writing to the pipe.
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]51 */
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]52 while (refs) {
53 char buf[42];
54
55 if (!is_null_sha1(refs->old_sha1) &&
56 has_sha1_file(refs->old_sha1)) {
57 memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40);
58 buf[0] = '^';
59 buf[41] = '\n';
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]60 if (!write_or_whine(po.in, buf, 42,
Andy Whitcroft825cee72007-01-02 14:12:09[diff] [blame]61 "send-pack: send refs"))
62 break;
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]63 }
64 if (!is_null_sha1(refs->new_sha1)) {
65 memcpy(buf, sha1_to_hex(refs->new_sha1), 40);
66 buf[40] = '\n';
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]67 if (!write_or_whine(po.in, buf, 41,
Andy Whitcroft825cee72007-01-02 14:12:09[diff] [blame]68 "send-pack: send refs"))
69 break;
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]70 }
71 refs = refs->next;
72 }
Andy Whitcroftc727fe22006-09-05 21:52:12[diff] [blame]73
Shawn O. Pearce38b1c662007-03-12 23:00:29[diff] [blame]74 if (finish_command(&po))
75 return error("pack-objects died with strange error");
76 return 0;
Linus Torvalds94fdb7a2005-06-30 17:17:39[diff] [blame]77}
Linus Torvaldse4b5c7f2005-06-30 05:31:41[diff] [blame]78
Junio C Hamano51b0fca2005-08-06 06:05:33[diff] [blame]79static void unmark_and_free(struct commit_list *list, unsigned int mark)
80{
81 while (list) {
82 struct commit_list *temp = list;
83 temp->item->object.flags &= ~mark;
84 list = temp->next;
85 free(temp);
86 }
87}
88
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]89static int ref_newer(const unsigned char *new_sha1,
90 const unsigned char *old_sha1)
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]91{
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]92 struct object *o;
93 struct commit *old, *new;
Junio C Hamano51b0fca2005-08-06 06:05:33[diff] [blame]94 struct commit_list *list, *used;
95 int found = 0;
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]96
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]97 /* Both new and old must be commit-ish and new is descendant of
98 * old. Otherwise we require --force.
99 */
Junio C Hamano9534f402005-11-02 23:19:13[diff] [blame]100 o = deref_tag(parse_object(old_sha1), NULL, 0);
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]101 if (!o || o->type != OBJ_COMMIT)
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]102 return 0;
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]103 old = (struct commit *) o;
104
Junio C Hamano9534f402005-11-02 23:19:13[diff] [blame]105 o = deref_tag(parse_object(new_sha1), NULL, 0);
Linus Torvalds19746322006-07-12 03:45:31[diff] [blame]106 if (!o || o->type != OBJ_COMMIT)
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]107 return 0;
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]108 new = (struct commit *) o;
109
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]110 if (parse_commit(new) < 0)
111 return 0;
Junio C Hamano51b0fca2005-08-06 06:05:33[diff] [blame]112
113 used = list = NULL;
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]114 commit_list_insert(new, &list);
Linus Torvaldsbdf25142005-07-27 03:04:22[diff] [blame]115 while (list) {
116 new = pop_most_recent_commit(&list, 1);
Junio C Hamano51b0fca2005-08-06 06:05:33[diff] [blame]117 commit_list_insert(new, &used);
118 if (new == old) {
119 found = 1;
120 break;
121 }
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]122 }
Junio C Hamano51b0fca2005-08-06 06:05:33[diff] [blame]123 unmark_and_free(list, 1);
124 unmark_and_free(used, 1);
125 return found;
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]126}
127
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]128static struct ref *local_refs, **local_tail;
129static struct ref *remote_refs, **remote_tail;
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]130
Junio C Hamano8da19772006-09-21 05:02:01[diff] [blame]131static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]132{
133 struct ref *ref;
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]134 int len = strlen(refname) + 1;
135 ref = xcalloc(1, sizeof(*ref) + len);
Shawn Pearcee7024962006-08-23 06:49:00[diff] [blame]136 hashcpy(ref->new_sha1, sha1);
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]137 memcpy(ref->name, refname, len);
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]138 *local_tail = ref;
139 local_tail = &ref->next;
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]140 return 0;
141}
142
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]143static void get_local_heads(void)
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]144{
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]145 local_tail = &local_refs;
Junio C Hamanocb5d7092006-09-21 04:47:42[diff] [blame]146 for_each_ref(one_local_ref, NULL);
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]147}
148
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]149static int receive_status(int in)
150{
151 char line[1000];
152 int ret = 0;
153 int len = packet_read_line(in, line, sizeof(line));
154 if (len < 10 || memcmp(line, "unpack ", 7)) {
155 fprintf(stderr, "did not receive status back\n");
156 return -1;
157 }
158 if (memcmp(line, "unpack ok\n", 10)) {
159 fputs(line, stderr);
160 ret = -1;
161 }
162 while (1) {
163 len = packet_read_line(in, line, sizeof(line));
164 if (!len)
165 break;
166 if (len < 3 ||
167 (memcmp(line, "ok", 2) && memcmp(line, "ng", 2))) {
168 fprintf(stderr, "protocol error: %s\n", line);
169 ret = -1;
170 break;
171 }
172 if (!memcmp(line, "ok", 2))
173 continue;
174 fputs(line, stderr);
175 ret = -1;
176 }
177 return ret;
178}
179
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]180static int send_pack(int in, int out, struct remote *remote, int nr_refspec, char **refspec)
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]181{
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]182 struct ref *ref;
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]183 int new_refs;
Petr Baudised249282005-12-14 00:45:40[diff] [blame]184 int ret = 0;
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]185 int ask_for_status_report = 0;
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]186 int allow_deleting_refs = 0;
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]187 int expect_status_report = 0;
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]188
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]189 /* No funny business with the matcher */
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]190 remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL);
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]191 get_local_heads();
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]192
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]193 /* Does the other end support the reporting? */
194 if (server_supports("report-status"))
195 ask_for_status_report = 1;
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]196 if (server_supports("delete-refs"))
197 allow_deleting_refs = 1;
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]198
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]199 /* match them up */
200 if (!remote_tail)
201 remote_tail = &remote_refs;
202 if (match_refs(local_refs, remote_refs, &remote_tail,
203 nr_refspec, refspec, send_all))
204 return -1;
Daniel Barkalow4c353e82005-12-04 16:59:37[diff] [blame]205
206 if (!remote_refs) {
207 fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
208 return 0;
209 }
210
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]211 /*
212 * Finally, tell the other end!
213 */
214 new_refs = 0;
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]215 for (ref = remote_refs; ref; ref = ref->next) {
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]216 char old_hex[60], *new_hex;
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]217 int will_delete_ref;
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]218
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]219 if (!ref->peer_ref)
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]220 continue;
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]221
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]222
223 will_delete_ref = is_null_sha1(ref->peer_ref->new_sha1);
224 if (will_delete_ref && !allow_deleting_refs) {
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]225 error("remote does not support deleting refs");
226 ret = -2;
227 continue;
228 }
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]229 if (!will_delete_ref &&
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]230 !hashcmp(ref->old_sha1, ref->peer_ref->new_sha1)) {
Linus Torvalds41f93a22005-12-21 02:13:02[diff] [blame]231 if (verbose)
232 fprintf(stderr, "'%s': up-to-date\n", ref->name);
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]233 continue;
234 }
235
236 /* This part determines what can overwrite what.
237 * The rules are:
238 *
Junio C Hamanoff27adf2005-08-24 07:40:14[diff] [blame]239 * (0) you can always use --force or +A:B notation to
240 * selectively force individual ref pairs.
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]241 *
242 * (1) if the old thing does not exist, it is OK.
243 *
244 * (2) if you do not have the old thing, you are not allowed
245 * to overwrite it; you would not know what you are losing
246 * otherwise.
247 *
248 * (3) if both new and old are commit-ish, and new is a
249 * descendant of old, it is OK.
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]250 *
251 * (4) regardless of all of the above, removing :B is
252 * always allowed.
Junio C Hamano37fde872005-08-05 07:47:56[diff] [blame]253 */
254
Junio C Hamanoff27adf2005-08-24 07:40:14[diff] [blame]255 if (!force_update &&
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]256 !will_delete_ref &&
Junio C Hamano4b4ee902006-12-31 08:59:53[diff] [blame]257 !is_null_sha1(ref->old_sha1) &&
Junio C Hamanoff27adf2005-08-24 07:40:14[diff] [blame]258 !ref->force) {
Junio C Hamano69310a32005-12-22 20:39:39[diff] [blame]259 if (!has_sha1_file(ref->old_sha1) ||
260 !ref_newer(ref->peer_ref->new_sha1,
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]261 ref->old_sha1)) {
Junio C Hamano69310a32005-12-22 20:39:39[diff] [blame]262 /* We do not have the remote ref, or
263 * we know that the remote ref is not
264 * an ancestor of what we are trying to
265 * push. Either way this can be losing
266 * commits at the remote end and likely
267 * we were not up to date to begin with.
268 */
269 error("remote '%s' is not a strict "
270 "subset of local ref '%s'. "
271 "maybe you are not up-to-date and "
272 "need to pull first?",
273 ref->name,
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]274 ref->peer_ref->name);
Petr Baudised249282005-12-14 00:45:40[diff] [blame]275 ret = -2;
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]276 continue;
277 }
278 }
Shawn Pearcee7024962006-08-23 06:49:00[diff] [blame]279 hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]280 if (!will_delete_ref)
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]281 new_refs++;
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]282 strcpy(old_hex, sha1_to_hex(ref->old_sha1));
283 new_hex = sha1_to_hex(ref->new_sha1);
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]284
285 if (ask_for_status_report) {
286 packet_write(out, "%s %s %s%c%s",
287 old_hex, new_hex, ref->name, 0,
288 "report-status");
289 ask_for_status_report = 0;
290 expect_status_report = 1;
291 }
292 else
293 packet_write(out, "%s %s %s",
294 old_hex, new_hex, ref->name);
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]295 if (will_delete_ref)
Junio C Hamanod4f694b2006-11-24 08:26:49[diff] [blame]296 fprintf(stderr, "deleting '%s'\n", ref->name);
297 else {
298 fprintf(stderr, "updating '%s'", ref->name);
299 if (strcmp(ref->name, ref->peer_ref->name))
300 fprintf(stderr, " using '%s'",
301 ref->peer_ref->name);
302 fprintf(stderr, "\n from %s\n to %s\n",
303 old_hex, new_hex);
304 }
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]305 if (remote) {
306 struct refspec rs;
307 rs.src = ref->name;
Johannes Schindelinb42f6922007-07-10 17:48:40[diff] [blame]308 rs.dst = NULL;
309 if (!remote_find_tracking(remote, &rs)) {
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]310 struct ref_lock *lock;
311 fprintf(stderr, " Also local %s\n", rs.dst);
312 if (will_delete_ref) {
313 if (delete_ref(rs.dst, NULL)) {
314 error("Failed to delete");
315 }
316 } else {
317 lock = lock_any_ref_for_update(rs.dst, NULL, 0);
318 if (!lock)
319 error("Failed to lock");
320 else
321 write_ref_sha1(lock, ref->new_sha1,
322 "update by push");
323 }
324 free(rs.dst);
325 }
326 }
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]327 }
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]328
Linus Torvaldsf3a32142005-06-30 03:50:15[diff] [blame]329 packet_flush(out);
Linus Torvalds584c6cc2005-07-08 20:58:40[diff] [blame]330 if (new_refs)
Junio C Hamano0ae5f982006-12-31 09:26:53[diff] [blame]331 ret = pack_objects(out, remote_refs);
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]332 close(out);
Junio C Hamanocfee10a2005-12-26 07:18:37[diff] [blame]333
334 if (expect_status_report) {
335 if (receive_status(in))
336 ret = -4;
337 }
338
339 if (!new_refs && ret == 0)
340 fprintf(stderr, "Everything up-to-date\n");
Petr Baudised249282005-12-14 00:45:40[diff] [blame]341 return ret;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]342}
343
Junio C Hamano37adac72006-12-13 18:30:11[diff] [blame]344static void verify_remote_names(int nr_heads, char **heads)
345{
346 int i;
347
348 for (i = 0; i < nr_heads; i++) {
349 const char *remote = strchr(heads[i], ':');
350
351 remote = remote ? (remote + 1) : heads[i];
352 switch (check_ref_format(remote)) {
353 case 0: /* ok */
354 case -2: /* ok but a single level -- that is fine for
355 * a match pattern.
356 */
Daniel Barkalow8558fd92007-05-25 05:20:56[diff] [blame]357 case -3: /* ok but ends with a pattern-match character */
Junio C Hamano37adac72006-12-13 18:30:11[diff] [blame]358 continue;
359 }
360 die("remote part of refspec is not a valid name in %s",
361 heads[i]);
362 }
363}
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]364
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]365int main(int argc, char **argv)
366{
367 int i, nr_heads = 0;
368 char *dest = NULL;
369 char **heads = NULL;
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]370 int fd[2], ret;
371 pid_t pid;
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]372 char *remote_name = NULL;
373 struct remote *remote = NULL;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]374
Junio C Hamano5a327712005-11-26 08:47:59[diff] [blame]375 setup_git_directory();
Junio C Hamano84a9b582006-03-24 07:41:18[diff] [blame]376 git_config(git_default_config);
377
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]378 argv++;
Linus Torvaldsd0893912005-07-16 20:26:33[diff] [blame]379 for (i = 1; i < argc; i++, argv++) {
380 char *arg = *argv;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]381
382 if (*arg == '-') {
Junio C Hamanocc44c762007-02-20 09:53:29[diff] [blame]383 if (!prefixcmp(arg, "--receive-pack=")) {
Uwe Kleine-Königd23842f2007-01-19 12:49:27[diff] [blame]384 receivepack = arg + 15;
385 continue;
386 }
Junio C Hamanocc44c762007-02-20 09:53:29[diff] [blame]387 if (!prefixcmp(arg, "--exec=")) {
Uwe Kleine-Königd23842f2007-01-19 12:49:27[diff] [blame]388 receivepack = arg + 7;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]389 continue;
390 }
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]391 if (!prefixcmp(arg, "--remote=")) {
392 remote_name = arg + 9;
393 continue;
394 }
Linus Torvaldsd0893912005-07-16 20:26:33[diff] [blame]395 if (!strcmp(arg, "--all")) {
396 send_all = 1;
397 continue;
398 }
Linus Torvalds2a9c3fe2005-07-19 11:03:47[diff] [blame]399 if (!strcmp(arg, "--force")) {
400 force_update = 1;
401 continue;
402 }
Linus Torvalds41f93a22005-12-21 02:13:02[diff] [blame]403 if (!strcmp(arg, "--verbose")) {
404 verbose = 1;
405 continue;
406 }
Junio C Hamano2245be32006-02-19 23:03:49[diff] [blame]407 if (!strcmp(arg, "--thin")) {
408 use_thin_pack = 1;
409 continue;
410 }
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]411 usage(send_pack_usage);
412 }
Linus Torvaldsd0893912005-07-16 20:26:33[diff] [blame]413 if (!dest) {
414 dest = arg;
415 continue;
416 }
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]417 heads = argv;
Linus Torvaldsd0893912005-07-16 20:26:33[diff] [blame]418 nr_heads = argc - i;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]419 break;
420 }
421 if (!dest)
422 usage(send_pack_usage);
Junio C Hamano0bc3cdf2005-08-02 19:20:27[diff] [blame]423 if (heads && send_all)
424 usage(send_pack_usage);
Junio C Hamano37adac72006-12-13 18:30:11[diff] [blame]425 verify_remote_names(nr_heads, heads);
426
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]427 if (remote_name) {
428 remote = remote_get(remote_name);
429 if (!remote_has_uri(remote, dest)) {
430 die("Destination %s is not a uri for %s",
431 dest, remote_name);
432 }
433 }
434
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]435 pid = git_connect(fd, dest, receivepack, verbose ? CONNECT_VERBOSE : 0);
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]436 if (pid < 0)
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]437 return 1;
Daniel Barkalowb5169682007-05-16 02:50:19[diff] [blame]438 ret = send_pack(fd[0], fd[1], remote, nr_heads, heads);
Linus Torvalds7f8e9822005-06-30 05:50:48[diff] [blame]439 close(fd[0]);
440 close(fd[1]);
Franck Bui-Huu8a5dbef2006-09-13 08:26:47[diff] [blame]441 ret |= finish_connect(pid);
442 return !!ret;
Linus Torvalds61221472005-06-30 02:09:05[diff] [blame]443}