From a54b7e64cc068eafb74493d69119f0ff4dd297c9 Mon Sep 17 00:00:00 2001 From: Jiyong Min Date: Thu, 14 May 2020 09:22:35 +0000 Subject: [PATCH] Revert "Remove out of memory related code by using glib" This reverts commit 39b40dbe44d4fd7c1605a78eed918a06abd6eba5. Change-Id: Ie1fa86f1387cf0f7e5decf340d02dab2cab6dc16 --- include/media_controller_private.h | 5 +- packaging/capi-media-controller.spec | 2 +- src/media_controller_client.c | 111 +++++++++------ src/media_controller_db.c | 121 +++++++++------- src/media_controller_ipc.c | 37 +++-- src/media_controller_metadata.c | 140 ++++++++++--------- src/media_controller_playlist.c | 49 ++++--- src/media_controller_server.c | 111 +++++++++------ src/media_controller_util.c | 14 +- svc/media_controller_cynara.c | 17 ++- svc/media_controller_db_util.c | 4 +- svc/media_controller_svc.c | 175 ++++++++++++++++-------- test/client_test/media_controller_client_test.c | 28 ++-- test/server_test/media_controller_server_test.c | 28 ++-- 14 files changed, 513 insertions(+), 329 deletions(-) diff --git a/include/media_controller_private.h b/include/media_controller_private.h index e7d0d46..e9ef5ba 100644 --- a/include/media_controller_private.h +++ b/include/media_controller_private.h @@ -112,7 +112,10 @@ extern "C" { src = NULL; \ } \ } while (0) - +#define MC_SAFE_G_FREE(src) do { \ + g_free((gpointer)src); \ + src = NULL; \ + } while (0) #define MC_SAFE_STRLCPY(dst, src, n) g_strlcpy(dst, src, n); #define MC_STRING_VALID(str) ((str != NULL && strlen(str) > 0) ? TRUE : FALSE) diff --git a/packaging/capi-media-controller.spec b/packaging/capi-media-controller.spec index 4d2ab8b..6822708 100644 --- a/packaging/capi-media-controller.spec +++ b/packaging/capi-media-controller.spec @@ -1,6 +1,6 @@ Name: capi-media-controller Summary: A media controller library in Tizen Native API -Version: 0.2.14 +Version: 0.2.15 Release: 1 Group: Multimedia/API License: Apache-2.0 diff --git a/src/media_controller_client.c b/src/media_controller_client.c index f631efa..ad7b93e 100644 --- a/src/media_controller_client.c +++ b/src/media_controller_client.c @@ -195,7 +195,13 @@ static void __client_playlist_cb(const char *interface_name, const char *signal_ mode = atoi(params[1]); - _playlist = g_new0(mc_playlist_s, 1); + _playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s)); + if (_playlist == NULL) { + mc_error("OUT_OF_MEMORY"); + g_strfreev(params); + + return; + } _playlist->server_name = g_strdup(params[0]); _playlist->playlist_name = g_strdup(params[2]); @@ -261,24 +267,24 @@ static void __client_custom_event_received_cb(const char *interface_name, const mc_retm_if(params == NULL, "invalid custom data"); if (params[0]) - sender = g_strdup(params[0]); + sender = strdup(params[0]); if (_mc_util_get_command_available(MC_PRIV_TYPE_CLIENT, sender, MC_EVENT_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("Error permission denied"); - g_free(sender); + MC_SAFE_FREE(sender); g_strfreev(params); return; } - command = g_strdup(params[1]); + command = strdup(params[1]); enc_size = atoi(params[2]); if (enc_size > 0) bundle_data = bundle_decode((bundle_raw *)params[3], enc_size); callback(sender, request_id, command, bundle_data, receiver->user_data); - g_free(sender); - g_free(command); + MC_SAFE_FREE(sender); + MC_SAFE_FREE(command); g_strfreev(params); } @@ -457,7 +463,8 @@ static int __mc_client_create(media_controller_client_s **mc_client) mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - _client = g_new0(media_controller_client_s, 1); + _client = (media_controller_client_s *)calloc(1, sizeof(media_controller_client_s)); + mc_retvm_if(_client == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory"); ret = _mc_util_get_own_name(&(_client->client_name)); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { @@ -487,8 +494,8 @@ Error: if (_client->db_handle) mc_db_disconnect(_client->db_handle); - g_free(_client->client_name); - g_free(_client); + MC_SAFE_FREE(_client->client_name); + MC_SAFE_FREE(_client); return ret; } @@ -516,8 +523,8 @@ static int __mc_client_destroy(media_controller_client_s *mc_client) if (mc_client->listeners != NULL) g_list_free(mc_client->listeners); - g_free(mc_client->client_name); - g_free(mc_client); + MC_SAFE_FREE(mc_client->client_name); + MC_SAFE_FREE(mc_client); return ret; } @@ -533,10 +540,18 @@ static int __mc_client_register_filter_listener(media_controller_client_s *mc_cl mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Fail _mc_util_make_filter_interface_name"); ret = _mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, filter_interface_name, signal_name, callback, user_data); - if (ret == MEDIA_CONTROLLER_ERROR_NONE) - *filter_list = g_list_append(*filter_list, g_strdup(server_name)); + if (ret == MEDIA_CONTROLLER_ERROR_NONE) { + char *filter_data = (char *)g_strdup(server_name); + if (filter_data == NULL) { + mc_debug("memeory allocation failed"); + _mc_ipc_unregister_listener(&mc_client->listeners, filter_interface_name, signal_name); + MC_SAFE_FREE(filter_interface_name); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + *filter_list = g_list_append(*filter_list, filter_data); + } - g_free(filter_interface_name); + MC_SAFE_FREE(filter_interface_name); return ret; } @@ -611,7 +626,7 @@ static int __mc_client_send_command(mc_client_h client, const char *server_name, if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Error _mc_ipc_send_message [%d]", ret); - g_free(interface_name); + MC_SAFE_G_FREE(interface_name); return ret; } @@ -677,7 +692,7 @@ static int __mc_client_set_updated_cb(mc_client_h client, mc_client_receive_even ret = _mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, interface_name, cb_event[event].signal_name, cb_event[event].cb_func, (void *)&(mc_client->updated_cb[event])); - g_free(interface_name); + MC_SAFE_FREE(interface_name); } else if ((event == MC_CLIENT_EVENT_PLAYBACK_INFO) || (event == MC_CLIENT_EVENT_METADATA) || (event == MC_CLIENT_EVENT_PLAYBACK_ABILITY) || (event == MC_CLIENT_EVENT_DISPLAY_MODE_ABILITY) || (event == MC_CLIENT_EVENT_DISPLAY_ROTATION_ABILITY)) { @@ -705,7 +720,7 @@ static int __mc_client_unset_updated_cb(mc_client_h client, mc_client_receive_ev ret = _mc_ipc_unregister_listener(&mc_client->listeners, interface_name, cb_event[event].signal_name); - g_free(interface_name); + MC_SAFE_FREE(interface_name); } else { ret = _mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name); @@ -1054,8 +1069,8 @@ int mc_client_destroy_playback(mc_playback_h playback) mc_retvm_if(mc_playback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - g_free(mc_playback->index); - g_free(mc_playback); + MC_SAFE_FREE(mc_playback->index); + MC_SAFE_FREE(mc_playback); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -1236,7 +1251,7 @@ int mc_client_send_playback_action_cmd(mc_client_h client, const char *server_na ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKACTION, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_ACTION, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1255,7 +1270,7 @@ int mc_client_send_playback_position_cmd(mc_client_h client, const char *server_ ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKPOSITION, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1276,7 +1291,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SHUFFLE); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1287,7 +1302,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_REPEAT); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1298,7 +1313,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SUBTITLES); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1309,7 +1324,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, DISPLAY_MODE_ABILITY + value); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1320,7 +1335,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, DISPLAY_ROTATION_ABILITY + value); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1331,7 +1346,7 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_360_MODE); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("fail to verify ability [%d]", ret); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1340,11 +1355,11 @@ static int __mc_client_send_cmd(mc_client_h client, const char *server_name, uns default: mc_error("Not supported event [%d]", event); - g_free(message); + MC_SAFE_G_FREE(message); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1407,7 +1422,7 @@ int mc_client_send_playlist_cmd(mc_client_h client, const char *server_name, con ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAY_PLAYLIST, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_PLAYLIST, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1426,12 +1441,12 @@ int mc_client_send_custom_cmd(mc_client_h client, const char *server_name, const mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%s%s%s", mc_client->client_name, MC_STRING_DELIMITER, command, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); ret = __mc_client_send_command(client, server_name, MC_COMMAND_CUSTOMACTION, command, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1487,10 +1502,16 @@ int __mc_client_get_bundle_from_search(mc_search_h search, bundle **res_bundle) search_item->category, MC_STRING_DELIMITER, search_item->search_keyword, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_FREE(bundle_str); mc_secure_debug("[%d][%d][%s][%s]", idx, length, key_str, val_str); + if (!key_str || !val_str) { + mc_error("fail to make val_str [%d]", idx); + ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + goto ERROR; + } + /*key - index, val - val_str (content_type, category, keyword, bundle_size, bundle)*/ ret = bundle_add_str(bundle_data, key_str, val_str); if (ret != BUNDLE_ERROR_NONE) { @@ -1499,8 +1520,8 @@ int __mc_client_get_bundle_from_search(mc_search_h search, bundle **res_bundle) goto ERROR; } - g_free(key_str); - g_free(val_str); + MC_SAFE_FREE(key_str); + MC_SAFE_FREE(val_str); } *res_bundle = bundle_data; @@ -1509,8 +1530,8 @@ int __mc_client_get_bundle_from_search(mc_search_h search, bundle **res_bundle) ERROR: bundle_free(bundle_data); - g_free(key_str); - g_free(val_str); + MC_SAFE_FREE(key_str); + MC_SAFE_FREE(val_str); return ret; } @@ -1536,12 +1557,12 @@ int mc_client_send_search_cmd(mc_client_h client, const char *server_name, mc_se mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%s", mc_client->client_name, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); ret = __mc_client_send_command(client, server_name, MC_COMMAND_SEARCH, NULL, MC_DBUS_SIGNAL_NAME_SEARCH_CMD, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1561,7 +1582,7 @@ int mc_client_send_event_reply(mc_client_h client, const char *server_name, cons mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%d%s%s", mc_client->client_name, MC_STRING_DELIMITER, result_code, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); char *interface_name = _mc_util_get_interface_name(MC_SERVER, server_name); @@ -1569,8 +1590,8 @@ int mc_client_send_event_reply(mc_client_h client, const char *server_name, cons if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Error _mc_ipc_send_message [%d]", ret); - g_free(message); - g_free(interface_name); + MC_SAFE_G_FREE(message); + MC_SAFE_G_FREE(interface_name); return ret; } @@ -1726,12 +1747,12 @@ int mc_client_send_custom_command(mc_client_h client, const char *server_name, c mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%s%s%s", mc_client->client_name, MC_STRING_DELIMITER, command, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); ret = __mc_client_send_command(client, server_name, MC_COMMAND_CUSTOM, command, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND, message, NULL); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1753,7 +1774,7 @@ int mc_client_send_playback_state_command(mc_client_h client, const char *server ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKSTATE, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD, message, NULL); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } diff --git a/src/media_controller_db.c b/src/media_controller_db.c index d1f26e5..53f99a7 100644 --- a/src/media_controller_db.c +++ b/src/media_controller_db.c @@ -123,7 +123,7 @@ int _mc_db_update_playback_info(const char *server_name, const media_controller_ ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -155,7 +155,7 @@ int _mc_db_update_whole_metadata(const char *server_name, ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -174,7 +174,7 @@ int _mc_db_update_icon_uri(const char *server_name, const char *uri) ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -190,7 +190,7 @@ int _mc_db_update_ability_supported(const char *server_name, const media_control ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -236,7 +236,13 @@ int _mc_db_get_playback_info(sqlite3 *handle, const char *server_name, mc_playba ret = __mc_db_get_record(handle, sql_str, &stmt); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "__mc_db_get_record failed [%d]", ret); - _playback = g_new0(media_controller_playback_s, 1); + _playback = (media_controller_playback_s *)calloc(1, sizeof(media_controller_playback_s)); + if (!_playback) { + mc_error("OUT_OF_MEMORY"); + SQLITE3_FINALIZE(stmt); + + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } _playback->state = sqlite3_column_int(stmt, 0); _playback->position = (unsigned long long)sqlite3_column_int64(stmt, 1); @@ -256,25 +262,27 @@ static int __mc_db_get_metadata(sqlite3_stmt *stmt, int col, mc_metadata_h *meta { media_controller_metadata_s *_metadata = NULL; - mc_retvm_if(!stmt, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid stmt"); mc_retvm_if(!metadata, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid metadata"); - _metadata = g_new0(media_controller_metadata_s, 1); - - _metadata->title = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->artist = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->album = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->author = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->genre = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->duration = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->date = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->copyright = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->description = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->track_num = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->picture = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->season = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->episode = g_strdup((const char *)sqlite3_column_text(stmt, col++)); - _metadata->resolution = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata = (media_controller_metadata_s *)calloc(1, sizeof(media_controller_metadata_s)); + mc_retvm_if(!_metadata, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); + + if (stmt != NULL) { + _metadata->title = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->artist = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->album = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->author = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->genre = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->duration = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->date = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->copyright = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->description = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->track_num = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->picture = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->season = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->episode = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + _metadata->resolution = g_strdup((const char *)sqlite3_column_text(stmt, col++)); + } *metadata = (mc_metadata_h)_metadata; @@ -394,7 +402,8 @@ int _mc_db_get_pb_action_ability(sqlite3 *handle, const char *server_name, mc_pl ret = __mc_db_get_ability(handle, server_name, &_decided, &_supported); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__mc_db_get_ability failed"); - basic_ability = g_new0(media_controller_ability_s, 1); + basic_ability = (media_controller_ability_s *)calloc(1, sizeof(media_controller_ability_s)); + mc_retvm_if(!basic_ability, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "malloc failed"); basic_ability->decided = _decided; basic_ability->supported = _supported; @@ -500,7 +509,12 @@ int _mc_db_get_foreach_playlist(sqlite3 *handle, const char *server_name, mc_pla mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle)); while (sqlite3_step(stmt) == SQLITE_ROW) { - mc_playlist_s *_playlist = (mc_playlist_s *)g_new0(mc_playlist_s, 1); + mc_playlist_s *_playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s)); + if (_playlist == NULL) { + mc_error("OUT_OF_MEMORY"); + SQLITE3_FINALIZE(stmt); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } _playlist->server_name = g_strdup(server_name); _playlist->playlist_name = g_strdup((const char *)sqlite3_column_text(stmt, 0)); @@ -541,26 +555,35 @@ gboolean _mc_db_is_playlist_exist(sqlite3 *handle, const char *server_name, cons int _mc_db_get_playlist_by_name(sqlite3 *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist) { - mc_playlist_s *_playlist = NULL; + int ret = MEDIA_CONTROLLER_ERROR_NONE; + gboolean is_exist = FALSE; mc_retvm_if(!controller_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid controller_name"); mc_retvm_if(!playlist_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid playlist_name"); mc_retvm_if(!playlist, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid playlist"); - if (!_mc_db_is_playlist_exist(handle, controller_name, playlist_name)) { - mc_error("playlist is not exist"); - return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER; - } + is_exist = _mc_db_is_playlist_exist(handle, controller_name, playlist_name); - _playlist = g_new0(mc_playlist_s, 1); + if (is_exist) { + mc_playlist_s *_playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s)); + if (_playlist != NULL) { + _playlist->type = type; + _playlist->server_name = g_strdup(controller_name); + _playlist->playlist_name = g_strdup(playlist_name); - _playlist->type = type; - _playlist->server_name = g_strdup(controller_name); - _playlist->playlist_name = g_strdup(playlist_name); + *playlist = (mc_playlist_h)_playlist; - *playlist = (mc_playlist_h)_playlist; + ret = MEDIA_CONTROLLER_ERROR_NONE; + } else { + mc_error("OUT_OF_MEMORY"); + ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + } else { + mc_error("playlist is not exist"); + ret = MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER; + } - return MEDIA_CONTROLLER_ERROR_NONE; + return ret; } int _mc_db_get_playlist_item_count(sqlite3 *handle, const char *server_name, char *playlist_name) @@ -615,12 +638,12 @@ int _mc_db_get_playlist_item(sqlite3 *handle, const char *server_name, char *pla index = g_strdup((char *)sqlite3_column_text(stmt, 0)); if (callback(index, (mc_metadata_h)_metadata, user_data) == false) { - g_free(index); + MC_SAFE_FREE(index); mc_metadata_destroy((mc_metadata_h)_metadata); break; } - g_free(index); + MC_SAFE_FREE(index); mc_metadata_destroy(_metadata); } @@ -756,19 +779,20 @@ int _mc_db_foreach_server_list(sqlite3 *handle, mc_activated_server_cb callback, mc_info("[ * Activated Server List - Start * ]"); while (SQLITE_ROW == ret) { - char *server_name = g_strdup((char *)sqlite3_column_text(stmt, 0)); + char *server_name = NULL; + server_name = strdup((char *)sqlite3_column_text(stmt, 0)); idx++; mc_info("[%d] %s", idx, server_name); if (callback != NULL) { if (callback(server_name, user_data) == false) { - g_free(server_name); + MC_SAFE_FREE(server_name); break; } } - g_free(server_name); + MC_SAFE_FREE(server_name); ret = sqlite3_step(stmt); } @@ -805,18 +829,19 @@ int _mc_db_foreach_client_list(sqlite3 *handle, mc_activated_client_cb callback, mc_info("[ * Activated Client List - Start * ]"); while (SQLITE_ROW == ret) { - char *client_name = g_strdup((char *)sqlite3_column_text(stmt, 0)); + char *client_name = NULL; + client_name = strdup((char *)sqlite3_column_text(stmt, 0)); idx++; mc_info("[%d] %s", idx, client_name); if (callback != NULL) { if (callback(client_name, user_data) == false) { - g_free(client_name); + MC_SAFE_FREE(client_name); break; } } - g_free(client_name); + MC_SAFE_FREE(client_name); ret = sqlite3_step(stmt); } @@ -839,7 +864,7 @@ int _mc_db_update_latest_server_table(const char *server_name) ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -856,7 +881,7 @@ int _mc_db_remove_playlist(const char *server_name, const char *playlist_name) ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -875,7 +900,7 @@ int _mc_db_update_playlist(const char *server_name, const char *playlist_name, b ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -889,7 +914,7 @@ int _mc_db_add_playlist(const char *server_name, const char *playlist_name) ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } @@ -906,7 +931,7 @@ int _mc_db_update_server_attribute(const char *server_name, const char *attribut ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str); - g_free(sql_str); + MC_SAFE_FREE(sql_str); return ret; } diff --git a/src/media_controller_ipc.c b/src/media_controller_ipc.c index 733e552..2daba8d 100644 --- a/src/media_controller_ipc.c +++ b/src/media_controller_ipc.c @@ -83,7 +83,7 @@ static void __dbus_signal_cb(GDBusConnection *connection, mc_secure_error("listener[%s] not found", key); } - g_free(key); + MC_SAFE_FREE(key); } static void __free_dbus_listener(gpointer data) @@ -93,8 +93,8 @@ static void __free_dbus_listener(gpointer data) return; mc_debug("listener[%s] will be unregistered.", listener->key); g_dbus_connection_signal_unsubscribe(listener->dbus_conn, listener->handler); - g_free(listener->key); - g_free(listener); + MC_SAFE_G_FREE(listener->key); + MC_SAFE_FREE(listener); } static gboolean __is_duplicated_dbus_listener(GList *listener_list, const char *key) @@ -185,7 +185,6 @@ int _mc_ipc_unref_dbus_connection(GDBusConnection *connection, int *dref_count) int _mc_ipc_register_listener(GList **listener_list, GDBusConnection *connection, const char *interface_name, const char *signal_name, mc_signal_received_cb callback, void *user_data) { char *key = NULL; - mc_ipc_listener_s *listener = NULL; mc_retvm_if(listener_list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "listener_list is NULL"); mc_retvm_if(connection == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "connection is NULL"); @@ -199,11 +198,16 @@ int _mc_ipc_register_listener(GList **listener_list, GDBusConnection *connection if (__is_duplicated_dbus_listener(*listener_list, key)) { mc_error("listener is duplicated"); - g_free(key); + MC_SAFE_G_FREE(key); return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER; } - listener = g_new0(mc_ipc_listener_s, 1); + mc_ipc_listener_s *listener = (mc_ipc_listener_s *)calloc(1, sizeof(mc_ipc_listener_s)); + if (listener == NULL) { + mc_error("Error memroy allocation"); + MC_SAFE_G_FREE(key); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } listener->dbus_conn = connection; listener->callback = callback; @@ -223,8 +227,8 @@ int _mc_ipc_register_listener(GList **listener_list, GDBusConnection *connection if (listener->handler == 0) { mc_error("Error signal subscribe"); - g_free(key); - g_free(listener); + MC_SAFE_G_FREE(key); + MC_SAFE_FREE(listener); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } @@ -256,7 +260,7 @@ int _mc_ipc_unregister_listener(GList **listener_list, const char *interface_nam mc_debug("listener[%s.%s] is unregistered. listener_cnt[%d]", interface_name, signal_name, g_list_length(*listener_list)); - g_free(key); + MC_SAFE_G_FREE(key); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -285,7 +289,7 @@ int _mc_ipc_unregister_filter_listener(GList **listener_list, const char *server ret = _mc_ipc_unregister_listener(listener_list, filter_interface, signal_name); - g_free(filter_interface); + MC_SAFE_G_FREE(filter_interface); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -320,7 +324,7 @@ static int __make_service_connection(mc_priv_type_e priv_type) ret = _mc_ipc_send_message_to_server(MC_MSG_SERVER_CONNECTION, priv_type, app_id); - g_free(app_id); + MC_SAFE_FREE(app_id); return ret; } @@ -373,7 +377,12 @@ int _mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_t head_msg_size = sizeof(send_msg) - sizeof(send_msg.msg); full_msg_size = head_msg_size + request_msg_size; - temp_buf = g_malloc0(full_msg_size + 1); + temp_buf = (char *)calloc(1, full_msg_size + 1); + if (temp_buf == NULL) { + mc_error("Error memroy allocation"); + close(sockfd); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } memcpy(temp_buf, &send_msg, head_msg_size); memcpy(temp_buf + head_msg_size, request_msg, request_msg_size); @@ -390,7 +399,7 @@ int _mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_t if (send_result < send_msg_size) { mc_stderror("send failed"); close(sockfd); - g_free(temp_buf); + MC_SAFE_FREE(temp_buf); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } temp_buf_index += send_result; @@ -400,7 +409,7 @@ int _mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_t send_msg_size = full_msg_size - temp_buf_index; } - g_free(temp_buf); + MC_SAFE_FREE(temp_buf); /* Receive Response */ int recv_msg_size = -1; diff --git a/src/media_controller_metadata.c b/src/media_controller_metadata.c index aa59a8b..9196790 100644 --- a/src/media_controller_metadata.c +++ b/src/media_controller_metadata.c @@ -36,74 +36,74 @@ int _mc_metadata_set(mc_metadata_h metadata, mc_meta_e attribute, const char *va switch (attribute) { case MC_META_MEDIA_TITLE: - g_free(_metadata->title); + MC_SAFE_FREE(_metadata->title); _metadata->title = g_strdup(value); break; case MC_META_MEDIA_ARTIST: - g_free(_metadata->artist); + MC_SAFE_FREE(_metadata->artist); _metadata->artist = g_strdup(value); break; case MC_META_MEDIA_ALBUM: - g_free(_metadata->album); + MC_SAFE_FREE(_metadata->album); _metadata->album = g_strdup(value); break; case MC_META_MEDIA_AUTHOR: - g_free(_metadata->author); + MC_SAFE_FREE(_metadata->author); _metadata->author = g_strdup(value); break; case MC_META_MEDIA_GENRE: - g_free(_metadata->genre); + MC_SAFE_FREE(_metadata->genre); _metadata->genre = g_strdup(value); break; case MC_META_MEDIA_DURATION: - g_free(_metadata->duration); + MC_SAFE_FREE(_metadata->duration); _metadata->duration = g_strdup(value); break; case MC_META_MEDIA_DATE: - g_free(_metadata->date); + MC_SAFE_FREE(_metadata->date); _metadata->date = g_strdup(value); break; case MC_META_MEDIA_COPYRIGHT: - g_free(_metadata->copyright); + MC_SAFE_FREE(_metadata->copyright); _metadata->copyright = g_strdup(value); break; case MC_META_MEDIA_DESCRIPTION: - g_free(_metadata->description); + MC_SAFE_FREE(_metadata->description); _metadata->description = g_strdup(value); break; case MC_META_MEDIA_TRACK_NUM: - g_free(_metadata->track_num); + MC_SAFE_FREE(_metadata->track_num); _metadata->track_num = g_strdup(value); break; case MC_META_MEDIA_PICTURE: - g_free(_metadata->picture); + MC_SAFE_FREE(_metadata->picture); _metadata->picture = g_strdup(value); break; case MC_META_MEDIA_SEASON: ret = _parse_encoded_meta(MC_META_MEDIA_SEASON, value, &int_val_1, &str_val, NULL); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta"); - g_free(str_val); + MC_SAFE_FREE(str_val); - g_free(_metadata->season); + MC_SAFE_FREE(_metadata->season); _metadata->season = g_strdup(value); break; case MC_META_MEDIA_EPISODE: ret = _parse_encoded_meta(MC_META_MEDIA_EPISODE, value, &int_val_1, &str_val, NULL); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta"); - g_free(str_val); + MC_SAFE_FREE(str_val); - g_free(_metadata->episode); + MC_SAFE_FREE(_metadata->episode); _metadata->episode = g_strdup(value); break; case MC_META_MEDIA_RESOLUTION: ret = _parse_encoded_meta(MC_META_MEDIA_RESOLUTION, value, &int_val_1, NULL, &int_val_2); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta"); - g_free(str_val); + MC_SAFE_FREE(str_val); - g_free(_metadata->resolution); + MC_SAFE_FREE(_metadata->resolution); _metadata->resolution = g_strdup(value); break; default: @@ -118,12 +118,12 @@ int mc_metadata_clone(mc_metadata_h src, mc_metadata_h *dst) { int ret = MEDIA_CONTROLLER_ERROR_NONE; media_controller_metadata_s *_src = (media_controller_metadata_s *)src; - media_controller_metadata_s *_dst = NULL; mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src"); mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst"); - _dst = g_new0(media_controller_metadata_s, 1); + media_controller_metadata_s *_dst = (media_controller_metadata_s*)calloc(1, sizeof(media_controller_metadata_s)); + mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->title = g_strdup(_src->title); _dst->artist = g_strdup(_src->artist); @@ -151,22 +151,22 @@ int mc_metadata_destroy(mc_metadata_h metadata) mc_retvm_if(mc_metadata == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - g_free(mc_metadata->title); - g_free(mc_metadata->artist); - g_free(mc_metadata->album); - g_free(mc_metadata->author); - g_free(mc_metadata->genre); - g_free(mc_metadata->duration); - g_free(mc_metadata->date); - g_free(mc_metadata->copyright); - g_free(mc_metadata->description); - g_free(mc_metadata->track_num); - g_free(mc_metadata->picture); - g_free(mc_metadata->season); - g_free(mc_metadata->episode); - g_free(mc_metadata->resolution); - - g_free(mc_metadata); + MC_SAFE_G_FREE(mc_metadata->title); + MC_SAFE_G_FREE(mc_metadata->artist); + MC_SAFE_G_FREE(mc_metadata->album); + MC_SAFE_G_FREE(mc_metadata->author); + MC_SAFE_G_FREE(mc_metadata->genre); + MC_SAFE_G_FREE(mc_metadata->duration); + MC_SAFE_G_FREE(mc_metadata->date); + MC_SAFE_G_FREE(mc_metadata->copyright); + MC_SAFE_G_FREE(mc_metadata->description); + MC_SAFE_G_FREE(mc_metadata->track_num); + MC_SAFE_G_FREE(mc_metadata->picture); + MC_SAFE_G_FREE(mc_metadata->season); + MC_SAFE_G_FREE(mc_metadata->episode); + MC_SAFE_G_FREE(mc_metadata->resolution); + + MC_SAFE_FREE(mc_metadata); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -186,59 +186,59 @@ int mc_metadata_get(mc_metadata_h metadata, mc_meta_e attribute, char **value) switch (attribute) { case MC_META_MEDIA_TITLE: if (mc_metadata->title != NULL) - meta_val = g_strdup(mc_metadata->title); + meta_val = strdup(mc_metadata->title); break; case MC_META_MEDIA_ARTIST: if (mc_metadata->artist != NULL) - meta_val = g_strdup(mc_metadata->artist); + meta_val = strdup(mc_metadata->artist); break; case MC_META_MEDIA_ALBUM: if (mc_metadata->album != NULL) - meta_val = g_strdup(mc_metadata->album); + meta_val = strdup(mc_metadata->album); break; case MC_META_MEDIA_AUTHOR: if (mc_metadata->author != NULL) - meta_val = g_strdup(mc_metadata->author); + meta_val = strdup(mc_metadata->author); break; case MC_META_MEDIA_GENRE: if (mc_metadata->genre != NULL) - meta_val = g_strdup(mc_metadata->genre); + meta_val = strdup(mc_metadata->genre); break; case MC_META_MEDIA_DURATION: if (mc_metadata->duration != NULL) - meta_val = g_strdup(mc_metadata->duration); + meta_val = strdup(mc_metadata->duration); break; case MC_META_MEDIA_DATE: if (mc_metadata->date != NULL) - meta_val = g_strdup(mc_metadata->date); + meta_val = strdup(mc_metadata->date); break; case MC_META_MEDIA_COPYRIGHT: if (mc_metadata->copyright != NULL) - meta_val = g_strdup(mc_metadata->copyright); + meta_val = strdup(mc_metadata->copyright); break; case MC_META_MEDIA_DESCRIPTION: if (mc_metadata->description != NULL) - meta_val = g_strdup(mc_metadata->description); + meta_val = strdup(mc_metadata->description); break; case MC_META_MEDIA_TRACK_NUM: if (mc_metadata->track_num != NULL) - meta_val = g_strdup(mc_metadata->track_num); + meta_val = strdup(mc_metadata->track_num); break; case MC_META_MEDIA_PICTURE: if (mc_metadata->picture != NULL) - meta_val = g_strdup(mc_metadata->picture); + meta_val = strdup(mc_metadata->picture); break; case MC_META_MEDIA_SEASON: if (mc_metadata->season != NULL) - meta_val = g_strdup(mc_metadata->season); + meta_val = strdup(mc_metadata->season); break; case MC_META_MEDIA_EPISODE: if (mc_metadata->episode != NULL) - meta_val = g_strdup(mc_metadata->episode); + meta_val = strdup(mc_metadata->episode); break; case MC_META_MEDIA_RESOLUTION: if (mc_metadata->resolution != NULL) - meta_val = g_strdup(mc_metadata->resolution); + meta_val = strdup(mc_metadata->resolution); break; default: mc_error("Invalid Parameter [%d]", attribute); @@ -254,12 +254,12 @@ int mc_playback_ability_clone(mc_playback_ability_h src, mc_playback_ability_h * { int ret = MEDIA_CONTROLLER_ERROR_NONE; media_controller_ability_s *_src = (media_controller_ability_s *)src; - media_controller_ability_s *_dst = NULL; mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src"); mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst"); - _dst = g_new0(media_controller_ability_s, 1); + media_controller_ability_s *_dst = (media_controller_ability_s*)calloc(1, sizeof(media_controller_ability_s)); + mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->decided = _src->decided; _dst->supported = _src->supported; @@ -275,7 +275,7 @@ int mc_playback_ability_destroy(mc_playback_ability_h ability) mc_retvm_if(mc_ability == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - g_free(mc_ability); + MC_SAFE_FREE(mc_ability); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -308,12 +308,12 @@ static void __destroy_search_list(gpointer data) { mc_search_item_s *search_item = (mc_search_item_s*)data; - if (!search_item) - return; - - bundle_free(search_item->data); - g_free(search_item->search_keyword); - g_free(search_item); + if (search_item) { + MC_SAFE_FREE(search_item->search_keyword); + if (search_item->data) + bundle_free(search_item->data); + MC_SAFE_FREE(search_item); + } } int mc_search_create(mc_search_h *search) @@ -321,7 +321,8 @@ int mc_search_create(mc_search_h *search) media_controller_search_s *mc_search = NULL; mc_retvm_if(search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL"); - mc_search = (media_controller_search_s *)g_new0(media_controller_search_s, 1); + mc_search = (media_controller_search_s *)calloc(1, sizeof(media_controller_search_s)); + mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory"); *search = (mc_search_h)mc_search; @@ -332,7 +333,6 @@ int mc_search_set_condition(mc_search_h search, mc_content_type_e content_type, { int ret = MEDIA_CONTROLLER_ERROR_NONE; media_controller_search_s *mc_search = (media_controller_search_s *)search; - mc_search_item_s *search_item = NULL; mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL"); mc_retvm_if(((content_type < MC_CONTENT_TYPE_IMAGE) || (content_type > MC_CONTENT_TYPE_UNDECIDED)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "content_type is invalid [%d]", content_type); @@ -341,7 +341,8 @@ int mc_search_set_condition(mc_search_h search, mc_content_type_e content_type, mc_retvm_if(g_list_length(mc_search->search_list) > 20, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Too many search items"); - search_item = g_new0(mc_search_item_s, 1); + mc_search_item_s *search_item = (mc_search_item_s*)calloc(1, sizeof(mc_search_item_s)); + mc_retvm_if(search_item == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); search_item->content_type = content_type; search_item->category = category; @@ -362,7 +363,9 @@ int mc_search_destroy(mc_search_h search) mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL"); g_list_free_full(mc_search->search_list, __destroy_search_list); - g_free(mc_search); + mc_search->search_list = NULL; + + MC_SAFE_FREE(mc_search); return ret; } @@ -448,11 +451,13 @@ int mc_metadata_encode_season(int season_num, const char *season_title, char **e else _meta = g_strdup_printf("%s%s%d%s", KEY_SEASON, MC_STRING_DELIMITER, season_num, MC_STRING_DELIMITER); + mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory"); + _encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta)); *encoded_season = _encoded_meta; - g_free(_meta); + MC_SAFE_G_FREE(_meta); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -469,11 +474,13 @@ int mc_metadata_encode_episode(int episode_num, const char *episode_title, char else _meta = g_strdup_printf("%s%s%d%s", KEY_EPISODE, MC_STRING_DELIMITER, episode_num, MC_STRING_DELIMITER); + mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory"); + _encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta)); *encoded_episode = _encoded_meta; - g_free(_meta); + MC_SAFE_G_FREE(_meta); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -486,12 +493,13 @@ int mc_metadata_encode_resolution(unsigned int width, unsigned int height, char mc_retvm_if(encoded_resolution == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid resolution"); _meta = g_strdup_printf("%s%s%d%s%d", KEY_RESOLUTION, MC_STRING_DELIMITER, width, MC_STRING_DELIMITER, height); + mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory"); _encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta)); *encoded_resolution = _encoded_meta; - g_free(_meta); + MC_SAFE_G_FREE(_meta); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -518,7 +526,7 @@ int _parse_encoded_meta(mc_meta_e attribute, const char *encoded_meta, int *int_ mc_retvm_if(_decoded_meta == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "decoding fail"); params = g_strsplit((const gchar *)_decoded_meta, MC_STRING_DELIMITER, 0); - g_free(_decoded_meta); + MC_SAFE_G_FREE(_decoded_meta); mc_retvm_if(params == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "parsing fail"); if ((params[0] == NULL) || (params[1] == NULL) || (params[2] == NULL)) { diff --git a/src/media_controller_playlist.c b/src/media_controller_playlist.c index 8826894..3d53ee8 100644 --- a/src/media_controller_playlist.c +++ b/src/media_controller_playlist.c @@ -25,14 +25,21 @@ typedef struct { media_controller_metadata_s *metadata; } mc_playlist_item_s; -static void __release_playlist_item(gpointer data) +static void __release_playlist_item(mc_playlist_item_s *playlist_item) { - mc_playlist_item_s *playlist_item = (mc_playlist_item_s *)data; - mc_retm_if(!playlist_item, "invalid playlist_item"); + mc_retm_if(playlist_item == NULL, "invalid playlist_item"); - g_free(playlist_item->index); + MC_SAFE_FREE(playlist_item->index); mc_metadata_destroy((mc_metadata_h)playlist_item->metadata); - g_free(playlist_item); + MC_SAFE_FREE(playlist_item); +} + +static void __item_destroy(gpointer data) +{ + mc_playlist_item_s *item = (mc_playlist_item_s *)data; + + if (item) + __release_playlist_item(item); } static gint __compare_playlist_index(gconstpointer data, gconstpointer user_data) @@ -87,7 +94,7 @@ static int __get_bundle_data(GList *playlist, bundle_raw **bundle_data, int *bun if (meta) { ret = bundle_add_str(bundle, item->index, meta); - g_free(meta); + MC_SAFE_G_FREE(meta); if (ret != BUNDLE_ERROR_NONE) mc_error("fail to bundle_add_str[%p]", iter->data); } @@ -126,7 +133,7 @@ int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlis if (_playlist->item_list != NULL) { ret = __get_bundle_data(_playlist->item_list, &bundle_data, &bundle_size); - g_list_free_full(_playlist->item_list, __release_playlist_item); + g_list_free_full(_playlist->item_list, __item_destroy); _playlist->item_list = NULL; mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__get_bundle_data failed"); @@ -150,12 +157,11 @@ int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlis int mc_playlist_create(const char *playlist_name, mc_playlist_h *playlist) { - mc_playlist_s *_playlist = NULL; - mc_retvm_if(!MC_STRING_VALID(playlist_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist_name"); mc_retvm_if(playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist"); - _playlist = g_new0(mc_playlist_s, 1); + mc_playlist_s *_playlist = (mc_playlist_s*)calloc(1, sizeof(mc_playlist_s)); + mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _playlist->playlist_name = g_strdup(playlist_name); @@ -178,9 +184,16 @@ int mc_playlist_update_item(mc_playlist_h playlist, const char *index, mc_meta_e found_item = g_list_find_custom(_playlist->item_list, (void *)index, __compare_playlist_index); if (!found_item) { - _playlist_item = g_new0(mc_playlist_item_s, 1); + _playlist_item = (mc_playlist_item_s*)calloc(1, sizeof(mc_playlist_item_s)); + mc_retvm_if(_playlist_item == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory alloc fail"); + + _playlist_item->metadata = (media_controller_metadata_s*)calloc(1, sizeof(media_controller_metadata_s)); + if (_playlist_item->metadata == NULL) { + mc_error("memory alloc fail"); + MC_SAFE_FREE(_playlist_item); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } - _playlist_item->metadata = g_new0(media_controller_metadata_s, 1); _playlist_item->index = g_strdup(index); } else { _playlist_item = (mc_playlist_item_s *)found_item->data; @@ -327,12 +340,12 @@ int mc_playlist_clone(mc_playlist_h src, mc_playlist_h *dst) { int ret = MEDIA_CONTROLLER_ERROR_NONE; mc_playlist_s *_src = (mc_playlist_s*)src; - mc_playlist_s *_dst = NULL; mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src"); mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst"); - _dst = (mc_playlist_s*)g_new0(mc_playlist_s, 1); + mc_playlist_s *_dst = (mc_playlist_s*)calloc(1, sizeof(mc_playlist_s)); + mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); _dst->server_name = g_strdup(_src->server_name); _dst->playlist_name = g_strdup(_src->playlist_name); @@ -349,10 +362,10 @@ int mc_playlist_destroy(mc_playlist_h playlist) mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist"); - g_free(_playlist->server_name); - g_free(_playlist->playlist_name); - g_list_free_full(_playlist->item_list, __release_playlist_item); - g_free(_playlist); + MC_SAFE_FREE(_playlist->server_name); + MC_SAFE_FREE(_playlist->playlist_name); + g_list_free_full(_playlist->item_list, __item_destroy); + MC_SAFE_FREE(_playlist); return ret; } diff --git a/src/media_controller_server.c b/src/media_controller_server.c index 5460b3b..8df2610 100644 --- a/src/media_controller_server.c +++ b/src/media_controller_server.c @@ -70,7 +70,8 @@ static int __mc_server_create(media_controller_server_s **mc_server) mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - _server = g_new0(media_controller_server_s, 1); + _server = (media_controller_server_s *)calloc(1, sizeof(media_controller_server_s)); + mc_retvm_if(_server == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory"); ret = _mc_util_get_own_name(&(_server->server_name)); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { @@ -84,7 +85,12 @@ static int __mc_server_create(media_controller_server_s **mc_server) _server->playback.index = NULL; _server->playback.content_type = MC_CONTENT_TYPE_UNDECIDED; - _server->metadata = g_new0(media_controller_metadata_s, 1); + _server->metadata = (media_controller_metadata_s *)calloc(1, sizeof(media_controller_metadata_s)); + if (_server->metadata == NULL) { + mc_error("Error allocation memory"); + ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + goto ERROR; + } _server->basic_ability.decided = (unsigned long)MC_BIT64_UNSET; _server->basic_ability.supported = (unsigned long)MC_BIT64_UNSET; @@ -112,9 +118,9 @@ ERROR: if (_server->db_handle) mc_db_disconnect(_server->db_handle); - g_free(_server->server_name); - g_free(_server->metadata); - g_free(_server); + MC_SAFE_FREE(_server->server_name); + MC_SAFE_FREE(_server->metadata); + MC_SAFE_FREE(_server); return ret; } @@ -142,12 +148,13 @@ static int __mc_server_destoy(media_controller_server_s *mc_server) if (mc_server->listeners != NULL) g_list_free(mc_server->listeners); - g_free(mc_server->server_name); + MC_SAFE_FREE(mc_server->server_name); - mc_metadata_destroy(mc_server->metadata); + if (mc_server->metadata != NULL) + mc_metadata_destroy(mc_server->metadata); - g_free(mc_server->playback.index); - g_free(mc_server); + MC_SAFE_FREE(mc_server->playback.index); + MC_SAFE_FREE(mc_server); return ret; } @@ -350,24 +357,24 @@ static void __server_custom_cmd_cb(const char *interface_name, const char *signa mc_retm_if(params == NULL, "invalid custom data"); if (params[0]) - sender = g_strdup(params[0]); + sender = strdup(params[0]); if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, sender, MC_COMMAND_CUSTOMACTION, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("Error permission denied"); - g_free(sender); + MC_SAFE_FREE(sender); g_strfreev(params); return; } - command = g_strdup(params[1]); + command = strdup(params[1]); enc_size = atoi(params[2]); if (enc_size > 0) bundle_data = bundle_decode((bundle_raw *)params[3], enc_size); callback(sender, request_id, command, bundle_data, receiver->user_data); - g_free(sender); - g_free(command); + MC_SAFE_FREE(sender); + MC_SAFE_FREE(command); g_strfreev(params); } @@ -416,7 +423,6 @@ static void __search_cb(const char *key, const int type, const bundle_keyval_t int bundle_size = 0; bundle *bundle_data = NULL; GList **mc_search = (GList**)user_data; - mc_search_item_s *search_item = NULL; bundle_keyval_get_basic_val((bundle_keyval_t *)kv, &basic_val, &basic_size); @@ -452,12 +458,21 @@ static void __search_cb(const char *key, const int type, const bundle_keyval_t g_strfreev(params); - search_item = g_new0(mc_search_item_s, 1); + mc_search_item_s *search_item = (mc_search_item_s*)calloc(1, sizeof(mc_search_item_s)); + if (search_item == NULL) { + mc_error("Error OUT_OF_MEMORY"); + MC_SAFE_FREE(keyword); + bundle_free(bundle_data); + return; + } search_item->content_type = content_type; search_item->category = category; search_item->search_keyword = keyword; - search_item->data = bundle_data; + search_item->data = bundle_dup(bundle_data); + + if (bundle_data != NULL) + bundle_free(bundle_data); *mc_search = g_list_append(*mc_search, search_item); } @@ -507,7 +522,13 @@ static void __server_search_cmd_cb(const char *interface_name, const char *signa return; } - mc_search = g_new0(media_controller_search_s, 1); + mc_search = (media_controller_search_s *)calloc(1, sizeof(media_controller_search_s)); + if (mc_search == NULL) { + mc_error("Error allocation memory"); + g_strfreev(params); + bundle_free(bundle_data); + return; + } bundle_foreach(bundle_data, __search_cb, &mc_search->search_list); @@ -679,8 +700,8 @@ static int __mc_server_send_message(media_controller_server_s *mc_server, const mc_error("Error _mc_ipc_send_message [%d]", ret); } - g_free(filter_interface_name); - g_free(message); + MC_SAFE_G_FREE(filter_interface_name); + MC_SAFE_G_FREE(message); return ret; } @@ -716,7 +737,7 @@ static int __mc_server_send_event(mc_server_h server, const char *client_name, c if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Error _mc_ipc_send_message [%d]", ret); - g_free(interface_name); + MC_SAFE_G_FREE(interface_name); return ret; } @@ -759,10 +780,15 @@ int mc_server_set_playlist_item_index(mc_server_h server, const char *index) mc_debug("index update [%s]", index); - g_free(mc_server->playback.index); + MC_SAFE_FREE(mc_server->playback.index); mc_server->playback.index = g_strdup(index); + if (mc_server->playback.index == NULL) { + mc_error("Fail to set playlist item index"); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + return MEDIA_CONTROLLER_ERROR_NONE; } @@ -775,12 +801,19 @@ int mc_server_set_playlist_item_info(mc_server_h server, const char *playlist_na mc_retvm_if(strlen(playlist_name) > MAX_INPUT_STR_LEN, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Playlist_name is too long. The length of the playlist name should be less than %d byte", MAX_INPUT_STR_LEN); mc_retvm_if(!MC_STRING_VALID(index), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid index"); - g_free(mc_server->playback.playlist_name); - g_free(mc_server->playback.index); + MC_SAFE_FREE(mc_server->playback.playlist_name); + MC_SAFE_FREE(mc_server->playback.index); mc_server->playback.playlist_name = g_strdup(playlist_name); mc_server->playback.index = g_strdup(index); + if ((mc_server->playback.playlist_name == NULL) || (mc_server->playback.index == NULL)) { + mc_error("Fail to set playlist item info"); + MC_SAFE_FREE(mc_server->playback.playlist_name); + MC_SAFE_FREE(mc_server->playback.index); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + return MEDIA_CONTROLLER_ERROR_NONE; } @@ -1096,7 +1129,7 @@ static int __mc_server_set_updated_cb(mc_server_h server, mc_server_receive_even ret = _mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, cb_event[event].signal_name, cb_event[event].cb_func, (void *)&(mc_server->updated_cb[event])); - g_free(interface_name); + MC_SAFE_FREE(interface_name); return ret; } @@ -1117,7 +1150,7 @@ static int __mc_server_unset_updated_cb(mc_server_h server, mc_server_receive_ev mc_server->updated_cb[event].callback = NULL; mc_server->updated_cb[event].user_data = NULL; - g_free(interface_name); + MC_SAFE_FREE(interface_name); return ret; } @@ -1256,7 +1289,7 @@ int mc_server_send_cmd_reply(mc_server_h server, const char *client_name, const mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%d%s%s", mc_server->server_name, MC_STRING_DELIMITER, result_code, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); char *interface_name = _mc_util_get_interface_name(MC_CLIENT, client_name); @@ -1264,8 +1297,8 @@ int mc_server_send_cmd_reply(mc_server_h server, const char *client_name, const if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Error _mc_ipc_send_message [%d]", ret); - g_free(message); - g_free(interface_name); + MC_SAFE_G_FREE(message); + MC_SAFE_G_FREE(interface_name); return ret; } @@ -1294,12 +1327,12 @@ int mc_server_send_custom_event(mc_server_h server, const char *client_name, con mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%s%s%s", mc_server->server_name, MC_STRING_DELIMITER, event, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); ret = __mc_server_send_event(server, client_name, MC_EVENT_CUSTOM, event, MC_DBUS_SIGNAL_NAME_CUSTOM_EVENT, message, request_id); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -1585,24 +1618,24 @@ static void __server_custom_command_cb(const char *interface_name, const char *s mc_retm_if(params == NULL, "invalid custom data"); if (params[0]) - sender = g_strdup(params[0]); + sender = strdup(params[0]); if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, sender, MC_COMMAND_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) { mc_error("Error permission denied"); - g_free(sender); + MC_SAFE_FREE(sender); g_strfreev(params); return; } - command = g_strdup(params[1]); + command = strdup(params[1]); enc_size = atoi(params[2]); if (enc_size > 0) bundle_data = bundle_decode((bundle_raw *)params[3], enc_size); callback(sender, command, bundle_data, receiver->user_data); - g_free(sender); - g_free(command); + MC_SAFE_FREE(sender); + MC_SAFE_FREE(command); g_strfreev(params); } @@ -1622,7 +1655,7 @@ int mc_server_send_command_reply(mc_server_h server, const char *client_name, in mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle"); message = g_strdup_printf("%s%s%d%s%s", mc_server->server_name, MC_STRING_DELIMITER, result_code, MC_STRING_DELIMITER, bundle_str); - g_free(bundle_str); + MC_SAFE_G_FREE(bundle_str); mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message"); char *interface_name = _mc_util_get_interface_name(MC_CLIENT, client_name); @@ -1630,8 +1663,8 @@ int mc_server_send_command_reply(mc_server_h server, const char *client_name, in if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Error _mc_ipc_send_message [%d]", ret); - g_free(message); - g_free(interface_name); + MC_SAFE_G_FREE(message); + MC_SAFE_G_FREE(interface_name); return ret; } diff --git a/src/media_controller_util.c b/src/media_controller_util.c index 3a997a0..5027b62 100644 --- a/src/media_controller_util.c +++ b/src/media_controller_util.c @@ -108,7 +108,7 @@ char *_mc_util_get_interface_name(const char *type, const char *name) temp = g_strdup_printf("%s.%s%s", MC_DBUS_INTERFACE_PREFIX, type, name); __mc_util_check_valid_name(temp, &interface_name); - g_free(temp); + MC_SAFE_G_FREE(temp); return interface_name; } @@ -122,9 +122,14 @@ int _mc_util_make_filter_interface_name(const char *prefix, const char *filter, temp = g_strdup_printf("%s.server%s", prefix, filter); + if (temp == NULL) { + mc_error("Fail to make interface_name"); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + __mc_util_check_valid_name(temp, interface_name); - g_free(temp); + MC_SAFE_G_FREE(temp); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -146,7 +151,7 @@ static int __send_command_available(mc_priv_type_e priv_type, const char *name, ret = _mc_ipc_send_message_to_server(msg_type, priv_type, message); - g_free(message); + MC_SAFE_G_FREE(message); return ret; } @@ -196,6 +201,9 @@ int _mc_util_bundle_to_string(bundle *bundle_data, char **str_data) else *str_data = g_strdup_printf("%d%s%s", size_r, MC_STRING_DELIMITER, (unsigned char *)raw_data); + if (*str_data == NULL) + ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + MC_SAFE_FREE(raw_data); return ret; diff --git a/svc/media_controller_cynara.c b/svc/media_controller_cynara.c index b0d7028..d99302c 100755 --- a/svc/media_controller_cynara.c +++ b/svc/media_controller_cynara.c @@ -91,8 +91,15 @@ int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_ size_t msg_index = 0; char *recv_buf = NULL; - recv_buf = g_malloc0(MAX_MSG_SIZE + 1); - recv_msg->msg = g_malloc0(recv_msg->msg_size + 1); + recv_buf = (char *)calloc(1, MAX_MSG_SIZE + 1); + recv_msg->msg = (char *)calloc(1, recv_msg->msg_size + 1); + + if (recv_buf == NULL || recv_msg->msg == NULL) { + mc_error("Error memroy allocation"); + MC_SAFE_FREE(recv_buf); + MC_SAFE_FREE(recv_msg->msg); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } while (remain_size > 0) { memset(recv_buf, 0, MAX_MSG_SIZE + 1); @@ -102,8 +109,8 @@ int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_ block_size = MAX_MSG_SIZE; if ((recv_msg_size = read(sockfd, recv_buf, block_size)) < block_size) { - g_free(recv_buf); - g_free(recv_msg->msg); + MC_SAFE_FREE(recv_buf); + MC_SAFE_FREE(recv_msg->msg); if (errno == EWOULDBLOCK) { mc_error("Timeout. Can't try any more"); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; @@ -124,7 +131,7 @@ int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_ remain_size -= recv_msg_size; } - g_free(recv_buf); + MC_SAFE_FREE(recv_buf); } else { mc_error("wrong msg_size [%zu]", recv_msg->msg_size); recv_msg->msg = NULL; diff --git a/svc/media_controller_db_util.c b/svc/media_controller_db_util.c index ccebb91..c4d7adc 100644 --- a/svc/media_controller_db_util.c +++ b/svc/media_controller_db_util.c @@ -320,7 +320,7 @@ int mc_db_connect(sqlite3 **handle, uid_t uid, gboolean needwrite) else ret = sqlite3_open_v2(db_path, &db_handle, SQLITE_OPEN_READONLY, NULL); - g_free(db_path); + MC_SAFE_G_FREE(db_path); mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "error when db open"); mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "db_handle is NULL"); @@ -396,7 +396,7 @@ int mc_db_util_remove_db(uid_t uid) mc_retvm_if(db_path == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "error when get db path"); db_file = g_file_new_for_path(db_path); - g_free(db_path); + MC_SAFE_G_FREE(db_path); mc_retvm_if(db_file == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "could not open file"); result = g_file_delete(db_file, NULL, &g_error); diff --git a/svc/media_controller_svc.c b/svc/media_controller_svc.c index 437b630..3849d7b 100644 --- a/svc/media_controller_svc.c +++ b/svc/media_controller_svc.c @@ -77,12 +77,12 @@ static int __mc_sys_get_uid(uid_t *uid) static void __mc_destroy_queue(gpointer data) { mc_service_request *req = (mc_service_request *)data; - mc_retm_if(!req, "invalid request"); - - if (req->req_msg) - g_free(req->req_msg->msg); - g_free(req->req_msg); - g_free(req); + if (req != NULL) { + if (req->req_msg != NULL) + MC_SAFE_FREE(req->req_msg->msg); + MC_SAFE_FREE(req->req_msg); + MC_SAFE_FREE(req); + } } static void __mc_destroy_connected_apps(gpointer data) @@ -94,21 +94,41 @@ static void __mc_destroy_connected_apps(gpointer data) g_list_free_full(_app_data->cmds_to_send, g_free); _app_data->cmds_to_send = NULL; } - g_free(_app_data->app_id); - g_free(_app_data); + MC_SAFE_FREE(_app_data->app_id); + MC_SAFE_FREE(_app_data); } -static void __mc_destroy_request_queue(mc_manage_queue_t *data) +static int __mc_create_request_queue(mc_manage_queue_t **data) { - mc_retm_if(!data, "invalid data"); + mc_manage_queue_t *_request = (mc_manage_queue_t *)calloc(1, sizeof(mc_manage_queue_t)); + mc_retvm_if(!_request, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Failed to create queue manager"); + + _request->queue = g_queue_new(); + + if (!_request->queue) { + mc_error("Failed to create new queue"); + MC_SAFE_FREE(_request); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } + + *data = _request; - g_queue_free_full(data->queue, __mc_destroy_queue); - data->queue = NULL; + return MEDIA_CONTROLLER_ERROR_NONE; +} - g_source_unref(data->source); - data->source = NULL; +static void __mc_destroy_request_queue(mc_manage_queue_t *data) +{ + mc_retm_if(!data, "invalid data"); - g_free(data); + if (data->queue) { + g_queue_free_full(data->queue, __mc_destroy_queue); + data->queue = NULL; + } + if (data->source) { + g_source_unref(data->source); + data->source = NULL; + } + MC_SAFE_FREE(data); } static void __mc_add_cmd_to_send(gpointer data, gpointer user_data) @@ -170,47 +190,53 @@ static int __mc_list_get_index(GList *list, int pid, mc_priv_type_e priv_type) static int __mc_list_remove_item(GList **list, int index) { - GList *found = NULL; - mc_retvm_if(list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid list"); mc_retvm_if(index < 0 || index >= (int)g_list_length(*list), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid index"); mc_secure_error("[No-error] index : %d", index); - found = g_list_nth(*list, index); - - if (!found) { - mc_secure_debug("app_data has been already removed."); - return MEDIA_CONTROLLER_ERROR_NONE; + mc_app_data_set_t *app_data = g_list_nth_data(*list, index); + if (app_data != NULL) { + *list = g_list_remove(*list, app_data); + MC_SAFE_FREE(app_data->app_id); + if (app_data->cmds_to_send) { + mc_secure_error("[No-error] cmd_to_send length [%u]", g_list_length(app_data->cmds_to_send)); + g_list_free_full(app_data->cmds_to_send, g_free); + } + MC_SAFE_FREE(app_data); + mc_secure_error("[No-error] cmd_to_send has been removed"); } - *list = g_list_remove_link(*list, found); - g_list_free_full(found, __mc_destroy_connected_apps); - return MEDIA_CONTROLLER_ERROR_NONE; } -static void __mc_service_init(mc_service_t **data) +static int __mc_service_init(mc_service_t **data) { - mc_service_t *_service_data = g_new0(mc_service_t, 1); + int res = MEDIA_CONTROLLER_ERROR_NONE; + mc_service_t *_service_data = (mc_service_t *)calloc(1, sizeof(mc_service_t)); + mc_retvm_if(!_service_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Failed to allocate service data"); - _service_data->request = g_new0(mc_manage_queue_t, 1); - _service_data->request->queue = g_queue_new(); + res = __mc_create_request_queue(&(_service_data->request)); + if (res != MEDIA_CONTROLLER_ERROR_NONE) { + mc_error("Failed to create queue data"); + MC_SAFE_FREE(_service_data); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } *data = _service_data; + + return MEDIA_CONTROLLER_ERROR_NONE; } static void __mc_service_deinit(mc_service_t *data) { - if (!data) - return; - - if (data->request != NULL) - __mc_destroy_request_queue(data->request); - if (data->connected_apps != NULL) - g_list_free_full(data->connected_apps, __mc_destroy_connected_apps); - - g_free(data); + if (data != NULL) { + if (data->request != NULL) + __mc_destroy_request_queue(data->request); + if (data->connected_apps != NULL) + g_list_free_full(data->connected_apps, __mc_destroy_connected_apps); + MC_SAFE_FREE(data); + } } static int __mc_service_check_db(uid_t uid) @@ -226,7 +252,7 @@ static int __mc_service_check_db(uid_t uid) /* Check the database exists */ if (!g_file_test(db_path, G_FILE_TEST_EXISTS)) { mc_error("[NO-ERROR] DB is not created yet, do not need to check DB"); - g_free(db_path); + MC_SAFE_G_FREE(db_path); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -234,16 +260,16 @@ static int __mc_service_check_db(uid_t uid) if (stat(db_path, &buf) == 0) { if (buf.st_size == 0) { mc_warning("The size of database is error"); - g_free(db_path); + MC_SAFE_G_FREE(db_path); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } } else { mc_stderror("stat failed"); - g_free(db_path); + MC_SAFE_G_FREE(db_path); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } - g_free(db_path); + MC_SAFE_G_FREE(db_path); /* Connect media controller DB*/ res = mc_db_connect(&db_handle, uid, TRUE); @@ -321,7 +347,7 @@ static int __mc_service_reset_db(uid_t uid) if (res != MEDIA_CONTROLLER_ERROR_NONE) mc_error("mc_db_util_migration failed [%d]", res); - g_free(latest_server_name); + MC_SAFE_FREE(latest_server_name); } } @@ -384,7 +410,8 @@ static int __mc_service_add_connection(GList **connected_list, mc_comm_msg_s *re return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER; } - _app_data = g_new0(mc_app_data_set_t, 1); + _app_data = (mc_app_data_set_t *)calloc(1, sizeof(mc_app_data_set_t)); + mc_retvm_if(!_app_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory allocation is failed"); _app_data->uid = request_msg->uid; _app_data->pid = request_msg->pid; @@ -432,8 +459,8 @@ static int __mc_service_add_cmd_to_send(GList **connected_list, mc_comm_msg_s *r static int __mc_service_remove_cmd_to_send(GList **connected_list, mc_comm_msg_s *request_msg) { - int ret = MEDIA_CONTROLLER_ERROR_NONE; - mc_list_user_data *user_data = g_new0(mc_list_user_data, 1); + mc_list_user_data *user_data = calloc(1, sizeof(mc_list_user_data)); + mc_retvm_if(!user_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory allocation is failed"); user_data->message = request_msg; user_data->result = 0; @@ -441,11 +468,13 @@ static int __mc_service_remove_cmd_to_send(GList **connected_list, mc_comm_msg_s g_list_foreach(*connected_list, __mc_remove_cmd_to_send, user_data); mc_debug("user_data->result : %d", user_data->result); - if (user_data->result == 0) - ret = MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED; - - g_free(user_data); - return ret; + if (user_data->result > 0) { + MC_SAFE_FREE(user_data); + return MEDIA_CONTROLLER_ERROR_NONE; + } else { + MC_SAFE_FREE(user_data); + return MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED; + } } static int __mc_notify_server_updated(const char *server_name, mc_server_state_e state) @@ -467,6 +496,11 @@ static int __mc_notify_server_updated(const char *server_name, mc_server_state_e } message = g_strdup_printf("%s%s%d", server_name, MC_STRING_DELIMITER, state); + if (message == NULL) { + mc_secure_error("Error in message generation"); + g_object_unref(bus); + return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + } /* Send the signal */ emmiting = g_dbus_connection_emit_signal( @@ -481,12 +515,12 @@ static int __mc_notify_server_updated(const char *server_name, mc_server_state_e mc_secure_error("Failed to emit gdbus signal : %s", error ? error->message : "none"); g_error_free(error); g_object_unref(bus); - g_free(message); + MC_SAFE_G_FREE(message); return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION; } g_object_unref(bus); - g_free(message); + MC_SAFE_G_FREE(message); return MEDIA_CONTROLLER_ERROR_NONE; } @@ -613,7 +647,10 @@ ERROR: if (close(req->client_sock) < 0) mc_stderror("close failed"); - __mc_destroy_queue(req); + if (req->req_msg != NULL) + MC_SAFE_FREE(req->req_msg->msg); + MC_SAFE_FREE(req->req_msg); + MC_SAFE_FREE(req); return G_SOURCE_CONTINUE; } @@ -644,8 +681,19 @@ static gboolean __mc_read_service_request_tcp_socket(GIOChannel *src, GIOConditi mc_peer_creds creds; memset(&creds, 0x00, sizeof(mc_peer_creds)); - req = g_new0(mc_service_request, 1); - req->req_msg = g_new0(mc_comm_msg_s, 1); + req = (mc_service_request *) calloc(1, sizeof(mc_service_request)); + if (req == NULL) { + mc_error("memory allocation is failed"); + send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + goto ERROR; + } + + req->req_msg = (mc_comm_msg_s *) calloc(1, sizeof(mc_comm_msg_s)); + if (req->req_msg == NULL) { + mc_error("memory allocation is failed"); + send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY; + goto ERROR; + } req->client_sock = client_sock; ret = mc_cynara_receive_untrusted_message(req->client_sock, req->req_msg, &creds); @@ -707,8 +755,12 @@ ERROR: if (close(client_sock) < 0) mc_stderror("close failed"); - __mc_destroy_queue(req); - + if (req != NULL) { + if (req->req_msg != NULL) + MC_SAFE_FREE(req->req_msg->msg); + MC_SAFE_FREE(req->req_msg); + MC_SAFE_FREE(req); + } MC_SAFE_FREE(creds.uid); MC_SAFE_FREE(creds.smack); @@ -728,7 +780,12 @@ gpointer mc_svc_thread(gpointer data) mc_debug_fenter(); /* Init data */ - __mc_service_init(&mc_service_data); + ret = __mc_service_init(&mc_service_data); + if (ret != MEDIA_CONTROLLER_ERROR_NONE) { + mc_error("Failed to create data"); + __mc_service_deinit(mc_service_data); + return NULL; + } /* Get uid for login user */ ret = __mc_sys_get_uid(&uid); diff --git a/test/client_test/media_controller_client_test.c b/test/client_test/media_controller_client_test.c index 74d7ea5..3c29332 100755 --- a/test/client_test/media_controller_client_test.c +++ b/test/client_test/media_controller_client_test.c @@ -142,8 +142,8 @@ void __get_and_check_metadata(mc_metadata_h metadata) mc_debug("metadata [%d] value is NULL\n", idx); } - g_free(str_val); - g_free(value); + MC_SAFE_FREE(str_val); + MC_SAFE_FREE(value); } } @@ -172,8 +172,8 @@ void _mc_playback_updated_cb(const char *server_name, mc_playback_h playback, vo mc_debug("[Client:%s] Playback updated from server[%s] playback_state[%d] position[%lld] playlist_name [%s] index[%s] content_type[%d] age_rating[%d]", _client->client_name, server_name, playback_state, position, playlist_name, index, content_type, age_rating); - g_free(playlist_name); - g_free(index); + MC_SAFE_FREE(playlist_name); + MC_SAFE_FREE(index); } void _mc_metadata_updated_cb(const char *server_name, mc_metadata_h metadata, void *user_data) @@ -220,7 +220,7 @@ void _mc_playlist_updated_cb(const char *server_name, mc_playlist_update_mode_e mc_debug("playlist_name [%s]", _name); - g_free(_name); + MC_SAFE_FREE(_name); ret = mc_playlist_get_item_count(playlist, &_item_cnt); if (ret != MEDIA_CONTROLLER_ERROR_NONE) @@ -260,8 +260,8 @@ void _mc_cmd_reply_received_cb(const char *server_name, const char *request_id, for (i = 0; i < TEST_REQ_MAX; i++) { if ((g_request_id[i] != NULL) && (strcmp(request_id, g_request_id[i]) == 0)) { found = 1; - find_request_id = g_strdup(g_request_id[i]); - g_free(g_request_id[i]); + find_request_id = strdup(g_request_id[i]); + MC_SAFE_FREE(g_request_id[i]); break; } } @@ -280,7 +280,7 @@ void _mc_cmd_reply_received_cb(const char *server_name, const char *request_id, mc_error("[Client:%s] Reply result code[%d] from server[%s]", _client->client_name, result_code, server_name); } - g_free(find_request_id); + MC_SAFE_FREE(find_request_id); } @@ -583,7 +583,7 @@ bool server_playlist_cb(mc_playlist_h playlist, void *user_data) return false; } - g_free(g_playlist_name); + MC_SAFE_FREE(g_playlist_name); ret = mc_playlist_get_name(playlist, &g_playlist_name); if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Fail to mc_playlist_get_name [%d]", ret); @@ -658,8 +658,8 @@ static gboolean _get_info(int type) g_print("playback state [%d], position [%lld], playlist_name [%s], index [%s], content_type[%d]", playback_state, playback_position, playlist_name, index, content_type); - g_free(playlist_name); - g_free(index); + MC_SAFE_FREE(playlist_name); + MC_SAFE_FREE(index); ret = mc_client_destroy_playback(playback); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_destroy_playback [%d]", ret); @@ -701,7 +701,7 @@ static gboolean _get_info(int type) mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_icon [%d]", ret); g_print("icon url: %s \n", icon_url); - g_free(icon_url); + MC_SAFE_FREE(icon_url); ret = mc_client_get_server_subtitles_enabled(g_mc_client, g_server_name, &b_value); mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_subtitles_enabled [%d]", ret); @@ -990,8 +990,8 @@ static gboolean _destroy() g_mc_client = NULL; - g_free(g_server_name); - g_free(g_playlist_name); + MC_SAFE_FREE(g_server_name); + MC_SAFE_FREE(g_playlist_name); mc_debug_fleave(); diff --git a/test/server_test/media_controller_server_test.c b/test/server_test/media_controller_server_test.c index 81ec54c..f95a1c4 100755 --- a/test/server_test/media_controller_server_test.c +++ b/test/server_test/media_controller_server_test.c @@ -152,8 +152,8 @@ static void __get_and_check_metadata(mc_metadata_h metadata) mc_debug("metadata [%d] value is NULL", idx); } - g_free(str_val); - g_free(value); + MC_SAFE_FREE(str_val); + MC_SAFE_FREE(value); } } @@ -331,7 +331,7 @@ static bool __server_playlist_list_cb(mc_playlist_h playlist, void *user_data) if (ret != MEDIA_CONTROLLER_ERROR_NONE) mc_error("Fail to mc_playlist_foreach_item [%d]", ret); - g_free(playlist_name); + MC_SAFE_FREE(playlist_name); return true; } @@ -378,9 +378,9 @@ static int __update_playlist(mc_server_h server, mc_playlist_update_mode_e mode) mc_server_add_item_to_playlist(server, playlist_1, "1", MC_META_MEDIA_EPISODE, episode); mc_server_add_item_to_playlist(server, playlist_1, "1", MC_META_MEDIA_RESOLUTION, resolution); - g_free(season); - g_free(episode); - g_free(resolution); + MC_SAFE_FREE(season); + MC_SAFE_FREE(episode); + MC_SAFE_FREE(resolution); ret = mc_metadata_encode_season(2, NULL, &season); ret = mc_metadata_encode_episode(2, NULL, &episode); @@ -401,9 +401,9 @@ static int __update_playlist(mc_server_h server, mc_playlist_update_mode_e mode) mc_server_add_item_to_playlist(server, playlist_1, "2", MC_META_MEDIA_EPISODE, episode); mc_server_add_item_to_playlist(server, playlist_1, "2", MC_META_MEDIA_RESOLUTION, resolution); - g_free(season); - g_free(episode); - g_free(resolution); + MC_SAFE_FREE(season); + MC_SAFE_FREE(episode); + MC_SAFE_FREE(resolution); for (idx = 3; idx < 100; idx++) { char idx_str[255] = {0,}; @@ -436,7 +436,7 @@ static int __update_playlist(mc_server_h server, mc_playlist_update_mode_e mode) mc_debug("playlist_name [%s]", playlist_name); - g_free(playlist_name); + MC_SAFE_FREE(playlist_name); mc_server_add_item_to_playlist(server, playlist_1, "100", MC_META_MEDIA_PICTURE, "picture_100"); ret = mc_server_update_playlist_done(server, playlist_1); @@ -466,7 +466,7 @@ static int __update_playlist(mc_server_h server, mc_playlist_update_mode_e mode) mc_debug("Remove playlist [%s]", playlist_name); - g_free(playlist_name); + MC_SAFE_FREE(playlist_name); ret = mc_server_delete_playlist(server, playlist); if (ret != MEDIA_CONTROLLER_ERROR_NONE) @@ -1470,9 +1470,9 @@ int server_sequential_test(void) ret = mc_server_set_metadata(g_mc_server, MC_META_MEDIA_EPISODE, episode); ret = mc_server_set_metadata(g_mc_server, MC_META_MEDIA_RESOLUTION, resolution); - g_free(season); - g_free(episode); - g_free(resolution); + MC_SAFE_FREE(season); + MC_SAFE_FREE(episode); + MC_SAFE_FREE(resolution); ret = mc_server_update_metadata(g_mc_server); if (ret != MEDIA_CONTROLLER_ERROR_NONE) { -- 2.7.4