src/odb.c

   1 /*
   2  * Copyright (C) 2009-2012 the libgit2 contributors
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include "common.h"
   9 #include <zlib.h>
  10 #include "git2/object.h"
  11 #include "fileops.h"
  12 #include "hash.h"
  13 #include "odb.h"
  14 #include "delta-apply.h"
  15 #include "filter.h"
  16
  17 #include "git2/odb_backend.h"
  18 #include "git2/oid.h"
  19
  20 #define GIT_ALTERNATES_FILE "info/alternates"
  21
  22 /* TODO: is this correct? */
  23 #define GIT_LOOSE_PRIORITY 2
  24 #define GIT_PACKED_PRIORITY 1
  25
  26 #define GIT_ALTERNATES_MAX_DEPTH 5
  27
  28 typedef struct
  29 {
  30         git_odb_backend *backend;
  31         int priority;
  32         int is_alternate;
  33 } backend_internal;
  34
  35 static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_depth);
  36
  37 int git_odb__format_object_header(char *hdr, size_t n, size_t obj_len, git_otype obj_type)
  38 {
  39         const char *type_str = git_object_type2string(obj_type);
  40         int len = p_snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len);
  41         assert(len > 0 && len <= (int)n);
  42         return len+1;
  43 }
  44
  45 int git_odb__hashobj(git_oid *id, git_rawobj *obj)
  46 {
  47         git_buf_vec vec[2];
  48         char header[64];
  49         int hdrlen;
  50
  51         assert(id && obj);
  52
  53         if (!git_object_typeisloose(obj->type))
  54                 return -1;
  55         if (!obj->data && obj->len != 0)
  56                 return -1;
  57
  58         hdrlen = git_odb__format_object_header(header, sizeof(header), obj->len, obj->type);
  59
  60         vec[0].data = header;
  61         vec[0].len = hdrlen;
  62         vec[1].data = obj->data;
  63         vec[1].len = obj->len;
  64
  65         git_hash_vec(id, vec, 2);
  66
  67         return 0;
  68 }
  69
  70
  71 static git_odb_object *new_odb_object(const git_oid *oid, git_rawobj *source)
  72 {
  73         git_odb_object *object = git__malloc(sizeof(git_odb_object));
  74         memset(object, 0x0, sizeof(git_odb_object));
  75
  76         git_oid_cpy(&object->cached.oid, oid);
  77         memcpy(&object->raw, source, sizeof(git_rawobj));
  78
  79         return object;
  80 }
  81
  82 static void free_odb_object(void *o)
  83 {
  84         git_odb_object *object = (git_odb_object *)o;
  85
  86         if (object != NULL) {
  87                 git__free(object->raw.data);
  88                 git__free(object);
  89         }
  90 }
  91
  92 const git_oid *git_odb_object_id(git_odb_object *object)
  93 {
  94         return &object->cached.oid;
  95 }
  96
  97 const void *git_odb_object_data(git_odb_object *object)
  98 {
  99         return object->raw.data;
 100 }
 101
 102 size_t git_odb_object_size(git_odb_object *object)
 103 {
 104         return object->raw.len;
 105 }
 106
 107 git_otype git_odb_object_type(git_odb_object *object)
 108 {
 109         return object->raw.type;
 110 }
 111
 112 void git_odb_object_free(git_odb_object *object)
 113 {
 114         if (object == NULL)
 115                 return;
 116
 117         git_cached_obj_decref((git_cached_obj *)object, &free_odb_object);
 118 }
 119
 120 int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type)
 121 {
 122         int hdr_len;
 123         char hdr[64], buffer[2048];
 124         git_hash_ctx ctx;
 125         ssize_t read_len = 0;
 126         int error = 0;
 127
 128         if (!git_object_typeisloose(type)) {
 129                 giterr_set(GITERR_INVALID, "Invalid object type for hash");
 130                 return -1;
 131         }
 132
 133         if ((error = git_hash_ctx_init(&ctx)) < 0)
 134                 return -1;
 135
 136         hdr_len = git_odb__format_object_header(hdr, sizeof(hdr), size, type);
 137
 138         if ((error = git_hash_update(&ctx, hdr, hdr_len)) < 0)
 139                 goto done;
 140
 141         while (size > 0 && (read_len = p_read(fd, buffer, sizeof(buffer))) > 0) {
 142                 if ((error = git_hash_update(&ctx, buffer, read_len)) < 0)
 143                         goto done;
 144
 145                 size -= read_len;
 146         }
 147
 148         /* If p_read returned an error code, the read obviously failed.
 149          * If size is not zero, the file was truncated after we originally
 150          * stat'd it, so we consider this a read failure too */
 151         if (read_len < 0 || size > 0) {
 152                 giterr_set(GITERR_OS, "Error reading file for hashing");
 153                 error = -1;
 154
 155                 goto done;
 156                 return -1;
 157         }
 158
 159         error = git_hash_final(out, &ctx);
 160
 161 done:
 162         git_hash_ctx_cleanup(&ctx);
 163         return error;
 164 }
 165
 166 int git_odb__hashfd_filtered(
 167         git_oid *out, git_file fd, size_t size, git_otype type, git_vector *filters)
 168 {
 169         int error;
 170         git_buf raw = GIT_BUF_INIT;
 171         git_buf filtered = GIT_BUF_INIT;
 172
 173         if (!filters || !filters->length)
 174                 return git_odb__hashfd(out, fd, size, type);
 175
 176         /* size of data is used in header, so we have to read the whole file
 177          * into memory to apply filters before beginning to calculate the hash
 178          */
 179
 180         if (!(error = git_futils_readbuffer_fd(&raw, fd, size)))
 181                 error = git_filters_apply(&filtered, &raw, filters);
 182
 183         git_buf_free(&raw);
 184
 185         if (!error)
 186                 error = git_odb_hash(out, filtered.ptr, filtered.size, type);
 187
 188         git_buf_free(&filtered);
 189
 190         return error;
 191 }
 192
 193 int git_odb__hashlink(git_oid *out, const char *path)
 194 {
 195         struct stat st;
 196         git_off_t size;
 197         int result;
 198
 199         if (git_path_lstat(path, &st) < 0)
 200                 return -1;
 201
 202         size = st.st_size;
 203
 204         if (!git__is_sizet(size)) {
 205                 giterr_set(GITERR_OS, "File size overflow for 32-bit systems");
 206                 return -1;
 207         }
 208
 209         if (S_ISLNK(st.st_mode)) {
 210                 char *link_data;
 211                 ssize_t read_len;
 212
 213                 link_data = git__malloc((size_t)(size + 1));
 214                 GITERR_CHECK_ALLOC(link_data);
 215
 216                 read_len = p_readlink(path, link_data, (size_t)size);
 217                 link_data[size] = '\0';
 218                 if (read_len != (ssize_t)size) {
 219                         giterr_set(GITERR_OS, "Failed to read symlink data for '%s'", path);
 220                         return -1;
 221                 }
 222
 223                 result = git_odb_hash(out, link_data, (size_t)size, GIT_OBJ_BLOB);
 224                 git__free(link_data);
 225         } else {
 226                 int fd = git_futils_open_ro(path);
 227                 if (fd < 0)
 228                         return -1;
 229                 result = git_odb__hashfd(out, fd, (size_t)size, GIT_OBJ_BLOB);
 230                 p_close(fd);
 231         }
 232
 233         return result;
 234 }
 235
 236 int git_odb_hashfile(git_oid *out, const char *path, git_otype type)
 237 {
 238         git_off_t size;
 239         int result, fd = git_futils_open_ro(path);
 240         if (fd < 0)
 241                 return fd;
 242
 243         if ((size = git_futils_filesize(fd)) < 0 || !git__is_sizet(size)) {
 244                 giterr_set(GITERR_OS, "File size overflow for 32-bit systems");
 245                 p_close(fd);
 246                 return -1;
 247         }
 248
 249         result = git_odb__hashfd(out, fd, (size_t)size, type);
 250         p_close(fd);
 251         return result;
 252 }
 253
 254 int git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type)
 255 {
 256         git_rawobj raw;
 257
 258         assert(id);
 259
 260         raw.data = (void *)data;
 261         raw.len = len;
 262         raw.type = type;
 263
 264         return git_odb__hashobj(id, &raw);
 265 }
 266
 267 /**
 268  * FAKE WSTREAM
 269  */
 270
 271 typedef struct {
 272         git_odb_stream stream;
 273         char *buffer;
 274         size_t size, written;
 275         git_otype type;
 276 } fake_wstream;
 277
 278 static int fake_wstream__fwrite(git_oid *oid, git_odb_stream *_stream)
 279 {
 280         fake_wstream *stream = (fake_wstream *)_stream;
 281         return _stream->backend->write(oid, _stream->backend, stream->buffer, stream->size, stream->type);
 282 }
 283
 284 static int fake_wstream__write(git_odb_stream *_stream, const char *data, size_t len)
 285 {
 286         fake_wstream *stream = (fake_wstream *)_stream;
 287
 288         if (stream->written + len > stream->size)
 289                 return -1;
 290
 291         memcpy(stream->buffer + stream->written, data, len);
 292         stream->written += len;
 293         return 0;
 294 }
 295
 296 static void fake_wstream__free(git_odb_stream *_stream)
 297 {
 298         fake_wstream *stream = (fake_wstream *)_stream;
 299
 300         git__free(stream->buffer);
 301         git__free(stream);
 302 }
 303
 304 static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend, size_t size, git_otype type)
 305 {
 306         fake_wstream *stream;
 307
 308         stream = git__calloc(1, sizeof(fake_wstream));
 309         GITERR_CHECK_ALLOC(stream);
 310
 311         stream->size = size;
 312         stream->type = type;
 313         stream->buffer = git__malloc(size);
 314         if (stream->buffer == NULL) {
 315                 git__free(stream);
 316                 return -1;
 317         }
 318
 319         stream->stream.backend = backend;
 320         stream->stream.read = NULL; /* read only */
 321         stream->stream.write = &fake_wstream__write;
 322         stream->stream.finalize_write = &fake_wstream__fwrite;
 323         stream->stream.free = &fake_wstream__free;
 324         stream->stream.mode = GIT_STREAM_WRONLY;
 325
 326         *stream_p = (git_odb_stream *)stream;
 327         return 0;
 328 }
 329
 330 /***********************************************************
 331  *
 332  * OBJECT DATABASE PUBLIC API
 333  *
 334  * Public calls for the ODB functionality
 335  *
 336  ***********************************************************/
 337
 338 static int backend_sort_cmp(const void *a, const void *b)
 339 {
 340         const backend_internal *backend_a = (const backend_internal *)(a);
 341         const backend_internal *backend_b = (const backend_internal *)(b);
 342
 343         if (backend_a->is_alternate == backend_b->is_alternate)
 344                 return (backend_b->priority - backend_a->priority);
 345
 346         return backend_a->is_alternate ? 1 : -1;
 347 }
 348
 349 int git_odb_new(git_odb **out)
 350 {
 351         git_odb *db = git__calloc(1, sizeof(*db));
 352         GITERR_CHECK_ALLOC(db);
 353
 354         if (git_cache_init(&db->cache, GIT_DEFAULT_CACHE_SIZE, &free_odb_object) < 0 ||
 355                 git_vector_init(&db->backends, 4, backend_sort_cmp) < 0)
 356         {
 357                 git__free(db);
 358                 return -1;
 359         }
 360
 361         *out = db;
 362         GIT_REFCOUNT_INC(db);
 363         return 0;
 364 }
 365
 366 static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int priority, int is_alternate)
 367 {
 368         backend_internal *internal;
 369
 370         assert(odb && backend);
 371
 372         GITERR_CHECK_VERSION(backend, GIT_ODB_BACKEND_VERSION, "git_odb_backend");
 373
 374         /* Check if the backend is already owned by another ODB */
 375         assert(!backend->odb || backend->odb == odb);
 376
 377         internal = git__malloc(sizeof(backend_internal));
 378         GITERR_CHECK_ALLOC(internal);
 379
 380         internal->backend = backend;
 381         internal->priority = priority;
 382         internal->is_alternate = is_alternate;
 383
 384         if (git_vector_insert(&odb->backends, internal) < 0) {
 385                 git__free(internal);
 386                 return -1;
 387         }
 388
 389         git_vector_sort(&odb->backends);
 390         internal->backend->odb = odb;
 391         return 0;
 392 }
 393
 394 int git_odb_add_backend(git_odb *odb, git_odb_backend *backend, int priority)
 395 {
 396         return add_backend_internal(odb, backend, priority, 0);
 397 }
 398
 399 int git_odb_add_alternate(git_odb *odb, git_odb_backend *backend, int priority)
 400 {
 401         return add_backend_internal(odb, backend, priority, 1);
 402 }
 403
 404 static int add_default_backends(git_odb *db, const char *objects_dir, int as_alternates, int alternate_depth)
 405 {
 406         git_odb_backend *loose, *packed;
 407
 408         /* add the loose object backend */
 409         if (git_odb_backend_loose(&loose, objects_dir, -1, 0) < 0 ||
 410                 add_backend_internal(db, loose, GIT_LOOSE_PRIORITY, as_alternates) < 0)
 411                 return -1;
 412
 413         /* add the packed file backend */
 414         if (git_odb_backend_pack(&packed, objects_dir) < 0 ||
 415                 add_backend_internal(db, packed, GIT_PACKED_PRIORITY, as_alternates) < 0)
 416                 return -1;
 417
 418         return load_alternates(db, objects_dir, alternate_depth);
 419 }
 420
 421 static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_depth)
 422 {
 423         git_buf alternates_path = GIT_BUF_INIT;
 424         git_buf alternates_buf = GIT_BUF_INIT;
 425         char *buffer;
 426         const char *alternate;
 427         int result = 0;
 428
 429         /* Git reports an error, we just ignore anything deeper */
 430         if (alternate_depth > GIT_ALTERNATES_MAX_DEPTH) {
 431                 return 0;
 432         }
 433
 434         if (git_buf_joinpath(&alternates_path, objects_dir, GIT_ALTERNATES_FILE) < 0)
 435                 return -1;
 436
 437         if (git_path_exists(alternates_path.ptr) == false) {
 438                 git_buf_free(&alternates_path);
 439                 return 0;
 440         }
 441
 442         if (git_futils_readbuffer(&alternates_buf, alternates_path.ptr) < 0) {
 443                 git_buf_free(&alternates_path);
 444                 return -1;
 445         }
 446
 447         buffer = (char *)alternates_buf.ptr;
 448
 449         /* add each alternate as a new backend; one alternate per line */
 450         while ((alternate = git__strtok(&buffer, "\r\n")) != NULL) {
 451                 if (*alternate == '\0' || *alternate == '#')
 452                         continue;
 453
 454                 /*
 455                  * Relative path: build based on the current `objects`
 456                  * folder. However, relative paths are only allowed in
 457                  * the current repository.
 458                  */
 459                 if (*alternate == '.' && !alternate_depth) {
 460                         if ((result = git_buf_joinpath(&alternates_path, objects_dir, alternate)) < 0)
 461                                 break;
 462                         alternate = git_buf_cstr(&alternates_path);
 463                 }
 464
 465                 if ((result = add_default_backends(odb, alternate, 1, alternate_depth + 1)) < 0)
 466                         break;
 467         }
 468
 469         git_buf_free(&alternates_path);
 470         git_buf_free(&alternates_buf);
 471
 472         return result;
 473 }
 474
 475 int git_odb_add_disk_alternate(git_odb *odb, const char *path)
 476 {
 477         return add_default_backends(odb, path, 1, 0);
 478 }
 479
 480 int git_odb_open(git_odb **out, const char *objects_dir)
 481 {
 482         git_odb *db;
 483
 484         assert(out && objects_dir);
 485
 486         *out = NULL;
 487
 488         if (git_odb_new(&db) < 0)
 489                 return -1;
 490
 491         if (add_default_backends(db, objects_dir, 0, 0) < 0) {
 492                 git_odb_free(db);
 493                 return -1;
 494         }
 495
 496         *out = db;
 497         return 0;
 498 }
 499
 500 static void odb_free(git_odb *db)
 501 {
 502         unsigned int i;
 503
 504         for (i = 0; i < db->backends.length; ++i) {
 505                 backend_internal *internal = git_vector_get(&db->backends, i);
 506                 git_odb_backend *backend = internal->backend;
 507
 508                 if (backend->free) backend->free(backend);
 509                 else git__free(backend);
 510
 511                 git__free(internal);
 512         }
 513
 514         git_vector_free(&db->backends);
 515         git_cache_free(&db->cache);
 516         git__free(db);
 517 }
 518
 519 void git_odb_free(git_odb *db)
 520 {
 521         if (db == NULL)
 522                 return;
 523
 524         GIT_REFCOUNT_DEC(db, odb_free);
 525 }
 526
 527 int git_odb_exists(git_odb *db, const git_oid *id)
 528 {
 529         git_odb_object *object;
 530         unsigned int i;
 531         bool found = false;
 532
 533         assert(db && id);
 534
 535         if ((object = git_cache_get(&db->cache, id)) != NULL) {
 536                 git_odb_object_free(object);
 537                 return (int)true;
 538         }
 539
 540         for (i = 0; i < db->backends.length && !found; ++i) {
 541                 backend_internal *internal = git_vector_get(&db->backends, i);
 542                 git_odb_backend *b = internal->backend;
 543
 544                 if (b->exists != NULL)
 545                         found = b->exists(b, id);
 546         }
 547
 548         return (int)found;
 549 }
 550
 551 int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
 552 {
 553         int error;
 554         git_odb_object *object;
 555
 556         error = git_odb__read_header_or_object(&object, len_p, type_p, db, id);
 557
 558         if (object)
 559                 git_odb_object_free(object);
 560
 561         return error;
 562 }
 563
 564 int git_odb__read_header_or_object(
 565         git_odb_object **out, size_t *len_p, git_otype *type_p,
 566         git_odb *db, const git_oid *id)
 567 {
 568         unsigned int i;
 569         int error = GIT_ENOTFOUND;
 570         git_odb_object *object;
 571
 572         assert(db && id && out && len_p && type_p);
 573
 574         if ((object = git_cache_get(&db->cache, id)) != NULL) {
 575                 *len_p = object->raw.len;
 576                 *type_p = object->raw.type;
 577                 *out = object;
 578                 return 0;
 579         }
 580
 581         *out = NULL;
 582
 583         for (i = 0; i < db->backends.length && error < 0; ++i) {
 584                 backend_internal *internal = git_vector_get(&db->backends, i);
 585                 git_odb_backend *b = internal->backend;
 586
 587                 if (b->read_header != NULL)
 588                         error = b->read_header(len_p, type_p, b, id);
 589         }
 590
 591         if (!error || error == GIT_PASSTHROUGH)
 592                 return 0;
 593
 594         /*
 595          * no backend could read only the header.
 596          * try reading the whole object and freeing the contents
 597          */
 598         if ((error = git_odb_read(&object, db, id)) < 0)
 599                 return error; /* error already set - pass along */
 600
 601         *len_p = object->raw.len;
 602         *type_p = object->raw.type;
 603         *out = object;
 604
 605         return 0;
 606 }
 607
 608 int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 609 {
 610         unsigned int i;
 611         int error = GIT_ENOTFOUND;
 612         git_rawobj raw;
 613
 614         assert(out && db && id);
 615
 616         *out = git_cache_get(&db->cache, id);
 617         if (*out != NULL)
 618                 return 0;
 619
 620         for (i = 0; i < db->backends.length && error < 0; ++i) {
 621                 backend_internal *internal = git_vector_get(&db->backends, i);
 622                 git_odb_backend *b = internal->backend;
 623
 624                 if (b->read != NULL)
 625                         error = b->read(&raw.data, &raw.len, &raw.type, b, id);
 626         }
 627
 628         /* TODO: If no backends are configured, this returns GIT_ENOTFOUND but
 629          * will never have called giterr_set().
 630          */
 631
 632         if (error && error != GIT_PASSTHROUGH)
 633                 return error;
 634
 635         *out = git_cache_try_store(&db->cache, new_odb_object(id, &raw));
 636         return 0;
 637 }
 638
 639 int git_odb_read_prefix(
 640         git_odb_object **out, git_odb *db, const git_oid *short_id, size_t len)
 641 {
 642         unsigned int i;
 643         int error = GIT_ENOTFOUND;
 644         git_oid found_full_oid = {{0}};
 645         git_rawobj raw;
 646         void *data = NULL;
 647         bool found = false;
 648
 649         assert(out && db);
 650
 651         if (len < GIT_OID_MINPREFIXLEN)
 652                 return git_odb__error_ambiguous("prefix length too short");
 653
 654         if (len > GIT_OID_HEXSZ)
 655                 len = GIT_OID_HEXSZ;
 656
 657         if (len == GIT_OID_HEXSZ) {
 658                 *out = git_cache_get(&db->cache, short_id);
 659                 if (*out != NULL)
 660                         return 0;
 661         }
 662
 663         for (i = 0; i < db->backends.length; ++i) {
 664                 backend_internal *internal = git_vector_get(&db->backends, i);
 665                 git_odb_backend *b = internal->backend;
 666
 667                 if (b->read != NULL) {
 668                         git_oid full_oid;
 669                         error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len);
 670                         if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH)
 671                                 continue;
 672
 673                         if (error)
 674                                 return error;
 675
 676                         git__free(data);
 677                         data = raw.data;
 678                         if (found && git_oid_cmp(&full_oid, &found_full_oid))
 679                                 return git_odb__error_ambiguous("multiple matches for prefix");
 680                         found_full_oid = full_oid;
 681                         found = true;
 682                 }
 683         }
 684
 685         if (!found)
 686                 return git_odb__error_notfound("no match for prefix", short_id);
 687
 688         *out = git_cache_try_store(&db->cache, new_odb_object(&found_full_oid, &raw));
 689         return 0;
 690 }
 691
 692 int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
 693 {
 694         unsigned int i;
 695         backend_internal *internal;
 696
 697         git_vector_foreach(&db->backends, i, internal) {
 698                 git_odb_backend *b = internal->backend;
 699                 int error = b->foreach(b, cb, payload);
 700                 if (error < 0)
 701                         return error;
 702         }
 703
 704         return 0;
 705 }
 706
 707 int git_odb_write(
 708         git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type)
 709 {
 710         unsigned int i;
 711         int error = GIT_ERROR;
 712         git_odb_stream *stream;
 713
 714         assert(oid && db);
 715
 716         git_odb_hash(oid, data, len, type);
 717         if (git_odb_exists(db, oid))
 718                 return 0;
 719
 720         for (i = 0; i < db->backends.length && error < 0; ++i) {
 721                 backend_internal *internal = git_vector_get(&db->backends, i);
 722                 git_odb_backend *b = internal->backend;
 723
 724                 /* we don't write in alternates! */
 725                 if (internal->is_alternate)
 726                         continue;
 727
 728                 if (b->write != NULL)
 729                         error = b->write(oid, b, data, len, type);
 730         }
 731
 732         if (!error || error == GIT_PASSTHROUGH)
 733                 return 0;
 734
 735         /* if no backends were able to write the object directly, we try a streaming
 736          * write to the backends; just write the whole object into the stream in one
 737          * push */
 738
 739         if ((error = git_odb_open_wstream(&stream, db, len, type)) != 0)
 740                 return error;
 741
 742         stream->write(stream, data, len);
 743         error = stream->finalize_write(oid, stream);
 744         stream->free(stream);
 745
 746         return error;
 747 }
 748
 749 int git_odb_open_wstream(
 750         git_odb_stream **stream, git_odb *db, size_t size, git_otype type)
 751 {
 752         unsigned int i;
 753         int error = GIT_ERROR;
 754
 755         assert(stream && db);
 756
 757         for (i = 0; i < db->backends.length && error < 0; ++i) {
 758                 backend_internal *internal = git_vector_get(&db->backends, i);
 759                 git_odb_backend *b = internal->backend;
 760
 761                 /* we don't write in alternates! */
 762                 if (internal->is_alternate)
 763                         continue;
 764
 765                 if (b->writestream != NULL)
 766                         error = b->writestream(stream, b, size, type);
 767                 else if (b->write != NULL)
 768                         error = init_fake_wstream(stream, b, size, type);
 769         }
 770
 771         if (error == GIT_PASSTHROUGH)
 772                 error = 0;
 773
 774         return error;
 775 }
 776
 777 int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oid)
 778 {
 779         unsigned int i;
 780         int error = GIT_ERROR;
 781
 782         assert(stream && db);
 783
 784         for (i = 0; i < db->backends.length && error < 0; ++i) {
 785                 backend_internal *internal = git_vector_get(&db->backends, i);
 786                 git_odb_backend *b = internal->backend;
 787
 788                 if (b->readstream != NULL)
 789                         error = b->readstream(stream, b, oid);
 790         }
 791
 792         if (error == GIT_PASSTHROUGH)
 793                 error = 0;
 794
 795         return error;
 796 }
 797
 798 int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_transfer_progress_callback progress_cb, void *progress_payload)
 799 {
 800         unsigned int i;
 801         int error = GIT_ERROR;
 802
 803         assert(out && db);
 804
 805         for (i = 0; i < db->backends.length && error < 0; ++i) {
 806                 backend_internal *internal = git_vector_get(&db->backends, i);
 807                 git_odb_backend *b = internal->backend;
 808
 809                 /* we don't write in alternates! */
 810                 if (internal->is_alternate)
 811                         continue;
 812
 813                 if (b->writepack != NULL)
 814                         error = b->writepack(out, b, progress_cb, progress_payload);
 815         }
 816
 817         if (error == GIT_PASSTHROUGH)
 818                 error = 0;
 819
 820         return error;
 821 }
 822
 823 void * git_odb_backend_malloc(git_odb_backend *backend, size_t len)
 824 {
 825         GIT_UNUSED(backend);
 826         return git__malloc(len);
 827 }
 828
 829 int git_odb__error_notfound(const char *message, const git_oid *oid)
 830 {
 831         if (oid != NULL) {
 832                 char oid_str[GIT_OID_HEXSZ + 1];
 833                 git_oid_tostr(oid_str, sizeof(oid_str), oid);
 834                 giterr_set(GITERR_ODB, "Object not found - %s (%s)", message, oid_str);
 835         } else
 836                 giterr_set(GITERR_ODB, "Object not found - %s", message);
 837
 838         return GIT_ENOTFOUND;
 839 }
 840
 841 int git_odb__error_ambiguous(const char *message)
 842 {
 843         giterr_set(GITERR_ODB, "Ambiguous SHA1 prefix - %s", message);
 844         return GIT_EAMBIGUOUS;
 845 }
 846