X-Git-Url: http://woldlab.caltech.edu/gitweb/?p=samtools.git;a=blobdiff_plain;f=bam_index.c;h=bc89b5b24b40736902d191c5e06774c8e8f228b6;hp=1ad2e93e5051972b084513d5d7391c45c6cf7bf2;hb=refs%2Fheads%2Fcalnh;hpb=8d2494d1fb7cd0fa7c63be5ffba8dd1a11457522 diff --git a/bam_index.c b/bam_index.c index 1ad2e93..bc89b5b 100644 --- a/bam_index.c +++ b/bam_index.c @@ -172,19 +172,23 @@ bam_index_t *bam_index_core(bamFile fp) save_bin = save_tid = last_tid = last_bin = 0xffffffffu; save_off = last_off = bam_tell(fp); last_coor = 0xffffffffu; - n_mapped = n_unmapped = n_no_coor = off_end = 0; + n_mapped = n_unmapped = n_no_coor = off_end = 0; off_beg = off_end = bam_tell(fp); while ((ret = bam_read1(fp, b)) >= 0) { if (c->tid < 0) ++n_no_coor; - if (last_tid != c->tid) { // change of chromosomes + if (last_tid < c->tid || (last_tid >= 0 && c->tid < 0)) { // change of chromosomes last_tid = c->tid; last_bin = 0xffffffffu; - } else if (last_coor > c->pos) { + } else if ((uint32_t)last_tid > (uint32_t)c->tid) { + fprintf(stderr, "[bam_index_core] the alignment is not sorted (%s): %d-th chr > %d-th chr\n", + bam1_qname(b), last_tid+1, c->tid+1); + return NULL; + } else if ((int32_t)c->tid >= 0 && last_coor > c->pos) { fprintf(stderr, "[bam_index_core] the alignment is not sorted (%s): %u > %u in %d-th chr\n", bam1_qname(b), last_coor, c->pos, c->tid+1); - exit(1); + return NULL; } - if (c->tid >= 0) insert_offset2(&idx->index2[b->core.tid], b, last_off); + if (c->tid >= 0 && !(c->flag & BAM_FUNMAP)) insert_offset2(&idx->index2[b->core.tid], b, last_off); if (c->bin != last_bin) { // then possibly write the binning index if (save_bin != 0xffffffffu) // save_bin==0xffffffffu only happens to the first record insert_offset(idx->index[save_tid], save_bin, save_off, last_off); @@ -203,7 +207,7 @@ bam_index_t *bam_index_core(bamFile fp) if (bam_tell(fp) <= last_off) { fprintf(stderr, "[bam_index_core] bug in BGZF/RAZF: %llx < %llx\n", (unsigned long long)bam_tell(fp), (unsigned long long)last_off); - exit(1); + return NULL; } if (c->flag & BAM_FUNMAP) ++n_unmapped; else ++n_mapped; @@ -212,13 +216,20 @@ bam_index_t *bam_index_core(bamFile fp) } if (save_tid >= 0) { insert_offset(idx->index[save_tid], save_bin, save_off, bam_tell(fp)); - insert_offset(idx->index[save_tid], BAM_MAX_BIN, off_beg, off_end); + insert_offset(idx->index[save_tid], BAM_MAX_BIN, off_beg, bam_tell(fp)); insert_offset(idx->index[save_tid], BAM_MAX_BIN, n_mapped, n_unmapped); } merge_chunks(idx); fill_missing(idx); - if (ret >= 0) - while ((ret = bam_read1(fp, b)) >= 0) ++n_no_coor; + if (ret >= 0) { + while ((ret = bam_read1(fp, b)) >= 0) { + ++n_no_coor; + if (c->tid >= 0 && n_no_coor) { + fprintf(stderr, "[bam_index_core] the alignment is not sorted: reads without coordinates prior to reads with coordinates.\n"); + return NULL; + } + } + } if (ret < -1) fprintf(stderr, "[bam_index_core] truncated file? Continue anyway. (%d)\n", ret); free(b->data); free(b); idx->n_no_coor = n_no_coor; @@ -248,10 +259,16 @@ void bam_index_save(const bam_index_t *idx, FILE *fp) { int32_t i, size; khint_t k; - fwrite("BAI\1", 1, 4, fp); + if (fwrite("BAI\1", 1, 4, fp) < 4) { + fprintf(stderr, "[bam_index_save] failed to write magic number.\n"); + abort(); + } if (bam_is_be) { uint32_t x = idx->n; - fwrite(bam_swap_endian_4p(&x), 4, 1, fp); + if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_ref.\n"); + abort(); + } } else fwrite(&idx->n, 4, 1, fp); for (i = 0; i < idx->n; ++i) { khash_t(i) *index = idx->index[i]; @@ -260,49 +277,91 @@ void bam_index_save(const bam_index_t *idx, FILE *fp) size = kh_size(index); if (bam_is_be) { // big endian uint32_t x = size; - fwrite(bam_swap_endian_4p(&x), 4, 1, fp); - } else fwrite(&size, 4, 1, fp); + if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_bin.\n"); + abort(); + } + } else if (fwrite(&size, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_bin.\n"); + abort(); + } for (k = kh_begin(index); k != kh_end(index); ++k) { if (kh_exist(index, k)) { bam_binlist_t *p = &kh_value(index, k); if (bam_is_be) { // big endian uint32_t x; - x = kh_key(index, k); fwrite(bam_swap_endian_4p(&x), 4, 1, fp); - x = p->n; fwrite(bam_swap_endian_4p(&x), 4, 1, fp); + x = kh_key(index, k); + if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write bin.\n"); + abort(); + } + x = p->n; + if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_chunk.\n"); + abort(); + } for (x = 0; (int)x < p->n; ++x) { bam_swap_endian_8p(&p->list[x].u); bam_swap_endian_8p(&p->list[x].v); } - fwrite(p->list, 16, p->n, fp); + if (fwrite(p->list, 16, p->n, fp) < p->n) { + fprintf(stderr, "[bam_index_save] failed to write chunk pair.\n"); + abort(); + } + // hmmm...sandbagging PPC or reverting? for (x = 0; (int)x < p->n; ++x) { bam_swap_endian_8p(&p->list[x].u); bam_swap_endian_8p(&p->list[x].v); } } else { - fwrite(&kh_key(index, k), 4, 1, fp); - fwrite(&p->n, 4, 1, fp); - fwrite(p->list, 16, p->n, fp); + if (fwrite(&kh_key(index, k), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write bin.\n"); + abort(); + } + if (fwrite(&p->n, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_chunk.\n"); + abort(); + } + if (fwrite(p->list, 16, p->n, fp) < p->n) { + fprintf(stderr, "[bam_index_save] failed to write chunk pair.\n"); + abort(); + } } } } // write linear index (index2) if (bam_is_be) { int x = index2->n; - fwrite(bam_swap_endian_4p(&x), 4, 1, fp); - } else fwrite(&index2->n, 4, 1, fp); + if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_intv.\n"); + abort(); + } + } else if (fwrite(&index2->n, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_intv.\n"); + abort(); + } if (bam_is_be) { // big endian int x; for (x = 0; (int)x < index2->n; ++x) bam_swap_endian_8p(&index2->offset[x]); - fwrite(index2->offset, 8, index2->n, fp); + if (fwrite(index2->offset, 8, index2->n, fp) < index2->n) { + fprintf(stderr, "[bam_index_save] failed to write ioffset.\n"); + abort(); + } for (x = 0; (int)x < index2->n; ++x) bam_swap_endian_8p(&index2->offset[x]); - } else fwrite(index2->offset, 8, index2->n, fp); + } else if (fwrite(index2->offset, 8, index2->n, fp) < index2->n) { + fprintf(stderr, "[bam_index_save] failed to write ioffset.\n"); + abort(); + } } { // write the number of reads coor-less records. uint64_t x = idx->n_no_coor; if (bam_is_be) bam_swap_endian_8p(&x); - fwrite(&x, 8, 1, fp); + if (fwrite(&x, 8, 1, fp) < 1) { + fprintf(stderr, "[bam_index_save] failed to write n_no_coor.\n"); + abort(); + } } fflush(fp); } @@ -316,14 +375,22 @@ static bam_index_t *bam_index_load_core(FILE *fp) fprintf(stderr, "[bam_index_load_core] fail to load index.\n"); return 0; } - fread(magic, 1, 4, fp); + if (fread(magic, 1, 4, fp) < 4) { + fprintf(stderr, "[bam_index_load] failed to read magic number.\n"); + fclose(fp); + return 0; + } if (strncmp(magic, "BAI\1", 4)) { fprintf(stderr, "[bam_index_load] wrong magic number.\n"); fclose(fp); return 0; } idx = (bam_index_t*)calloc(1, sizeof(bam_index_t)); - fread(&idx->n, 4, 1, fp); + if (fread(&idx->n, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_load] failed to read n_ref field.\n"); + fclose(fp); + return 0; + } if (bam_is_be) bam_swap_endian_4p(&idx->n); idx->index = (khash_t(i)**)calloc(idx->n, sizeof(void*)); idx->index2 = (bam_lidx_t*)calloc(idx->n, sizeof(bam_lidx_t)); @@ -336,18 +403,34 @@ static bam_index_t *bam_index_load_core(FILE *fp) bam_binlist_t *p; index = idx->index[i] = kh_init(i); // load binning index - fread(&size, 4, 1, fp); + if (fread(&size, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_load] read error while loading n_bin.\n"); + fclose(fp); + return 0; + } if (bam_is_be) bam_swap_endian_4p(&size); for (j = 0; j < (int)size; ++j) { - fread(&key, 4, 1, fp); + if (fread(&key, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_load] read error while loading bin.\n"); + fclose(fp); + return 0; + } if (bam_is_be) bam_swap_endian_4p(&key); k = kh_put(i, index, key, &ret); p = &kh_value(index, k); - fread(&p->n, 4, 1, fp); + if (fread(&p->n, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_load] read error while loading n_chunk.\n"); + fclose(fp); + return 0; + } if (bam_is_be) bam_swap_endian_4p(&p->n); p->m = p->n; p->list = (pair64_t*)malloc(p->m * 16); - fread(p->list, 16, p->n, fp); + if (fread(p->list, 16, p->n, fp) < p->n) { + fprintf(stderr, "[bam_index_load] read error while loading chunk pairs.\n"); + fclose(fp); + return 0; + } if (bam_is_be) { int x; for (x = 0; x < p->n; ++x) { @@ -357,11 +440,20 @@ static bam_index_t *bam_index_load_core(FILE *fp) } } // load linear index - fread(&index2->n, 4, 1, fp); + if (fread(&index2->n, 4, 1, fp) < 1) { + fprintf(stderr, "[bam_index_load] read error while loading n_intv.\n"); + fclose(fp); + return 0; + } if (bam_is_be) bam_swap_endian_4p(&index2->n); index2->m = index2->n; index2->offset = (uint64_t*)calloc(index2->m, 8); - fread(index2->offset, index2->n, 8, fp); + ret = fread(index2->offset, index2->n, 8, fp); + if ((ret > 0) && (ret < 8)) { + fprintf(stderr, "[bam_index_load] read error while loading ioffset.\n"); + fclose(fp); + return 0; + } if (bam_is_be) for (j = 0; j < index2->n; ++j) bam_swap_endian_8p(&index2->offset[j]); } @@ -427,7 +519,10 @@ static void download_from_remote(const char *url) } buf = (uint8_t*)calloc(buf_size, 1); while ((l = knet_read(fp_remote, buf, buf_size)) != 0) - fwrite(buf, 1, l, fp); + if (fwrite(buf, 1, l, fp) < l) { + fprintf(stderr, "[download_from_remote] fail to write to destination file.\n"); + break; + } free(buf); fclose(fp); knet_close(fp_remote); @@ -466,6 +561,10 @@ int bam_index_build2(const char *fn, const char *_fnidx) } idx = bam_index_core(fp); bam_close(fp); + if(idx == 0) { + fprintf(stderr, "[bam_index_build2] fail to index the BAM file.\n"); + return -1; + } if (_fnidx == 0) { fnidx = (char*)calloc(strlen(fn) + 5, 1); strcpy(fnidx, fn); strcat(fnidx, ".bai"); @@ -608,6 +707,9 @@ bam_iter_t bam_iter_query(const bam_index_t *idx, int tid, int beg, int end) } } free(bins); + if (n_off == 0) { + free(off); return iter; + } { bam1_t *b = (bam1_t*)calloc(1, sizeof(bam1_t)); int l; @@ -695,6 +797,7 @@ int bam_fetch(bamFile fp, const bam_index_t *idx, int tid, int beg, int end, voi b = bam_init1(); iter = bam_iter_query(idx, tid, beg, end); while ((ret = bam_iter_read(fp, iter, b)) >= 0) func(b, data); + bam_iter_destroy(iter); bam_destroy1(b); return (ret == -1)? 0 : ret; }