Make function for managing sound_data_s

In previous code, instance of sound_data_s is created by ttsd_server.c. However, destruction of
instance is by ttsd_data.c.
This way of memory management is dangerous, because invalid memory access can occur by the mistake
of developers.

This patch provides two new function for creating and destroying instance of sound_data_s.
These functions provide safe creation and destruction of the instance.

Change-Id: I18634d45e5a145238989c5eeefb7457332e7a782
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp
index 770770ba80cd7b42e96a07b8571b4d80476f014d..3751550966d6f53935c3912dbbcf5d4bdc1a4f70 100644 (file)
--- a/server/ttsd_data.cpp
+++ b/server/ttsd_data.cpp
@@ -192,8 +192,19 @@ static inline void __destroy_speak_data(speak_data_s* speak_data)
        delete speak_data;
 }
 
+static inline void __destroy_sound_data(sound_data_s* sound_data)
+{
+       SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] event(%d) data(%p) size(%d) rate(%d) utt(%d)",
+                       sound_data, sound_data->event, sound_data->data, sound_data->data_size, sound_data->rate, sound_data->utt_id);
+
+       delete[] sound_data->data;
+       delete sound_data;
+}
+
 static void __clean_data(app_data_s& app_data)
 {
+       SLOG(LOG_ERROR, tts_tag(), "[INFO] Clean data. uid(%u)", app_data.uid);
+
        int removed_last_uttid = -1;
        for (auto& speak_data : app_data.m_speak_data) {
                if (nullptr == speak_data) {
@@ -210,21 +221,12 @@ static void __clean_data(app_data_s& app_data)
                app_data.utt_id_stopped = removed_last_uttid;
        }
 
-       unsigned int uid = app_data.uid;
        for (auto& sound_data : app_data.m_wav_data) {
                if (nullptr == sound_data) {
                        continue;
                }
 
-               SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] uid(%u), event(%d) data(%p) size(%d) rate(%d) utt(%d)",
-                       sound_data, uid, sound_data->event, sound_data->data, sound_data->data_size, sound_data->rate, sound_data->utt_id);
-
-               if (nullptr != sound_data->data) {
-                       free(sound_data->data);
-                       sound_data->data = nullptr;
-               }
-
-               free(sound_data);
+               __destroy_sound_data(sound_data);
                sound_data = nullptr;
        }
 
@@ -567,6 +569,52 @@ int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data)
        return TTSD_ERROR_NONE;
 }
 
+sound_data_s* ttsd_data_create_sound_data(int utt_id, const void* data, unsigned int data_size, ttse_result_event_e event,
+               ttse_audio_type_e audio_type, int rate, int channels)
+{
+       /* add wav data */
+       sound_data_s* sound_data = new sound_data_s();
+       if (nullptr == sound_data) {
+               SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory for speak_data_s");
+               return nullptr;
+       }
+
+       sound_data->data = nullptr;
+       sound_data->data_size = 0;
+
+       if (nullptr != data && 0 < data_size) {
+               sound_data->data = new char[data_size];
+               if (nullptr != sound_data->data) {
+                       memcpy(sound_data->data, data, data_size);
+                       sound_data->data_size = data_size;
+                       SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] event(%d) sound_data(%p) data(%p) size(%u)",
+                               event, sound_data, sound_data->data, sound_data->data_size);
+               } else {
+                       SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
+               }
+       } else {
+               SLOG(LOG_ERROR, tts_tag(), "Sound data is nullptr");
+       }
+
+       sound_data->utt_id = utt_id;
+       sound_data->event = event;
+       sound_data->audio_type = audio_type;
+       sound_data->rate = rate;
+       sound_data->channels = channels;
+
+       return sound_data;
+}
+
+void ttsd_data_destroy_sound_data(sound_data_s* sound_data)
+{
+       if (nullptr == sound_data) {
+               SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] data is nullptr");
+               return;
+       }
+
+       __destroy_sound_data(sound_data);
+}
+
 int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data)
 {
        lock_guard<mutex> lock(g_app_data_mutex);
@@ -650,29 +698,6 @@ int ttsd_data_get_sound_data_size(unsigned int uid)
        return app_data->m_wav_data.size();
 }
 
-int ttsd_data_clear_sound_data(sound_data_s** sound_data)
-{
-       if (nullptr == sound_data) {
-               SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] sound_data is nullptr");
-               return TTSD_ERROR_INVALID_PARAMETER;
-       }
-
-       if (nullptr != *sound_data) {
-               SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] event(%d) data(%p) size(%d) rate(%d) utt(%d)",
-                               (*sound_data), (*sound_data)->event, (*sound_data)->data, (*sound_data)->data_size, (*sound_data)->rate, (*sound_data)->utt_id);
-
-               if (nullptr != (*sound_data)->data) {
-                       free((*sound_data)->data);
-                       (*sound_data)->data = nullptr;
-               }
-
-               free(*sound_data);
-               *sound_data = nullptr;
-       }
-
-       return TTSD_ERROR_NONE;
-}
-
 int ttsd_data_clear_data(unsigned int uid)
 {
        lock_guard<mutex> lock(g_app_data_mutex);

diff --git a/server/ttsd_data.h b/server/ttsd_data.h
index b45fd0c15b6638f6b3c6294ad20703adb54d629a..f0df92fd2e011fc08f3938c0f48b2cb97e2e21f1 100644 (file)
--- a/server/ttsd_data.h
+++ b/server/ttsd_data.h
@@ -48,7 +48,7 @@ typedef struct {
 
 typedef struct {
        int utt_id;
-       void* data;
+       char* data;
        unsigned int data_size;
 
        ttse_result_event_e event;
@@ -97,14 +97,17 @@ int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data);
 int ttsd_data_get_speak_data_size(unsigned int uid);
 
 /* sound data */
+sound_data_s* ttsd_data_create_sound_data(int utt_id, const void* data, unsigned int data_size, ttse_result_event_e event,
+               ttse_audio_type_e audio_type, int rate, int channels);
+
+void ttsd_data_destroy_sound_data(sound_data_s* sound_data);
+
 int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data);
 
 int ttsd_data_get_sound_data(unsigned int uid, sound_data_s** data);
 
 int ttsd_data_get_sound_data_size(unsigned int uid);
 
-int ttsd_data_clear_sound_data(sound_data_s** sound_data);
-
 int ttsd_data_clear_data(unsigned int uid);
 
 

diff --git a/server/ttsd_player.c b/server/ttsd_player.c
index cd37958027de9819b8d3532e89dac1a5c9a7e03b..9c90c6e06b02828a3a57851cf034ce22f9fe1190 100644 (file)
--- a/server/ttsd_player.c
+++ b/server/ttsd_player.c
@@ -614,33 +614,18 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
 
                if (true == player->is_paused_data && NULL != player->paused_data) {
                        /* Resume player */
-                       if (NULL != sound_data) {
-                               ttsd_data_clear_sound_data(&sound_data);
-                       }
+                       sound_data_s* paused_data = player->paused_data;
+                       player->paused_data = NULL;
 
-                       sound_data = (sound_data_s*)calloc(1, sizeof(sound_data_s));
+                       ttsd_data_destroy_sound_data(sound_data);
+                       sound_data = ttsd_data_create_sound_data(paused_data->utt_id, paused_data->data, paused_data->data_size,
+                                       paused_data->event, paused_data->audio_type, paused_data->rate, paused_data->channels);
                        if (NULL == sound_data || player->paused_data->data_size <= 0) {
                                SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Out of memory OR paused_data is empty");
-                               ttsd_data_clear_sound_data(&sound_data);
-
-                               sound_data = player->paused_data;
-                               player->paused_data = NULL;
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = paused_data;
                        } else { // NULL != sound_data && NULL != temp && player->paused_data->data_size > 0
-                               char* temp = (char*)calloc(player->paused_data->data_size + 5, sizeof(char));
-
-                               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Copy paused_data to sound_data");
-                               sound_data->data = NULL;
-                               sound_data->rate = 0;
-                               sound_data->data_size = 0;
-                               sound_data->utt_id = player->paused_data->utt_id;
-                               sound_data->event = player->paused_data->event;
-                               sound_data->audio_type = player->paused_data->audio_type;
-                               sound_data->rate = player->paused_data->rate;
-
-                               sound_data->data = temp;
-                               memcpy(sound_data->data, player->paused_data->data, player->paused_data->data_size);
-                               sound_data->data_size = player->paused_data->data_size;
-                               ttsd_data_clear_sound_data(&player->paused_data);
+                               ttsd_data_destroy_sound_data(paused_data);
                        }
 
                        idx = player->idx;
@@ -743,7 +728,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                        SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
                                        /* unset volume policy, volume will be 100% */
                                        __unset_policy_for_playing();
-                                       ttsd_data_clear_sound_data(&sound_data);
+                                       ttsd_data_destroy_sound_data(sound_data);
+                                       sound_data = NULL;
                                        return;
                                }
 
@@ -773,7 +759,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                                SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
                                                /* unset volume policy, volume will be 100% */
                                                __unset_policy_for_playing();
-                                               ttsd_data_clear_sound_data(&sound_data);
+                                               ttsd_data_destroy_sound_data(sound_data);
+                                               sound_data = NULL;
                                                return;
                                        }
 
@@ -792,7 +779,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                        }
                                } // TTSE_RESULT_EVENT_FINISH == sound_data->event
                                SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%u), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
-                               ttsd_data_clear_sound_data(&sound_data);
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = NULL;
                                continue;
                        } // (NULL == sound_data->data || 0 >= sound_data->data_size)
                } // NO player->is_paused_data
@@ -809,7 +797,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                /* unset volume policy, volume will be 100% */
                                __unset_policy_for_playing();
 
-                               ttsd_data_clear_sound_data(&sound_data);
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = NULL;
                                return;
                        }
 
@@ -841,7 +830,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                        /* unset volume policy, volume will be 100% */
                                        __unset_policy_for_playing();
 
-                                       ttsd_data_clear_sound_data(&sound_data);
+                                       ttsd_data_destroy_sound_data(sound_data);
+                                       sound_data = NULL;
                                        return;
                                }
                                SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
@@ -872,15 +862,15 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                /* unset volume policy, volume will be 100% */
                                __unset_policy_for_playing();
 
-                               ttsd_data_clear_sound_data(&sound_data);
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = NULL;
                                return;
                        } // (NULL == g_playing_info && APP_STATE_PAUSED != player->state)
 
                        if (APP_STATE_PAUSED == player->state) {
                                /* Save data */
                                SLOG(LOG_DEBUG, tts_tag(), "[Player] player(%p)", player);
-                               ttsd_data_clear_sound_data(&player->paused_data);
-
+                               ttsd_data_destroy_sound_data(player->paused_data);
                                player->paused_data = sound_data;
 
                                player->is_paused_data = true;
@@ -918,7 +908,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
 
                        /* unset volume policy, volume will be 100% */
                        __unset_policy_for_playing();
-                       ttsd_data_clear_sound_data(&sound_data);
+                       ttsd_data_destroy_sound_data(sound_data);
+                       sound_data = NULL;
                        return;
                } // (NULL == g_playing_info && APP_STATE_READY == player->state)
 
@@ -931,7 +922,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
                                /* unset volume policy, volume will be 100% */
                                __unset_policy_for_playing();
-                               ttsd_data_clear_sound_data(&sound_data);
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = NULL;
                                return;
                        }
 
@@ -944,14 +936,16 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                        pid, player->uid, sound_data->utt_id);
                                /* unset volume policy, volume will be 100% */
                                __unset_policy_for_playing();
-                               ttsd_data_clear_sound_data(&sound_data);
+                               ttsd_data_destroy_sound_data(sound_data);
+                               sound_data = NULL;
                                return;
                        }
 
                        SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%u), uttid(%d)", player->uid, sound_data->utt_id);
                } // ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) && (TTSE_RESULT_EVENT_FINISH == sound_data->event))
 
-               ttsd_data_clear_sound_data(&sound_data);
+               ttsd_data_destroy_sound_data(sound_data);
+               sound_data = NULL;
 
                if (NULL == g_playing_info) {
                        SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
@@ -962,7 +956,8 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                        }
                        /* unset volume policy, volume will be 100% */
                        __unset_policy_for_playing();
-                       ttsd_data_clear_sound_data(&sound_data);
+                       ttsd_data_destroy_sound_data(sound_data);
+                       sound_data = NULL;
                        return;
                }
        } // end of 1st while(1)
@@ -1375,7 +1370,8 @@ int ttsd_player_clear(unsigned int uid)
 
        if (true == current->is_paused_data) {
                SLOG(LOG_INFO, tts_tag(), "[Player INFO] Clear paused data");
-               ttsd_data_clear_sound_data(&current->paused_data);
+               ttsd_data_destroy_sound_data(current->paused_data);
+               current->paused_data = NULL;
        }
 
        current->event = TTSE_RESULT_EVENT_FINISH;
@@ -1512,7 +1508,8 @@ int ttsd_player_all_stop()
 
                                if (true == data->is_paused_data) {
                                        SLOG(LOG_INFO, tts_tag(), "[Player INFO] Clear paused data");
-                                       ttsd_data_clear_sound_data(&data->paused_data);
+                                       ttsd_data_destroy_sound_data(data->paused_data);
+                                       data->paused_data = NULL;
                                }
 
                                data->is_paused_data = false;

diff --git a/server/ttsd_server.c b/server/ttsd_server.c
index c34482824b05b0b0cb6cd86218450903a3630d50..4821c65e3a1ff0d82b302fc46669460317ef5273 100644 (file)
--- a/server/ttsd_server.c
+++ b/server/ttsd_server.c
@@ -271,45 +271,15 @@ int ttsd_send_result(ttse_result_event_e event, const void* data, unsigned int d
        }
 
        /* add wav data */
-       sound_data_s* temp_sound_data = NULL;
-       temp_sound_data = (sound_data_s*)calloc(1, sizeof(sound_data_s));
-       if (NULL == temp_sound_data) {
+       sound_data_s* sound_data = ttsd_data_create_sound_data(uttid, data, data_size, event, audio_type, rate, 0);
+       if (NULL == sound_data) {
                SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Out of memory");
                return TTSD_ERROR_OUT_OF_MEMORY;
        }
 
-       temp_sound_data->data = NULL;
-       temp_sound_data->rate = 0;
-       temp_sound_data->data_size = 0;
-
-       if (NULL != data && 0 < data_size) {
-               temp_sound_data->data = (char*)calloc(data_size + 5, sizeof(char));
-               if (NULL != temp_sound_data->data) {
-                       memcpy(temp_sound_data->data, data, data_size);
-                       temp_sound_data->data_size = data_size;
-                       SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%u), event(%d) sound_data(%p) data(%p) size(%d)",
-                               uid, event, temp_sound_data, temp_sound_data->data, temp_sound_data->data_size);
-               } else {
-                       SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
-               }
-       } else {
-               SLOG(LOG_ERROR, tts_tag(), "Sound data is NULL");
-       }
-
-       temp_sound_data->utt_id = uttid;
-       temp_sound_data->event = event;
-       temp_sound_data->audio_type = audio_type;
-       temp_sound_data->rate = rate;
-
-       if (0 != ttsd_data_add_sound_data(uid, temp_sound_data)) {
+       if (0 != ttsd_data_add_sound_data(uid, sound_data)) {
                SECURE_SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Fail to add sound data : uid(%u)", uid);
-               if (NULL != temp_sound_data->data) {
-                       free(temp_sound_data->data);
-                       temp_sound_data->data = NULL;
-               }
-
-               free(temp_sound_data);
-               temp_sound_data = NULL;
+               ttsd_data_destroy_sound_data(sound_data);
 
                return TTSD_ERROR_OPERATION_FAILED;
        }
@@ -1398,47 +1368,15 @@ int ttsd_server_add_pcm(unsigned int uid, int event, void* data, int data_size,
                        return TTSD_ERROR_INVALID_PARAMETER;
                }
 
-               /* add wav data */
-               sound_data_s* temp_sound_data = NULL;
-               temp_sound_data = (sound_data_s*)calloc(1, sizeof(sound_data_s));
-               if (NULL == temp_sound_data) {
+               sound_data_s* sound_data = ttsd_data_create_sound_data(uttid, data, data_size, event, audio_type, rate, 0);
+               if (NULL == sound_data) {
                        SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Out of memory");
                        return TTSD_ERROR_OUT_OF_MEMORY;
                }
 
-               temp_sound_data->data = NULL;
-               temp_sound_data->rate = 0;
-               temp_sound_data->data_size = 0;
-
-               if (0 < data_size) {
-                       temp_sound_data->data = (char*)calloc(data_size + 5, sizeof(char));
-                       if (NULL != temp_sound_data->data) {
-                               memcpy(temp_sound_data->data, data, data_size);
-                               temp_sound_data->data_size = data_size;
-                               SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%u), event(%d) sound_data(%p) data(%p) size(%d)",
-                                       uid, event, temp_sound_data, temp_sound_data->data, temp_sound_data->data_size);
-                       } else {
-                               SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
-                       }
-               } else {
-                       SLOG(LOG_ERROR, tts_tag(), "Sound data is NULL");
-               }
-
-               temp_sound_data->utt_id = uttid;
-               temp_sound_data->event = event;
-               temp_sound_data->audio_type = audio_type;
-               temp_sound_data->rate = rate;
-
-               if (0 != ttsd_data_add_sound_data(uid, temp_sound_data)) {
+               if (0 != ttsd_data_add_sound_data(uid, sound_data)) {
                        SECURE_SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Fail to add sound data : uid(%u)", uid);
-
-                       if (NULL != temp_sound_data->data) {
-                               free(temp_sound_data->data);
-                               temp_sound_data->data = NULL;
-                       }
-
-                       free(temp_sound_data);
-                       temp_sound_data = NULL;
+                       ttsd_data_destroy_sound_data(sound_data);
                }
        } else {
                SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_ERROR");