device-manager-dbus: Fix SVACE defect (DEREF_OF_NULL.RET.STAT)

in addition, all other usages for pa_streq is also replaced by pa_safe_streq

[Version] 11.1.33
[Issue type] SVACE

Change-Id: I0b959cc6687a04d0e96c603f22287c944ab9df88

diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec
index 96a9a01..579184a 100644 (file)
--- a/packaging/pulseaudio-modules-tizen.spec
+++ b/packaging/pulseaudio-modules-tizen.spec
@@ -1,6 +1,6 @@
 Name:             pulseaudio-modules-tizen
 Summary:          Pulseaudio modules for Tizen
-Version:          11.1.32
+Version:          11.1.33
 Release:          0
 Group:            Multimedia/Audio
 License:          LGPL-2.1+

diff --git a/src/device-manager-dbus.c b/src/device-manager-dbus.c
index 2ad1377..08cb2e8 100644 (file)
--- a/src/device-manager-dbus.c
+++ b/src/device-manager-dbus.c
@@ -498,7 +498,7 @@ static DBusHandlerResult dbus_filter_device_detect_handler(DBusConnection *c, DB
             dbus_bool_t value;
             char *name = NULL;
             dbus_message_iter_get_basic(&variant_iter, &value);
-            if (pa_streq(property_name, "Connected")) {
+            if (pa_safe_streq(property_name, "Connected")) {
                 pa_log_info("HFP Connection : %d", value);
                 if (value) {
                     method_call_bt_get_name(c, dbus_message_get_path(s), &name);
@@ -512,7 +512,7 @@ static DBusHandlerResult dbus_filter_device_detect_handler(DBusConnection *c, DB
                 }
                 handle_device_status_changed(dm, DEVICE_TYPE_BT_SCO,
                         name, dbus_message_get_path(s),  detected);
-            } else if (pa_streq(property_name, "Playing")) {
+            } else if (pa_safe_streq(property_name, "Playing")) {
                 pa_tz_device *device;
                 pa_log_info("SCO Playing : %d", value);
                 if ((device = device_list_get_device(dm, DEVICE_TYPE_BT_SCO, NULL)) != NULL) {
@@ -994,7 +994,7 @@ static bool is_usb_output_device(pa_tz_device *device) {
     pa_assert(device);
 
     type = pa_tz_device_get_type(device);
-    if (!pa_streq(type, DEVICE_TYPE_USB_AUDIO)) {
+    if (!pa_safe_streq(type, DEVICE_TYPE_USB_AUDIO)) {
         pa_log_error("device(id:%d, %s) is not USB AUDIO type", pa_tz_device_get_id(device), type);
         return false;
     }
@@ -1387,7 +1387,7 @@ static void handle_set_specific_stream_only(DBusConnection *conn, DBusMessage *m
         pa_dbus_send_error(conn, msg, DBUS_ERROR_NOT_SUPPORTED, "%s", "org.tizen.multimedia.audio.InvalidOperation");
         return;
     }
-    if (!pa_streq(stream_role, "none") && !pa_stream_manager_is_valid_stream_role(dm->core, stream_role)) {
+    if (!pa_safe_streq(stream_role, "none") && !pa_stream_manager_is_valid_stream_role(dm->core, stream_role)) {
         pa_dbus_send_error(conn, msg, DBUS_ERROR_NOT_SUPPORTED, "%s", "org.tizen.multimedia.audio.InvalidOperation");
         return;
     }
@@ -1613,7 +1613,7 @@ static DBusHandlerResult method_call_handler(DBusConnection *c, DBusMessage *m,
 
     pa_log_info("DeviceManager Method Call Handler : path=%s, interface=%s, member=%s", path, interface, member);
 
-    if (!pa_streq(path, DBUS_OBJECT_DEVICE_MANAGER))
+    if (!pa_safe_streq(path, DBUS_OBJECT_DEVICE_MANAGER))
         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
     if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
@@ -1867,4 +1867,4 @@ void deinit_dm_dbus(pa_device_manager *dm) {
         dm->dbus_conn = NULL;
     }
 }
-#endif
\ No newline at end of file
+#endif

diff --git a/src/device-manager.c b/src/device-manager.c
index c3a28f8..842eb9c 100644 (file)
--- a/src/device-manager.c
+++ b/src/device-manager.c
@@ -361,7 +361,7 @@ static bool pulse_device_is_alsa(pa_object *pdevice) {
         return false;
 
     if ((api_name = pa_proplist_gets(prop, PA_PROP_DEVICE_API))) {
-        if (pa_streq(api_name, DEVICE_API_ALSA)) {
+        if (pa_safe_streq(api_name, DEVICE_API_ALSA)) {
             return true;
         } else {
             return false;
@@ -379,7 +379,7 @@ static bool pulse_device_is_bluez(pa_object *pdevice) {
         return false;
 
     if ((api_name = pa_proplist_gets(prop, PA_PROP_DEVICE_API))) {
-        if (pa_streq(api_name, DEVICE_API_BLUEZ)) {
+        if (pa_safe_streq(api_name, DEVICE_API_BLUEZ)) {
             return true;
         } else {
             return false;
@@ -405,10 +405,10 @@ static bool pulse_device_is_tizenaudio(pa_object *pdevice) {
 
     if (pa_sink_isinstance(pdevice)) {
         pa_sink *sink = PA_SINK(pdevice);
-        return pa_streq(sink->module->name, "module-tizenaudio-sink");
+        return pa_safe_streq(sink->module->name, "module-tizenaudio-sink");
     } else {
         pa_source *source = PA_SOURCE(pdevice);
-        return pa_streq(source->module->name, "module-tizenaudio-source");
+        return pa_safe_streq(source->module->name, "module-tizenaudio-source");
     }
 }
 
@@ -420,7 +420,7 @@ static bool pulse_device_is_usb(pa_object *pdevice) {
         return false;
 
     if ((bus_name = pa_proplist_gets(prop, PA_PROP_DEVICE_BUS))) {
-        if (pa_streq(bus_name, DEVICE_BUS_USB)) {
+        if (pa_safe_streq(bus_name, DEVICE_BUS_USB)) {
             return true;
         } else {
             return false;
@@ -440,10 +440,10 @@ static bool pulse_device_is_null(pa_object *pdevice) {
 
     if (pa_sink_isinstance(pdevice)) {
         sink = PA_SINK(pdevice);
-        return pa_streq(sink->module->name, "module-null-sink");
+        return pa_safe_streq(sink->module->name, "module-null-sink");
     } else {
         source = PA_SOURCE(pdevice);
-        return pa_streq(source->module->name, "module-null-source");
+        return pa_safe_streq(source->module->name, "module-null-source");
     }
 }
 
@@ -530,7 +530,7 @@ static bool pulse_device_is_monitor(pa_object *pdevice) {
     prop = pulse_device_get_proplist(pdevice);
 
     if ((device_class = pa_proplist_gets(prop, PA_PROP_DEVICE_CLASS))) {
-        if (device_class && pa_streq(device_class, DEVICE_CLASS_MONITOR)) {
+        if (pa_safe_streq(device_class, DEVICE_CLASS_MONITOR)) {
             return true;
         } else {
             return false;
@@ -613,10 +613,8 @@ static struct device_file_info* _device_manager_get_file_info(pa_idxset *file_in
     pa_assert(file_infos);
 
     PA_IDXSET_FOREACH(file_info, file_infos, file_idx) {
-        if (file_info->device_string) {
-            if (pa_streq(file_info->device_string, device_string)) {
-                return file_info;
-            }
+        if (pa_safe_streq(file_info->device_string, device_string)) {
+            return file_info;
         }
     }
 
@@ -662,7 +660,7 @@ static struct device_status_info* _get_device_status(pa_device_manager *manager,
                     return status_info;
                 else if (status_info->system_id == NULL)
                     continue;
-                else if (pa_streq(status_info->system_id, system_id))
+                else if (pa_safe_streq(status_info->system_id, system_id))
                     return status_info;
                 else
                     continue;
@@ -758,13 +756,13 @@ pa_tz_device* device_list_get_device(pa_device_manager *manager, const char *typ
     PA_IDXSET_FOREACH(device, manager->device_list, idx) {
         _type = pa_tz_device_get_type(device);
         _system_id = pa_tz_device_get_system_id(device);
-        if (pa_streq(_type, type)) {
+        if (pa_safe_streq(_type, type)) {
             if (device_type_is_avail_multi_device(type)) {
                 if (system_id == NULL)
                     return device;
                 else if (_system_id == NULL)
                     continue;
-                else if (pa_streq(_system_id, system_id))
+                else if (pa_safe_streq(_system_id, system_id))
                     return device;
                 else
                     continue;
@@ -840,7 +838,7 @@ static bool device_params_is_equal(const char *params1, const char *params2) {
     for (state = NULL, key = pa_modargs_iterate(modargs1, &state); key; key = pa_modargs_iterate(modargs1, &state)) {
         value1 = pa_modargs_get_value(modargs1, key, NULL);
         value2 = pa_modargs_get_value(modargs2, key, NULL);
-        if (!value1 || !value2 || !pa_streq(value1, value2)) {
+        if (!value1 || !value2 || !pa_safe_streq(value1, value2)) {
             equal = false;
             goto finish;
         }
@@ -849,7 +847,7 @@ static bool device_params_is_equal(const char *params1, const char *params2) {
     for (state = NULL, key = pa_modargs_iterate(modargs2, &state); key; key = pa_modargs_iterate(modargs2, &state)) {
         value1 = pa_modargs_get_value(modargs1, key, NULL);
         value2 = pa_modargs_get_value(modargs2, key, NULL);
-        if (!value1 || !value2 || !pa_streq(value1, value2)) {
+        if (!value1 || !value2 || !pa_safe_streq(value1, value2)) {
             equal = false;
             goto finish;
         }
@@ -931,7 +929,7 @@ static bool pulse_device_same_device_string(pa_object *pdevice, const char *devi
     if (pulse_device_get_device_string(pdevice, _device_string) < 0)
         return false;
 
-    return pa_streq(_device_string, device_string);
+    return pa_safe_streq(_device_string, device_string);
 }
 
 static const char* device_type_info_get_device_string(struct device_type_info *type_info, bool is_playback, const char *role) {
@@ -1629,14 +1627,14 @@ static pa_hook_result_t sink_source_state_changed_hook_cb(pa_core *c, pa_object
         pa_sink *s = PA_SINK(pdevice);
         pa_sink_state_t state = pa_sink_get_state(s);
         pa_log_debug("=========== Sink(%p,%s) state has been changed to [%d](0:RUNNING, 1:IDLE, 2:SUSPEND) ==========", s, s->name, state);
-        if (!s->use_internal_codec && !pa_streq(s->name, SINK_NAME_NULL))
+        if (!s->use_internal_codec && !pa_safe_streq(s->name, SINK_NAME_NULL))
             if ((device = pa_device_manager_get_device_with_sink(s)))
                 pa_tz_device_set_running_and_notify(device, (state == PA_SINK_RUNNING));
     } else if (pa_source_isinstance(pdevice)) {
         pa_source *s = PA_SOURCE(pdevice);
         pa_source_state_t state = pa_source_get_state(s);
         pa_log_debug("=========== Source(%p,%s) state has been changed to [%d](0:RUNNING, 1:IDLE, 2:SUSPEND) ==========", s, s->name, state);
-        if (!s->use_internal_codec && !pa_streq(s->name, SOURCE_NAME_NULL))
+        if (!s->use_internal_codec && !pa_safe_streq(s->name, SOURCE_NAME_NULL))
             if ((device = pa_device_manager_get_device_with_source(s)))
                 pa_tz_device_set_running_and_notify(device, (state == PA_SOURCE_RUNNING));
     }
@@ -2340,7 +2338,7 @@ pa_sink* pa_device_manager_load_sink(pa_device_manager *dm, const char *type, co
 
     pa_log_info("Load Sink for '%s.%s'", type, role);
     PA_IDXSET_FOREACH(device, dm->device_list, device_idx) {
-        if (pa_streq(type, pa_tz_device_get_type(device))) {
+        if (pa_safe_streq(type, pa_tz_device_get_type(device))) {
             if (pa_tz_device_get_sink(device, role)) {
                 pa_log_warn("Proper sink for '%s.%s' already loaded", type, role);
                 return NULL;
@@ -2438,7 +2436,7 @@ pa_source* pa_device_manager_load_source(pa_device_manager *dm, const char *type
     pa_log_info("Load Source for '%s.%s'", type, role);
 
     PA_IDXSET_FOREACH(device, dm->device_list, device_idx) {
-        if (pa_streq(type, pa_tz_device_get_type(device))) {
+        if (pa_safe_streq(type, pa_tz_device_get_type(device))) {
             if (pa_tz_device_get_source(device, role)) {
                 pa_log_warn("Proper source for '%s.%s' already loaded", type, role);
                 return NULL;

diff --git a/src/module-sound-player.c b/src/module-sound-player.c
index 7ef1a7e..310b631 100644 (file)
--- a/src/module-sound-player.c
+++ b/src/module-sound-player.c
@@ -358,7 +358,7 @@ static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg,
 
     for (idx = 0; idx < METHOD_HANDLER_MAX; idx++) {
         if (dbus_message_is_method_call(msg, SOUND_PLAYER_INTERFACE, method_handlers[idx].method_name)) {
-            if (pa_streq(dbus_message_get_signature(msg), signature_args_for_in[idx])) {
+            if (pa_safe_streq(dbus_message_get_signature(msg), signature_args_for_in[idx])) {
                 method_handlers[idx].receive_cb(conn, msg, userdata);
                 return DBUS_HANDLER_RESULT_HANDLED;
             } else {
@@ -386,7 +386,7 @@ static DBusHandlerResult method_handler_for_vt(DBusConnection *c, DBusMessage *m
 
     pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
 
-    if (!pa_streq(path, SOUND_PLAYER_OBJECT_PATH))
+    if (!pa_safe_streq(path, SOUND_PLAYER_OBJECT_PATH))
         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
     if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {

diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c
index 3f938cf..a60be73 100644 (file)
--- a/src/module-tizenaudio-policy.c
+++ b/src/module-tizenaudio-policy.c
@@ -126,25 +126,25 @@ int cached_connected_devices[DEVICE_MAX][CACHED_DEVICE_DIRECTION_MAX];
 
 static device_type_t convert_device_type_str(const char *device)
 {
-    if (pa_streq(device, DEVICE_TYPE_SPEAKER))
+    if (pa_safe_streq(device, DEVICE_TYPE_SPEAKER))
         return DEVICE_BUILTIN_SPEAKER;
-    else if (pa_streq(device, DEVICE_TYPE_RECEIVER))
+    else if (pa_safe_streq(device, DEVICE_TYPE_RECEIVER))
         return DEVICE_BUILTIN_RECEIVER;
-    else if (pa_streq(device, DEVICE_TYPE_MIC))
+    else if (pa_safe_streq(device, DEVICE_TYPE_MIC))
         return DEVICE_BUILTIN_MIC;
-    else if (pa_streq(device, DEVICE_TYPE_AUDIO_JACK))
+    else if (pa_safe_streq(device, DEVICE_TYPE_AUDIO_JACK))
         return DEVICE_AUDIO_JACK;
-    else if (pa_streq(device, DEVICE_TYPE_BT_A2DP))
+    else if (pa_safe_streq(device, DEVICE_TYPE_BT_A2DP))
         return DEVICE_BT_A2DP;
-    else if (pa_streq(device, DEVICE_TYPE_BT_SCO))
+    else if (pa_safe_streq(device, DEVICE_TYPE_BT_SCO))
         return DEVICE_BT_SCO;
-    else if (pa_streq(device, DEVICE_TYPE_HDMI))
+    else if (pa_safe_streq(device, DEVICE_TYPE_HDMI))
         return DEVICE_HDMI;
-    else if (pa_streq(device, DEVICE_TYPE_FORWARDING))
+    else if (pa_safe_streq(device, DEVICE_TYPE_FORWARDING))
         return DEVICE_FORWARDING;
-    else if (pa_streq(device, DEVICE_TYPE_USB_AUDIO))
+    else if (pa_safe_streq(device, DEVICE_TYPE_USB_AUDIO))
         return DEVICE_USB_AUDIO;
-    else if (pa_streq(device, DEVICE_TYPE_RAOP))
+    else if (pa_safe_streq(device, DEVICE_TYPE_RAOP))
         return DEVICE_RAOP;
 
 
@@ -228,7 +228,7 @@ static pa_tz_device* _get_sco_connected_device(pa_device_manager *dm) {
     device_list = pa_device_manager_get_device_list(dm);
 
     PA_IDXSET_FOREACH(device, device_list, device_idx) {
-        if (pa_streq(device->type, DEVICE_TYPE_BT_SCO)) {
+        if (pa_safe_streq(device->type, DEVICE_TYPE_BT_SCO)) {
             return device;
         }
     }
@@ -256,7 +256,7 @@ static bool is_bt_a2dp_connected(pa_device_manager *dm) {
     device_list = pa_device_manager_get_device_list(dm);
 
     PA_IDXSET_FOREACH(device, device_list, device_idx) {
-        if (pa_streq(device->type, DEVICE_TYPE_BT_A2DP)) {
+        if (pa_safe_streq(device->type, DEVICE_TYPE_BT_A2DP)) {
             return true;
         }
     }
@@ -346,8 +346,8 @@ static int bt_sco_open(struct userdata *u, const char *role) {
         return 0;
     }
 
-    if (pa_streq(role, STREAM_ROLE_VOICE_RECOGNITION) ||
-        pa_streq(role, STREAM_ROLE_VOICE_RECOGNITION_SERVICE))
+    if (pa_safe_streq(role, STREAM_ROLE_VOICE_RECOGNITION) ||
+        pa_safe_streq(role, STREAM_ROLE_VOICE_RECOGNITION_SERVICE))
         pa_tz_device_sco_enable_pcm(bt_device, true);
 
     if (pa_tz_device_sco_open(bt_device) < 0) {
@@ -510,9 +510,9 @@ static void unload_combine_sink_module(struct userdata *u, const char *combine_s
     pa_assert(combine_sink_name);
     pa_assert(dst_sink);
 
-    if (pa_streq(combine_sink_name, SINK_NAME_COMBINED)) {
+    if (pa_safe_streq(combine_sink_name, SINK_NAME_COMBINED)) {
         combine_sink_module = &u->module_combine_sink;
-    } else if (pa_streq(combine_sink_name, SINK_NAME_COMBINED_EX)) {
+    } else if (pa_safe_streq(combine_sink_name, SINK_NAME_COMBINED_EX)) {
         combine_sink_module = &u->module_combine_sink_for_ex;
     } else {
         pa_log_error("unknown combine_sink_name(%s)", combine_sink_name);
@@ -542,7 +542,7 @@ static bool skip_device(const char *stream_role, const char *device_type)
 {
     int sound_on = 1;
 
-    if (pa_streq(device_type, DEVICE_TYPE_FORWARDING))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_FORWARDING))
         return true;
 
     /* get sound profile */
@@ -551,7 +551,7 @@ static bool skip_device(const char *stream_role, const char *device_type)
         return false;
     }
 
-    if (!sound_on && IS_ROLE_RINGTONE(stream_role) && pa_streq(device_type, DEVICE_TYPE_SPEAKER)) {
+    if (!sound_on && IS_ROLE_RINGTONE(stream_role) && pa_safe_streq(device_type, DEVICE_TYPE_SPEAKER)) {
         pa_log_info("sound status is 0 with ringtone-call stream, skip built-in speaker");
         return true;
     }
@@ -564,7 +564,7 @@ static bool skip_bt_sco_device(struct userdata *u, const char *stream_role, cons
     pa_assert(stream_role);
     pa_assert(device_type);
 
-    if (pa_streq(stream_role, STREAM_ROLE_VOICE_INFORMATION) && pa_streq(device_type, DEVICE_TYPE_BT_SCO)) {
+    if (pa_safe_streq(stream_role, STREAM_ROLE_VOICE_INFORMATION) && pa_safe_streq(device_type, DEVICE_TYPE_BT_SCO)) {
         if (!is_bt_sco_connected(u->device_manager)) {
             pa_log_warn("It is VOICE_INFORMATION, BT SCO is not connected, skip this device");
             return true;
@@ -592,7 +592,7 @@ static bool skip_bt_sco_device(struct userdata *u, const char *stream_role, cons
 static bool is_supported_stream_role_for_usb(const char *role) {
     pa_assert(role);
 
-    if (pa_streq(STREAM_ROLE_MEDIA, role))
+    if (pa_safe_streq(STREAM_ROLE_MEDIA, role))
         return true;
 
     pa_log_error("not supported role for usb(%s)", role);
@@ -606,14 +606,14 @@ static bool skip_usb_device(const char *stream_role, pa_tz_device *device) {
     pa_assert(stream_role);
     pa_assert(device);
 
-    if (!pa_streq(pa_tz_device_get_type(device), DEVICE_TYPE_USB_AUDIO))
+    if (!pa_safe_streq(pa_tz_device_get_type(device), DEVICE_TYPE_USB_AUDIO))
         return false;
 
     if (!(specified_stream_role = pa_tz_device_get_specified_stream_role(device)))
         return false;
 
     if (is_supported_stream_role_for_usb(specified_stream_role) &&
-        pa_streq(stream_role, specified_stream_role))
+        pa_safe_streq(stream_role, specified_stream_role))
         return false;
 
     pa_log_info("skip this usb device, stream role(%s), specified stream role(%s)", stream_role, specified_stream_role);
@@ -703,7 +703,7 @@ static pa_hook_result_t select_proper_sink_or_source_hook_cb(pa_core *c, pa_stre
                     dm_device_id = pa_tz_device_get_id(device);
                     pa_log_debug("  -- type[%-16s], direction[0x%x], id[%u]",
                                  dm_device_type, dm_device_direction, dm_device_id);
-                    if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                    if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                         pa_log_info("  ** found a matched device: type[%-16s], direction[0x%x]", dm_device_type, dm_device_direction);
                         if (skip_bt_sco_device(u, data->stream_role, dm_device_type))
                             continue;
@@ -742,7 +742,7 @@ static pa_hook_result_t select_proper_sink_or_source_hook_cb(pa_core *c, pa_stre
                     creation_time = pa_tz_device_get_creation_time(device);
                     pa_log_debug("  -- type[%-16s], direction[0x%x], id[%u], creation_time[%llu]",
                                  dm_device_type, dm_device_direction, dm_device_id, creation_time);
-                    if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                    if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                         if (skip_bt_sco_device(u, data->stream_role, dm_device_type))
                             continue;
                         if (skip_usb_device(data->stream_role, device))
@@ -779,7 +779,7 @@ static pa_hook_result_t select_proper_sink_or_source_hook_cb(pa_core *c, pa_stre
                 dm_device_direction = pa_tz_device_get_direction(device);
                 pa_log_debug("  -- type[%-16s], direction[0x%x], device id[%u]",
                              dm_device_type, dm_device_direction, *device_id);
-                if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                     pa_log_info("  ** found a matched device: type[%-16s], direction[0x%x]", device_type, dm_device_direction);
                     if (data->stream_type == STREAM_SINK_INPUT) {
                         if ((*(data->proper_sink)) == null_sink)
@@ -808,7 +808,7 @@ static pa_hook_result_t select_proper_sink_or_source_hook_cb(pa_core *c, pa_stre
                 dm_device_direction = pa_tz_device_get_direction(device);
                 pa_log_debug("  -- type[%-16s], direction[0x%x], device id[%u]",
                              dm_device_type, dm_device_direction, *device_id);
-                if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                     pa_log_info("  ** found a matched device: type[%-16s], direction[0x%x]", device_type, dm_device_direction);
                     /* currently, we support two sinks for combining */
                     if (data->stream_type == STREAM_SINK_INPUT) {
@@ -819,7 +819,7 @@ static pa_hook_result_t select_proper_sink_or_source_hook_cb(pa_core *c, pa_stre
                                 pa_log_warn("  -- could not get combine_sink_arg1");
                         } else if (!combine_sink_arg2) {
                             sink = combine_sink_arg2 = pa_tz_device_get_sink(device, DEVICE_ROLE_NORMAL);
-                            if (sink && !pa_streq(sink->name, combine_sink_arg1->name)) {
+                            if (sink && !pa_safe_streq(sink->name, combine_sink_arg1->name)) {
                                 uint32_t s_idx = 0;
 
                                 pa_log_info("  -- combine_sink_arg2[%s]", sink->name);
@@ -1130,7 +1130,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                     dm_device_id = pa_tz_device_get_id(device);
                     pa_log_debug("  -- type[%-16s], direction[0x%x], id[%u]",
                                  dm_device_type, dm_device_direction, dm_device_id);
-                    if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                    if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                         pa_log_debug("  ** found a matched device: type[%-16s], direction[0x%x]", dm_device_type, dm_device_direction);
                         if (skip_usb_device(data->stream_role, device))
                             continue;
@@ -1164,7 +1164,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                             pa_log_error("[ROUTE][AUTO] could not get sink");
                     }
 
-                    if (pa_streq(dm_device_type, DEVICE_TYPE_BT_SCO)) {
+                    if (pa_safe_streq(dm_device_type, DEVICE_TYPE_BT_SCO)) {
                         if (IS_ROLE_AVAILABLE_BT_SCO_OPEN(route_info.role)) {
                             if (update_bt_sco_state(u, true, false, route_info.role)) {
                                 pa_log_error("  ** could not open BT SCO");
@@ -1196,7 +1196,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                             pa_log_error("[ROUTE][AUTO_ALL] could not get sink from pa_device_manager_get_sink");
                     } else if (data->stream_type == STREAM_SINK_INPUT && !combine_sink_arg2) {
                         sink = combine_sink_arg2 = pa_tz_device_get_sink(device, data->device_role);
-                        if (sink && !pa_streq(sink->name, combine_sink_arg1->name)) {
+                        if (sink && !pa_safe_streq(sink->name, combine_sink_arg1->name)) {
                             pa_log_info("[ROUTE][AUTO_ALL] combine_sink_arg2[%s]", sink->name);
                             /* load combine sink */
                             if (!u->module_combine_sink) {
@@ -1261,7 +1261,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                     creation_time = pa_tz_device_get_creation_time(device);
                     pa_log_debug("  -- type[%-16s], direction[0x%x], id[%u], creation_time[%llu]",
                                  dm_device_type, dm_device_direction, dm_device_id, creation_time);
-                    if (pa_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
+                    if (pa_safe_streq(device_type, dm_device_type) && IS_AVAILABLE_DIRECTION(data->stream_type, dm_device_direction)) {
                         if (skip_usb_device(data->stream_role, device))
                             continue;
                         use_internal_codec = pa_tz_device_is_use_internal_codec(device);
@@ -1303,7 +1303,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                         pa_log_error("[ROUTE][AUTO_LAST_CONN] could not get sink");
                 }
 
-                if (pa_streq(dm_device_type, DEVICE_TYPE_BT_SCO)) {
+                if (pa_safe_streq(dm_device_type, DEVICE_TYPE_BT_SCO)) {
                     if (IS_ROLE_AVAILABLE_BT_SCO_OPEN(route_info.role)) {
                         if (update_bt_sco_state(u, true, false, route_info.role)) {
                             pa_log_error("  ** could not open BT SCO");
@@ -1332,13 +1332,13 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                 if (!(device = pa_device_manager_get_device_by_id(u->device_manager, *device_id)))
                     continue;
                 dm_device_type = pa_tz_device_get_type(device);
-                if (!pa_streq(device_type, dm_device_type))
+                if (!pa_safe_streq(device_type, dm_device_type))
                     continue;
                 dm_device_direction = pa_tz_device_get_direction(device);
                 pa_log_debug("  ** found a matched device: type[%-16s], direction[0x%x]",
                              dm_device_type, dm_device_direction);
                 /* Check for availability for opening Bluetooth SCO */
-                if (pa_streq(dm_device_type, DEVICE_TYPE_BT_SCO) && IS_ROLE_AVAILABLE_BT_SCO_OPEN(route_info.role)) {
+                if (pa_safe_streq(dm_device_type, DEVICE_TYPE_BT_SCO) && IS_ROLE_AVAILABLE_BT_SCO_OPEN(route_info.role)) {
                     /* update BT SCO: open */
                     if (update_bt_sco_state(u, true, false, route_info.role)) {
                         pa_log_error("  ** could not open BT SCO");
@@ -1350,7 +1350,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                     update_bt_sco_state(u, false, false, NULL);
                 }
                 /* Check for in/out devices in case of loopback */
-                if (pa_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
+                if (pa_safe_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
                     if ((data->stream_type == STREAM_SINK_INPUT) && (dm_device_direction & DM_DEVICE_DIRECTION_OUT))
                         u->loopback_args.sink = pa_tz_device_get_sink(device, DEVICE_ROLE_NORMAL);
                     else if ((data->stream_type == STREAM_SOURCE_OUTPUT) && (dm_device_direction & DM_DEVICE_DIRECTION_IN))
@@ -1366,7 +1366,7 @@ static pa_hook_result_t route_change_hook_cb(pa_core *c, pa_stream_manager_hook_
                 }
             }
         }
-        if (pa_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
+        if (pa_safe_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
             /* load module-loopback */
             if (u->loopback_args.sink && u->loopback_args.source)
                 update_loopback_module(u, true);
@@ -1396,11 +1396,11 @@ static pa_hook_result_t update_info_hook_cb(pa_core *c, pa_stream_manager_hook_d
     pa_assert(data);
     pa_assert(u);
 
-    if (pa_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
+    if (pa_safe_streq(data->stream_role, STREAM_ROLE_LOOPBACK)) {
         pa_log_info("[UPDATE] stream_role(%s) [name(%s)/value(%d)]", data->stream_role, data->name, data->value);
-        if (pa_streq(data->name, MSG_FOR_LOOPBACK_ARG_LATENCY))
+        if (pa_safe_streq(data->name, MSG_FOR_LOOPBACK_ARG_LATENCY))
             u->loopback_args.latency_msec = data->value;
-        else if (pa_streq(data->name, MSG_FOR_LOOPBACK_ARG_ADJUST_TIME))
+        else if (pa_safe_streq(data->name, MSG_FOR_LOOPBACK_ARG_ADJUST_TIME))
             u->loopback_args.adjust_sec = data->value;
     }
 

diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c
index e193bc1..5c402ec 100644 (file)
--- a/src/stream-manager-dbus.c
+++ b/src/stream-manager-dbus.c
@@ -568,9 +568,9 @@ static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID));
@@ -617,9 +617,9 @@ static void handle_get_volume_level(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, 0, DBUS_TYPE_INVALID));
@@ -660,9 +660,9 @@ static void handle_get_volume_max_level(DBusConnection *conn, DBusMessage *msg,
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, 0, DBUS_TYPE_INVALID));
@@ -704,9 +704,9 @@ static void handle_set_volume_mute(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID));
@@ -749,9 +749,9 @@ static void handle_get_volume_mute(DBusConnection *conn, DBusMessage *msg, void
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, 0, DBUS_TYPE_INVALID));
@@ -793,10 +793,10 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in")) {
+    if (pa_safe_streq(direction, "in")) {
         stream_type = STREAM_SOURCE_OUTPUT;
         streams = m->core->source_outputs;
-    } else if (pa_streq(direction, "out")) {
+    } else if (pa_safe_streq(direction, "out")) {
         stream_type = STREAM_SINK_INPUT;
         streams = m->core->sink_inputs;
     } else {
@@ -864,9 +864,9 @@ static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMess
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in")) {
+    if (pa_safe_streq(direction, "in")) {
         dm_device_direction = DM_DEVICE_DIRECTION_IN;
-    } else if (pa_streq(direction, "out")) {
+    } else if (pa_safe_streq(direction, "out")) {
         dm_device_direction = DM_DEVICE_DIRECTION_OUT;
     } else {
         pa_log_error("invalid direction[%s]", direction);
@@ -1121,7 +1121,7 @@ static void handle_update_call_parameters(DBusConnection *conn, DBusMessage *msg
 
     /* Currently, we only use network band */
     route_option.name = "call-wideband";
-    if (pa_streq(network_band, "wb"))
+    if (pa_safe_streq(network_band, "wb"))
         route_option.value = 1;
     else
         route_option.value = 0;
@@ -1286,9 +1286,9 @@ static void handle_check_stream_exist_by_pid(DBusConnection *conn, DBusMessage *
 
     pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
-    if (pa_streq(direction, "in"))
+    if (pa_safe_streq(direction, "in"))
         stream_type = STREAM_SOURCE_OUTPUT;
-    else if (pa_streq(direction, "out"))
+    else if (pa_safe_streq(direction, "out"))
         stream_type = STREAM_SINK_INPUT;
     else {
         pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT],
@@ -1320,7 +1320,7 @@ static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg,
     for (idx = 0; idx < METHOD_HANDLER_MAX; idx++) {
         if (dbus_message_is_method_call(msg, STREAM_MANAGER_INTERFACE, method_handlers[idx].method_name)) {
             pa_log_debug("Message signature [%s] (Expected [%s])", dbus_message_get_signature(msg), signature_args_for_in[idx]);
-            if (pa_streq(dbus_message_get_signature(msg), signature_args_for_in[idx])) {
+            if (pa_safe_streq(dbus_message_get_signature(msg), signature_args_for_in[idx])) {
                 method_handlers[idx].receive_cb(conn, msg, userdata);
                 return DBUS_HANDLER_RESULT_HANDLED;
             } else {
@@ -1348,7 +1348,7 @@ static DBusHandlerResult method_handler_for_vt(DBusConnection *c, DBusMessage *m
 
     pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
 
-    if (!pa_streq(path, STREAM_MANAGER_OBJECT_PATH))
+    if (!pa_safe_streq(path, STREAM_MANAGER_OBJECT_PATH))
         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
     if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {

diff --git a/src/stream-manager-filter.c b/src/stream-manager-filter.c
index 9aeb9cb..a0d0842 100644 (file)
--- a/src/stream-manager-filter.c
+++ b/src/stream-manager-filter.c
@@ -202,7 +202,7 @@ static void update_prop_filter_apply_params(pa_sink_input *si, filter_info *f, c
 int32_t apply_filter_to_sink_input(pa_sink_input *si, filter_info *f, bool need_to_hook) {
     pa_assert(si);
 
-    if (f && (!f->filter_apply || pa_streq(f->filter_apply, ""))) {
+    if (f && (!f->filter_apply || pa_safe_streq(f->filter_apply, ""))) {
         pa_log_error("Try to applying empty filter module");
         return -1;
     }
@@ -326,7 +326,7 @@ int32_t control_filter(pa_stream_manager *m, const char *filter_name, const char
     uint32_t s_idx = 0;
     pa_sink *s = NULL;
 
-    if (pa_streq(filter_name, "") || pa_streq(filter_controls, "")) {
+    if (pa_safe_streq(filter_name, "") || pa_safe_streq(filter_controls, "")) {
         pa_log_error("Empty filter name or controls");
         return -1;
     }
@@ -509,7 +509,7 @@ void init_filters(pa_stream_manager *m) {
 
     /* Load module-filter-apply */
     PA_IDXSET_FOREACH(i, m->core->modules, idx) {
-        if (pa_streq(i->name, MODULE_FILTER_APPLY)) {
+        if (pa_safe_streq(i->name, MODULE_FILTER_APPLY)) {
             module = i;
             pa_log("module-filter-apply loaded already");
             break;
@@ -531,7 +531,7 @@ void deinit_filters(pa_stream_manager *m) {
 
     /* Unload module-filter-apply */
     PA_IDXSET_FOREACH(i, m->core->modules, idx) {
-        if (pa_streq(i->name, MODULE_FILTER_APPLY)) {
+        if (pa_safe_streq(i->name, MODULE_FILTER_APPLY)) {
             pa_module_unload(i, true);
             pa_log("module-filter-apply unloaded");
             break;

diff --git a/src/stream-manager-restriction.c b/src/stream-manager-restriction.c
index fa5ec58..818b6c5 100644 (file)
--- a/src/stream-manager-restriction.c
+++ b/src/stream-manager-restriction.c
@@ -33,7 +33,7 @@ int32_t handle_restrictions(pa_stream_manager *m, const char *name, uint32_t val
 
     pa_assert(m);
 
-    if (pa_streq(name, STREAM_MANAGER_METHOD_ARGS_BLOCK_RECORDING_MEDIA) ) {
+    if (pa_safe_streq(name, STREAM_MANAGER_METHOD_ARGS_BLOCK_RECORDING_MEDIA) ) {
         if (value == 1) {
             pa_log_info("block MEDIA recording");
             m->restrictions.block_recording_media = true;

diff --git a/src/stream-manager-volume.c b/src/stream-manager-volume.c
index 79f3a6c..db3c4b7 100644 (file)
--- a/src/stream-manager-volume.c
+++ b/src/stream-manager-volume.c
@@ -297,18 +297,18 @@ int32_t set_volume_level_by_type(pa_stream_manager *m, stream_type_t stream_type
         return -1;
     }
 
-    if (pa_streq(volume_type, MASTER_VOLUME_TYPE) && MASTER_VOLUME_LEVEL_MAX < volume_level) {
+    if (pa_safe_streq(volume_type, MASTER_VOLUME_TYPE) && MASTER_VOLUME_LEVEL_MAX < volume_level) {
         pa_log_error("could not set volume level of MASTER type, out of range[%u]", volume_level);
         return -1;
     }
 
     v->values[stream_type].current_level = volume_level;
-    if (is_hal_volume && pa_streq(volume_type, MASTER_VOLUME_TYPE)) {
+    if (is_hal_volume && pa_safe_streq(volume_type, MASTER_VOLUME_TYPE)) {
         /* no need to update the value of pulseaudio stream */
         return 0;
     }
 
-    if (!pa_streq(volume_type, MASTER_VOLUME_TYPE)) {
+    if (!pa_safe_streq(volume_type, MASTER_VOLUME_TYPE)) {
         if (get_volume_value(m, stream_type, is_hal_volume, volume_type, volume_level, &volume_linear))
             return -1;
 
@@ -320,7 +320,7 @@ int32_t set_volume_level_by_type(pa_stream_manager *m, stream_type_t stream_type
             modifier_gain = pa_proplist_gets(GET_STREAM_PROPLIST(s, stream_type), PA_PROP_MEDIA_TIZEN_VOLUME_GAIN_TYPE);
 
             /* Update volume level of stream if it has requested the volume type */
-            if (pa_streq(volume_type_str, volume_type)) {
+            if (pa_safe_streq(volume_type_str, volume_type)) {
                 if (modifier_gain) {
                     if (m->volume_modifiers) {
                        if ((modifier_gain_value = pa_hashmap_get(m->volume_modifiers, modifier_gain))) {
@@ -411,7 +411,7 @@ int32_t get_volume_level_by_type(pa_stream_manager *m, pa_volume_get_command_t c
         }
     } else if (command == GET_VOLUME_MAX_LEVEL) {
         /* If it is the master volume type */
-        if (pa_streq(volume_type, MASTER_VOLUME_TYPE)) {
+        if (pa_safe_streq(volume_type, MASTER_VOLUME_TYPE)) {
             *volume_level = MASTER_VOLUME_LEVEL_MAX;
         } else {
             /* Get max level */
@@ -574,7 +574,7 @@ int32_t set_volume_mute_by_type(pa_stream_manager *m, stream_type_t stream_type,
         }
 
         /* Update mute of stream if it has requested the volume type */
-        if (pa_streq(volume_type_str, volume_type)) {
+        if (pa_safe_streq(volume_type_str, volume_type)) {
             if (stream_type == STREAM_SINK_INPUT)
                 pa_sink_input_set_mute((pa_sink_input*)s, volume_mute, true);
             else if (stream_type == STREAM_SOURCE_OUTPUT)

diff --git a/src/stream-manager.c b/src/stream-manager.c
index 33ca9b3..0370154 100644 (file)
--- a/src/stream-manager.c
+++ b/src/stream-manager.c
@@ -146,15 +146,15 @@ static int32_t convert_route_type(const char *route_type_str, stream_route_type_
     pa_assert(route_type);
     pa_assert(route_type_str);
 
-    if (pa_streq("auto", route_type_str))
+    if (pa_safe_streq("auto", route_type_str))
         *route_type = STREAM_ROUTE_TYPE_AUTO;
-    else if (pa_streq("auto-last-connected", route_type_str))
+    else if (pa_safe_streq("auto-last-connected", route_type_str))
         *route_type = STREAM_ROUTE_TYPE_AUTO_LAST_CONNECTED;
-    else if (pa_streq("auto-all", route_type_str))
+    else if (pa_safe_streq("auto-all", route_type_str))
         *route_type = STREAM_ROUTE_TYPE_AUTO_ALL;
-    else if (pa_streq("manual", route_type_str))
+    else if (pa_safe_streq("manual", route_type_str))
         *route_type = STREAM_ROUTE_TYPE_MANUAL;
-    else if (pa_streq("manual-ext", route_type_str))
+    else if (pa_safe_streq("manual-ext", route_type_str))
         *route_type = STREAM_ROUTE_TYPE_MANUAL_EXT;
     else {
         ret = -1;
@@ -874,7 +874,7 @@ static bool check_name_to_skip(pa_stream_manager *m, process_command_type_t comm
     if (command == PROCESS_COMMAND_PREPARE && is_new_data) {
         if ((name = pa_proplist_gets(GET_STREAM_NEW_PROPLIST(stream, type), PA_PROP_MEDIA_NAME))) {
             for (i = 0; i < NAME_FOR_SKIP_MAX; i++)
-                if (pa_streq(name, stream_manager_media_names_for_skip[i])) {
+                if (pa_safe_streq(name, stream_manager_media_names_for_skip[i])) {
                     ret = true;
                     pa_proplist_sets(GET_STREAM_NEW_PROPLIST(stream, type), PA_PROP_MEDIA_ROLE, SKIP_ROLE);
                     break;
@@ -887,7 +887,7 @@ static bool check_name_to_skip(pa_stream_manager *m, process_command_type_t comm
         else
             role = pa_proplist_gets(GET_STREAM_PROPLIST(stream, type), PA_PROP_MEDIA_ROLE);
 
-        if (role && pa_streq(role, SKIP_ROLE))
+        if (pa_safe_streq(role, SKIP_ROLE))
             ret = true;
     }
 
@@ -904,7 +904,7 @@ static bool check_role_to_skip(pa_stream_manager *m, process_command_type_t comm
 
     if ((s = pa_hashmap_get(m->stream_infos, role)))
       ret = false;
-    if (s && pa_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING) &&
+    if (s && pa_safe_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING) &&
        (command == PROCESS_COMMAND_CHANGE_ROUTE_BY_STREAM_STARTED ||
        command == PROCESS_COMMAND_CHANGE_ROUTE_BY_STREAM_ENDED))
       ret = true;
@@ -943,11 +943,10 @@ static bool check_name_is_vstream(void *stream, stream_type_t type, bool is_new_
         name = pa_proplist_gets(GET_STREAM_NEW_PROPLIST(stream, type), PA_PROP_MEDIA_NAME);
     else
         name = pa_proplist_gets(GET_STREAM_PROPLIST(stream, type), PA_PROP_MEDIA_NAME);
-    if (name) {
-        if (pa_streq(name, VIRTUAL_STREAM_NAME)) {
-            ret = true;
-            pa_log_info("name is [%s]", name);
-        }
+
+    if (pa_safe_streq(name, VIRTUAL_STREAM_NAME)) {
+        ret = true;
+        pa_log_info("name is [%s]", name);
     }
 
     return ret;
@@ -1005,7 +1004,7 @@ static bool update_volume_type_of_stream(pa_stream_manager *m, void *stream, str
     if ((s = pa_hashmap_get(m->stream_infos, role)))
         volume_type = s->volume_types[type];
 
-    if (volume_type && (!pa_streq(volume_type, "none"))) {
+    if (volume_type && (!pa_safe_streq(volume_type, "none"))) {
         pa_proplist_sets(GET_STREAM_NEW_PROPLIST(stream, type), PA_PROP_MEDIA_TIZEN_VOLUME_TYPE, volume_type);
         ret = true;
     } else
@@ -1684,7 +1683,7 @@ static void update_mirroring_streams(pa_stream_manager *m, pa_source_output *o,
     pa_assert(o);
 
     if ((role = pa_proplist_gets(GET_STREAM_PROPLIST(o, STREAM_SOURCE_OUTPUT), PA_PROP_MEDIA_ROLE)) &&
-        pa_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING)) {
+        pa_safe_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING)) {
         if (put)
             pa_idxset_put(m->mirroring_streams, o, NULL);
         else
@@ -1812,7 +1811,7 @@ process_stream_result_t process_stream(pa_stream_manager *m, void *stream, strea
                 goto finish;
             }
             /* load forwarding device */
-            if (type == STREAM_SOURCE_OUTPUT && pa_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING))
+            if (type == STREAM_SOURCE_OUTPUT && pa_safe_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING))
                 update_forwarding_device(m, true);
         }
         /* update the priority of this stream */
@@ -1926,7 +1925,7 @@ process_stream_result_t process_stream(pa_stream_manager *m, void *stream, strea
         role = pa_proplist_gets(GET_STREAM_PROPLIST(stream, type), PA_PROP_MEDIA_ROLE);
         if (role) {
             /* unload forwarding device */
-            if (type == STREAM_SOURCE_OUTPUT && pa_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING))
+            if (type == STREAM_SOURCE_OUTPUT && pa_safe_streq(role, STREAM_ROLE_LOOPBACK_MIRRORING))
                 update_forwarding_device(m, false);
 
             /* skip roles */
@@ -2326,7 +2325,7 @@ static void find_next_device_for_auto_route(pa_stream_manager *m, stream_route_t
 
     if (route_type == STREAM_ROUTE_TYPE_AUTO) {
         PA_IDXSET_FOREACH(device_type, devices, idx) {
-            if (pa_streq(device_type, cur_device_type)) {
+            if (pa_safe_streq(device_type, cur_device_type)) {
                 ret_next = true;
                 continue;
             }
@@ -2386,12 +2385,12 @@ static void is_available_device_for_auto_route(pa_stream_manager *m, stream_rout
 
     PA_IDXSET_FOREACH(device_type, devices, idx) {
         if (route_type == STREAM_ROUTE_TYPE_AUTO) {
-            if (pa_streq(device_type, cur_device_type)) {
+            if (pa_safe_streq(device_type, cur_device_type)) {
                 pa_log_debug("cur_device[%s]'s priority is more higher than new_device[%s]", cur_device_type, new_device_type);
                 break;
             }
         }
-        if (pa_streq(device_type, new_device_type)) {
+        if (pa_safe_streq(device_type, new_device_type)) {
             *available = true;
             break;
         }
@@ -2700,7 +2699,7 @@ static void update_sink_or_source_as_device_change(pa_stream_manager *m, stream_
             PA_IDXSET_FOREACH(s, streams, s_idx) { /* streams: core->source_outputs/core->sink_inputs */
                 if ((cur_device_type = pa_proplist_gets(GET_STREAM_PROPLIST(s, stream_type), PA_PROP_MEDIA_ROUTE_AUTO_ACTIVE_DEV))) {
                     for (cnt = 0; cached_prev_dev_list[cnt].device_type; cnt++) {
-                        if (pa_streq(cur_device_type, cached_prev_dev_list[cnt].device_type))
+                        if (pa_safe_streq(cur_device_type, cached_prev_dev_list[cnt].device_type))
                             cached_prev_dev_list[cnt].count++;
                     }
                 }
@@ -3006,7 +3005,7 @@ static void subscribe_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t
             return;
         }
         name = pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME);
-        if (!name || (name && !pa_streq(name, STREAM_MANAGER_CLIENT_NAME))) {
+        if (!pa_safe_streq(name, STREAM_MANAGER_CLIENT_NAME)) {
             pa_log_warn(" - this is not a client(%s) that we should take care of, skip it", name);
             return;
         }

diff --git a/src/stream-manager.h b/src/stream-manager.h
index 98c0804..55f2572 100644 (file)
--- a/src/stream-manager.h
+++ b/src/stream-manager.h
@@ -25,7 +25,8 @@
 #include <pulsecore/core.h>
 
 #define IS_AUTO_ROUTE_TYPE_SERIES(route_type_enum) \
-    ((route_type_enum == STREAM_ROUTE_TYPE_AUTO) || (route_type_enum == STREAM_ROUTE_TYPE_AUTO_LAST_CONNECTED) || \
+    ((route_type_enum == STREAM_ROUTE_TYPE_AUTO) || \
+     (route_type_enum == STREAM_ROUTE_TYPE_AUTO_LAST_CONNECTED) || \
      (route_type_enum == STREAM_ROUTE_TYPE_AUTO_ALL))
 
 #define IS_MANUAL_ROUTE_TYPE_SERIES(route_type_enum) \
@@ -41,17 +42,23 @@
     (route_type_str && !pa_atoi(route_type_str, (int32_t*)&route_type) && (route_type == STREAM_ROUTE_TYPE_AUTO_LAST_CONNECTED))
 
 #define IS_ROLE_COMMUNICATION(stream_role) \
-    (stream_role && (pa_streq(stream_role, STREAM_ROLE_CALL_VOICE) || pa_streq(stream_role, STREAM_ROLE_CALL_VIDEO) || \
-                     pa_streq(stream_role, STREAM_ROLE_VOIP) || pa_streq(stream_role, STREAM_ROLE_RINGBACKTONE_CALL)))
+    (pa_safe_streq(stream_role, STREAM_ROLE_CALL_VOICE) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_CALL_VIDEO) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_VOIP) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_RINGBACKTONE_CALL))
 
 #define IS_ROLE_RINGTONE(stream_role) \
-    (pa_streq(stream_role, STREAM_ROLE_RINGTONE_CALL) || pa_streq(stream_role, STREAM_ROLE_RINGTONE_VOIP))
+    (pa_safe_streq(stream_role, STREAM_ROLE_RINGTONE_CALL) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_RINGTONE_VOIP))
 
 #define IS_ROLE_AVAILABLE_BT_SCO_OPEN(stream_role) \
-    (stream_role && (pa_streq(stream_role, STREAM_ROLE_CALL_VOICE) || pa_streq(stream_role, STREAM_ROLE_CALL_VIDEO) || \
-                     pa_streq(stream_role, STREAM_ROLE_VOIP) || pa_streq(stream_role, STREAM_ROLE_RINGBACKTONE_CALL) || \
-                     pa_streq(stream_role, STREAM_ROLE_VOICE_RECOGNITION) || pa_streq(stream_role, STREAM_ROLE_VOICE_RECOGNITION_SERVICE) || \
-                     pa_streq(stream_role, STREAM_ROLE_VOICE_INFORMATION)))
+    (pa_safe_streq(stream_role, STREAM_ROLE_CALL_VOICE) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_CALL_VIDEO) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_VOIP) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_RINGBACKTONE_CALL) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_VOICE_RECOGNITION) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_VOICE_RECOGNITION_SERVICE) || \
+     pa_safe_streq(stream_role, STREAM_ROLE_VOICE_INFORMATION))
 
 #define CONVERT_TO_DEVICE_ROLE(x_stream_role, x_device_role) \
 do { \

diff --git a/src/tizen-device-def.c b/src/tizen-device-def.c
index acd1fc2..22f6612 100644 (file)
--- a/src/tizen-device-def.c
+++ b/src/tizen-device-def.c
@@ -14,7 +14,7 @@
 
 static inline bool pa_safe_streq2(const char *a, const char *b) {
     if (a && b)
-        return pa_streq(a, b);
+        return pa_safe_streq(a, b);
     if (!a && !b)
         return true;
     return false;
@@ -24,87 +24,77 @@ bool device_type_is_equal(const char *device_type1, const char *device_type2) {
     pa_assert(device_type1);
     pa_assert(device_type2);
 
-    return pa_streq(device_type1, device_type2);
+    return pa_safe_streq(device_type1, device_type2);
 }
 
 bool device_type_is_builtin(const char *device_type) {
-    if (!device_type)
-        return false;
-    else if (pa_streq(device_type, DEVICE_TYPE_SPEAKER))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_SPEAKER))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_RECEIVER))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RECEIVER))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_MIC))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_MIC))
         return true;
     else
         return false;
 }
 
 bool device_type_is_valid(const char *device_type) {
-    if (!device_type)
-        return false;
-    else if (pa_streq(device_type, DEVICE_TYPE_SPEAKER))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_SPEAKER))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_RECEIVER))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RECEIVER))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_MIC))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_MIC))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_AUDIO_JACK))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_AUDIO_JACK))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_A2DP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_A2DP))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_SCO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_SCO))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_HDMI))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_HDMI))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_FORWARDING))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_FORWARDING))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_USB_AUDIO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_USB_AUDIO))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_RAOP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RAOP))
         return true;
     else
         return false;
 }
 
 bool device_type_is_use_external_card(const char *device_type) {
-    if (!device_type)
-        return false;
-    else if (pa_streq(device_type, DEVICE_TYPE_USB_AUDIO))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_USB_AUDIO))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_A2DP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_A2DP))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_RAOP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RAOP))
         return true;
     else
         return false;
 }
 
 bool device_type_is_avail_multi_device(const char *device_type) {
-    if (!device_type)
-        return false;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_A2DP))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_BT_A2DP))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_SCO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_SCO))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_USB_AUDIO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_USB_AUDIO))
         return true;
-    else if (pa_streq(device_type, DEVICE_TYPE_RAOP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RAOP))
         return true;
     else
         return false;
 }
 
 bool device_type_is_need_detect(const char *type) {
-    if (!type)
-        return false;
-    else if (pa_streq(type, DEVICE_TYPE_AUDIO_JACK))
+    if (pa_safe_streq(type, DEVICE_TYPE_AUDIO_JACK))
         return true;
-    else if (pa_streq(type, DEVICE_TYPE_HDMI))
+    else if (pa_safe_streq(type, DEVICE_TYPE_HDMI))
         return true;
-    else if (pa_streq(type, DEVICE_TYPE_FORWARDING))
+    else if (pa_safe_streq(type, DEVICE_TYPE_FORWARDING))
         return true;
-    else if (pa_streq(type, DEVICE_TYPE_BT_SCO))
+    else if (pa_safe_streq(type, DEVICE_TYPE_BT_SCO))
         return true;
     else
         return false;
@@ -117,17 +107,17 @@ bool device_type_is_need_detect(const char *type) {
 dm_device_direction_t device_type_get_static_direction(const char *type) {
     if (!type)
         return DM_DEVICE_DIRECTION_NONE;
-    else if (pa_streq(type, DEVICE_TYPE_SPEAKER))
+    else if (pa_safe_streq(type, DEVICE_TYPE_SPEAKER))
         return DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(type, DEVICE_TYPE_RECEIVER))
+    else if (pa_safe_streq(type, DEVICE_TYPE_RECEIVER))
         return DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(type, DEVICE_TYPE_MIC))
+    else if (pa_safe_streq(type, DEVICE_TYPE_MIC))
         return DM_DEVICE_DIRECTION_IN;
     else if (device_type_is_equal(type, DEVICE_TYPE_BT_SCO))
         return DM_DEVICE_DIRECTION_BOTH;
-    else if (pa_streq(type, DEVICE_TYPE_HDMI))
+    else if (pa_safe_streq(type, DEVICE_TYPE_HDMI))
         return DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(type, DEVICE_TYPE_FORWARDING))
+    else if (pa_safe_streq(type, DEVICE_TYPE_FORWARDING))
         return DM_DEVICE_DIRECTION_BOTH;
     else
         return DM_DEVICE_DIRECTION_NONE;
@@ -139,34 +129,33 @@ bool device_type_is_valid_direction(const char *device_type, dm_device_direction
     if (!device_type || direction == DM_DEVICE_DIRECTION_NONE)
         return false;
 
-    if (pa_streq(device_type, DEVICE_TYPE_SPEAKER))
+    if (pa_safe_streq(device_type, DEVICE_TYPE_SPEAKER))
         return direction == DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(device_type, DEVICE_TYPE_RECEIVER))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RECEIVER))
         return direction == DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(device_type, DEVICE_TYPE_MIC))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_MIC))
         return direction == DM_DEVICE_DIRECTION_IN;
-    else if (pa_streq(device_type, DEVICE_TYPE_AUDIO_JACK))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_AUDIO_JACK))
         return direction == DM_DEVICE_DIRECTION_OUT || direction == DM_DEVICE_DIRECTION_BOTH;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_SCO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_SCO))
         return direction == DM_DEVICE_DIRECTION_BOTH;
-    else if (pa_streq(device_type, DEVICE_TYPE_BT_A2DP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_BT_A2DP))
         return direction == DM_DEVICE_DIRECTION_OUT || direction == DM_DEVICE_DIRECTION_IN;
-    else if (pa_streq(device_type, DEVICE_TYPE_HDMI))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_HDMI))
         return direction == DM_DEVICE_DIRECTION_OUT;
-    else if (pa_streq(device_type, DEVICE_TYPE_FORWARDING))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_FORWARDING))
         return direction == DM_DEVICE_DIRECTION_BOTH;
-    else if (pa_streq(device_type, DEVICE_TYPE_USB_AUDIO))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_USB_AUDIO))
         return direction == DM_DEVICE_DIRECTION_BOTH || direction == DM_DEVICE_DIRECTION_OUT || direction == DM_DEVICE_DIRECTION_IN;
-    else if (pa_streq(device_type, DEVICE_TYPE_RAOP))
+    else if (pa_safe_streq(device_type, DEVICE_TYPE_RAOP))
         return direction == DM_DEVICE_DIRECTION_OUT;
     else
         return false;
 }
 
 const char* device_direction_to_string(dm_device_direction_t direction) {
-    if (direction > DM_DEVICE_DIRECTION_BOTH) {
+    if (direction > DM_DEVICE_DIRECTION_BOTH)
         return NULL;
-    }
 
     if (direction == DM_DEVICE_DIRECTION_NONE)
         return DEVICE_DIRECTION_STR_NONE;
@@ -181,40 +170,33 @@ const char* device_direction_to_string(dm_device_direction_t direction) {
 }
 
 bool device_role_is_valid(const char *device_role) {
-    if (!device_role)
-        return false;
-    else if (pa_streq(device_role, DEVICE_ROLE_NORMAL))
+    if (pa_safe_streq(device_role, DEVICE_ROLE_NORMAL))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_CALL_VOICE))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_CALL_VOICE))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_CALL_VIDEO))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_CALL_VIDEO))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_VOIP))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_VOIP))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_LOW_LATENCY))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_LOW_LATENCY))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_HIGH_LATENCY))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_HIGH_LATENCY))
         return true;
-    else if (pa_streq(device_role, DEVICE_ROLE_UHQA))
+    else if (pa_safe_streq(device_role, DEVICE_ROLE_UHQA))
         return true;
     else
         return false;
 }
 
 dm_device_direction_t device_direction_to_int(const char *device_direction) {
-    if (!device_direction) {
-        return -1;
-    }
-
-    if (pa_streq(device_direction, DEVICE_DIRECTION_STR_NONE)) {
+    if (pa_safe_streq(device_direction, DEVICE_DIRECTION_STR_NONE))
         return DM_DEVICE_DIRECTION_NONE;
-    } else if (pa_streq(device_direction, DEVICE_DIRECTION_STR_OUT)) {
+    else if (pa_safe_streq(device_direction, DEVICE_DIRECTION_STR_OUT))
         return DM_DEVICE_DIRECTION_OUT;
-    } else if (pa_streq(device_direction, DEVICE_DIRECTION_STR_IN)) {
+    else if (pa_safe_streq(device_direction, DEVICE_DIRECTION_STR_IN))
         return DM_DEVICE_DIRECTION_IN;
-    } else if (pa_streq(device_direction, DEVICE_DIRECTION_STR_BOTH)) {
+    else if (pa_safe_streq(device_direction, DEVICE_DIRECTION_STR_BOTH))
         return DM_DEVICE_DIRECTION_BOTH;
-    } else {
+    else
         return -1;
-    }
 }

diff --git a/src/tizen-device.c b/src/tizen-device.c
index 56e5479..81f3401 100644 (file)
--- a/src/tizen-device.c
+++ b/src/tizen-device.c
@@ -696,7 +696,7 @@ int pa_tz_device_get_product_id(pa_tz_device *device) {
 char* pa_tz_device_get_specified_stream_role(pa_tz_device *device) {
     pa_assert(device);
 
-    if (pa_streq("none", device->specified_stream_role))
+    if (pa_safe_streq("none", device->specified_stream_role))
         return NULL;
 
     return device->specified_stream_role;
@@ -861,33 +861,34 @@ static int method_call_bt_sco_get_property(pa_dbus_connection *conn, bool *is_wi
 
     while (dbus_message_iter_get_arg_type(&reply_iter_entry) == DBUS_TYPE_DICT_ENTRY) {
         DBusMessageIter dict_entry, dict_entry_val;
+
         dbus_message_iter_recurse(&reply_iter_entry, &dict_entry);
         dbus_message_iter_get_basic(&dict_entry, &property);
         pa_log_debug("String received = %s", property);
-        if (property) {
-            if (pa_streq("codec", property) && is_wide_band) {
-                dbus_message_iter_next(&dict_entry);
-                dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
-                if (dbus_message_iter_get_arg_type(&dict_entry_val) != DBUS_TYPE_UINT32)
-                    continue;
-                dbus_message_iter_get_basic(&dict_entry_val, &codec);
-                pa_log_debug("Codec = [%d]", codec);
-                *is_wide_band = (codec == BT_MSBC_CODEC_ID) ? true : false;
-            } else if (pa_streq("nrec", property) && is_nrec) {
-                dbus_message_iter_next(&dict_entry);
-                dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
-                if (dbus_message_iter_get_arg_type(&dict_entry_val) != DBUS_TYPE_BOOLEAN)
-                    continue;
-                dbus_message_iter_get_basic(&dict_entry_val, &nrec);
-                pa_log_debug("nrec= [%d]", nrec);
-                *is_nrec = nrec;
-            }
+
+        if (pa_safe_streq("codec", property) && is_wide_band) {
+            dbus_message_iter_next(&dict_entry);
+            dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
+            if (dbus_message_iter_get_arg_type(&dict_entry_val) != DBUS_TYPE_UINT32)
+                continue;
+            dbus_message_iter_get_basic(&dict_entry_val, &codec);
+            pa_log_debug("Codec = [%d]", codec);
+            *is_wide_band = (codec == BT_MSBC_CODEC_ID) ? true : false;
+        } else if (pa_safe_streq("nrec", property) && is_nrec) {
+            dbus_message_iter_next(&dict_entry);
+            dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
+            if (dbus_message_iter_get_arg_type(&dict_entry_val) != DBUS_TYPE_BOOLEAN)
+                continue;
+            dbus_message_iter_get_basic(&dict_entry_val, &nrec);
+            pa_log_debug("nrec= [%d]", nrec);
+            *is_nrec = nrec;
         }
+
         dbus_message_iter_next(&reply_iter_entry);
     }
 
-
     dbus_message_unref(reply);
+
     return 0;
 }