bam_index.c:

	wrapped fread() and fwrite() calls with error checking

	removed unused and duplicated endian-swap after writing
	n-chunks for big-endian systems in bam_index_save()

diff --git a/bam_index.c b/bam_index.c
index 9610a2656031657b796abc68bf32c1b6f1564745..8dc7ce38171fcc830b22f3e642a13a165ee2f4a7 100644 (file)
--- a/bam_index.c
+++ b/bam_index.c
@@ -259,11 +259,23 @@ void bam_index_save(const bam_index_t *idx, FILE *fp)
 {
        int32_t i, size;
        khint_t k;
 {
        int32_t i, size;
        khint_t k;

-       fwrite("BAI\1", 1, 4, fp);
+       if (fwrite("BAI\1", 1, 4, fp) < 4) {
+               fprintf(stderr, "[%s] failed to write magic number.\n", __func__);
+               return;
+       }

        if (bam_is_be) {
                uint32_t x = idx->n;
        if (bam_is_be) {
                uint32_t x = idx->n;

-               fwrite(bam_swap_endian_4p(&x), 4, 1, fp);
-       } else fwrite(&idx->n, 4, 1, fp);
+               if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) {
+                       fprintf(stderr, "[%s] failed to write n_ref.\n", __func__);
+                       return;
+               }
+       }
+       else {
+               if (fwrite(&idx->n, 4, 1, fp) < 1) {
+                       fprintf(stderr, "[%s] failed to write n_ref.\n", __func__);
+                       return;
+               }
+       }

        for (i = 0; i < idx->n; ++i) {
                khash_t(i) *index = idx->index[i];
                bam_lidx_t *index2 = idx->index2 + i;
        for (i = 0; i < idx->n; ++i) {
                khash_t(i) *index = idx->index[i];
                bam_lidx_t *index2 = idx->index2 + i;


@@ -271,49 +283,100 @@ 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;
                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, "[%s] failed to write n_bin.\n", __func__);
+                               return;
+                       }
+               }
+               else {
+                       if (fwrite(&size, 4, 1, fp) < 1) {
+                               fprintf(stderr, "[%s] failed to write n_bin.\n", __func__);
+                               return;
+                       }
+               }

                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;
                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, "[%s] failed to write bin.\n", __func__);
+                                               return;
+                                       }
+                                       x = p->n;
+                                       if (fwrite(bam_swap_endian_4p(&x), 4, 1, fp) < 1) {
+                                               fprintf(stderr, "[%s] failed to write n_chunk.\n", __func__);
+                                               return;
+                                       }

                                        for (x = 0; (int)x < p->n; ++x) {
                                                bam_swap_endian_8p(&p->list[x].u);
                                                bam_swap_endian_8p(&p->list[x].v);
                                        }
                                        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, "[%s] failed to write %d chunks.\n", __func__, p->n);
+                                               return;
+                                       }
+                                       /*

                                        for (x = 0; (int)x < p->n; ++x) {
                                                bam_swap_endian_8p(&p->list[x].u);
                                                bam_swap_endian_8p(&p->list[x].v);
                                        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 {
+                                       if (fwrite(&kh_key(index, k), 4, 1, fp) < 1) {
+                                               fprintf(stderr, "[%s] failed to write bin.\n", __func__);
+                                               return;
+                                       }
+                                       if (fwrite(&p->n, 4, 1, fp) < 1) {
+                                               fprintf(stderr, "[%s] failed to write n_chunk.\n", __func__);
+                                               return;
+                                       }
+                                       if (fwrite(p->list, 16, p->n, fp) < p->n) {
+                                               fprintf(stderr, "[%s] failed to write %d chunks.\n", __func__, p->n);
+                                               return;

                                        }
                                        }

-                               } else {
-                                       fwrite(&kh_key(index, k), 4, 1, fp);
-                                       fwrite(&p->n, 4, 1, fp);
-                                       fwrite(p->list, 16, p->n, fp);

                                }
                        }
                }
                // write linear index (index2)
                if (bam_is_be) {
                        int x = index2->n;
                                }
                        }
                }
                // 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, "[%s] failed to write n_intv.\n", __func__);
+                               return;
+                       }
+               }
+               else {
+                       if (fwrite(&index2->n, 4, 1, fp) < 1) {
+                               fprintf(stderr, "[%s] failed to write n_intv.\n", __func__);
+                               return;
+                       }
+               }

                if (bam_is_be) { // big endian
                        int x;
                        for (x = 0; (int)x < index2->n; ++x)
                                bam_swap_endian_8p(&index2->offset[x]);
                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, "[%s] failed to write ioffset.\n", __func__);
+                               return;
+                       }

                        for (x = 0; (int)x < index2->n; ++x)
                                bam_swap_endian_8p(&index2->offset[x]);
                        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, "[%s] failed to write ioffset.\n", __func__);
+                               return;
+                       }
+               }

        }
        { // write the number of reads coor-less records.
                uint64_t x = idx->n_no_coor;
                if (bam_is_be) bam_swap_endian_8p(&x);
        }
        { // 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, "[%s] failed to write n_no_coor.\n", __func__);
+               }

        }
        fflush(fp);
 }
        }
        fflush(fp);
 }


@@ -327,14 +390,22 @@ static bam_index_t *bam_index_load_core(FILE *fp)
                fprintf(stderr, "[bam_index_load_core] fail to load index.\n");
                return 0;
        }
                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, "[%s] failed to read magic number.\n", __func__);
+               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));     
        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, "[%s] failed to read n_ref.\n", __func__);
+               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));
        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));


@@ -347,18 +418,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
                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, "[%s] failed to read n_bin.\n", __func__);
+                       fclose(fp);
+                       return 0;
+               }

                if (bam_is_be) bam_swap_endian_4p(&size);
                for (j = 0; j < (int)size; ++j) {
                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, "[%s] failed to read bin.\n", __func__);
+                               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);
                        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, "[%s] failed to read n_chunk.\n", __func__);
+                               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);
                        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, "[%s] failed to read %d chunks.\n", __func__, p->n);
+                               fclose(fp);
+                               return 0;
+                       }

                        if (bam_is_be) {
                                int x;
                                for (x = 0; x < p->n; ++x) {
                        if (bam_is_be) {
                                int x;
                                for (x = 0; x < p->n; ++x) {


@@ -368,13 +455,26 @@ static bam_index_t *bam_index_load_core(FILE *fp)
                        }
                }
                // load linear index
                        }
                }
                // load linear index

-               fread(&index2->n, 4, 1, fp);
+               if (fread(&index2->n, 4, 1, fp) < 1) {
+                       fprintf(stderr, "[%s] failed to read n_intv", __func__);
+                       fclose(fp);
+                       return 0;
+               }

                if (bam_is_be) bam_swap_endian_4p(&index2->n);
                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);
-               if (bam_is_be)
-                       for (j = 0; j < index2->n; ++j) bam_swap_endian_8p(&index2->offset[j]);
+               if (index2->n > 0) {
+                       index2->m = index2->n;
+                       index2->offset = (uint64_t*)calloc(index2->m, 8);
+                       if (fread(index2->offset, index2->n, 8, fp) < index2->n) {
+                               fprintf(stderr, "[%s] failed to read %d intervals.", __func__, index2->n);
+                               fclose(fp);
+                               return 0;
+                       }
+                       if (bam_is_be) {
+                               for (j = 0; j < index2->n; ++j) {
+                                       bam_swap_endian_8p(&index2->offset[j]);
+                               }
+                       }
+               }

        }
        if (fread(&idx->n_no_coor, 8, 1, fp) == 0) idx->n_no_coor = 0;
        if (bam_is_be) bam_swap_endian_8p(&idx->n_no_coor);
        }
        if (fread(&idx->n_no_coor, 8, 1, fp) == 0) idx->n_no_coor = 0;
        if (bam_is_be) bam_swap_endian_8p(&idx->n_no_coor);


@@ -437,8 +537,12 @@ static void download_from_remote(const char *url)
                return;
        }
        buf = (uint8_t*)calloc(buf_size, 1);
                return;
        }
        buf = (uint8_t*)calloc(buf_size, 1);

-       while ((l = knet_read(fp_remote, buf, buf_size)) != 0)
-               fwrite(buf, 1, l, fp);
+       while ((l = knet_read(fp_remote, buf, buf_size)) != 0) {
+               if (fwrite(buf, 1, l, fp) < l) {
+                       fprintf(stderr, "[%s] fail to write to destination file.\n", __func__);
+                       break;
+               }
+       }

        free(buf);
        fclose(fp);
        knet_close(fp_remote);
        free(buf);
        fclose(fp);
        knet_close(fp_remote);