[ismrmrd] 65/177: harden checks for valid pointers
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Wed Jan 14 20:02:03 UTC 2015
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to annotated tag v1.1.0.beta.1
in repository ismrmrd.
commit 7f21bbdade2259b0a65d9ca3096849407780bfe5
Author: Ghislain Antony Vaillant <ghisvail at gmail.com>
Date: Fri Sep 19 18:04:32 2014 +0100
harden checks for valid pointers
---
libsrc/ismrmrd.c | 441 +++++++++++++++++++++++++++++++------------------------
1 file changed, 251 insertions(+), 190 deletions(-)
diff --git a/libsrc/ismrmrd.c b/libsrc/ismrmrd.c
index b4fcf5c..2607d3c 100644
--- a/libsrc/ismrmrd.c
+++ b/libsrc/ismrmrd.c
@@ -30,22 +30,28 @@ extern "C" {
/* Acquisition functions */
void ismrmrd_init_acquisition_header(ISMRMRD_AcquisitionHeader *hdr) {
- memset(hdr, 0, sizeof(ISMRMRD_AcquisitionHeader));
- hdr->version = ISMRMRD_VERSION;
- hdr->number_of_samples = 0;
- hdr->available_channels = 1;
- hdr->active_channels = 1;
+ if (hdr) {
+ memset(hdr, 0, sizeof(ISMRMRD_AcquisitionHeader));
+ hdr->version = ISMRMRD_VERSION;
+ hdr->number_of_samples = 0;
+ hdr->available_channels = 1;
+ hdr->active_channels = 1;
+ }
}
void ismrmrd_init_acquisition(ISMRMRD_Acquisition *acq) {
- ismrmrd_init_acquisition_header(&acq->head);
- acq->traj = NULL;
- acq->data = NULL;
+ if (acq) {
+ ismrmrd_init_acquisition_header(&acq->head);
+ acq->traj = NULL;
+ acq->data = NULL;
+ }
}
void ismrmrd_cleanup_acquisition(ISMRMRD_Acquisition *acq) {
- free(acq->data); acq->data = NULL;
- free(acq->traj); acq->traj = NULL;
+ if (acq) {
+ free(acq->data); acq->data = NULL;
+ free(acq->traj); acq->traj = NULL;
+ }
}
ISMRMRD_Acquisition * ismrmrd_create_acquisition() {
@@ -55,44 +61,52 @@ ISMRMRD_Acquisition * ismrmrd_create_acquisition() {
}
void ismrmrd_free_acquisition(ISMRMRD_Acquisition *acq) {
- ismrmrd_cleanup_acquisition(acq);
- free(acq);
+ if (acq) {
+ ismrmrd_cleanup_acquisition(acq);
+ free(acq);
+ }
}
void ismrmrd_copy_acquisition(ISMRMRD_Acquisition *acqdest, const ISMRMRD_Acquisition *acqsource) {
- /* Copy the header */
- memcpy(&acqdest->head, &acqsource->head, sizeof(ISMRMRD_AcquisitionHeader));
- /* Reallocate memory for the trajectory and the data*/
- ismrmrd_make_consistent_acquisition(acqdest);
- /* Copy the trajectory and the data */
- memcpy(acqdest->traj, acqsource->traj, ismrmrd_size_of_acquisition_traj(acqsource));
- memcpy(acqdest->data, acqsource->data, ismrmrd_size_of_acquisition_data(acqsource));
+ if (acqsource) {
+ if (acqdest) {
+ /* Copy the header */
+ memcpy(&acqdest->head, &acqsource->head, sizeof(ISMRMRD_AcquisitionHeader));
+ /* Reallocate memory for the trajectory and the data*/
+ ismrmrd_make_consistent_acquisition(acqdest);
+ /* Copy the trajectory and the data */
+ memcpy(acqdest->traj, acqsource->traj, ismrmrd_size_of_acquisition_traj(acqsource));
+ memcpy(acqdest->data, acqsource->data, ismrmrd_size_of_acquisition_data(acqsource));
+ }
+ }
}
int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq) {
- size_t traj_size, data_size;
-
- if (acq->head.available_channels < acq->head.active_channels) {
- acq->head.available_channels = acq->head.active_channels;
- }
-
- traj_size = ismrmrd_size_of_acquisition_traj(acq);
- if (traj_size > 0) {
- acq->traj = (float *)realloc(acq->traj, traj_size);
- if (acq->traj == NULL) {
- ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
- "Failed to realloc acquisition trajectory array");
- return ISMRMRD_MEMORYERROR;
+ if (acq) {
+ size_t traj_size, data_size;
+
+ if (acq->head.available_channels < acq->head.active_channels) {
+ acq->head.available_channels = acq->head.active_channels;
}
- }
-
- data_size = ismrmrd_size_of_acquisition_data(acq);
- if (data_size > 0) {
- acq->data = (complex_float_t *)realloc(acq->data, data_size);
- if (acq->data == NULL) {
- ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
- "Failed to realloc acquisition data array");
- return ISMRMRD_MEMORYERROR;
+
+ traj_size = ismrmrd_size_of_acquisition_traj(acq);
+ if (traj_size > 0) {
+ acq->traj = (float *)realloc(acq->traj, traj_size);
+ if (acq->traj == NULL) {
+ ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
+ "Failed to realloc acquisition trajectory array");
+ return ISMRMRD_MEMORYERROR;
+ }
+ }
+
+ data_size = ismrmrd_size_of_acquisition_data(acq);
+ if (data_size > 0) {
+ acq->data = (complex_float_t *)realloc(acq->data, data_size);
+ if (acq->data == NULL) {
+ ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
+ "Failed to realloc acquisition data array");
+ return ISMRMRD_MEMORYERROR;
+ }
}
}
@@ -100,29 +114,39 @@ int ismrmrd_make_consistent_acquisition(ISMRMRD_Acquisition *acq) {
}
size_t ismrmrd_size_of_acquisition_traj(const ISMRMRD_Acquisition *acq) {
- int num_traj = acq->head.number_of_samples * acq->head.trajectory_dimensions;
- return num_traj * sizeof(*acq->traj);
+ if (acq) {
+ int num_traj = acq->head.number_of_samples * acq->head.trajectory_dimensions;
+ return num_traj * sizeof(*acq->traj);
+ }
+ return 0;
}
size_t ismrmrd_size_of_acquisition_data(const ISMRMRD_Acquisition *acq) {
- int num_data = acq->head.number_of_samples * acq->head.active_channels;
- return num_data * sizeof(*acq->data);
+ if (acq) {
+ int num_data = acq->head.number_of_samples * acq->head.active_channels;
+ return num_data * sizeof(*acq->data);
+ }
+ return 0;
}
/* Image functions */
void ismrmrd_init_image_header(ISMRMRD_ImageHeader *hdr) {
- memset(hdr, 0, sizeof(ISMRMRD_ImageHeader));
- hdr->version = ISMRMRD_VERSION;
- hdr->matrix_size[0] = 0;
- hdr->matrix_size[1] = 1;
- hdr->matrix_size[2] = 1;
- hdr->channels = 1;
+ if (hdr) {
+ memset(hdr, 0, sizeof(ISMRMRD_ImageHeader));
+ hdr->version = ISMRMRD_VERSION;
+ hdr->matrix_size[0] = 0;
+ hdr->matrix_size[1] = 1;
+ hdr->matrix_size[2] = 1;
+ hdr->channels = 1;
+ }
}
void ismrmrd_init_image(ISMRMRD_Image *im) {
- ismrmrd_init_image_header(&im->head);
- im->attribute_string = NULL;
- im->data = NULL;
+ if (im) {
+ ismrmrd_init_image_header(&im->head);
+ im->attribute_string = NULL;
+ im->data = NULL;
+ }
}
ISMRMRD_Image * ismrmrd_create_image() {
@@ -132,43 +156,53 @@ ISMRMRD_Image * ismrmrd_create_image() {
}
void ismrmrd_cleanup_image(ISMRMRD_Image *im) {
- free(im->attribute_string); im->attribute_string = NULL;
- free(im->data); im->data = NULL;
+ if (im) {
+ free(im->attribute_string); im->attribute_string = NULL;
+ free(im->data); im->data = NULL;
+ }
}
void ismrmrd_free_image(ISMRMRD_Image *im) {
- ismrmrd_cleanup_image(im);
- free(im);
+ if (im) {
+ ismrmrd_cleanup_image(im);
+ free(im);
+ }
}
void ismrmrd_copy_image(ISMRMRD_Image *imdest, const ISMRMRD_Image *imsource) {
- memcpy(&imdest->head, &imsource->head, sizeof(ISMRMRD_ImageHeader));
- ismrmrd_make_consistent_image(imdest);
- memcpy(&imdest->attribute_string, &imsource->attribute_string,
- ismrmrd_size_of_image_attribute_string(imdest));
- memcpy(&imdest->data, &imsource->data, ismrmrd_size_of_image_data(imdest));
+ if (imsource) {
+ if (imdest) {
+ memcpy(&imdest->head, &imsource->head, sizeof(ISMRMRD_ImageHeader));
+ ismrmrd_make_consistent_image(imdest);
+ memcpy(&imdest->attribute_string, &imsource->attribute_string,
+ ismrmrd_size_of_image_attribute_string(imdest));
+ memcpy(&imdest->data, &imsource->data, ismrmrd_size_of_image_data(imdest));
+ }
+ }
}
int ismrmrd_make_consistent_image(ISMRMRD_Image *im) {
- size_t attr_size, data_size;
-
- attr_size = ismrmrd_size_of_image_attribute_string(im);
- if (attr_size > 0) {
- im->attribute_string = (char *)realloc(im->attribute_string, attr_size);
- if (im->attribute_string == NULL) {
- ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
- "Failed to realloc image attribute string");
- return ISMRMRD_MEMORYERROR;
+ if (im) {
+ size_t attr_size, data_size;
+
+ attr_size = ismrmrd_size_of_image_attribute_string(im);
+ if (attr_size > 0) {
+ im->attribute_string = (char *)realloc(im->attribute_string, attr_size);
+ if (im->attribute_string == NULL) {
+ ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
+ "Failed to realloc image attribute string");
+ return ISMRMRD_MEMORYERROR;
+ }
}
- }
-
- data_size = ismrmrd_size_of_image_data(im);
- if (data_size > 0) {
- im->data = realloc(im->data, data_size);
- if (im->data == NULL) {
- ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
- "Failed to realloc image data array");
- return ISMRMRD_MEMORYERROR;
+
+ data_size = ismrmrd_size_of_image_data(im);
+ if (data_size > 0) {
+ im->data = realloc(im->data, data_size);
+ if (im->data == NULL) {
+ ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
+ "Failed to realloc image data array");
+ return ISMRMRD_MEMORYERROR;
+ }
}
}
@@ -176,58 +210,66 @@ int ismrmrd_make_consistent_image(ISMRMRD_Image *im) {
}
size_t ismrmrd_size_of_image_data(const ISMRMRD_Image *im) {
- size_t data_size = 0;
- int num_data = im->head.matrix_size[0] * im->head.matrix_size[1] *
- im->head.matrix_size[2] * im->head.channels;
-
- switch (im->head.data_type) {
- case ISMRMRD_USHORT:
- data_size = num_data * sizeof(uint16_t);
- break;
- case ISMRMRD_SHORT:
- data_size = num_data * sizeof(int16_t);
- break;
- case ISMRMRD_UINT:
- data_size = num_data * sizeof(uint32_t);
- break;
- case ISMRMRD_INT:
- data_size = num_data * sizeof(int32_t);
- break;
- case ISMRMRD_FLOAT:
- data_size = num_data * sizeof(float);
- break;
- case ISMRMRD_DOUBLE:
- data_size = num_data * sizeof(double);
- break;
- case ISMRMRD_CXFLOAT:
- data_size = num_data * sizeof(complex_float_t);
- break;
- case ISMRMRD_CXDOUBLE:
- data_size = num_data * sizeof(complex_double_t);
- break;
- default:
- ISMRMRD_THROW(ISMRMRD_TYPEERROR, "Invalid image data type");
- data_size = 0;
+ if (im) {
+ size_t data_size = 0;
+ int num_data = im->head.matrix_size[0] * im->head.matrix_size[1] *
+ im->head.matrix_size[2] * im->head.channels;
+
+ switch (im->head.data_type) {
+ case ISMRMRD_USHORT:
+ data_size = num_data * sizeof(uint16_t);
+ break;
+ case ISMRMRD_SHORT:
+ data_size = num_data * sizeof(int16_t);
+ break;
+ case ISMRMRD_UINT:
+ data_size = num_data * sizeof(uint32_t);
+ break;
+ case ISMRMRD_INT:
+ data_size = num_data * sizeof(int32_t);
+ break;
+ case ISMRMRD_FLOAT:
+ data_size = num_data * sizeof(float);
+ break;
+ case ISMRMRD_DOUBLE:
+ data_size = num_data * sizeof(double);
+ break;
+ case ISMRMRD_CXFLOAT:
+ data_size = num_data * sizeof(complex_float_t);
+ break;
+ case ISMRMRD_CXDOUBLE:
+ data_size = num_data * sizeof(complex_double_t);
+ break;
+ default:
+ ISMRMRD_THROW(ISMRMRD_TYPEERROR, "Invalid image data type");
+ data_size = 0;
+ }
+ return data_size;
}
- return data_size;
+ return 0;
}
size_t ismrmrd_size_of_image_attribute_string(const ISMRMRD_Image *im) {
- return im->head.attribute_string_len * sizeof(*im->attribute_string);
+ if (im) {
+ return im->head.attribute_string_len * sizeof(*im->attribute_string);
+ }
+ return 0;
}
/* NDArray functions */
void ismrmrd_init_ndarray(ISMRMRD_NDArray *arr) {
- int n;
-
- arr->version = ISMRMRD_VERSION;
- arr->data_type = 0; // no default data type
- arr->ndim = 0;
-
- for (n = 0; n < ISMRMRD_NDARRAY_MAXDIM; n++) {
- arr->dims[n] = 0;
+ if (arr) {
+ int n;
+
+ arr->version = ISMRMRD_VERSION;
+ arr->data_type = 0; // no default data type
+ arr->ndim = 0;
+
+ for (n = 0; n < ISMRMRD_NDARRAY_MAXDIM; n++) {
+ arr->dims[n] = 0;
+ }
+ arr->data = NULL;
}
- arr->data = NULL;
}
ISMRMRD_NDArray * ismrmrd_create_ndarray() {
@@ -237,85 +279,98 @@ ISMRMRD_NDArray * ismrmrd_create_ndarray() {
}
void ismrmrd_cleanup_ndarray(ISMRMRD_NDArray *arr) {
- free(arr->data); arr->data = NULL;
+ if (arr) {
+ free(arr->data); arr->data = NULL;
+ }
}
void ismrmrd_free_ndarray(ISMRMRD_NDArray *arr) {
- ismrmrd_cleanup_ndarray(arr);
- free(arr);
+ if (arr) {
+ ismrmrd_cleanup_ndarray(arr);
+ free(arr);
+ }
}
void ismrmrd_copy_ndarray(ISMRMRD_NDArray *arrdest, const ISMRMRD_NDArray *arrsource) {
- int n;
-
- arrdest->version = arrsource->version;
- arrdest->data_type = arrsource->data_type;
- arrdest->ndim = arrsource->ndim;
-
- for (n = 0; n < ISMRMRD_NDARRAY_MAXDIM; n++) {
- arrdest->dims[n] = arrsource->dims[n];
+ if (arrsource) {
+ if (arrdest) {
+ int n;
+
+ arrdest->version = arrsource->version;
+ arrdest->data_type = arrsource->data_type;
+ arrdest->ndim = arrsource->ndim;
+
+ for (n = 0; n < ISMRMRD_NDARRAY_MAXDIM; n++) {
+ arrdest->dims[n] = arrsource->dims[n];
+ }
+ ismrmrd_make_consistent_ndarray(arrdest);
+ memcpy(&arrdest->data, &arrsource->data, ismrmrd_size_of_ndarray_data(arrdest));
+ }
}
- ismrmrd_make_consistent_ndarray(arrdest);
- memcpy(&arrdest->data, &arrsource->data, ismrmrd_size_of_ndarray_data(arrdest));
}
int ismrmrd_make_consistent_ndarray(ISMRMRD_NDArray *arr) {
- size_t data_size = ismrmrd_size_of_ndarray_data(arr);
- if (data_size > 0) {
- arr->data = realloc(arr->data, data_size);
- if (arr->data == NULL) {
- ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
- "Failed to realloc NDArray data array");
+ if (arr) {
+ size_t data_size = ismrmrd_size_of_ndarray_data(arr);
+ if (data_size > 0) {
+ arr->data = realloc(arr->data, data_size);
+ if (arr->data == NULL) {
+ ISMRMRD_THROW(ISMRMRD_MEMORYERROR,
+ "Failed to realloc NDArray data array");
+ return ISMRMRD_MEMORYERROR;
+ }
+ }
+ else {
+ /* data_size == 0 */
+ /* the data type is invalid for some other reason */
return ISMRMRD_MEMORYERROR;
}
}
- else {
- /* data_size == 0 */
- /* the data type is invalid for some other reason */
- return ISMRMRD_MEMORYERROR;
- }
return ISMRMRD_NOERROR;
}
size_t ismrmrd_size_of_ndarray_data(const ISMRMRD_NDArray *arr) {
- size_t data_size = 0;
- int num_data = 1;
- int n;
- for (n = 0; n < arr->ndim; n++) {
- num_data *= arr->dims[n];
- }
-
- switch (arr->data_type) {
- case ISMRMRD_USHORT:
- data_size = num_data * sizeof(uint16_t);
- break;
- case ISMRMRD_SHORT:
- data_size = num_data * sizeof(int16_t);
- break;
- case ISMRMRD_UINT:
- data_size = num_data * sizeof(uint32_t);
- break;
- case ISMRMRD_INT:
- data_size = num_data * sizeof(int32_t);
- break;
- case ISMRMRD_FLOAT:
- data_size = num_data * sizeof(float);
- break;
- case ISMRMRD_DOUBLE:
- data_size = num_data * sizeof(double);
- break;
- case ISMRMRD_CXFLOAT:
- data_size = num_data * sizeof(complex_float_t);
- break;
- case ISMRMRD_CXDOUBLE:
- data_size = num_data * sizeof(complex_double_t);
- break;
- default:
- ISMRMRD_THROW(ISMRMRD_TYPEERROR, "Invalid NDArray data type");
- data_size = 0;
+ if (arr) {
+ size_t data_size = 0;
+ int num_data = 1;
+ int n;
+ for (n = 0; n < arr->ndim; n++) {
+ num_data *= arr->dims[n];
+ }
+
+ switch (arr->data_type) {
+ case ISMRMRD_USHORT:
+ data_size = num_data * sizeof(uint16_t);
+ break;
+ case ISMRMRD_SHORT:
+ data_size = num_data * sizeof(int16_t);
+ break;
+ case ISMRMRD_UINT:
+ data_size = num_data * sizeof(uint32_t);
+ break;
+ case ISMRMRD_INT:
+ data_size = num_data * sizeof(int32_t);
+ break;
+ case ISMRMRD_FLOAT:
+ data_size = num_data * sizeof(float);
+ break;
+ case ISMRMRD_DOUBLE:
+ data_size = num_data * sizeof(double);
+ break;
+ case ISMRMRD_CXFLOAT:
+ data_size = num_data * sizeof(complex_float_t);
+ break;
+ case ISMRMRD_CXDOUBLE:
+ data_size = num_data * sizeof(complex_double_t);
+ break;
+ default:
+ ISMRMRD_THROW(ISMRMRD_TYPEERROR, "Invalid NDArray data type");
+ data_size = 0;
+ }
+
+ return data_size;
}
-
- return data_size;
+ return 0;
}
/* Misc. functions */
@@ -325,17 +380,23 @@ bool ismrmrd_is_flag_set(const uint64_t flags, const uint64_t val) {
}
void ismrmrd_set_flag(uint64_t *flags, const uint64_t val) {
- uint64_t bitmask = 1 << (val - 1);
- *flags |= bitmask;
+ if (flags) {
+ uint64_t bitmask = 1 << (val - 1);
+ *flags |= bitmask;
+ }
}
void ismrmrd_clear_flag(uint64_t *flags, const uint64_t val) {
- uint64_t bitmask = 1 << (val - 1);
- *flags &= ~bitmask;
+ if (flags) {
+ uint64_t bitmask = 1 << (val - 1);
+ *flags &= ~bitmask;
+ }
}
void ismrmrd_clear_all_flags(uint64_t *flags) {
- *flags = 0;
+ if (flags) {
+ *flags = 0;
+ }
}
static void ismrmrd_error_default(const char *file, int line, const char *func, int err, char *msg)
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/ismrmrd.git
More information about the debian-science-commits
mailing list