2 * Copyright (c) 2018, 2019 Ori Bernstein <ori@openbsd.org>
3 * Copyright (c) 2021 Stefan Sperling <stsp@openbsd.org>
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #include <sys/types.h>
21 #include <sys/socket.h>
23 #include <sys/resource.h>
24 #include <sys/socket.h>
40 #include "got_error.h"
41 #include "got_reference.h"
42 #include "got_repository.h"
44 #include "got_cancel.h"
45 #include "got_worktree.h"
46 #include "got_object.h"
47 #include "got_opentemp.h"
49 #include "got_repository_admin.h"
50 #include "got_commit_graph.h"
52 #include "got_lib_delta.h"
53 #include "got_lib_inflate.h"
54 #include "got_lib_object.h"
55 #include "got_lib_object_parse.h"
56 #include "got_lib_object_create.h"
57 #include "got_lib_pack.h"
58 #include "got_lib_sha1.h"
59 #include "got_lib_privsep.h"
60 #include "got_lib_object_cache.h"
61 #include "got_lib_repository.h"
62 #include "got_lib_pack_create.h"
63 #include "got_lib_dial.h"
66 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
70 #define ssizeof(_x) ((ssize_t)(sizeof(_x)))
74 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
77 const struct got_error
*
78 got_send_connect(pid_t
*sendpid
, int *sendfd
, const char *proto
,
79 const char *host
, const char *port
, const char *server_path
, int verbosity
)
81 const struct got_error
*err
= NULL
;
86 if (strcmp(proto
, "ssh") == 0 || strcmp(proto
, "git+ssh") == 0)
87 err
= got_dial_ssh(sendpid
, sendfd
, host
, port
, server_path
,
88 GOT_DIAL_DIRECTION_SEND
, verbosity
);
89 else if (strcmp(proto
, "git") == 0)
90 err
= got_dial_git(sendfd
, host
, port
, server_path
,
91 GOT_DIAL_DIRECTION_SEND
);
92 else if (strcmp(proto
, "http") == 0 || strcmp(proto
, "git+http") == 0)
93 err
= got_error_path(proto
, GOT_ERR_NOT_IMPL
);
95 err
= got_error_path(proto
, GOT_ERR_BAD_PROTO
);
99 struct pack_progress_arg
{
100 got_send_progress_cb progress_cb
;
110 static const struct got_error
*
111 pack_progress(void *arg
, off_t packfile_size
, int ncommits
,
112 int nobj_total
, int nobj_deltify
, int nobj_written
)
114 const struct got_error
*err
;
115 struct pack_progress_arg
*a
= arg
;
117 err
= a
->progress_cb(a
->progress_arg
, packfile_size
, ncommits
,
118 nobj_total
, nobj_deltify
, nobj_written
, 0, NULL
, 0);
122 a
->packfile_size
= packfile_size
;
123 a
->ncommits
= ncommits
;
124 a
->nobj_total
= nobj_total
;
125 a
->nobj_deltify
= nobj_deltify
;
126 a
->nobj_written
= nobj_written
;
130 static const struct got_error
*
131 insert_ref(struct got_reflist_head
*refs
, const char *refname
,
132 struct got_repository
*repo
)
134 const struct got_error
*err
;
135 struct got_reference
*ref
;
136 struct got_reflist_entry
*new;
138 err
= got_ref_open(&ref
, repo
, refname
, 0);
142 err
= got_reflist_insert(&new, refs
, ref
, got_ref_cmp_by_name
, NULL
);
143 if (err
|| new == NULL
/* duplicate */)
149 static const struct got_error
*
150 check_linear_ancestry(const char *refname
, struct got_object_id
*my_id
,
151 struct got_object_id
*their_id
, struct got_repository
*repo
,
152 got_cancel_cb cancel_cb
, void *cancel_arg
)
154 const struct got_error
*err
= NULL
;
155 struct got_object_id
*yca_id
;
158 err
= got_object_get_type(&obj_type
, repo
, their_id
);
161 if (obj_type
!= GOT_OBJ_TYPE_COMMIT
)
162 return got_error_fmt(GOT_ERR_OBJ_TYPE
,
163 "bad object type on server for %s", refname
);
165 err
= got_commit_graph_find_youngest_common_ancestor(&yca_id
,
166 my_id
, their_id
, 1, repo
, cancel_cb
, cancel_arg
);
170 return got_error_fmt(GOT_ERR_SEND_ANCESTRY
, "%s", refname
);
173 * Require a straight line of history between the two commits,
174 * with their commit being older than my commit.
176 * Non-linear situations such as this require a rebase:
178 * (theirs) D F (mine)
186 if (got_object_id_cmp(their_id
, yca_id
) != 0)
187 err
= got_error_fmt(GOT_ERR_SEND_ANCESTRY
, "%s", refname
);
193 static const struct got_error
*
194 realloc_ids(struct got_object_id
***ids
, size_t *nalloc
, size_t n
)
196 struct got_object_id
**new;
197 const size_t alloc_chunksz
= 256;
202 new = recallocarray(*ids
, *nalloc
, *nalloc
+ alloc_chunksz
,
203 sizeof(struct got_object_id
));
205 return got_error_from_errno("recallocarray");
208 *nalloc
+= alloc_chunksz
;
212 static struct got_reference
*
213 find_ref(struct got_reflist_head
*refs
, const char *refname
)
215 struct got_reflist_entry
*re
;
217 TAILQ_FOREACH(re
, refs
, entry
) {
218 if (got_path_cmp(got_ref_get_name(re
->ref
), refname
,
219 strlen(got_ref_get_name(re
->ref
)),
220 strlen(refname
)) == 0) {
228 static struct got_pathlist_entry
*
229 find_their_ref(struct got_pathlist_head
*their_refs
, const char *refname
)
231 struct got_pathlist_entry
*pe
;
233 TAILQ_FOREACH(pe
, their_refs
, entry
) {
234 const char *their_refname
= pe
->path
;
235 if (got_path_cmp(their_refname
, refname
,
236 strlen(their_refname
), strlen(refname
)) == 0) {
244 static const struct got_error
*
245 get_remote_refname(char **remote_refname
, const char *remote_name
,
248 if (strncmp(refname
, "refs/", 5) == 0)
250 if (strncmp(refname
, "heads/", 6) == 0)
253 if (asprintf(remote_refname
, "refs/remotes/%s/%s",
254 remote_name
, refname
) == -1)
255 return got_error_from_errno("asprintf");
260 static const struct got_error
*
261 update_remote_ref(struct got_reference
*my_ref
, const char *remote_name
,
262 struct got_repository
*repo
)
264 const struct got_error
*err
, *unlock_err
;
265 struct got_object_id
*my_id
;
266 struct got_reference
*ref
= NULL
;
267 char *remote_refname
= NULL
;
270 err
= got_ref_resolve(&my_id
, repo
, my_ref
);
274 err
= get_remote_refname(&remote_refname
, remote_name
,
275 got_ref_get_name(my_ref
));
279 err
= got_ref_open(&ref
, repo
, remote_refname
, 1 /* lock */);
281 if (err
->code
!= GOT_ERR_NOT_REF
)
283 err
= got_ref_alloc(&ref
, remote_refname
, my_id
);
288 err
= got_ref_change_ref(ref
, my_id
);
293 err
= got_ref_write(ref
, repo
);
297 unlock_err
= got_ref_unlock(ref
);
298 if (unlock_err
&& err
== NULL
)
304 free(remote_refname
);
308 const struct got_error
*
309 got_send_pack(const char *remote_name
, struct got_pathlist_head
*branch_names
,
310 struct got_pathlist_head
*tag_names
,
311 struct got_pathlist_head
*delete_branches
,
312 int verbosity
, int overwrite_refs
, int sendfd
,
313 struct got_repository
*repo
, got_send_progress_cb progress_cb
,
314 void *progress_arg
, got_cancel_cb cancel_cb
, void *cancel_arg
)
317 int npackfd
= -1, nsendfd
= -1;
318 int sendstatus
, done
= 0;
319 const struct got_error
*err
;
320 struct imsgbuf sendibuf
;
322 struct got_reflist_head refs
;
323 struct got_pathlist_head have_refs
;
324 struct got_pathlist_head their_refs
;
325 struct got_pathlist_entry
*pe
;
326 struct got_reflist_entry
*re
;
327 struct got_object_id
**our_ids
= NULL
;
328 struct got_object_id
**their_ids
= NULL
;
329 int i
, nours
= 0, ntheirs
= 0;
330 size_t nalloc_ours
= 0, nalloc_theirs
= 0;
331 int refs_to_send
= 0, refs_to_delete
= 0;
332 off_t bytes_sent
= 0;
333 struct pack_progress_arg ppa
;
334 uint8_t packsha1
[SHA1_DIGEST_LENGTH
];
335 FILE *packfile
= NULL
;
338 TAILQ_INIT(&have_refs
);
339 TAILQ_INIT(&their_refs
);
341 TAILQ_FOREACH(pe
, branch_names
, entry
) {
342 const char *branchname
= pe
->path
;
343 if (strncmp(branchname
, "refs/heads/", 11) != 0) {
345 if (asprintf(&s
, "refs/heads/%s", branchname
) == -1) {
346 err
= got_error_from_errno("asprintf");
349 err
= insert_ref(&refs
, s
, repo
);
352 err
= insert_ref(&refs
, branchname
, repo
);
358 TAILQ_FOREACH(pe
, delete_branches
, entry
) {
359 const char *branchname
= pe
->path
;
360 struct got_reference
*ref
;
361 if (strncmp(branchname
, "refs/heads/", 11) != 0) {
362 err
= got_error_fmt(GOT_ERR_SEND_DELETE_REF
, "%s",
366 ref
= find_ref(&refs
, branchname
);
368 err
= got_error_fmt(GOT_ERR_SEND_DELETE_REF
,
369 "changes on %s will be sent to server",
375 TAILQ_FOREACH(pe
, tag_names
, entry
) {
376 const char *tagname
= pe
->path
;
377 if (strncmp(tagname
, "refs/tags/", 10) != 0) {
379 if (asprintf(&s
, "refs/tags/%s", tagname
) == -1) {
380 err
= got_error_from_errno("asprintf");
383 err
= insert_ref(&refs
, s
, repo
);
386 err
= insert_ref(&refs
, tagname
, repo
);
392 if (TAILQ_EMPTY(&refs
) && TAILQ_EMPTY(delete_branches
)) {
393 err
= got_error(GOT_ERR_SEND_EMPTY
);
397 TAILQ_FOREACH(re
, &refs
, entry
) {
398 struct got_object_id
*id
;
401 if (got_ref_is_symbolic(re
->ref
)) {
402 err
= got_error_fmt(GOT_ERR_BAD_REF_TYPE
,
403 "cannot send symbolic reference %s",
404 got_ref_get_name(re
->ref
));
408 err
= got_ref_resolve(&id
, repo
, re
->ref
);
411 err
= got_object_get_type(&obj_type
, repo
, id
);
416 case GOT_OBJ_TYPE_COMMIT
:
417 case GOT_OBJ_TYPE_TAG
:
420 err
= got_error_fmt(GOT_ERR_OBJ_TYPE
,
421 "cannot send %s", got_ref_get_name(re
->ref
));
426 packfile
= got_opentemp();
427 if (packfile
== NULL
) {
428 err
= got_error_from_errno("got_opentemp");
432 if (socketpair(AF_UNIX
, SOCK_STREAM
, PF_UNSPEC
, imsg_sendfds
) == -1) {
433 err
= got_error_from_errno("socketpair");
439 err
= got_error_from_errno("fork");
441 } else if (sendpid
== 0){
442 got_privsep_exec_child(imsg_sendfds
,
443 GOT_PATH_PROG_SEND_PACK
, got_repo_get_path(repo
));
446 if (close(imsg_sendfds
[1]) == -1) {
447 err
= got_error_from_errno("close");
450 imsg_init(&sendibuf
, imsg_sendfds
[0]);
451 nsendfd
= dup(sendfd
);
453 err
= got_error_from_errno("dup");
458 * Convert reflist to pathlist since the privsep layer
459 * is linked into helper programs which lack reference.c.
461 TAILQ_FOREACH(re
, &refs
, entry
) {
462 struct got_object_id
*id
;
463 err
= got_ref_resolve(&id
, repo
, re
->ref
);
466 err
= got_pathlist_append(&have_refs
,
467 got_ref_get_name(re
->ref
), id
);
471 * Also prepare the array of our object IDs which
472 * will be needed for generating a pack file.
474 err
= realloc_ids(&our_ids
, &nalloc_ours
, nours
+ 1);
481 err
= got_privsep_send_send_req(&sendibuf
, nsendfd
, &have_refs
,
482 delete_branches
, verbosity
);
487 err
= got_privsep_recv_send_remote_refs(&their_refs
, &sendibuf
);
492 * Process references reported by the server.
493 * Push appropriate object IDs onto the "their IDs" array.
494 * This array will be used to exclude objects which already
495 * exist on the server from our pack file.
497 TAILQ_FOREACH(pe
, &their_refs
, entry
) {
498 const char *refname
= pe
->path
;
499 struct got_object_id
*their_id
= pe
->data
;
501 struct got_object
*obj
;
502 struct got_reference
*my_ref
= NULL
;
505 /* Don't blindly trust the server to send us valid names. */
506 if (!got_ref_name_is_valid(refname
))
510 * Find out whether this is a reference we want to upload.
511 * Otherwise we can still use this reference as a hint to
512 * avoid uploading any objects the server already has.
514 my_ref
= find_ref(&refs
, refname
);
516 struct got_object_id
*my_id
;
517 err
= got_ref_resolve(&my_id
, repo
, my_ref
);
520 if (got_object_id_cmp(my_id
, their_id
) != 0)
526 if (strncmp(refname
, "refs/tags/", 10) == 0)
529 /* Prevent tags from being overwritten by default. */
530 if (!overwrite_refs
&& my_ref
&& is_tag
) {
531 err
= got_error_fmt(GOT_ERR_SEND_TAG_EXISTS
,
536 /* Check if their object exists locally. */
537 err
= got_object_open(&obj
, repo
, their_id
);
539 if (err
->code
!= GOT_ERR_NO_OBJ
)
541 if (!overwrite_refs
&& my_ref
!= NULL
) {
542 err
= got_error_fmt(GOT_ERR_SEND_ANCESTRY
,
548 got_object_close(obj
);
552 err
= realloc_ids(&their_ids
, &nalloc_theirs
, ntheirs
+ 1);
557 /* Enforce linear ancestry if required. */
558 if (!overwrite_refs
&& my_ref
&& !is_tag
) {
559 struct got_object_id
*my_id
;
560 err
= got_ref_resolve(&my_id
, repo
, my_ref
);
563 err
= check_linear_ancestry(refname
, my_id
,
564 their_id
, repo
, cancel_cb
, cancel_arg
);
570 /* Exclude any objects reachable via their ID. */
571 their_ids
[ntheirs
] = got_object_id_dup(their_id
);
572 if (their_ids
[ntheirs
] == NULL
) {
573 err
= got_error_from_errno("got_object_id_dup");
577 } else if (!is_tag
) {
578 char *remote_refname
;
579 struct got_reference
*ref
;
581 * Exclude any objects which exist on the server
582 * according to a locally cached remote reference.
584 err
= get_remote_refname(&remote_refname
,
585 remote_name
, refname
);
588 err
= got_ref_open(&ref
, repo
, remote_refname
, 0);
589 free(remote_refname
);
591 if (err
->code
!= GOT_ERR_NOT_REF
)
594 err
= got_ref_resolve(&their_ids
[ntheirs
],
604 /* Account for any new references we are going to upload. */
605 TAILQ_FOREACH(re
, &refs
, entry
) {
606 if (find_their_ref(&their_refs
,
607 got_ref_get_name(re
->ref
)) == NULL
)
611 /* Account for any existing references we are going to delete. */
612 TAILQ_FOREACH(pe
, delete_branches
, entry
) {
613 const char *branchname
= pe
->path
;
614 if (find_their_ref(&their_refs
, branchname
))
618 if (refs_to_send
== 0 && refs_to_delete
== 0) {
619 got_privsep_send_stop(imsg_sendfds
[0]);
623 if (refs_to_send
> 0) {
624 memset(&ppa
, 0, sizeof(ppa
));
625 ppa
.progress_cb
= progress_cb
;
626 ppa
.progress_arg
= progress_arg
;
627 err
= got_pack_create(packsha1
, packfile
, their_ids
, ntheirs
,
628 our_ids
, nours
, repo
, 0, 1, pack_progress
, &ppa
,
629 cancel_cb
, cancel_arg
);
633 if (fflush(packfile
) == -1) {
634 err
= got_error_from_errno("fflush");
638 npackfd
= dup(fileno(packfile
));
640 err
= got_error_from_errno("dup");
643 err
= got_privsep_send_packfd(&sendibuf
, npackfd
);
648 err
= got_privsep_send_packfd(&sendibuf
, -1);
655 char *refname
= NULL
;
656 off_t bytes_sent_cur
= 0;
658 err
= (*cancel_cb
)(cancel_arg
);
662 err
= got_privsep_recv_send_progress(&done
, &bytes_sent
,
663 &success
, &refname
, &sendibuf
);
666 if (refname
&& got_ref_name_is_valid(refname
) && success
&&
667 strncmp(refname
, "refs/tags/", 10) != 0) {
668 struct got_reference
*my_ref
;
670 * The server has accepted our changes.
671 * Update our reference in refs/remotes/ accordingly.
673 my_ref
= find_ref(&refs
, refname
);
675 err
= update_remote_ref(my_ref
, remote_name
,
681 if (refname
!= NULL
||
682 bytes_sent_cur
!= bytes_sent
) {
683 err
= progress_cb(progress_arg
, ppa
.packfile_size
,
684 ppa
.ncommits
, ppa
.nobj_total
, ppa
.nobj_deltify
,
685 ppa
.nobj_written
, bytes_sent
,
691 bytes_sent_cur
= bytes_sent
;
698 got_privsep_send_stop(imsg_sendfds
[0]);
699 if (waitpid(sendpid
, &sendstatus
, 0) == -1 && err
== NULL
)
700 err
= got_error_from_errno("waitpid");
702 if (packfile
&& fclose(packfile
) == EOF
&& err
== NULL
)
703 err
= got_error_from_errno("fclose");
704 if (nsendfd
!= -1 && close(nsendfd
) == -1 && err
== NULL
)
705 err
= got_error_from_errno("close");
706 if (npackfd
!= -1 && close(npackfd
) == -1 && err
== NULL
)
707 err
= got_error_from_errno("close");
709 got_ref_list_free(&refs
);
710 got_pathlist_free(&have_refs
);
711 got_pathlist_free(&their_refs
);
712 for (i
= 0; i
< nours
; i
++)
715 for (i
= 0; i
< ntheirs
; i
++)