Refactor index-pack "keep $sha1" handling for reuse
[git/git.git] / builtin-fetch-pack.c
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"
10
11 static int keep_pack;
12 static int transfer_unpack_limit = -1;
13 static int fetch_unpack_limit = -1;
14 static int unpack_limit = 100;
15 static int quiet;
16 static int verbose;
17 static int fetch_all;
18 static int depth;
19 static int no_progress;
20 static 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>...]";
22 static const char *uploadpack = "git-upload-pack";
23
24 #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
30 /*
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
35
36 static struct commit_list *rev_list;
37 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
38
39 static void rev_list_push(struct commit *commit, int mark)
40 {
41 if (!(commit->object.flags & mark)) {
42 commit->object.flags |= mark;
43
44 if (!(commit->object.parsed))
45 parse_commit(commit);
46
47 insert_by_date(commit, &rev_list);
48
49 if (!(commit->object.flags & COMMON))
50 non_common_revs++;
51 }
52 }
53
54 static 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
58 if (o && o->type == OBJ_COMMIT)
59 rev_list_push((struct commit *)o, SEEN);
60
61 return 0;
62 }
63
64 /*
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 */
69
70 static 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
76 if (!ancestors_only)
77 o->flags |= COMMON;
78
79 if (!(o->flags & SEEN))
80 rev_list_push(commit, SEEN);
81 else {
82 struct commit_list *parents;
83
84 if (!ancestors_only && !(o->flags & POPPED))
85 non_common_revs--;
86 if (!o->parsed && !dont_parse)
87 parse_commit(commit);
88
89 for (parents = commit->parents;
90 parents;
91 parents = parents->next)
92 mark_common(parents->item, 0, dont_parse);
93 }
94 }
95 }
96
97 /*
98 Get the next rev to send, ignoring the common.
99 */
100
101 static const unsigned char* get_rev(void)
102 {
103 struct commit *commit = NULL;
104
105 while (commit == NULL) {
106 unsigned int mark;
107 struct commit_list* parents;
108
109 if (rev_list == NULL || non_common_revs == 0)
110 return NULL;
111
112 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
119 parents = commit->parents;
120
121 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
132 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
140 rev_list = rev_list->next;
141 }
142
143 return commit->object.sha1;
144 }
145
146 static 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
155 for_each_ref(rev_list_insert_ref, NULL);
156
157 fetching = 0;
158 for ( ; refs ; refs = refs->next) {
159 unsigned char *remote = refs->old_sha1;
160 struct object *o;
161
162 /*
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
177 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
198 if (depth > 0) {
199 char line[1024];
200 unsigned char sha1[20];
201 int len;
202
203 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
225 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
235 packet_flush(fd[1]);
236 flushes++;
237
238 /*
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
245 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 }
272 done:
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 }
295
296 static struct commit_list *complete;
297
298 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
299 {
300 struct object *o = parse_object(sha1);
301
302 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 }
316
317 static 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 }
326
327 static 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
335 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
346 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
368 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 }
383
384 static 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
390 track_object_refs = 0;
391 save_commit_buffer = 0;
392
393 for (ref = *refs; ref; ref = ref->next) {
394 struct object *o;
395
396 o = parse_object(ref->old_sha1);
397 if (!o)
398 continue;
399
400 /* 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
411 if (!depth) {
412 for_each_ref(mark_complete, NULL);
413 if (cutoff)
414 mark_recent_complete_commits(cutoff);
415 }
416
417 /*
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
425 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
426 continue;
427
428 if (!(o->flags & SEEN)) {
429 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
430
431 mark_common((struct commit *)o, 1, 1);
432 }
433 }
434
435 filter_refs(refs, nr_match, match);
436
437 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
442 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
453 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 }
462
463 static pid_t setup_sideband(int fd[2], int xd[2])
464 {
465 pid_t side_pid;
466
467 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 }
495
496 static int get_pack(int xd[2])
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
507 side_pid = setup_sideband(fd, xd);
508
509 av = argv;
510 *hdr_arg = 0;
511 if (unpack_limit) {
512 struct pack_header header;
513
514 if (read_pack_header(fd[0], &header))
515 die("protocol error: bad pack header");
516 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
517 ntohl(header.hdr_version), ntohl(header.hdr_entries));
518 if (ntohl(header.hdr_entries) < unpack_limit)
519 do_keep = 0;
520 else
521 do_keep = 1;
522 }
523
524 if (do_keep) {
525 *av++ = "index-pack";
526 *av++ = "--stdin";
527 if (!quiet && !no_progress)
528 *av++ = "-v";
529 if (use_thin_pack)
530 *av++ = "--fix-thin";
531 if (keep_pack > 1 || unpack_limit) {
532 int s = sprintf(keep_arg,
533 "--keep=fetch-pack %d on ", getpid());
534 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
535 strcpy(keep_arg + s, "localhost");
536 *av++ = keep_arg;
537 }
538 }
539 else {
540 *av++ = "unpack-objects";
541 if (quiet)
542 *av++ = "-q";
543 }
544 if (*hdr_arg)
545 *av++ = hdr_arg;
546 *av++ = NULL;
547
548 pid = fork();
549 if (pid < 0)
550 die("fetch-pack: unable to fork off %s", argv[0]);
551 if (!pid) {
552 dup2(fd[0], 0);
553 close(fd[0]);
554 close(fd[1]);
555 execv_git_cmd(argv);
556 die("%s exec failed", argv[0]);
557 }
558 close(fd[0]);
559 close(fd[1]);
560 while (waitpid(pid, &status, 0) < 0) {
561 if (errno != EINTR)
562 die("waiting for %s: %s", argv[0], strerror(errno));
563 }
564 if (WIFEXITED(status)) {
565 int code = WEXITSTATUS(status);
566 if (code)
567 die("%s died with error code %d", argv[0], code);
568 return 0;
569 }
570 if (WIFSIGNALED(status)) {
571 int sig = WTERMSIG(status);
572 die("%s died of signal %d", argv[0], sig);
573 }
574 die("%s died of unnatural causes %d", argv[0], status);
575 }
576
577 static struct ref *do_fetch_pack(int fd[2], int nr_match, char **match)
578 {
579 struct ref *ref;
580 unsigned char sha1[20];
581
582 get_remote_heads(fd[0], &ref, 0, NULL, 0);
583 if (is_repository_shallow() && !server_supports("shallow"))
584 die("Server does not support shallow clients");
585 if (server_supports("multi_ack")) {
586 if (verbose)
587 fprintf(stderr, "Server supports multi_ack\n");
588 multi_ack = 1;
589 }
590 if (server_supports("side-band-64k")) {
591 if (verbose)
592 fprintf(stderr, "Server supports side-band-64k\n");
593 use_sideband = 2;
594 }
595 else if (server_supports("side-band")) {
596 if (verbose)
597 fprintf(stderr, "Server supports side-band\n");
598 use_sideband = 1;
599 }
600 if (!ref) {
601 packet_flush(fd[1]);
602 die("no matching remote head");
603 }
604 if (everything_local(&ref, nr_match, match)) {
605 packet_flush(fd[1]);
606 goto all_done;
607 }
608 if (find_common(fd, sha1, ref) < 0)
609 if (keep_pack != 1)
610 /* When cloning, it is not unusual to have
611 * no common commit.
612 */
613 fprintf(stderr, "warning: no common commits\n");
614
615 if (get_pack(fd))
616 die("git-fetch-pack: fetch failed.");
617
618 all_done:
619 return ref;
620 }
621
622 static int remove_duplicates(int nr_heads, char **heads)
623 {
624 int src, dst;
625
626 for (src = dst = 0; src < nr_heads; src++) {
627 /* If heads[src] is different from any of
628 * heads[0..dst], push it in.
629 */
630 int i;
631 for (i = 0; i < dst; i++) {
632 if (!strcmp(heads[i], heads[src]))
633 break;
634 }
635 if (i < dst)
636 continue;
637 if (src != dst)
638 heads[dst] = heads[src];
639 dst++;
640 }
641 heads[dst] = 0;
642 return dst;
643 }
644
645 static int fetch_pack_config(const char *var, const char *value)
646 {
647 if (strcmp(var, "fetch.unpacklimit") == 0) {
648 fetch_unpack_limit = git_config_int(var, value);
649 return 0;
650 }
651
652 if (strcmp(var, "transfer.unpacklimit") == 0) {
653 transfer_unpack_limit = git_config_int(var, value);
654 return 0;
655 }
656
657 return git_default_config(var, value);
658 }
659
660 static struct lock_file lock;
661
662 void setup_fetch_pack(struct fetch_pack_args *args)
663 {
664 uploadpack = args->uploadpack;
665 quiet = args->quiet;
666 keep_pack = args->keep_pack;
667 if (args->unpacklimit >= 0)
668 unpack_limit = args->unpacklimit;
669 if (args->keep_pack)
670 unpack_limit = 0;
671 use_thin_pack = args->use_thin_pack;
672 fetch_all = args->fetch_all;
673 verbose = args->verbose;
674 depth = args->depth;
675 no_progress = args->no_progress;
676 }
677
678 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
679 {
680 int i, ret, nr_heads;
681 struct ref *ref;
682 char *dest = NULL, **heads;
683
684 git_config(fetch_pack_config);
685
686 if (0 <= transfer_unpack_limit)
687 unpack_limit = transfer_unpack_limit;
688 else if (0 <= fetch_unpack_limit)
689 unpack_limit = fetch_unpack_limit;
690
691 nr_heads = 0;
692 heads = NULL;
693 for (i = 1; i < argc; i++) {
694 const char *arg = argv[i];
695
696 if (*arg == '-') {
697 if (!prefixcmp(arg, "--upload-pack=")) {
698 uploadpack = arg + 14;
699 continue;
700 }
701 if (!prefixcmp(arg, "--exec=")) {
702 uploadpack = arg + 7;
703 continue;
704 }
705 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
706 quiet = 1;
707 continue;
708 }
709 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
710 keep_pack++;
711 unpack_limit = 0;
712 continue;
713 }
714 if (!strcmp("--thin", arg)) {
715 use_thin_pack = 1;
716 continue;
717 }
718 if (!strcmp("--all", arg)) {
719 fetch_all = 1;
720 continue;
721 }
722 if (!strcmp("-v", arg)) {
723 verbose = 1;
724 continue;
725 }
726 if (!prefixcmp(arg, "--depth=")) {
727 depth = strtol(arg + 8, NULL, 0);
728 continue;
729 }
730 if (!strcmp("--no-progress", arg)) {
731 no_progress = 1;
732 continue;
733 }
734 usage(fetch_pack_usage);
735 }
736 dest = (char *)arg;
737 heads = (char **)(argv + i + 1);
738 nr_heads = argc - i - 1;
739 break;
740 }
741 if (!dest)
742 usage(fetch_pack_usage);
743
744 ref = fetch_pack(dest, nr_heads, heads);
745
746 ret = !ref;
747
748 while (ref) {
749 printf("%s %s\n",
750 sha1_to_hex(ref->old_sha1), ref->name);
751 ref = ref->next;
752 }
753
754 return ret;
755 }
756
757 struct ref *fetch_pack(const char *dest, int nr_heads, char **heads)
758 {
759 int i, ret;
760 int fd[2];
761 pid_t pid;
762 struct ref *ref;
763 struct stat st;
764
765 if (depth > 0) {
766 if (stat(git_path("shallow"), &st))
767 st.st_mtime = 0;
768 }
769
770 pid = git_connect(fd, (char *)dest, uploadpack,
771 verbose ? CONNECT_VERBOSE : 0);
772 if (pid < 0)
773 return NULL;
774 if (heads && nr_heads)
775 nr_heads = remove_duplicates(nr_heads, heads);
776 ref = do_fetch_pack(fd, nr_heads, heads);
777 close(fd[0]);
778 close(fd[1]);
779 ret = finish_connect(pid);
780
781 if (!ret && nr_heads) {
782 /* If the heads to pull were given, we should have
783 * consumed all of them by matching the remote.
784 * Otherwise, 'git-fetch remote no-such-ref' would
785 * silently succeed without issuing an error.
786 */
787 for (i = 0; i < nr_heads; i++)
788 if (heads[i] && heads[i][0]) {
789 error("no such remote ref %s", heads[i]);
790 ret = 1;
791 }
792 }
793
794 if (!ret && depth > 0) {
795 struct cache_time mtime;
796 char *shallow = git_path("shallow");
797 int fd;
798
799 mtime.sec = st.st_mtime;
800 #ifdef USE_NSEC
801 mtime.usec = st.st_mtim.usec;
802 #endif
803 if (stat(shallow, &st)) {
804 if (mtime.sec)
805 die("shallow file was removed during fetch");
806 } else if (st.st_mtime != mtime.sec
807 #ifdef USE_NSEC
808 || st.st_mtim.usec != mtime.usec
809 #endif
810 )
811 die("shallow file was changed during fetch");
812
813 fd = hold_lock_file_for_update(&lock, shallow, 1);
814 if (!write_shallow_commits(fd, 0)) {
815 unlink(shallow);
816 rollback_lock_file(&lock);
817 } else {
818 close(fd);
819 commit_lock_file(&lock);
820 }
821 }
822
823 if (ret)
824 ref = NULL;
825
826 return ref;
827 }