2977a941973ce44e9896fb2e4a44967107ed9c9a
1#include "cache.h"
2#include "refs.h"
3#include "pkt-line.h"
4#include "commit.h"
5#include "tag.h"
6#include "exec_cmd.h"
7#include "pack.h"
8#include "sideband.h"
9#include "fetch-pack.h"
10static int keep_pack;
12static int transfer_unpack_limit = -1;
13static int fetch_unpack_limit = -1;
14static int unpack_limit = 100;
15static int quiet;
16static int verbose;
17static int fetch_all;
18static int depth;
19static int no_progress;
20static const char fetch_pack_usage[] =
21"git-fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
22static const char *uploadpack = "git-upload-pack";
23#define COMPLETE (1U << 0)
25#define COMMON (1U << 1)
26#define COMMON_REF (1U << 2)
27#define SEEN (1U << 3)
28#define POPPED (1U << 4)
29/*
31 * After sending this many "have"s if we do not get any new ACK , we
32 * give up traversing our history.
33 */
34#define MAX_IN_VAIN 256
35static struct commit_list *rev_list;
37static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
38static void rev_list_push(struct commit *commit, int mark)
40{
41 if (!(commit->object.flags & mark)) {
42 commit->object.flags |= mark;
43 if (!(commit->object.parsed))
45 parse_commit(commit);
46 insert_by_date(commit, &rev_list);
48 if (!(commit->object.flags & COMMON))
50 non_common_revs++;
51 }
52}
53static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
55{
56 struct object *o = deref_tag(parse_object(sha1), path, 0);
57 if (o && o->type == OBJ_COMMIT)
59 rev_list_push((struct commit *)o, SEEN);
60 return 0;
62}
63/*
65 This function marks a rev and its ancestors as common.
66 In some cases, it is desirable to mark only the ancestors (for example
67 when only the server does not yet know that they are common).
68*/
69static void mark_common(struct commit *commit,
71 int ancestors_only, int dont_parse)
72{
73 if (commit != NULL && !(commit->object.flags & COMMON)) {
74 struct object *o = (struct object *)commit;
75 if (!ancestors_only)
77 o->flags |= COMMON;
78 if (!(o->flags & SEEN))
80 rev_list_push(commit, SEEN);
81 else {
82 struct commit_list *parents;
83 if (!ancestors_only && !(o->flags & POPPED))
85 non_common_revs--;
86 if (!o->parsed && !dont_parse)
87 parse_commit(commit);
88 for (parents = commit->parents;
90 parents;
91 parents = parents->next)
92 mark_common(parents->item, 0, dont_parse);
93 }
94 }
95}
96/*
98 Get the next rev to send, ignoring the common.
99*/
100static const unsigned char* get_rev(void)
102{
103 struct commit *commit = NULL;
104 while (commit == NULL) {
106 unsigned int mark;
107 struct commit_list* parents;
108 if (rev_list == NULL || non_common_revs == 0)
110 return NULL;
111 commit = rev_list->item;
113 if (!(commit->object.parsed))
114 parse_commit(commit);
115 commit->object.flags |= POPPED;
116 if (!(commit->object.flags & COMMON))
117 non_common_revs--;
118 parents = commit->parents;
120 if (commit->object.flags & COMMON) {
122 /* do not send "have", and ignore ancestors */
123 commit = NULL;
124 mark = COMMON | SEEN;
125 } else if (commit->object.flags & COMMON_REF)
126 /* send "have", and ignore ancestors */
127 mark = COMMON | SEEN;
128 else
129 /* send "have", also for its ancestors */
130 mark = SEEN;
131 while (parents) {
133 if (!(parents->item->object.flags & SEEN))
134 rev_list_push(parents->item, mark);
135 if (mark & COMMON)
136 mark_common(parents->item, 1, 0);
137 parents = parents->next;
138 }
139 rev_list = rev_list->next;
141 }
142 return commit->object.sha1;
144}
145static int find_common(int fd[2], unsigned char *result_sha1,
147 struct ref *refs)
148{
149 int fetching;
150 int count = 0, flushes = 0, retval;
151 const unsigned char *sha1;
152 unsigned in_vain = 0;
153 int got_continue = 0;
154 for_each_ref(rev_list_insert_ref, NULL);
156 fetching = 0;
158 for ( ; refs ; refs = refs->next) {
159 unsigned char *remote = refs->old_sha1;
160 struct object *o;
161 /*
163 * If that object is complete (i.e. it is an ancestor of a
164 * local ref), we tell them we have it but do not have to
165 * tell them about its ancestors, which they already know
166 * about.
167 *
168 * We use lookup_object here because we are only
169 * interested in the case we *know* the object is
170 * reachable and we have already scanned it.
171 */
172 if (((o = lookup_object(remote)) != NULL) &&
173 (o->flags & COMPLETE)) {
174 continue;
175 }
176 if (!fetching)
178 packet_write(fd[1], "want %s%s%s%s%s%s%s\n",
179 sha1_to_hex(remote),
180 (multi_ack ? " multi_ack" : ""),
181 (use_sideband == 2 ? " side-band-64k" : ""),
182 (use_sideband == 1 ? " side-band" : ""),
183 (use_thin_pack ? " thin-pack" : ""),
184 (no_progress ? " no-progress" : ""),
185 " ofs-delta");
186 else
187 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
188 fetching++;
189 }
190 if (is_repository_shallow())
191 write_shallow_commits(fd[1], 1);
192 if (depth > 0)
193 packet_write(fd[1], "deepen %d", depth);
194 packet_flush(fd[1]);
195 if (!fetching)
196 return 1;
197 if (depth > 0) {
199 char line[1024];
200 unsigned char sha1[20];
201 int len;
202 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
204 if (!prefixcmp(line, "shallow ")) {
205 if (get_sha1_hex(line + 8, sha1))
206 die("invalid shallow line: %s", line);
207 register_shallow(sha1);
208 continue;
209 }
210 if (!prefixcmp(line, "unshallow ")) {
211 if (get_sha1_hex(line + 10, sha1))
212 die("invalid unshallow line: %s", line);
213 if (!lookup_object(sha1))
214 die("object not found: %s", line);
215 /* make sure that it is parsed as shallow */
216 parse_object(sha1);
217 if (unregister_shallow(sha1))
218 die("no shallow found: %s", line);
219 continue;
220 }
221 die("expected shallow/unshallow, got %s", line);
222 }
223 }
224 flushes = 0;
226 retval = -1;
227 while ((sha1 = get_rev())) {
228 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
229 if (verbose)
230 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
231 in_vain++;
232 if (!(31 & ++count)) {
233 int ack;
234 packet_flush(fd[1]);
236 flushes++;
237 /*
239 * We keep one window "ahead" of the other side, and
240 * will wait for an ACK only on the next one
241 */
242 if (count == 32)
243 continue;
244 do {
246 ack = get_ack(fd[0], result_sha1);
247 if (verbose && ack)
248 fprintf(stderr, "got ack %d %s\n", ack,
249 sha1_to_hex(result_sha1));
250 if (ack == 1) {
251 flushes = 0;
252 multi_ack = 0;
253 retval = 0;
254 goto done;
255 } else if (ack == 2) {
256 struct commit *commit =
257 lookup_commit(result_sha1);
258 mark_common(commit, 0, 1);
259 retval = 0;
260 in_vain = 0;
261 got_continue = 1;
262 }
263 } while (ack);
264 flushes--;
265 if (got_continue && MAX_IN_VAIN < in_vain) {
266 if (verbose)
267 fprintf(stderr, "giving up\n");
268 break; /* give up */
269 }
270 }
271 }
272done:
273 packet_write(fd[1], "done\n");
274 if (verbose)
275 fprintf(stderr, "done\n");
276 if (retval != 0) {
277 multi_ack = 0;
278 flushes++;
279 }
280 while (flushes || multi_ack) {
281 int ack = get_ack(fd[0], result_sha1);
282 if (ack) {
283 if (verbose)
284 fprintf(stderr, "got ack (%d) %s\n", ack,
285 sha1_to_hex(result_sha1));
286 if (ack == 1)
287 return 0;
288 multi_ack = 1;
289 continue;
290 }
291 flushes--;
292 }
293 return retval;
294}
295static struct commit_list *complete;
297static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
299{
300 struct object *o = parse_object(sha1);
301 while (o && o->type == OBJ_TAG) {
303 struct tag *t = (struct tag *) o;
304 if (!t->tagged)
305 break; /* broken repository */
306 o->flags |= COMPLETE;
307 o = parse_object(t->tagged->sha1);
308 }
309 if (o && o->type == OBJ_COMMIT) {
310 struct commit *commit = (struct commit *)o;
311 commit->object.flags |= COMPLETE;
312 insert_by_date(commit, &complete);
313 }
314 return 0;
315}
316static void mark_recent_complete_commits(unsigned long cutoff)
318{
319 while (complete && cutoff <= complete->item->date) {
320 if (verbose)
321 fprintf(stderr, "Marking %s as complete\n",
322 sha1_to_hex(complete->item->object.sha1));
323 pop_most_recent_commit(&complete, COMPLETE);
324 }
325}
326static void filter_refs(struct ref **refs, int nr_match, char **match)
328{
329 struct ref **return_refs;
330 struct ref *newlist = NULL;
331 struct ref **newtail = &newlist;
332 struct ref *ref, *next;
333 struct ref *fastarray[32];
334 if (nr_match && !fetch_all) {
336 if (ARRAY_SIZE(fastarray) < nr_match)
337 return_refs = xcalloc(nr_match, sizeof(struct ref *));
338 else {
339 return_refs = fastarray;
340 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
341 }
342 }
343 else
344 return_refs = NULL;
345 for (ref = *refs; ref; ref = next) {
347 next = ref->next;
348 if (!memcmp(ref->name, "refs/", 5) &&
349 check_ref_format(ref->name + 5))
350 ; /* trash */
351 else if (fetch_all &&
352 (!depth || prefixcmp(ref->name, "refs/tags/") )) {
353 *newtail = ref;
354 ref->next = NULL;
355 newtail = &ref->next;
356 continue;
357 }
358 else {
359 int order = path_match(ref->name, nr_match, match);
360 if (order) {
361 return_refs[order-1] = ref;
362 continue; /* we will link it later */
363 }
364 }
365 free(ref);
366 }
367 if (!fetch_all) {
369 int i;
370 for (i = 0; i < nr_match; i++) {
371 ref = return_refs[i];
372 if (ref) {
373 *newtail = ref;
374 ref->next = NULL;
375 newtail = &ref->next;
376 }
377 }
378 if (return_refs != fastarray)
379 free(return_refs);
380 }
381 *refs = newlist;
382}
383static int everything_local(struct ref **refs, int nr_match, char **match)
385{
386 struct ref *ref;
387 int retval;
388 unsigned long cutoff = 0;
389 track_object_refs = 0;
391 save_commit_buffer = 0;
392 for (ref = *refs; ref; ref = ref->next) {
394 struct object *o;
395 o = parse_object(ref->old_sha1);
397 if (!o)
398 continue;
399 /* We already have it -- which may mean that we were
401 * in sync with the other side at some time after
402 * that (it is OK if we guess wrong here).
403 */
404 if (o->type == OBJ_COMMIT) {
405 struct commit *commit = (struct commit *)o;
406 if (!cutoff || cutoff < commit->date)
407 cutoff = commit->date;
408 }
409 }
410 if (!depth) {
412 for_each_ref(mark_complete, NULL);
413 if (cutoff)
414 mark_recent_complete_commits(cutoff);
415 }
416 /*
418 * Mark all complete remote refs as common refs.
419 * Don't mark them common yet; the server has to be told so first.
420 */
421 for (ref = *refs; ref; ref = ref->next) {
422 struct object *o = deref_tag(lookup_object(ref->old_sha1),
423 NULL, 0);
424 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
426 continue;
427 if (!(o->flags & SEEN)) {
429 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
430 mark_common((struct commit *)o, 1, 1);
432 }
433 }
434 filter_refs(refs, nr_match, match);
436 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
438 const unsigned char *remote = ref->old_sha1;
439 unsigned char local[20];
440 struct object *o;
441 o = lookup_object(remote);
443 if (!o || !(o->flags & COMPLETE)) {
444 retval = 0;
445 if (!verbose)
446 continue;
447 fprintf(stderr,
448 "want %s (%s)\n", sha1_to_hex(remote),
449 ref->name);
450 continue;
451 }
452 hashcpy(ref->new_sha1, local);
454 if (!verbose)
455 continue;
456 fprintf(stderr,
457 "already have %s (%s)\n", sha1_to_hex(remote),
458 ref->name);
459 }
460 return retval;
461}
462static pid_t setup_sideband(int fd[2], int xd[2])
464{
465 pid_t side_pid;
466 if (!use_sideband) {
468 fd[0] = xd[0];
469 fd[1] = xd[1];
470 return 0;
471 }
472 /* xd[] is talking with upload-pack; subprocess reads from
473 * xd[0], spits out band#2 to stderr, and feeds us band#1
474 * through our fd[0].
475 */
476 if (pipe(fd) < 0)
477 die("fetch-pack: unable to set up pipe");
478 side_pid = fork();
479 if (side_pid < 0)
480 die("fetch-pack: unable to fork off sideband demultiplexer");
481 if (!side_pid) {
482 /* subprocess */
483 close(fd[0]);
484 if (xd[0] != xd[1])
485 close(xd[1]);
486 if (recv_sideband("fetch-pack", xd[0], fd[1], 2))
487 exit(1);
488 exit(0);
489 }
490 close(xd[0]);
491 close(fd[1]);
492 fd[1] = xd[1];
493 return side_pid;
494}
495static int get_pack(int xd[2], char **pack_lockfile)
497{
498 int status;
499 pid_t pid, side_pid;
500 int fd[2];
501 const char *argv[20];
502 char keep_arg[256];
503 char hdr_arg[256];
504 const char **av;
505 int do_keep = keep_pack;
506 int keep_pipe[2];
507 side_pid = setup_sideband(fd, xd);
509 av = argv;
511 *hdr_arg = 0;
512 if (unpack_limit) {
513 struct pack_header header;
514 if (read_pack_header(fd[0], &header))
516 die("protocol error: bad pack header");
517 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
518 ntohl(header.hdr_version), ntohl(header.hdr_entries));
519 if (ntohl(header.hdr_entries) < unpack_limit)
520 do_keep = 0;
521 else
522 do_keep = 1;
523 }
524 if (do_keep) {
526 if (pack_lockfile && pipe(keep_pipe))
527 die("fetch-pack: pipe setup failure: %s", strerror(errno));
528 *av++ = "index-pack";
529 *av++ = "--stdin";
530 if (!quiet && !no_progress)
531 *av++ = "-v";
532 if (use_thin_pack)
533 *av++ = "--fix-thin";
534 if (keep_pack > 1 || unpack_limit) {
535 int s = sprintf(keep_arg,
536 "--keep=fetch-pack %d on ", getpid());
537 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
538 strcpy(keep_arg + s, "localhost");
539 *av++ = keep_arg;
540 }
541 }
542 else {
543 *av++ = "unpack-objects";
544 if (quiet)
545 *av++ = "-q";
546 }
547 if (*hdr_arg)
548 *av++ = hdr_arg;
549 *av++ = NULL;
550 pid = fork();
552 if (pid < 0)
553 die("fetch-pack: unable to fork off %s", argv[0]);
554 if (!pid) {
555 dup2(fd[0], 0);
556 if (do_keep && pack_lockfile) {
557 dup2(keep_pipe[1], 1);
558 close(keep_pipe[0]);
559 close(keep_pipe[1]);
560 }
561 close(fd[0]);
562 close(fd[1]);
563 execv_git_cmd(argv);
564 die("%s exec failed", argv[0]);
565 }
566 close(fd[0]);
567 close(fd[1]);
568 if (do_keep && pack_lockfile) {
569 close(keep_pipe[1]);
570 *pack_lockfile = index_pack_lockfile(keep_pipe[0]);
571 close(keep_pipe[0]);
572 }
573 while (waitpid(pid, &status, 0) < 0) {
574 if (errno != EINTR)
575 die("waiting for %s: %s", argv[0], strerror(errno));
576 }
577 if (WIFEXITED(status)) {
578 int code = WEXITSTATUS(status);
579 if (code)
580 die("%s died with error code %d", argv[0], code);
581 return 0;
582 }
583 if (WIFSIGNALED(status)) {
584 int sig = WTERMSIG(status);
585 die("%s died of signal %d", argv[0], sig);
586 }
587 die("%s died of unnatural causes %d", argv[0], status);
588}
589static struct ref *do_fetch_pack(int fd[2],
591 int nr_match,
592 char **match,
593 char **pack_lockfile)
594{
595 struct ref *ref;
596 unsigned char sha1[20];
597 get_remote_heads(fd[0], &ref, 0, NULL, 0);
599 if (is_repository_shallow() && !server_supports("shallow"))
600 die("Server does not support shallow clients");
601 if (server_supports("multi_ack")) {
602 if (verbose)
603 fprintf(stderr, "Server supports multi_ack\n");
604 multi_ack = 1;
605 }
606 if (server_supports("side-band-64k")) {
607 if (verbose)
608 fprintf(stderr, "Server supports side-band-64k\n");
609 use_sideband = 2;
610 }
611 else if (server_supports("side-band")) {
612 if (verbose)
613 fprintf(stderr, "Server supports side-band\n");
614 use_sideband = 1;
615 }
616 if (!ref) {
617 packet_flush(fd[1]);
618 die("no matching remote head");
619 }
620 if (everything_local(&ref, nr_match, match)) {
621 packet_flush(fd[1]);
622 goto all_done;
623 }
624 if (find_common(fd, sha1, ref) < 0)
625 if (keep_pack != 1)
626 /* When cloning, it is not unusual to have
627 * no common commit.
628 */
629 fprintf(stderr, "warning: no common commits\n");
630 if (get_pack(fd, pack_lockfile))
632 die("git-fetch-pack: fetch failed.");
633 all_done:
635 return ref;
636}
637static int remove_duplicates(int nr_heads, char **heads)
639{
640 int src, dst;
641 for (src = dst = 0; src < nr_heads; src++) {
643 /* If heads[src] is different from any of
644 * heads[0..dst], push it in.
645 */
646 int i;
647 for (i = 0; i < dst; i++) {
648 if (!strcmp(heads[i], heads[src]))
649 break;
650 }
651 if (i < dst)
652 continue;
653 if (src != dst)
654 heads[dst] = heads[src];
655 dst++;
656 }
657 return dst;
658}
659static int fetch_pack_config(const char *var, const char *value)
661{
662 if (strcmp(var, "fetch.unpacklimit") == 0) {
663 fetch_unpack_limit = git_config_int(var, value);
664 return 0;
665 }
666 if (strcmp(var, "transfer.unpacklimit") == 0) {
668 transfer_unpack_limit = git_config_int(var, value);
669 return 0;
670 }
671 return git_default_config(var, value);
673}
674static struct lock_file lock;
676void setup_fetch_pack(struct fetch_pack_args *args)
678{
679 uploadpack = args->uploadpack;
680 quiet = args->quiet;
681 keep_pack = args->keep_pack;
682 if (args->unpacklimit >= 0)
683 unpack_limit = args->unpacklimit;
684 if (args->keep_pack)
685 unpack_limit = 0;
686 use_thin_pack = args->use_thin_pack;
687 fetch_all = args->fetch_all;
688 verbose = args->verbose;
689 depth = args->depth;
690 no_progress = args->no_progress;
691}
692int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
694{
695 int i, ret, nr_heads;
696 struct ref *ref;
697 char *dest = NULL, **heads;
698 git_config(fetch_pack_config);
700 if (0 <= transfer_unpack_limit)
702 unpack_limit = transfer_unpack_limit;
703 else if (0 <= fetch_unpack_limit)
704 unpack_limit = fetch_unpack_limit;
705 nr_heads = 0;
707 heads = NULL;
708 for (i = 1; i < argc; i++) {
709 const char *arg = argv[i];
710 if (*arg == '-') {
712 if (!prefixcmp(arg, "--upload-pack=")) {
713 uploadpack = arg + 14;
714 continue;
715 }
716 if (!prefixcmp(arg, "--exec=")) {
717 uploadpack = arg + 7;
718 continue;
719 }
720 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
721 quiet = 1;
722 continue;
723 }
724 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
725 keep_pack++;
726 unpack_limit = 0;
727 continue;
728 }
729 if (!strcmp("--thin", arg)) {
730 use_thin_pack = 1;
731 continue;
732 }
733 if (!strcmp("--all", arg)) {
734 fetch_all = 1;
735 continue;
736 }
737 if (!strcmp("-v", arg)) {
738 verbose = 1;
739 continue;
740 }
741 if (!prefixcmp(arg, "--depth=")) {
742 depth = strtol(arg + 8, NULL, 0);
743 continue;
744 }
745 if (!strcmp("--no-progress", arg)) {
746 no_progress = 1;
747 continue;
748 }
749 usage(fetch_pack_usage);
750 }
751 dest = (char *)arg;
752 heads = (char **)(argv + i + 1);
753 nr_heads = argc - i - 1;
754 break;
755 }
756 if (!dest)
757 usage(fetch_pack_usage);
758 ref = fetch_pack(dest, nr_heads, heads, NULL);
760 ret = !ref;
762 while (ref) {
764 printf("%s %s\n",
765 sha1_to_hex(ref->old_sha1), ref->name);
766 ref = ref->next;
767 }
768 return ret;
770}
771struct ref *fetch_pack(const char *dest,
773 int nr_heads,
774 char **heads,
775 char **pack_lockfile)
776{
777 int i, ret;
778 int fd[2];
779 pid_t pid;
780 struct ref *ref;
781 struct stat st;
782 if (depth > 0) {
784 if (stat(git_path("shallow"), &st))
785 st.st_mtime = 0;
786 }
787 pid = git_connect(fd, (char *)dest, uploadpack,
789 verbose ? CONNECT_VERBOSE : 0);
790 if (pid < 0)
791 return NULL;
792 if (heads && nr_heads)
793 nr_heads = remove_duplicates(nr_heads, heads);
794 ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
795 close(fd[0]);
796 close(fd[1]);
797 ret = finish_connect(pid);
798 if (!ret && nr_heads) {
800 /* If the heads to pull were given, we should have
801 * consumed all of them by matching the remote.
802 * Otherwise, 'git-fetch remote no-such-ref' would
803 * silently succeed without issuing an error.
804 */
805 for (i = 0; i < nr_heads; i++)
806 if (heads[i] && heads[i][0]) {
807 error("no such remote ref %s", heads[i]);
808 ret = 1;
809 }
810 }
811 if (!ret && depth > 0) {
813 struct cache_time mtime;
814 char *shallow = git_path("shallow");
815 int fd;
816 mtime.sec = st.st_mtime;
818#ifdef USE_NSEC
819 mtime.usec = st.st_mtim.usec;
820#endif
821 if (stat(shallow, &st)) {
822 if (mtime.sec)
823 die("shallow file was removed during fetch");
824 } else if (st.st_mtime != mtime.sec
825#ifdef USE_NSEC
826 || st.st_mtim.usec != mtime.usec
827#endif
828 )
829 die("shallow file was changed during fetch");
830 fd = hold_lock_file_for_update(&lock, shallow, 1);
832 if (!write_shallow_commits(fd, 0)) {
833 unlink(shallow);
834 rollback_lock_file(&lock);
835 } else {
836 close(fd);
837 commit_lock_file(&lock);
838 }
839 }
840 if (ret)
842 ref = NULL;
843 return ref;
845}