Compile in pedantic mode and fail compilation on warnings. Also cleanup all existing warnings.

4 files changed, 165 insertions, 82 deletions

diff --git a/src/backends/jerasure/jerasure_rs_cauchy.c b/src/backends/jerasure/jerasure_rs_cauchy.c
index 40a6f11..042166a 100644
--- a/src/backends/jerasure/jerasure_rs_cauchy.c
+++ b/src/backends/jerasure/jerasure_rs_cauchy.c
@@ -37,6 +37,17 @@
 struct ec_backend_op_stubs jerasure_rs_cauchy_ops;
 struct ec_backend jerasure_rs_cauchy;
 
+typedef int* (*cauchy_original_coding_matrix_func)(int, int, int);
+typedef int* (*jerasure_matrix_to_bitmatrix_func)(int, int, int, int *);
+typedef int** (*jerasure_smart_bitmatrix_to_schedule_func)(int, int, int, int *);
+typedef void (*jerasure_bitmatrix_encode_func)(int, int, int, int *, char **, char **, int, int);
+typedef int (*jerasure_bitmatrix_decode_func)(int, int, int, int *, int, int *,char **, char **, int, int);
+typedef int * (*jerasure_erasures_to_erased_func)(int, int, int *);
+typedef int (*jerasure_make_decoding_bitmatrix_func)(int, int, int, int *, int *, int *, int *);
+typedef void (*jerasure_bitmatrix_dotprod_func)(int, int, int *, int *, int,char **, char **, int, int);
+
+
+
 /*
  * ToDo (KMG): Should we make this a parameter, or is that
  * exposing too much b.s. to the client?
@@ -45,22 +56,22 @@ struct ec_backend jerasure_rs_cauchy;
 
 struct jerasure_rs_cauchy_descriptor {
     /* calls required for init */
-    int * (*cauchy_original_coding_matrix)(int, int, int);
-    int * (*jerasure_matrix_to_bitmatrix)(int, int, int, int*);
-    int ** (*jerasure_smart_bitmatrix_to_schedule)(int, int, int, int*);
- 
+    cauchy_original_coding_matrix_func cauchy_original_coding_matrix;
+    jerasure_matrix_to_bitmatrix_func jerasure_matrix_to_bitmatrix;
+    jerasure_smart_bitmatrix_to_schedule_func jerasure_smart_bitmatrix_to_schedule;
+
     /* calls required for encode */
-    void (*jerasure_bitmatrix_encode)(int, int, int, int *, char **, char **, int, int);
+    jerasure_bitmatrix_encode_func jerasure_bitmatrix_encode;
                             
     
     /* calls required for decode */
-    int (*jerasure_bitmatrix_decode)(int, int, int, int *, int, int *,char **, char **, int, int);
+    jerasure_bitmatrix_decode_func jerasure_bitmatrix_decode;
                             
     
     /* calls required for reconstruct */
-    int * (*jerasure_erasures_to_erased)(int, int, int *);
-    int (*jerasure_make_decoding_bitmatrix)(int, int, int, int *, int *, int *, int *);
-    void (*jerasure_bitmatrix_dotprod)(int, int, int *, int *, int,char **, char **, int, int);
+    jerasure_erasures_to_erased_func jerasure_erasures_to_erased;
+    jerasure_make_decoding_bitmatrix_func jerasure_make_decoding_bitmatrix;
+    jerasure_bitmatrix_dotprod_func jerasure_bitmatrix_dotprod;
 
     /* fields needed to hold state */
     int *matrix;
@@ -93,7 +104,7 @@ static int jerasure_rs_cauchy_decode(void *desc, char **data, char **parity,
         (struct jerasure_rs_cauchy_descriptor*)desc;
 
     /* FIXME - make jerasure_matrix_decode return a value */
-    jerasure_desc->jerasure_bitmatrix_decode(jerasure_desc->k, 
+    return jerasure_desc->jerasure_bitmatrix_decode(jerasure_desc->k, 
                                              jerasure_desc->m, 
                                              jerasure_desc->w, 
                                              jerasure_desc->bitmatrix, 
@@ -181,7 +192,6 @@ static int jerasure_rs_cauchy_min_fragments(void *desc, int *missing_idxs,
         }
     }
 
-out:
     return ret;
 }
 
@@ -221,52 +231,77 @@ static void * jerasure_rs_cauchy_init(struct ec_backend_args *args,
             goto error;
         }
     }
+
+    /*
+     * ISO C forbids casting a void* to a function pointer.
+     * Since dlsym return returns a void*, we use this union to
+     * "transform" the void* to a function pointer.
+     */
+    union {
+        cauchy_original_coding_matrix_func  initp;
+        jerasure_matrix_to_bitmatrix_func matrixtobitmatrixp;
+        jerasure_smart_bitmatrix_to_schedule_func matrixschedulep;
+        jerasure_bitmatrix_encode_func encodep;
+        jerasure_bitmatrix_decode_func decodep;
+        jerasure_erasures_to_erased_func erasedp; 
+        jerasure_make_decoding_bitmatrix_func decodematrixp;
+        jerasure_bitmatrix_dotprod_func dotprodp;
+        void *vptr;
+    } func_handle = {.vptr = NULL};
     
     /* fill in function addresses */
-    desc->jerasure_bitmatrix_encode = dlsym(
-            backend_sohandle, "jerasure_bitmatrix_encode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_encode");
+    desc->jerasure_bitmatrix_encode = func_handle.encodep;
     if (NULL == desc->jerasure_bitmatrix_encode) {
         goto error; 
     }
   
-    desc->jerasure_bitmatrix_decode = dlsym(
-            backend_sohandle, "jerasure_bitmatrix_decode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_decode");
+    desc->jerasure_bitmatrix_decode = func_handle.decodep;
     if (NULL == desc->jerasure_bitmatrix_decode) {
         goto error; 
     }
   
-    desc->cauchy_original_coding_matrix = dlsym(
-            backend_sohandle, "cauchy_original_coding_matrix");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "cauchy_original_coding_matrix");
+    desc->cauchy_original_coding_matrix = func_handle.initp;
     if (NULL == desc->cauchy_original_coding_matrix) {
         goto error; 
     }
     
-    desc->jerasure_matrix_to_bitmatrix = dlsym(
-            backend_sohandle, "jerasure_matrix_to_bitmatrix");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_to_bitmatrix");
+    desc->jerasure_matrix_to_bitmatrix = func_handle.matrixtobitmatrixp;
     if (NULL == desc->jerasure_matrix_to_bitmatrix) {
         goto error; 
     }
     
-    desc->jerasure_smart_bitmatrix_to_schedule = dlsym(
-            backend_sohandle, "jerasure_smart_bitmatrix_to_schedule");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_smart_bitmatrix_to_schedule");
+    desc->jerasure_smart_bitmatrix_to_schedule = func_handle.matrixschedulep;
     if (NULL == desc->jerasure_smart_bitmatrix_to_schedule) {
         goto error; 
     }
     
-    desc->jerasure_make_decoding_bitmatrix = dlsym(
-            backend_sohandle, "jerasure_make_decoding_bitmatrix");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_make_decoding_bitmatrix");
+    desc->jerasure_make_decoding_bitmatrix = func_handle.decodematrixp;
     if (NULL == desc->jerasure_make_decoding_bitmatrix) {
         goto error; 
     }
     
-    desc->jerasure_bitmatrix_dotprod = dlsym(
-            backend_sohandle, "jerasure_bitmatrix_dotprod");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_dotprod");
+    desc->jerasure_bitmatrix_dotprod = func_handle.dotprodp;
     if (NULL == desc->jerasure_bitmatrix_dotprod) {
         goto error; 
     }
   
-    desc->jerasure_erasures_to_erased = dlsym(
-            backend_sohandle, "jerasure_erasures_to_erased");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_erasures_to_erased");
+    desc->jerasure_erasures_to_erased = func_handle.erasedp;
     if (NULL == desc->jerasure_erasures_to_erased) {
         goto error; 
     } 
@@ -324,6 +359,7 @@ static int jerasure_rs_cauchy_exit(void *desc)
         free(jerasure_desc->schedule);
     }
     free(desc);
+    return 0;
 }
 
 struct ec_backend_op_stubs jerasure_rs_cauchy_op_stubs = {
diff --git a/src/backends/jerasure/jerasure_rs_vand.c b/src/backends/jerasure/jerasure_rs_vand.c
index 3392a24..5866cd5 100644
--- a/src/backends/jerasure/jerasure_rs_vand.c
+++ b/src/backends/jerasure/jerasure_rs_vand.c
@@ -37,20 +37,27 @@
 struct ec_backend_op_stubs jerasure_rs_vand_ops;
 struct ec_backend jerasure_rs_vand;
 
+typedef int* (*reed_sol_vandermonde_coding_matrix_func)(int, int, int);
+typedef void (*jerasure_matrix_encode_func)(int, int, int, int*, char **, char **, int); 
+typedef int (*jerasure_matrix_decode_func)(int, int, int, int *, int, int*, char **, char **, int);
+typedef int (*jerasure_make_decoding_matrix_func)(int, int, int, int *, int *, int *, int *);
+typedef int * (*jerasure_erasures_to_erased_func)(int, int, int *);
+typedef void (*jerasure_matrix_dotprod_func)(int, int, int *,int *, int,char **, char **, int);
+
 struct jerasure_rs_vand_descriptor {
     /* calls required for init */
-    int * (*reed_sol_vandermonde_coding_matrix)(int, int, int);
+    reed_sol_vandermonde_coding_matrix_func reed_sol_vandermonde_coding_matrix;
  
     /* calls required for encode */
-    void (*jerasure_matrix_encode)(int, int, int, int*, char **, char **, int); 
+    jerasure_matrix_encode_func jerasure_matrix_encode;
     
     /* calls required for decode */
-    int (*jerasure_matrix_decode)(int, int, int, int *, int, int*, char **, char **, int);
+    jerasure_matrix_decode_func jerasure_matrix_decode;
     
     /* calls required for reconstruct */
-    int (*jerasure_make_decoding_matrix)(int, int, int, int *, int *, int *, int *);
-    int * (*jerasure_erasures_to_erased)(int, int, int *);
-    void (*jerasure_matrix_dotprod)(int, int, int *,int *, int,char **, char **, int);
+    jerasure_make_decoding_matrix_func jerasure_make_decoding_matrix;
+    jerasure_erasures_to_erased_func jerasure_erasures_to_erased;
+    jerasure_matrix_dotprod_func jerasure_matrix_dotprod;
 
     /* fields needed to hold state */
     int *matrix;
@@ -161,7 +168,6 @@ static int jerasure_rs_vand_min_fragments(void *desc, int *missing_idxs,
         }
     }
 
-out:
     return ret;
 }
 
@@ -198,39 +204,61 @@ static void * jerasure_rs_vand_init(struct ec_backend_args *args,
         }
      }
 
+     /*
+     * ISO C forbids casting a void* to a function pointer.
+     * Since dlsym return returns a void*, we use this union to
+     * "transform" the void* to a function pointer.
+     */
+    union {
+        reed_sol_vandermonde_coding_matrix_func initp;
+        jerasure_matrix_encode_func encodep;
+        jerasure_matrix_decode_func decodep;
+        jerasure_make_decoding_matrix_func decodematrixp;
+        jerasure_erasures_to_erased_func erasep;
+        jerasure_matrix_dotprod_func dotprodp;
+        void *vptr;
+    } func_handle = {.vptr = NULL};
+
+
     /* fill in function addresses */
-    desc->jerasure_matrix_encode = dlsym( 
-            backend_sohandle, "jerasure_matrix_encode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_encode");
+    desc->jerasure_matrix_encode = func_handle.encodep;
     if (NULL == desc->jerasure_matrix_encode) {
         goto error; 
     }
   
-    desc->jerasure_matrix_decode = dlsym(
-            backend_sohandle, "jerasure_matrix_decode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_decode");
+    desc->jerasure_matrix_decode = func_handle.decodep;
     if (NULL == desc->jerasure_matrix_decode) {
         goto error; 
     }
   
-    desc->jerasure_make_decoding_matrix = dlsym(
-            backend_sohandle, "jerasure_make_decoding_matrix");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_make_decoding_matrix");
+    desc->jerasure_make_decoding_matrix = func_handle.decodematrixp;
     if (NULL == desc->jerasure_make_decoding_matrix) {
         goto error; 
     }
   
-    desc->jerasure_matrix_dotprod = dlsym(
-            backend_sohandle, "jerasure_matrix_dotprod");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_dotprod");
+    desc->jerasure_matrix_dotprod = func_handle.dotprodp;
     if (NULL == desc->jerasure_matrix_dotprod) {
         goto error; 
     }
   
-    desc->jerasure_erasures_to_erased = dlsym(
-            backend_sohandle, "jerasure_erasures_to_erased");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "jerasure_erasures_to_erased");
+    desc->jerasure_erasures_to_erased = func_handle.erasep;
     if (NULL == desc->jerasure_erasures_to_erased) {
         goto error; 
     }
  
-    desc->reed_sol_vandermonde_coding_matrix = dlsym(
-            backend_sohandle, "reed_sol_vandermonde_coding_matrix");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "reed_sol_vandermonde_coding_matrix");
+    desc->reed_sol_vandermonde_coding_matrix = func_handle.initp;
     if (NULL == desc->reed_sol_vandermonde_coding_matrix) {
         goto error; 
     }
@@ -273,6 +301,8 @@ static int jerasure_rs_vand_exit(void *desc)
     jerasure_desc = (struct jerasure_rs_vand_descriptor*) desc;
 
     free(jerasure_desc);
+
+    return 0;
 }
 
 struct ec_backend_op_stubs jerasure_rs_vand_op_stubs = {
diff --git a/src/backends/null/null.c b/src/backends/null/null.c
index ab4215f..f71312c 100644
--- a/src/backends/null/null.c
+++ b/src/backends/null/null.c
@@ -36,25 +36,27 @@
 struct ec_backend null;
 struct ec_backend_op_stubs null_ops;
 
+typedef void* (*init_null_code_func)(int, int, int);
+typedef int (*null_code_encode_func)(void *, char **, char **, int);
+typedef int (*null_code_decode_func)(void *, char **, char **, int *, int, int);
+typedef int (*null_reconstruct_func)(char  **, int, uint64_t, int, char *);
+typedef int (*null_code_fragments_needed_func)(void *, int *, int *, int *);
+
 struct null_descriptor {
     /* calls required for init */
-    void* (*init_null_code)(int k, int m, int hd); 
+    init_null_code_func init_null_code;
 
     /* calls required for encode */
-    int (*null_code_encode)(void *code_desc, char **data, char **parity,
-            int blocksize); 
+    null_code_encode_func null_code_encode;
 
     /* calls required for decode */
-    int (*null_code_decode)(void *code_desc, char **data, char **parity,
-            int *missing_idxs, int blocksize, int decode_parity);
+    null_code_decode_func null_code_decode;
 
     /* calls required for reconstruct */
-    int (*null_reconstruct)(char **available_fragments, int num_fragments,
-            uint64_t fragment_len, int destination_idx, char* out_fragment);
+    null_reconstruct_func null_reconstruct;
 
     /* set of fragments needed to reconstruct at a minimum */
-    int (*null_code_fragments_needed)(void *code_desc, int *missing_idxs,
-            int *fragments_to_exclude, int *fragments_needed);
+    null_code_fragments_needed_func null_code_fragments_needed;
 
     /* fields needed to hold state */
     int *matrix;
@@ -68,32 +70,24 @@ struct null_descriptor {
 
 static int null_encode(void *desc, char **data, char **parity, int blocksize)
 {
-    struct null_descriptor *xdesc = (struct null_descriptor *) desc;
-
     return 0;
 }
 
 static int null_decode(void *desc, char **data, char **parity,
         int *missing_idxs, int blocksize)
 {
-    struct null_descriptor *xdesc = (struct null_descriptor *) desc;
-
     return 0;
 }
 
 static int null_reconstruct(void *desc, char **data, char **parity,
         int *missing_idxs, int destination_idx, int blocksize)
 {
-    struct null_descriptor *xdesc = (struct null_descriptor *) desc;
-
     return 0;
 }
 
 static int null_min_fragments(void *desc, int *missing_idxs,
         int *fragments_to_exclude, int *fragments_needed)
 {
-    struct null_descriptor *xdesc = (struct null_descriptor *) desc;
-
     return 0;
 }
 
@@ -143,33 +137,52 @@ static void * null_init(struct ec_backend_args *args, void *backend_sohandle)
         }
     }
 
+    /*
+     * ISO C forbids casting a void* to a function pointer.
+     * Since dlsym return returns a void*, we use this union to
+     * "transform" the void* to a function pointer.
+     */
+    union {
+        init_null_code_func initp;
+        null_code_encode_func encodep;
+        null_code_decode_func decodep;
+        null_reconstruct_func reconp;
+        null_code_fragments_needed_func fragsneededp;
+        void *vptr;
+    } func_handle = {.vptr = NULL};
+
     /* fill in function addresses */
-    xdesc->init_null_code = dlsym(
-            backend_sohandle, "null_code_init");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "null_code_init");
+    xdesc->init_null_code = func_handle.initp;
     if (NULL == xdesc->init_null_code) {
         goto error; 
     }
 
-    xdesc->null_code_encode = dlsym(
-            backend_sohandle, "null_code_encode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "null_code_encode");
+    xdesc->null_code_encode = func_handle.encodep;
     if (NULL == xdesc->null_code_encode) {
         goto error; 
     }
 
-    xdesc->null_code_decode = dlsym(
-            backend_sohandle, "null_code_decode");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "null_code_decode");
+    xdesc->null_code_decode = func_handle.decodep;
     if (NULL == xdesc->null_code_decode) {
         goto error; 
     }
 
-    xdesc->null_reconstruct = dlsym(
-            backend_sohandle, "null_reconstruct");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "null_reconstruct");
+    xdesc->null_reconstruct = func_handle.reconp;
     if (NULL == xdesc->null_reconstruct) {
         goto error; 
     }
 
-    xdesc->null_code_fragments_needed = dlsym(
-            backend_sohandle, "null_code_fragments_needed");
+    func_handle.vptr = NULL;
+    func_handle.vptr = dlsym(backend_sohandle, "null_code_fragments_needed");
+    xdesc->null_code_fragments_needed = func_handle.fragsneededp;
     if (NULL == xdesc->null_code_fragments_needed) {
         goto error; 
     }
@@ -187,6 +200,7 @@ static int null_exit(void *desc)
     struct null_descriptor *xdesc = (struct null_descriptor *) desc;
 
     free (xdesc);
+    return 0;
 }
 
 struct ec_backend_op_stubs null_op_stubs = {
diff --git a/src/backends/xor/flat_xor_hd.c b/src/backends/xor/flat_xor_hd.c
index a9faf2c..289f36e 100644
--- a/src/backends/xor/flat_xor_hd.c
+++ b/src/backends/xor/flat_xor_hd.c
@@ -37,16 +37,17 @@
 struct ec_backend_op_stubs flat_xor_hd_ops;
 struct ec_backend flat_xor_hd;
 
+typedef xor_code_t* (*init_xor_hd_code_func)(int, int, int);
+typedef void (*xor_code_encode_func)(xor_code_t *, char **, char **, int);
+typedef int (*xor_code_decode_func)(xor_code_t *, char **, char **, int *, int, int);
+typedef int (*xor_hd_fragments_needed_func)(xor_code_t *, int *, int *, int *);
+
 struct flat_xor_hd_descriptor {
     xor_code_t *xor_desc;
-
-    xor_code_t* (*init_xor_hd_code)(int k, int m, int hd); 
-    void (*xor_code_encode)(xor_code_t *code_desc, char **data, char **parity,
-            int blocksize); 
-    int (*xor_hd_decode)(xor_code_t *code_desc, char **data, char **parity,
-            int *missing_idxs, int blocksize, int decode_parity);
-    int (*xor_hd_fragments_needed)(xor_code_t *code_desc, int *missing_idxs,
-            int *fragments_to_exclude, int *fragments_needed);
+    init_xor_hd_code_func init_xor_hd_code;
+    xor_code_encode_func  xor_code_encode;
+    xor_code_decode_func xor_code_decode;
+    xor_hd_fragments_needed_func  xor_hd_fragments_needed;
 };
 
 #define DEFAULT_W 32
@@ -59,6 +60,7 @@ static int flat_xor_hd_encode(void *desc,
 
     xor_code_t *xor_desc = (xor_code_t *) xdesc->xor_desc;
     xor_desc->encode(xor_desc, data, parity, blocksize);
+    return 0;
 }
 
 static int flat_xor_hd_decode(void *desc,
@@ -69,7 +71,7 @@ static int flat_xor_hd_decode(void *desc,
         (struct flat_xor_hd_descriptor *) desc;
 
     xor_code_t *xor_desc = (xor_code_t *) xdesc->xor_desc;
-    xor_desc->decode(xor_desc, data, parity, missing_idxs, blocksize, 1);
+    return xor_desc->decode(xor_desc, data, parity, missing_idxs, blocksize, 1);
 }
 
 static int flat_xor_hd_reconstruct(void *desc,
@@ -145,6 +147,7 @@ static int flat_xor_hd_exit(void *desc)
 
     free (bdesc->xor_desc);
     free (bdesc);
+    return 0;
 }
 
 struct ec_backend_op_stubs flat_xor_hd_op_stubs = {