1 /*
2  * Copyright (c) 2020 Ori Bernstein
3  * Copyright (c) 2021, 2022 Stefan Sperling <stsp@openbsd.org>
4  *
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.
8  *
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.
16  */
17 
18 #include <sys/types.h>
19 #include <sys/queue.h>
20 #include <sys/tree.h>
21 #include <sys/uio.h>
22 
23 #include <sha1.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <time.h>
30 #include <imsg.h>
31 #include <inttypes.h>
32 #include <unistd.h>
33 
34 #include "got_error.h"
35 #include "got_cancel.h"
36 #include "got_object.h"
37 #include "got_reference.h"
38 #include "got_repository_admin.h"
39 #include "got_path.h"
40 
41 #include "got_lib_delta.h"
42 #include "got_lib_object.h"
43 #include "got_lib_object_cache.h"
44 #include "got_lib_object_idset.h"
45 #include "got_lib_privsep.h"
46 #include "got_lib_ratelimit.h"
47 #include "got_lib_pack.h"
48 #include "got_lib_pack_create.h"
49 #include "got_lib_repository.h"
50 
51 struct send_id_arg {
52 	struct imsgbuf *ibuf;
53 	struct got_object_id *ids[GOT_IMSG_OBJ_ID_LIST_MAX_NIDS];
54 	size_t nids;
55 };
56 
57 static const struct got_error *
58 send_id(struct got_object_id *id, void *data, void *arg)
59 {
60 	const struct got_error *err = NULL;
61 	struct send_id_arg *a = arg;
62 
63 	a->ids[a->nids++] = id;
64 
65 	if (a->nids >= GOT_IMSG_OBJ_ID_LIST_MAX_NIDS) {
66 		err = got_privsep_send_object_idlist(a->ibuf, a->ids, a->nids);
67 		if (err)
68 			return err;
69 		a->nids = 0;
70 	}
71 
72 	return NULL;
73 }
74 
75 static const struct got_error *
76 send_idset(struct imsgbuf *ibuf, struct got_object_idset *idset)
77 {
78 	const struct got_error *err;
79 	struct send_id_arg sia;
80 
81 	memset(&sia, 0, sizeof(sia));
82 	sia.ibuf = ibuf;
83 	err = got_object_idset_for_each(idset, send_id, &sia);
84 	if (err)
85 		return err;
86 
87 	if (sia.nids > 0) {
88 		err = got_privsep_send_object_idlist(ibuf, sia.ids, sia.nids);
89 		if (err)
90 			return err;
91 	}
92 
93 	return got_privsep_send_object_idlist_done(ibuf);
94 }
95 
96 static const struct got_error *
97 recv_reused_delta(struct got_imsg_reused_delta *delta,
98     struct got_object_idset *idset, struct got_pack_metavec *v)
99 {
100 	struct got_pack_meta *m, *base;
101 
102 	if (delta->delta_offset + delta->delta_size < delta->delta_offset ||
103 	    delta->delta_offset +
104 	    delta->delta_compressed_size < delta->delta_offset)
105 		return got_error(GOT_ERR_BAD_PACKFILE);
106 
107 	m = got_object_idset_get(idset, &delta->id);
108 	if (m == NULL)
109 		return got_error(GOT_ERR_NO_OBJ);
110 
111 	base = got_object_idset_get(idset, &delta->base_id);
112 	if (base == NULL)
113 		return got_error(GOT_ERR_NO_OBJ);
114 
115 	m->delta_len = delta->delta_size;
116 	m->delta_compressed_len = delta->delta_compressed_size;
117 	m->delta_offset = 0;
118 	m->prev = base;
119 	m->size = delta->result_size;
120 	m->reused_delta_offset = delta->delta_offset;
121 	m->base_obj_id = got_object_id_dup(&delta->base_id);
122 	if (m->base_obj_id == NULL)
123 		return got_error_from_errno("got_object_id_dup");
124 
125 	return got_pack_add_meta(m, v);
126 }
127 
128 const struct got_error *
129 got_pack_search_deltas(struct got_packidx **packidx, struct got_pack **pack,
130     struct got_pack_metavec *v, struct got_object_idset *idset,
131     int ncolored, int nfound, int ntrees, int ncommits,
132     struct got_repository *repo,
133     got_pack_progress_cb progress_cb, void *progress_arg,
134     struct got_ratelimit *rl, got_cancel_cb cancel_cb, void *cancel_arg)
135 {
136 	const struct got_error *err = NULL;
137 	struct got_imsg_reused_delta deltas[GOT_IMSG_REUSED_DELTAS_MAX_NDELTAS];
138 	size_t ndeltas, i;
139 
140 	*packidx = NULL;
141 	*pack = NULL;
142 
143 	err = got_pack_find_pack_for_reuse(packidx, repo);
144 	if (err)
145 		return err;
146 
147 	if (*packidx == NULL)
148 		return NULL;
149 
150 	err = got_pack_cache_pack_for_packidx(pack, *packidx, repo);
151 	if (err)
152 		goto done;
153 
154 	if ((*pack)->privsep_child == NULL) {
155 		err = got_pack_start_privsep_child(*pack, *packidx);
156 		if (err)
157 			goto done;
158 	}
159 
160 	err = got_privsep_send_delta_reuse_req((*pack)->privsep_child->ibuf);
161 	if (err)
162 		goto done;
163 
164 	err = send_idset((*pack)->privsep_child->ibuf, idset);
165 	if (err)
166 		goto done;
167 
168 	for (;;) {
169 		int done = 0;
170 
171 		if (cancel_cb) {
172 			err = (*cancel_cb)(cancel_arg);
173 			if (err)
174 				break;
175 		}
176 
177 		err = got_privsep_recv_reused_deltas(&done, deltas, &ndeltas,
178 		    (*pack)->privsep_child->ibuf);
179 		if (err || done)
180 			break;
181 
182 		for (i = 0; i < ndeltas; i++) {
183 			struct got_imsg_reused_delta *delta = &deltas[i];
184 			err = recv_reused_delta(delta, idset, v);
185 			if (err)
186 				goto done;
187 		}
188 
189 		err = got_pack_report_progress(progress_cb, progress_arg, rl,
190 		    ncolored, nfound, ntrees, 0L, ncommits,
191 		    got_object_idset_num_elements(idset), v->nmeta, 0);
192 		if (err)
193 			break;
194 	}
195 done:
196 	return err;
197 }
198 
199 struct recv_painted_commit_arg {
200 	int *ncolored;
201 	int *nqueued;
202 	int *nskip;
203 	struct got_object_id_queue *ids;
204 	struct got_object_idset *keep;
205 	struct got_object_idset *drop;
206 	struct got_object_idset *skip;
207 	got_pack_progress_cb progress_cb;
208 	void *progress_arg;
209 	struct got_ratelimit *rl;
210 	got_cancel_cb cancel_cb;
211 	void *cancel_arg;
212 };
213 
214 static const struct got_error *
215 recv_painted_commit(void *arg, struct got_object_id *id, intptr_t color)
216 {
217 	const struct got_error *err = NULL;
218 	struct recv_painted_commit_arg *a = arg;
219 	struct got_object_qid *qid, *tmp;
220 
221 	if (a->cancel_cb) {
222 		err = a->cancel_cb(a->cancel_arg);
223 		if (err)
224 			return err;
225 	}
226 
227 	switch (color) {
228 	case COLOR_KEEP:
229 		err = got_object_idset_add(a->keep, id, NULL);
230 		if (err)
231 			return err;
232 		(*a->ncolored)++;
233 		break;
234 	case COLOR_DROP:
235 		err = got_object_idset_add(a->drop, id, NULL);
236 		if (err)
237 			return err;
238 		(*a->ncolored)++;
239 		break;
240 	case COLOR_SKIP:
241 		err = got_object_idset_add(a->skip, id, NULL);
242 		if (err)
243 			return err;
244 		break;
245 	default:
246 		/* should not happen */
247 		return got_error_fmt(GOT_ERR_NOT_IMPL,
248 		    "%s invalid commit color %"PRIdPTR, __func__, color);
249 	}
250 
251 	STAILQ_FOREACH_SAFE(qid, a->ids, entry, tmp) {
252 		if (got_object_id_cmp(&qid->id, id) != 0)
253 			continue;
254 		STAILQ_REMOVE(a->ids, qid, got_object_qid, entry);
255 		color = (intptr_t)qid->data;
256 		got_object_qid_free(qid);
257 		(*a->nqueued)--;
258 		if (color == COLOR_SKIP)
259 			(*a->nskip)--;
260 		break;
261 	}
262 
263 	return got_pack_report_progress(a->progress_cb, a->progress_arg, a->rl,
264 	    *a->ncolored, 0, 0, 0L, 0, 0, 0, 0);
265 }
266 
267 static const struct got_error *
268 paint_packed_commits(struct got_pack *pack, struct got_object_id *id,
269     int idx, intptr_t color, int *ncolored, int *nqueued, int *nskip,
270     struct got_object_id_queue *ids,
271     struct got_object_idset *keep, struct got_object_idset *drop,
272     struct got_object_idset *skip, struct got_repository *repo,
273     got_pack_progress_cb progress_cb, void *progress_arg,
274     struct got_ratelimit *rl, got_cancel_cb cancel_cb, void *cancel_arg)
275 {
276 	const struct got_error *err = NULL;
277 	struct got_object_id_queue next_ids;
278 	struct got_object_qid *qid, *tmp;
279 	struct recv_painted_commit_arg arg;
280 
281 	STAILQ_INIT(&next_ids);
282 
283 	err = got_privsep_send_painting_request(pack->privsep_child->ibuf,
284 	    idx, id, color);
285 	if (err)
286 		return err;
287 
288 	arg.ncolored = ncolored;
289 	arg.nqueued = nqueued;
290 	arg.nskip = nskip;
291 	arg.ids = ids;
292 	arg.keep = keep;
293 	arg.drop = drop;
294 	arg.skip = skip;
295 	arg.progress_cb = progress_cb;
296 	arg.progress_arg = progress_arg;
297 	arg.rl = rl;
298 	arg.cancel_cb = cancel_cb;
299 	arg.cancel_arg = cancel_arg;
300 	err = got_privsep_recv_painted_commits(&next_ids,
301 	    recv_painted_commit, &arg, pack->privsep_child->ibuf);
302 	if (err)
303 		return err;
304 
305 	STAILQ_FOREACH_SAFE(qid, &next_ids, entry, tmp) {
306 		struct got_object_qid *old_id;
307 		intptr_t qcolor, ocolor;
308 		STAILQ_FOREACH(old_id, ids, entry) {
309 			if (got_object_id_cmp(&qid->id, &old_id->id))
310 				continue;
311 			qcolor = (intptr_t)qid->data;
312 			ocolor = (intptr_t)old_id->data;
313 			STAILQ_REMOVE(&next_ids, qid, got_object_qid, entry);
314 			got_object_qid_free(qid);
315 			qid = NULL;
316 			if (qcolor != ocolor) {
317 				got_pack_paint_commit(old_id, qcolor);
318 				if (ocolor == COLOR_SKIP)
319 					(*nskip)--;
320 				else if (qcolor == COLOR_SKIP)
321 					(*nskip)++;
322 			}
323 			break;
324 		}
325 	}
326 	while (!STAILQ_EMPTY(&next_ids)) {
327 		qid = STAILQ_FIRST(&next_ids);
328 		STAILQ_REMOVE_HEAD(&next_ids, entry);
329 		got_pack_paint_commit(qid, color);
330 		STAILQ_INSERT_TAIL(ids, qid, entry);
331 		(*nqueued)++;
332 		if (color == COLOR_SKIP)
333 			(*nskip)++;
334 	}
335 
336 	return err;
337 }
338 
339 const struct got_error *
340 got_pack_paint_commits(int *ncolored, struct got_object_id_queue *ids, int nids,
341     struct got_object_idset *keep, struct got_object_idset *drop,
342     struct got_object_idset *skip, struct got_repository *repo,
343     got_pack_progress_cb progress_cb, void *progress_arg,
344     struct got_ratelimit *rl, got_cancel_cb cancel_cb, void *cancel_arg)
345 {
346 	const struct got_error *err = NULL;
347 	struct got_commit_object *commit = NULL;
348 	struct got_packidx *packidx = NULL;
349 	struct got_pack *pack = NULL;
350 	const struct got_object_id_queue *parents;
351 	struct got_object_qid *qid = NULL;
352 	int nqueued = nids, nskip = 0;
353 	int idx;
354 
355 	while (!STAILQ_EMPTY(ids) && nskip != nqueued) {
356 		intptr_t color;
357 
358 		if (cancel_cb) {
359 			err = cancel_cb(cancel_arg);
360 			if (err)
361 				break;
362 		}
363 
364 		qid = STAILQ_FIRST(ids);
365 		STAILQ_REMOVE_HEAD(ids, entry);
366 		nqueued--;
367 		color = (intptr_t)qid->data;
368 		if (color == COLOR_SKIP)
369 			nskip--;
370 
371 		if (got_object_idset_contains(skip, &qid->id)) {
372 			got_object_qid_free(qid);
373 			qid = NULL;
374 			continue;
375 		}
376 		if (color == COLOR_KEEP &&
377 		    got_object_idset_contains(keep, &qid->id)) {
378 			got_object_qid_free(qid);
379 			qid = NULL;
380 			continue;
381 		}
382 		if (color == COLOR_DROP &&
383 		    got_object_idset_contains(drop, &qid->id)) {
384 			got_object_qid_free(qid);
385 			qid = NULL;
386 			continue;
387 		}
388 
389 		/* Pinned pack may have moved to different cache slot. */
390 		pack = got_repo_get_pinned_pack(repo);
391 
392 		if (packidx && pack) {
393 			idx = got_packidx_get_object_idx(packidx, &qid->id);
394 			if (idx != -1) {
395 				err = paint_packed_commits(pack, &qid->id,
396 				    idx, color, ncolored, &nqueued, &nskip,
397 				    ids, keep, drop, skip, repo,
398 				    progress_cb, progress_arg, rl,
399 				    cancel_cb, cancel_arg);
400 				if (err)
401 					break;
402 				got_object_qid_free(qid);
403 				qid = NULL;
404 				continue;
405 			}
406 		}
407 
408 		switch (color) {
409 		case COLOR_KEEP:
410 			if (got_object_idset_contains(drop, &qid->id)) {
411 				err = got_pack_paint_commit(qid, COLOR_SKIP);
412 				if (err)
413 					goto done;
414 			} else
415 				(*ncolored)++;
416 			err = got_object_idset_add(keep, &qid->id, NULL);
417 			if (err)
418 				goto done;
419 			break;
420 		case COLOR_DROP:
421 			if (got_object_idset_contains(keep, &qid->id)) {
422 				err = got_pack_paint_commit(qid, COLOR_SKIP);
423 				if (err)
424 					goto done;
425 			} else
426 				(*ncolored)++;
427 			err = got_object_idset_add(drop, &qid->id, NULL);
428 			if (err)
429 				goto done;
430 			break;
431 		case COLOR_SKIP:
432 			if (!got_object_idset_contains(skip, &qid->id)) {
433 				err = got_object_idset_add(skip, &qid->id,
434 				    NULL);
435 				if (err)
436 					goto done;
437 			}
438 			break;
439 		default:
440 			/* should not happen */
441 			err = got_error_fmt(GOT_ERR_NOT_IMPL,
442 			    "%s invalid commit color %"PRIdPTR, __func__,
443 			    color);
444 			goto done;
445 		}
446 
447 		err = got_pack_report_progress(progress_cb, progress_arg, rl,
448 		    *ncolored, 0, 0, 0L, 0, 0, 0, 0);
449 		if (err)
450 			break;
451 
452 		err = got_object_open_as_commit(&commit, repo, &qid->id);
453 		if (err)
454 			break;
455 
456 		parents = got_object_commit_get_parent_ids(commit);
457 		if (parents) {
458 			struct got_object_qid *pid;
459 			color = (intptr_t)qid->data;
460 			STAILQ_FOREACH(pid, parents, entry) {
461 				err = got_pack_queue_commit_id(ids, &pid->id,
462 				    color, repo);
463 				if (err)
464 					break;
465 				nqueued++;
466 				if (color == COLOR_SKIP)
467 					nskip++;
468 			}
469 		}
470 
471 		if (pack == NULL && (commit->flags & GOT_COMMIT_FLAG_PACKED)) {
472 			if (packidx == NULL) {
473 				err = got_pack_find_pack_for_commit_painting(
474 				    &packidx, ids, nqueued, repo);
475 				if (err)
476 					goto done;
477 			}
478 			if (packidx != NULL) {
479 				err = got_pack_cache_pack_for_packidx(&pack,
480 				    packidx, repo);
481 				if (err)
482 					goto done;
483 				if (pack->privsep_child == NULL) {
484 					err = got_pack_start_privsep_child(
485 					    pack, packidx);
486 					if (err)
487 						goto done;
488 				}
489 				err = got_privsep_init_commit_painting(
490 				    pack->privsep_child->ibuf);
491 				if (err)
492 					goto done;
493 				err = send_idset(pack->privsep_child->ibuf,
494 				    keep);
495 				if (err)
496 					goto done;
497 				err = send_idset(pack->privsep_child->ibuf, drop);
498 				if (err)
499 					goto done;
500 				err = send_idset(pack->privsep_child->ibuf, skip);
501 				if (err)
502 					goto done;
503 				err = got_repo_pin_pack(repo, packidx, pack);
504 				if (err)
505 					goto done;
506 			}
507 		}
508 
509 		got_object_commit_close(commit);
510 		commit = NULL;
511 
512 		got_object_qid_free(qid);
513 		qid = NULL;
514 	}
515 done:
516 	if (pack) {
517 		const struct got_error *pack_err;
518 		pack_err = got_privsep_send_painting_commits_done(
519 		    pack->privsep_child->ibuf);
520 		if (err == NULL)
521 			err = pack_err;
522 	}
523 	if (commit)
524 		got_object_commit_close(commit);
525 	got_object_qid_free(qid);
526 	got_repo_unpin_pack(repo);
527 	return err;
528 }
529 
530 struct load_packed_obj_arg {
531 	/* output parameters: */
532 	struct got_object_id *id;
533 	char *dpath;
534 	time_t mtime;
535 
536 	/* input parameters: */
537 	uint32_t seed;
538 	int want_meta;
539 	struct got_object_idset *idset;
540 	struct got_object_idset *idset_exclude;
541 	int loose_obj_only;
542 	int *ncolored;
543 	int *nfound;
544 	int *ntrees;
545 	got_pack_progress_cb progress_cb;
546 	void *progress_arg;
547 	struct got_ratelimit *rl;
548 	got_cancel_cb cancel_cb;
549 	void *cancel_arg;
550 };
551 
552 static const struct got_error *
553 load_packed_commit_id(void *arg, time_t mtime, struct got_object_id *id,
554     struct got_repository *repo)
555 {
556 	struct load_packed_obj_arg *a = arg;
557 
558 	if (got_object_idset_contains(a->idset, id) ||
559 	    got_object_idset_contains(a->idset_exclude, id))
560 		return NULL;
561 
562 	return got_pack_add_object(a->want_meta,
563 	    a->want_meta ? a->idset : a->idset_exclude,
564 	    id, "", GOT_OBJ_TYPE_COMMIT, mtime, a->seed, a->loose_obj_only,
565 	    repo, a->ncolored, a->nfound, a->ntrees,
566 	    a->progress_cb, a->progress_arg, a->rl);
567 }
568 
569 static const struct got_error *
570 load_packed_tree_ids(void *arg, struct got_tree_object *tree, time_t mtime,
571     struct got_object_id *id, const char *dpath, struct got_repository *repo)
572 {
573 	const struct got_error *err;
574 	struct load_packed_obj_arg *a = arg;
575 	const char *relpath;
576 
577 	/*
578 	 * When we receive a tree's ID and path but not the tree itself,
579 	 * this tree object was not found in the pack file. This is the
580 	 * last time we are being called for this optimized traversal.
581 	 * Return from here and switch to loading objects the slow way.
582 	 */
583 	if (tree == NULL) {
584 		free(a->id);
585 		a->id = got_object_id_dup(id);
586 		if (a->id == NULL) {
587 			err = got_error_from_errno("got_object_id_dup");
588 			free(a->dpath);
589 			a->dpath = NULL;
590 			return err;
591 		}
592 
593 		free(a->dpath);
594 		a->dpath = strdup(dpath);
595 		if (a->dpath == NULL) {
596 			err = got_error_from_errno("strdup");
597 			free(a->id);
598 			a->id = NULL;
599 			return err;
600 		}
601 
602 		a->mtime = mtime;
603 		return NULL;
604 	}
605 
606 	if (got_object_idset_contains(a->idset, id) ||
607 	    got_object_idset_contains(a->idset_exclude, id))
608 		return NULL;
609 
610 	relpath = dpath;
611 	while (relpath[0] == '/')
612 		relpath++;
613 
614 	err = got_pack_add_object(a->want_meta,
615 	    a->want_meta ? a->idset : a->idset_exclude,
616 	    id, relpath, GOT_OBJ_TYPE_TREE, mtime, a->seed,
617 	    a->loose_obj_only, repo, a->ncolored, a->nfound, a->ntrees,
618 	    a->progress_cb, a->progress_arg, a->rl);
619 	if (err)
620 		return err;
621 
622 	return got_pack_load_tree_entries(NULL, a->want_meta, a->idset,
623 	    a->idset_exclude, tree, dpath, mtime, a->seed, repo,
624 	    a->loose_obj_only, a->ncolored, a->nfound, a->ntrees,
625 	    a->progress_cb, a->progress_arg, a->rl,
626 	    a->cancel_cb, a->cancel_arg);
627 }
628 
629 const struct got_error *
630 got_pack_load_packed_object_ids(int *found_all_objects,
631     struct got_object_id **ours, int nours,
632     struct got_object_id **theirs, int ntheirs,
633     int want_meta, uint32_t seed, struct got_object_idset *idset,
634     struct got_object_idset *idset_exclude, int loose_obj_only,
635     struct got_repository *repo, struct got_packidx *packidx,
636     int *ncolored, int *nfound, int *ntrees,
637     got_pack_progress_cb progress_cb, void *progress_arg,
638     struct got_ratelimit *rl, got_cancel_cb cancel_cb, void *cancel_arg)
639 {
640 	const struct got_error *err = NULL;
641 	struct load_packed_obj_arg lpa;
642 
643 	memset(&lpa, 0, sizeof(lpa));
644 	lpa.seed = seed;
645 	lpa.want_meta = want_meta;
646 	lpa.idset = idset;
647 	lpa.idset_exclude = idset_exclude;
648 	lpa.loose_obj_only = loose_obj_only;
649 	lpa.ncolored = ncolored;
650 	lpa.nfound = nfound;
651 	lpa.ntrees = ntrees;
652 	lpa.progress_cb = progress_cb;
653 	lpa.progress_arg = progress_arg;
654 	lpa.rl = rl;
655 	lpa.cancel_cb = cancel_cb;
656 	lpa.cancel_arg = cancel_arg;
657 
658 	/* Attempt to load objects via got-read-pack, as far as possible. */
659 	err = got_object_enumerate(found_all_objects, load_packed_commit_id,
660 	   load_packed_tree_ids, &lpa, ours, nours, theirs, ntheirs,
661 	   packidx, repo);
662 	if (err)
663 		return err;
664 
665 	if (lpa.id == NULL)
666 		return NULL;
667 
668 	/*
669 	 * An incomplete tree hierarchy was present in the pack file
670 	 * and caused loading to be aborted.
671 	 * Continue loading trees the slow way.
672 	 */
673 	err = got_pack_load_tree(want_meta, idset, idset_exclude,
674 	    lpa.id, lpa.dpath, lpa.mtime, seed, repo, loose_obj_only,
675 	    ncolored, nfound, ntrees, progress_cb, progress_arg, rl,
676 	    cancel_cb, cancel_arg);
677 	free(lpa.id);
678 	free(lpa.dpath);
679 	return err;
680 }