net/tls: removes pthread macro in security api.

This commit removes pthread lock and unlock macro in security api.
Because those macros are including return command, with those macro,
user can't release the allocate memory.

Change-Id: I740a31812106e0de941439000ae41c3d0809dc21
Signed-off-by: Junyeon LEE <junyeon2.lee@samsung.com>

diff --git a/os/include/tls/see_api.h b/os/include/tls/see_api.h
index ab407cd..672c5f4 100644 (file)
--- a/os/include/tls/see_api.h
+++ b/os/include/tls/see_api.h
@@ -104,17 +104,6 @@ typedef enum {
 #define ISP_CHECKBUSY()
 #endif
 
-#define _SEE_MUTEX_LOCK                                        \
-{                                                      \
-       if (see_mutex_lock(&m_handler) != SEE_OK)       \
-               return SEE_MUTEX_LOCK_ERROR;            \
-}
-#define _SEE_MUTEX_UNLOCK                              \
-{                                                      \
-       if (see_mutex_unlock(&m_handler) != SEE_OK)     \
-               return SEE_MUTEX_UNLOCK_ERROR;          \
-}
-
 /****************************************************************************
  * Public types
 ****************************************************************************/

diff --git a/os/net/tls/see_api.c b/os/net/tls/see_api.c
index 20566ca..6154876 100644 (file)
--- a/os/net/tls/see_api.c
+++ b/os/net/tls/see_api.c
@@ -83,27 +83,39 @@ int see_get_certificate(unsigned char *cert, unsigned int *cert_len, unsigned in
                return SEE_ALLOC_ERROR;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               r = SEE_MUTEX_LOCK_ERROR;
+               goto get_cert_exit;
+       }
+
        ISP_CHECKBUSY();
 #if defined(SEE_SUPPORT_USERCERT)
        if (cert_index < SEE_MAX_CERT_INDEX) {
                if ((r = isp_read_cert(buf, &buf_len, cert_index)) != 0) {
                        isp_clear(0);
-                       _SEE_MUTEX_UNLOCK
-                       SEE_DEBUG("isp_read_cert fail %x\n", r);
                        r = SEE_READ_CERT_ERROR;
+                       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                               r = SEE_MUTEX_UNLOCK_ERROR;
+                       }
+                       SEE_DEBUG("isp_read_cert fail %x\n", r);
                        goto get_cert_exit;
                }
        } else
 #endif
        if ((r = isp_get_factorykey_data(buf, &buf_len, cert_index)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
-               SEE_DEBUG("isp_read_cert fail %x\n", r);
                r = SEE_READ_CERT_ERROR;
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       r = SEE_MUTEX_UNLOCK_ERROR;
+               }
+               SEE_DEBUG("isp_read_cert fail %x\n", r);
+               goto get_cert_exit;
+       }
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               r = SEE_MUTEX_UNLOCK_ERROR;
                goto get_cert_exit;
        }
-       _SEE_MUTEX_UNLOCK
 
        if (*cert_len < buf_len) {
                SEE_DEBUG("input buffer is too small\n");
@@ -134,15 +146,23 @@ int see_generate_random(unsigned int *data, unsigned int len)
                len = len + 4 - (len & 0x3);
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_generate_random(data, len / 4)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                SEE_DEBUG("isp_generate_random fail %x\n", r);
                return SEE_GET_RANDOM_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        return SEE_OK;
 }
@@ -161,13 +181,23 @@ int see_get_ecdsa_signature(struct sECC_SIGN *ecc_sign, unsigned char *hash, uns
                return SEE_INVALID_KEY_INDEX;
        }
 
-       _SEE_MUTEX_LOCK ISP_CHECKBUSY();
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
+       ISP_CHECKBUSY();
        if ((r = isp_ecdsa_sign_securekey(ecc_sign, hash, hash_len, key_index)) != 0) {
                SEE_DEBUG("isp_ecdsa_sign fail %x\n", r);
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK return SEE_ECDSA_SIGN_ERROR;
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
+               return SEE_ECDSA_SIGN_ERROR;
+       }
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
        }
-       _SEE_MUTEX_UNLOCK return SEE_OK;
+       return SEE_OK;
 }
 
 int see_compute_ecdh_param(struct sECC_KEY *ecc_pub, unsigned int key_index, unsigned char *output, unsigned int *olen)
@@ -184,15 +214,22 @@ int see_compute_ecdh_param(struct sECC_KEY *ecc_pub, unsigned int key_index, uns
 
        SEE_DEBUG("%s : key_index : %d \n", __func__, key_index);
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_compute_ecdh_securekey(output, olen, *ecc_pub, key_index)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                SEE_DEBUG("isp_compute_ecdh_param fail %x\n", r);
                return SEE_ECDH_COMPUTE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        return SEE_OK;
 }

diff --git a/os/net/tls/see_internal.c b/os/net/tls/see_internal.c
index 83f7003..41c589c 100644 (file)
--- a/os/net/tls/see_internal.c
+++ b/os/net/tls/see_internal.c
@@ -35,17 +35,25 @@ int see_generate_key_internal(unsigned int key_type, unsigned char *key_buf,
 
        SEE_DEBUG("%s IN\n", __func__);
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        switch (key) {
        case ECC_KEY:
                ISP_CHECKBUSY();
                r = isp_ecdsa_generate_key_encryptedkey(object_id, key_buf);
                break;
        default:
-               _SEE_MUTEX_UNLOCK
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_INVALID_INPUT_PARAMS;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        if (r) {
                SEE_DEBUG("isp_generate_key fail %x %x %x\n", r, key, object_id);
@@ -68,15 +76,23 @@ int see_get_ecc_publickey_internal(struct sECC_KEY *ecc_pub, unsigned char *key_
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_ecdsa_get_publickey_encryptedkey(ecc_pub, object_id, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_get_ecdsa_pubkey fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;
@@ -93,15 +109,23 @@ int see_compute_ecdh_param_internal(struct sECC_KEY *ecc_pub, unsigned char *key
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_compute_ecdh_encryptedkey(output, olen, *ecc_pub, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_compute_ecdh_param fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;
@@ -132,15 +156,23 @@ int see_generate_dhm_params_internal(struct sDH_PARAM *d_param, unsigned char *k
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_dh_generate_keypair_userparam_encryptedkey(d_param, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_generate_dh_param fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;
@@ -158,15 +190,23 @@ int see_compute_dhm_param_internal(struct sDH_PARAM *d_param, unsigned char *key
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_dh_compute_shared_secret_encryptedkey(output, olen, *d_param, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_compute_dh_param fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;
@@ -190,15 +230,23 @@ int see_setup_key_internal(unsigned char *key_der, unsigned int key_len,
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_set_encryptedkey(key_der, key_len, key_type, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_set_userkey fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;
@@ -216,16 +264,24 @@ int see_verify_ecdsa_signature_internal(struct sECC_SIGN *ecc_sign,
                return SEE_INVALID_INPUT_PARAMS;
        }
 
-       _SEE_MUTEX_LOCK
+       if (see_mutex_lock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_LOCK_ERROR;
+       }
+
        ISP_CHECKBUSY();
        if ((r = isp_ecdsa_verify_md_encryptedkey(ecc_sign,
                         hash, hash_len, key_buf)) != 0) {
                isp_clear(0);
-               _SEE_MUTEX_UNLOCK
                SEE_DEBUG("isp_ecdsa_verify fail %x\n", r);
+               if (see_mutex_unlock(&m_handler) != SEE_OK) {
+                       return SEE_MUTEX_UNLOCK_ERROR;
+               }
                return SEE_ERROR;
        }
-       _SEE_MUTEX_UNLOCK
+
+       if (see_mutex_unlock(&m_handler) != SEE_OK) {
+               return SEE_MUTEX_UNLOCK_ERROR;
+       }
 
        SEE_DEBUG("%s OUT\n", __func__);
        return SEE_OK;