Fix defects identified by Coverity Scan

4 files changed, 102 insertions, 36 deletions

diff --git a/sensors-service/src/acceleration.c b/sensors-service/src/acceleration.c
index 51b2be5..6e501e0 100644
--- a/sensors-service/src/acceleration.c
+++ b/sensors-service/src/acceleration.c
@@ -26,8 +26,11 @@ TAccelerationConfiguration gAccelerationConfiguration;
 
 bool snsAccelerationInit()
 {
+    pthread_mutex_lock(&mutexCb);
     cbAcceleration = 0;
-
+    pthread_mutex_unlock(&mutexCb);
+    
+    pthread_mutex_lock(&mutexData);
     //example accelerometer configuration for a 3-axis accelerometer
     gAccelerationConfiguration.dist2RefPointX = 0;
     gAccelerationConfiguration.dist2RefPointY = 0;
@@ -47,6 +50,7 @@ bool snsAccelerationInit()
       ACCELERATION_CONFIG_ANGLEPITCH_VALID |
       ACCELERATION_CONFIG_ANGLEROLL_VALID |
       ACCELERATION_CONFIG_TYPE_VALID;
+    pthread_mutex_unlock(&mutexData);
 
     return true;
 }
@@ -76,13 +80,19 @@ bool snsAccelerationGetAccelerationData(TAccelerationData * accelerationData)
 
 bool snsAccelerationRegisterCallback(AccelerationCallback callback)
 {
-    //printf("snsAccelerationRegisterCallback\n");
-    if(cbAcceleration != 0) 
+    if(!callback)
     {
         return false;
     }
 
+    //printf("snsAccelerationRegisterCallback\n");
     pthread_mutex_lock(&mutexCb);
+    if(cbAcceleration != 0) 
+    {   
+        //already registered
+        pthread_mutex_unlock(&mutexCb);
+        return false;
+    }
     cbAcceleration = callback;
     pthread_mutex_unlock(&mutexCb);
 
@@ -91,17 +101,20 @@ bool snsAccelerationRegisterCallback(AccelerationCallback callback)
 
 bool snsAccelerationDeregisterCallback(AccelerationCallback callback)
 {
+    if(!callback)
+    {
+        return false;
+    }
+
     //printf("snsAccelerationDeregisterCallback\n");
-    if(cbAcceleration == callback && callback != 0)
+    pthread_mutex_lock(&mutexCb);
+    if(cbAcceleration == callback)
     {
-        pthread_mutex_lock(&mutexCb);
         cbAcceleration = 0;
-        pthread_mutex_unlock(&mutexCb);
-
-        return true;
     }
+    pthread_mutex_unlock(&mutexCb);
 
-    return false;
+    return true;
 }
 
 bool snsAccelerationGetMetaData(TSensorMetaData *data)
@@ -120,7 +133,15 @@ bool snsAccelerationGetMetaData(TSensorMetaData *data)
 
 bool snsAccelerationGetAccelerationConfiguration(TAccelerationConfiguration* config)
 {
+    if(!config) 
+    {
+        return false;
+    }
+
+    pthread_mutex_lock(&mutexData);
     *config = gAccelerationConfiguration;
+    pthread_mutex_unlock(&mutexData);
+
     return true;
 }
 
diff --git a/sensors-service/src/gyroscope.c b/sensors-service/src/gyroscope.c
index e88fbdc..002edb3 100644
--- a/sensors-service/src/gyroscope.c
+++ b/sensors-service/src/gyroscope.c
@@ -26,8 +26,11 @@ TGyroscopeConfiguration gGyroscopeConfiguration;
 
 bool snsGyroscopeInit()
 {
+    pthread_mutex_lock(&mutexCb);
     cbGyroscope = 0;
+    pthread_mutex_unlock(&mutexCb);
 
+    pthread_mutex_lock(&mutexData);
     //example gyroscope configuration for a 3-axis gyro
     gGyroscopeConfiguration.angleYaw = 0;
     gGyroscopeConfiguration.anglePitch = 0;
@@ -43,6 +46,7 @@ bool snsGyroscopeInit()
       GYROSCOPE_CONFIG_ANGLEPITCH_VALID |
       GYROSCOPE_CONFIG_ANGLEROLL_VALID |
       GYROSCOPE_CONFIG_TYPE_VALID;
+    pthread_mutex_unlock(&mutexData);
 
     return true;
 }
@@ -72,13 +76,19 @@ bool snsGyroscopeGetGyroscopeData(TGyroscopeData * gyroData)
 
 bool snsGyroscopeRegisterCallback(GyroscopeCallback callback)
 {
-    //printf("snsGyroscopeRegisterCallback\n");
-    if(cbGyroscope != 0) 
+    if(!callback)
     {
         return false;
     }
 
+    //printf("snsGyroscopeRegisterCallback\n");
     pthread_mutex_lock(&mutexCb);
+    if(cbGyroscope != 0) 
+    {   
+        //already registered
+        pthread_mutex_unlock(&mutexCb);
+        return false;
+    }
     cbGyroscope = callback;
     pthread_mutex_unlock(&mutexCb);
 
@@ -87,17 +97,20 @@ bool snsGyroscopeRegisterCallback(GyroscopeCallback callback)
 
 bool snsGyroscopeDeregisterCallback(GyroscopeCallback callback)
 {
-    //printf("snsGyroscopeDeregisterCallback\n");
-    if(cbGyroscope == callback && callback != 0)
+    if(!callback)
     {
-        pthread_mutex_lock(&mutexCb);
-        cbGyroscope = 0;
-        pthread_mutex_unlock(&mutexCb);
+        return false;
+    }
 
-        return true;
+    //printf("snsGyroscopeDeregisterCallback\n");
+    pthread_mutex_lock(&mutexCb);
+    if(cbGyroscope == callback)
+    { 
+        cbGyroscope = 0;
     }
+    pthread_mutex_unlock(&mutexCb);
 
-    return false;
+    return true;
 }
 
 bool snsGyroscopeGetMetaData(TSensorMetaData *data)
@@ -116,7 +129,15 @@ bool snsGyroscopeGetMetaData(TSensorMetaData *data)
 
 bool snsGyroscopeGetConfiguration(TGyroscopeConfiguration* gyroConfig)
 {
+    if(!gyroConfig) 
+    {
+        return false;
+    }
+
+    pthread_mutex_lock(&mutexData);
     *gyroConfig = gGyroscopeConfiguration;
+    pthread_mutex_unlock(&mutexData);
+
     return true;
 }
 
diff --git a/sensors-service/src/vehicle-speed.c b/sensors-service/src/vehicle-speed.c
index fbab896..bd44023 100644
--- a/sensors-service/src/vehicle-speed.c
+++ b/sensors-service/src/vehicle-speed.c
@@ -20,7 +20,9 @@ TVehicleSpeedData gVehicleSpeedData;
 
 bool snsVehicleSpeedInit()
 {
+    pthread_mutex_lock(&mutexCb);
     cbVehicleSpeed = 0;
+    pthread_mutex_unlock(&mutexCb);
 
     return true;
 }
@@ -50,13 +52,19 @@ bool snsVehicleSpeedGetVehicleSpeedData(TVehicleSpeedData* vehicleSpeed)
 
 bool snsVehicleSpeedRegisterCallback(VehicleSpeedCallback callback)
 {
-    //printf("snsVehicleSpeedRegisterCallback\n");
-    if(cbVehicleSpeed != 0) 
+    if(!callback)
     {
         return false;
     }
 
+    //printf("snsVehicleSpeedRegisterCallback\n");
     pthread_mutex_lock(&mutexCb);
+    if(cbVehicleSpeed != 0) 
+    {
+        //already registered
+        pthread_mutex_unlock(&mutexCb);
+        return false;
+    }
     cbVehicleSpeed = callback;
     pthread_mutex_unlock(&mutexCb);
 
@@ -65,15 +73,18 @@ bool snsVehicleSpeedRegisterCallback(VehicleSpeedCallback callback)
 
 bool snsVehicleSpeedDeregisterCallback(VehicleSpeedCallback callback)
 {
+    if(!callback)
+    {
+        return false;
+    }
+
     //printf("snsGyroscopeDeregisterCallback\n");
-    if(cbVehicleSpeed == callback && callback != 0)
+    pthread_mutex_lock(&mutexCb);
+    if(cbVehicleSpeed == callback)
     {
-        pthread_mutex_lock(&mutexCb);
         cbVehicleSpeed = 0;
-        pthread_mutex_unlock(&mutexCb);
-
-        return true;
     }
+    pthread_mutex_unlock(&mutexCb);
 
     return false;
 }
diff --git a/sensors-service/src/wheeltick.c b/sensors-service/src/wheeltick.c
index 0ae0801..99422ea 100644
--- a/sensors-service/src/wheeltick.c
+++ b/sensors-service/src/wheeltick.c
@@ -26,13 +26,17 @@ bool snsWheeltickInit()
 {
     int i;
 
+    pthread_mutex_lock(&mutexCb);
+    cbWheelticks = 0;
+    pthread_mutex_unlock(&mutexCb);
+
+    pthread_mutex_lock(&mutexData);
     for(i = 0; i < WHEEL_NUM_ELEMENTS; i++)
     {
         gWheelticks.elements[i].wheeltickCounter = 0;
         gWheelticks.elements[i].wheeltickIdentifier = WHEEL_INVALID;
     }
-
-    cbWheelticks = 0;
+    pthread_mutex_unlock(&mutexData);
 
     return true;
 }
@@ -62,13 +66,19 @@ bool snsWheeltickGetWheelticks(TWheelticks * ticks)
 
 bool snsWheeltickRegisterCallback(WheeltickCallback callback)
 {
-    //printf("snsWheeltickRegisterCallback\n");
-    if(cbWheelticks != 0) 
+    if(!callback)
     {
         return false;
     }
 
+    //printf("snsWheeltickRegisterCallback\n");
     pthread_mutex_lock(&mutexCb);
+    if(cbWheelticks != 0) 
+    {
+        //already registered
+        pthread_mutex_unlock(&mutexCb);
+        return false; 
+    }
     cbWheelticks = callback;
     pthread_mutex_unlock(&mutexCb);
 
@@ -77,15 +87,18 @@ bool snsWheeltickRegisterCallback(WheeltickCallback callback)
 
 bool snsWheeltickDeregisterCallback(WheeltickCallback callback)
 {
-    //printf("snsWheeltickDeregisterCallback\n");
-    if(cbWheelticks == callback && callback != 0)
+    if(!callback)
     {
-        pthread_mutex_lock(&mutexCb);
-        cbWheelticks = 0;
-        pthread_mutex_unlock(&mutexCb);
+        return false;
+    }
 
-        return true;
+    //printf("snsWheeltickDeregisterCallback\n");
+    pthread_mutex_lock(&mutexCb);
+    if(cbWheelticks == callback)
+    { 
+        cbWheelticks = 0;      
     }
+    pthread_mutex_unlock(&mutexCb);  
 
-    return false;
+    return true;
 }