#define INM_CONN_IFACE INM_MANAGER_SERVICE ".conn"
#define INM_CONN_OBJ INM_MANAGER_OBJ "/conn"
+#define DEBUG_G_VARIANT(str, parameters)\
+ do {\
+ gchar *parameters_debug_str = NULL;\
+ if (parameters)\
+ parameters_debug_str = g_variant_print(parameters, TRUE);\
+ INM_LOGI("<%s:%s>", str, parameters_debug_str ? parameters_debug_str : "NULL");\
+ g_free(parameters_debug_str);\
+ } while (0)
+
+#define DEBUG_SIGNAL(sender_name, object_path, interface_name, signal_name, parameters)\
+ do {\
+ INM_LOGI("<GDBus signal sender name:%s>", sender_name);\
+ INM_LOGI("<GDBus signal signal name:%s>", signal_name);\
+ INM_LOGI("signal object path [%s]", object_path);\
+ INM_LOGI("signal interface name [%s]", interface_name);\
+ DEBUG_G_VARIANT("signal params ", parameters);\
+ INM_LOGI("signal params type [%s]", g_variant_get_type_string(parameters));\
+ } while (0)
+
#define DECLARE_DBUS_SIGNAL_HANDLER(name) void __##name(\
const gchar *sender_name,\
const gchar *object_path,\
if (memcmp(ah->arp_sha, arp_data->hwaddr, ETH_ALEN) == 0 ||
memcmp(ah->arp_sip, arp_data->ipaddr, 4) != 0) {
- INM_LOGI("Packet not intended to us.\n");
+ INM_LOGI("Packet not intended to us");
return;
}
- INM_LOGI("arp found !\n");
+ INM_LOGI("arp found");
arping_data->found = TRUE;
if (arping_cb)
arping_cb(TRUE,
gboolean ret;
if (!arping_data) {
- INM_LOGI("NULL data");
+ INM_LOGW("NULL data");
__INM_FUNC_EXIT__;
return;
}
arping_data->arp_reply_timer_source_id =
g_timeout_add(DEFAULT_INTERVAL, __send_arp, arping_data);
} else {
- INM_LOGD("Sent ARP Packet \n");
+ INM_LOGI("Sent ARP Packet");
REMOVE_G_SOURCE(arping_data->arp_reply_timer_source_id);
/* Adding timeout callback for arp request */
arping_data =
(arping_data_s *)g_try_malloc0(sizeof(arping_data_s));
if (!arping_data) {
- INM_LOGI("Error! Failed to allocate memory");
+ INM_LOGE("Failed to allocate memory");
__INM_FUNC_EXIT__;
return NULL;
}
__start_arping(0, arping_data, NULL);
if (arping_data->arp_data.sock_source_id == 0) {
- INM_LOGI("Failed to start to ping ARP");
+ INM_LOGE("Failed to start to ping ARP");
__stop_arping(0, arping_data, NULL);
arping_data->in_progress = FALSE;
return INM_ARPING_ERROR_OPERATION_FAILED;
arping_data =
__get_arping_data(if_name, target_ip);
if (!arping_data) {
- INM_LOGI("arping_data not found");
+ INM_LOGW("arping_data not found");
__INM_FUNC_EXIT__;
return INM_ARPING_ERROR_OPERATION_FAILED;
}
ret = access(NETWORK_CONGESTION_MON, F_OK);
if (ret < 0) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGE("Could not access %s, error:[%s]", NETWORK_CONGESTION_MON, error_buf);
+ INM_LOGE("Could not access %s:[%s]", NETWORK_CONGESTION_MON, error_buf);
return -1;
}
fd = fopen(NETWORK_CONGESTION_MON, "r");
int status;
if (!g_cong_mon_started) {
- INM_LOGE("congestion monitor is stopped");
+ INM_LOGW("congestion monitor is stopped");
return FALSE;
}
__INM_FUNC_ENTER__;
if (!cong_mon.is_initialized) {
- INM_LOGE("congestion monitor is not initialized");
+ INM_LOGW("congestion monitor is not initialized");
__INM_FUNC_EXIT__;
return INM_CONG_MON_NOT_INITIALIZED;
}
if (g_cong_mon_started) {
- INM_LOGE("congestion monitor is already started");
+ INM_LOGW("congestion monitor is already started");
__INM_FUNC_EXIT__;
return INM_CONG_MON_ALREADY_STARTED;
}
if (!cb) {
- INM_LOGE("Invalid parameter");
+ INM_LOGW("Invalid parameter");
__INM_FUNC_EXIT__;
return INM_CONG_MON_INVALID_PARAMETER;
}
int i = 0;
if (!txt || !mac) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return -1;
}
inm_gdbus_emit_conn_ipv4_state_changed(service->obj_path,
__inm_connman_service_get_ipv4_state(service));
- INM_LOGI("State [%s]", state_str);
+ INM_LOGI("<Connman Service State:%s>", state_str);
}
static inline void __get_state_ipv6(connman_service_s *service, GVariant *value)
inm_gdbus_emit_conn_ipv6_state_changed(service->obj_path,
__inm_connman_service_get_ipv6_state(service));
- INM_LOGI("IP V6 state [%s]", state_str);
+ INM_LOGI("<Connman IP V6 state:%s>", state_str);
}
static inline void __get_error(connman_service_s *service, GVariant *value)
else
service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
- INM_LOGI("error [%s]", err_str);
+ INM_LOGI("<Connman service error:%s>", err_str);
if (g_conn_error_cb)
g_conn_error_cb(service->error);
else
service->type = CONNMAN_SERVICE_TYPE_UNKNOWN;
- INM_LOGI("type [%s]", str);
+ INM_LOGI("<Connman service type:%s>", str);
}
static inline void __get_strength(connman_service_s *service, GVariant *value)
{
g_variant_get(value, "y", &(service->strength));
- INM_LOGI("strength [%u]", service->strength);
+ INM_LOGI("<Connman service strength:%u>", service->strength);
}
static inline void __get_favorite(connman_service_s *service, GVariant *value)
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.address) == 0)
- INM_LOGI("Fail in converting ipv4 address");
+ INM_LOGW("Fail in converting ipv4 address");
} else if (g_strcmp0(key, "Netmask") == 0) {
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.netmask) == 0)
- INM_LOGI("Fail in converting ipv4 netmask");
+ INM_LOGW("Fail in converting ipv4 netmask");
} else if (g_strcmp0(key, "Gateway") == 0) {
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.gateway) == 0)
- INM_LOGI("Fail in converting ipv4 gateway");
+ INM_LOGW("Fail in converting ipv4 gateway");
} else if (g_strcmp0(key, "DHCPServerIP") == 0) {
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.dhcp_server_ip) == 0)
- INM_LOGI("Fail in converting ipv4 dhcp server ip");
+ INM_LOGW("Fail in converting ipv4 dhcp server ip");
} else if (g_strcmp0(key, "DHCPLeaseDuration") == 0) {
service->ip.dhcp_lease_duration = g_variant_get_int32(var);
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.address) == 0)
- INM_LOGI("Fail in converting ipv4 address");
+ INM_LOGW("Fail in converting ipv4 address");
} else if (g_strcmp0(key, "Netmask") == 0) {
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.netmask) == 0)
- INM_LOGI("Fail in converting ipv4 netmask");
+ INM_LOGW("Fail in converting ipv4 netmask");
} else if (g_strcmp0(key, "Gateway") == 0) {
str = g_variant_get_string(var, NULL);
if (inet_aton(str, &service->ip.gateway) == 0)
- INM_LOGI("Fail in converting ipv4 gateway");
+ INM_LOGW("Fail in converting ipv4 gateway");
}
}
g_variant_iter_free(iter);
g_variant_get(var, "as", &iter_inner);
if (!g_variant_iter_loop(iter_inner, "s", &servers))
- INM_LOGI("There was no value");
+ INM_LOGW("There was no value");
g_variant_iter_free(iter_sub);
}
}
service = g_hash_table_lookup(service_tbl, object_path);
if (!service) {
__INM_FUNC_EXIT__;
- INM_LOGI("Service not found");
+ INM_LOGW("Service not found");
return;
}
g_variant_get(parameters, "(&sv)", &key, &value);
ret = (connman_service_s *)g_try_malloc0(sizeof(connman_service_s));
if (!ret) {
- INM_LOGI("Error! Failed to allocate service");
+ INM_LOGE("Failed to allocate service");
__INM_FUNC_EXIT__;
return;
}
if (__register_service_obj(path, ret) != 0) {
g_free(ret);
- INM_LOGI("Error! Failed to register service object");
+ INM_LOGE("Failed to register service object");
__INM_FUNC_EXIT__;
return;
}
if (!g_hash_table_insert(service_tbl, g_strdup(path), ret)) {
g_free(ret);
- INM_LOGI("Error! Failed to insert service");
+ INM_LOGE("Failed to insert service");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
if (!path || ! iter) {
- INM_LOGI("NULL path or iter");
+ INM_LOGW("NULL path or iter");
return;
}
__get_service_data(path, &service, added);
if (!service) {
- INM_LOGI("Failed to get service");
+ INM_LOGW("Failed to get service");
return;
}
__INM_FUNC_ENTER__;
if (!path) {
- INM_LOGI("NULL path");
+ INM_LOGW("NULL path");
return;
}
service->obj_path);
if (!g_hash_table_remove(service_tbl, path)) {
- INM_LOGI("service not found");
+ INM_LOGW("service not found");
__INM_FUNC_EXIT__;
return;
}
GVariant *ret = NULL;
if (!service) {
- INM_LOGI("There's no current conn");
+ INM_LOGW("There's no current conn");
return NULL;
}
GVariant *ret = NULL;
if (!service) {
- INM_LOGI("There's no current conn");
+ INM_LOGW("There's no current conn");
return NULL;
}
if (!parameters) {
g_variant_builder_unref(added_builder);
g_variant_builder_unref(removed_builder);
- INM_LOGI("Empty parameters");
+ INM_LOGW("Empty parameters");
return;
}
while (g_variant_iter_loop(added, "(oa{sv})", &path, &variants)) {
if (!path || !variants) {
- INM_LOGI("NULL path or variants");
+ INM_LOGW("NULL path or variants");
continue;
}
while (g_variant_iter_loop(removed, "o", &path)) {
if (!path) {
- INM_LOGI("NULL path");
+ INM_LOGW("NULL path");
continue;
}
service = __get_current_service();
if (service == NULL) {
- INM_LOGI("No current connections");
+ INM_LOGW("No current connections");
__INM_FUNC_EXIT__;
return INM_CONNMAN_ERROR_NO_CONNECTION;
}
service = __get_current_service();
if (service == NULL) {
- INM_LOGI("No current connections");
+ INM_LOGW("No current connections");
__INM_FUNC_EXIT__;
return INM_CONNMAN_ERROR_NO_CONNECTION;
}
service = __get_current_service();
if (service == NULL) {
- INM_LOGI("No current connections");
+ INM_LOGW("No current connections");
__INM_FUNC_EXIT__;
return INM_CONNMAN_ERROR_NO_CONNECTION;
}
if (service->type != CONNMAN_SERVICE_TYPE_ETHERNET &&
service->type != CONNMAN_SERVICE_TYPE_WIFI) {
- INM_LOGI("Can't get iface name");
+ INM_LOGW("Can't get iface name");
return INM_CONNMAN_ERROR_OPERATION_FAILED;
}
service = __get_current_service();
if (service == NULL) {
- INM_LOGI("No current connections");
+ INM_LOGW("No current connections");
__INM_FUNC_EXIT__;
return INM_CONNMAN_ERROR_NO_CONNECTION;
}
__INM_FUNC_ENTER__;
if (g_hash_table_size(service_tbl) == 0) {
- INM_LOGI("No connections");
+ INM_LOGW("No connections");
return INM_CONNMAN_ERROR_NO_CONNECTION;
}
if (service_tbl) {
g_conn_error_cb = cb;
} else {
- INM_LOGI("Service is not initialized!");
+ INM_LOGW("Service is not initialized!");
ret = -1;
}
if (service_tbl) {
g_conn_error_cb = NULL;
} else {
- INM_LOGI("Service is not initialized!");
+ INM_LOGW("Service is not initialized!");
ret = -1;
}
if (service_tbl) {
g_conn_changed_cb = cb;
} else {
- INM_LOGI("Service is not initialized!");
+ INM_LOGW("Service is not initialized!");
ret = -1;
}
if (service_tbl) {
g_conn_changed_cb = NULL;
} else {
- INM_LOGI("Service is not initialized!");
+ INM_LOGW("Service is not initialized!");
ret = -1;
}
static inline void __get_powered(GVariant *value, connman_tech_s *tech)
{
g_variant_get(value, "b", &(tech->powered));
- INM_LOGI("Powered %s", (tech->powered) ? "On" : "Off");
+ INM_LOGI("<Connman tech powered:%s>", (tech->powered) ? "On" : "Off");
}
static inline void __get_connected(GVariant *value, connman_tech_s *tech)
{
g_variant_get(value, "b", &(tech->connected));
- INM_LOGI("%s", (tech->connected) ? "Connected" : "Not connected");
+ INM_LOGI("<Connman tech connected:%s>", (tech->connected) ? "Connected" : "Not connected");
}
static inline void __get_name(GVariant *value, connman_tech_s *tech)
tech = g_hash_table_lookup(tech_tbl, object_path);
if (!tech) {
__INM_FUNC_EXIT__;
- INM_LOGI("Tech not found");
+ INM_LOGW("Tech not found");
return;
}
prev_tech_state = __connman_tech_get_state(tech->powered, tech->connected);
if (tech_tbl) {
g_tech_changed_cb = cb;
} else {
- INM_LOGI("Tech is not initialized!");
+ INM_LOGW("Tech is not initialized!");
ret = -1;
}
if (tech_tbl) {
g_tech_changed_cb = NULL;
} else {
- INM_LOGI("Tech is not initialized!");
+ INM_LOGW("Tech is not initialized!");
ret = -1;
}
g_variant_get(parameters, "(&s&s&s)", &name, &old, &new);
if (g_strcmp0(name, CONNMAN_SERVICE) == 0 && *new == '\0')
- INM_LOGI("ConnMan destroyed: name %s, old %s, new %s", name, old, new);
+ INM_LOGI("<ConnMan:destroyed>");
return;
}
{
int ret = access(TCP_DUMP_IN_BOOT_TIME, F_OK);
if (ret != 0) {
- INM_LOGI("Dumpstate Get Failed (%d).", ret);
+ INM_LOGE("Dumpstate Get Failed (%d).", ret);
return FALSE;
}
rv = inm_execute_file(path, args, envs);
if (rv < 0) {
- INM_LOGI("Fail to execute network log dump shell");
+ INM_LOGE("Fail to execute network log dump shell");
return -EIO;
}
return 0;
char *const envs[] = { NULL };
if (!dump_mon.is_tcpdump_running) {
- INM_LOGI("tcpdump is not running");
+ INM_LOGW("tcpdump is not running");
return FALSE;
}
ret = inm_execute_file(path, args, envs);
if (ret < 0) {
- INM_LOGI("Failed to Kill tcpdump, ret : %d\n", ret);
+ INM_LOGE("Failed to Kill tcpdump, ret : %d\n", ret);
return FALSE;
}
ret = inm_execute_file_no_wait(start_path, start_args);
if (ret < 0) {
- INM_LOGI("Failed to start tcpdump, ret : %d", ret);
+ INM_LOGE("Failed to start tcpdump, ret : %d", ret);
return FALSE;
}
}
if (!dump_mon.is_tcpdump_running) {
- INM_LOGI("tcpdump not running");
+ INM_LOGW("tcpdump not running");
return ret;
}
return INM_DUMP_OPERATION_FAILED;
if (!__start_tcpdump()) {
- INM_LOGI("Failed to start tcpdump");
+ INM_LOGE("Failed to start tcpdump");
return INM_DUMP_OPERATION_FAILED;
}
INM_LOGI("Successfully started tcpdump and running..");
}
if (dump_mon.is_tcpdump_running) {
- INM_LOGI("tcpdump is running, shutdown");
+ INM_LOGW("tcpdump is running, shutdown");
__stop_tcpdump();
}
#define DBUS_REPLY_TIMEOUT (120 * 1000)
-#define DEBUG_G_VARIANT(str, parameters)\
- do {\
- gchar *parameters_debug_str = NULL;\
- if (parameters)\
- parameters_debug_str = g_variant_print(parameters, TRUE);\
- INM_LOGI("%s[%s]", str, parameters_debug_str ? parameters_debug_str : "NULL");\
- g_free(parameters_debug_str);\
- } while (0)
-
-#define DEBUG_SIGNAL(sender_name, object_path, interface_name, signal_name, parameters)\
- do {\
- INM_LOGI("signal sender name [%s]", sender_name);\
- INM_LOGI("signal object path [%s]", object_path);\
- INM_LOGI("signal interface name [%s]", interface_name);\
- INM_LOGI("signal signal name [%s]", signal_name);\
- DEBUG_G_VARIANT("signal params ", parameters);\
- INM_LOGI("signal params type [%s]", g_variant_get_type_string(parameters));\
- } while (0)
-
typedef struct {
GDBusConnection *conn;
GDBusNodeInfo *daemon_introspection;
return rv;
}
- INM_LOGE("Sent signal (%s), Interface (%s)", signal_name, interface_name);
+ INM_LOGI("Sent signal (%s), Interface (%s)", signal_name, interface_name);
return rv;
}
if (!params || !params->bus_name || !params->object_path)
return INM_GDBUS_ERROR_INVALID_PARAM;
- INM_LOGI("method [%s]", params->method_name);
+ INM_LOGI("<GDbus method:%s>", params->method_name);
reply = g_dbus_connection_call_sync(
gdbus_mon.conn,
&error); /* error */
if (error != NULL) {
- INM_LOGI("Error! Failed to call method: [%s]", error->message);
+ INM_LOGE("Error! Failed to call method: [%s]", error->message);
g_error_free(error);
if (reply)
g_variant_unref(reply);
__INM_FUNC_ENTER__;
ret = inm_connman_get_current_connection(&arg);
if (ret != INM_MANAGER_ERROR_NONE) {
- INM_LOGI("Failed to get current connection");
+ INM_LOGW("Failed to get current connection");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_connman_get_connections(&arg);
if (ret != INM_MANAGER_ERROR_NONE) {
- INM_LOGI("Failed to get connections");
+ INM_LOGW("Failed to get connections");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_wifi_module_state(&state);
if (ret < 0) {
- INM_LOGI("Failed to get wifi module state");
+ INM_LOGW("Failed to get wifi module state");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_ethernet_cable_state(&state);
if (ret < 0) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_ip_conflict_state(&state);
if (ret < 0) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_ip_conflict_detect(&state);
if (ret < 0) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_tcpdump_state(&state);
if (ret != INM_MANAGER_ERROR_NONE) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
&local_error);
if (local_error != NULL) {
- INM_LOGI("Signal emit failed. error [%d: %s]",
+ INM_LOGE("Signal emit failed. error [%d: %s]",
local_error->code, local_error->message);
g_error_free(local_error);
}
ret = inm_manager_get_cellular_state(&state);
if (ret < 0) {
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__INM_FUNC_EXIT__;
return;
}
ret = inm_manager_get_wifi_state(&state);
if (ret < 0) {
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__INM_FUNC_EXIT__;
return;
}
ret = inm_manager_get_ethernet_state(&state);
if (ret < 0) {
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
ret = inm_manager_get_congestion_level(&level);
if (ret < 0) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_retry_tx_rate(&rate);
if (ret < 0) {
- INM_LOGI("Failed to get");
+ INM_LOGW("Failed to get");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_channel_interference(&ch_interference);
if (ret < 0) {
- INM_LOGI("Failed to get channel_interference");
+ INM_LOGW("Failed to get channel_interference");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
ret = inm_manager_get_reacher_is_running(&is_running);
if (ret < 0) {
- INM_LOGI("Failed to get reacher is running");
+ INM_LOGW("Failed to get reacher is running");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_ip_conflicted() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_ip_conflicted() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_arping_result() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_arping_result() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_gateway_check_result() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_gateway_check_result() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_reacher_results() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_reacher_results() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_ethernet_cable_state() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_ethernet_cable_state() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_wifi_module_state() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_wifi_module_state() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_retry_tx_rate_changed() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_retry_tx_rate_changed() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
g_variant_builder_unref(builder);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_channel_interference() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_channel_interference() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_congestion_level_changed() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_congestion_level_changed() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_cellular_state() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_cellular_state() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_wifi_state() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_wifi_state() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_ethernet_state() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_ethernet_state() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_connections_changed() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_connections_changed() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_conn_%s failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_conn_%s failed. error [%d: %s]",
property, error->code, error->message);
g_error_free(error);
}
__INM_FUNC_ENTER__;
if (!gdbus_mon.is_bus_aquired) {
- INM_LOGI("DBus is not acquired yet");
+ INM_LOGW("DBus is not acquired yet");
__INM_FUNC_EXIT__;
return;
}
&error);
if (error != NULL) {
- INM_LOGI("inm_gdbus_emit_wifi_scanning_changed() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_emit_wifi_scanning_changed() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
}
ret = inm_manager_get_wifi_scan_state(&wifi_scan_state);
if (ret < 0) {
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
- INM_LOGI("Failed to get");
+ INM_LOGE("Failed to get");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
ret = inm_connman_get_connection(user_data, &arg);
if (ret != 0) {
- INM_LOGI("Failed to get connection");
+ INM_LOGE("Failed to get connection");
__dbus_return_err(INM_MANAGER_ERROR_OPERATION_FAILED, invocation);
__INM_FUNC_EXIT__;
return;
NULL,
&error);
if (obj_id == 0) {
- INM_LOGI("register object failed!");
+ INM_LOGE("register object failed!");
return -1;
}
if (error != NULL) {
- INM_LOGI("inm_gdbus_register_conn_iface() failed. error [%d: %s]",
+ INM_LOGE("inm_gdbus_register_conn_iface() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
return -1;
return -1;
}
if (error != NULL) {
- INM_LOGI("__register_inm_manager_iface() failed. error [%d: %s]",
+ INM_LOGE("__register_inm_manager_iface() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
__INM_FUNC_EXIT__;
}
if (error != NULL) {
- INM_LOGI("__register_inm_wifi_iface() failed. error [%d: %s]",
+ INM_LOGE("__register_inm_wifi_iface() failed. error [%d: %s]",
error->code, error->message);
g_error_free(error);
__INM_FUNC_EXIT__;
&error); /* error */
if (error != NULL) {
- INM_LOGI("Error! Failed to call method: [%s]", error->message);
+ INM_LOGE("Error! Failed to call method: [%s]", error->message);
if (g_strrstr(error->message, DBUS_ERROR_STR_NO_OWNER) != NULL)
ret = INM_GDBUS_ERROR_HAS_NO_OWNER;
else
const gchar *name_owner,
gpointer user_data)
{
- INM_LOGI("%s is appeared", name);
+ INM_LOGI("<GDBus name appeared:%s>", name);
if (g_strcmp0(name, WPASUPPLICANT_BUS_NAME) == 0) {
if (gdbus_mon.wpasupplicant_watching_cb)
const gchar *name,
gpointer user_data)
{
- INM_LOGI("%s is vanished", name);
+ INM_LOGI("GDBus name vanished:%s>", name);
if (g_strcmp0(name, WPASUPPLICANT_BUS_NAME) == 0) {
if (gdbus_mon.wpasupplicant_watching_cb)
g_dbus_node_info_new_for_xml(inm_manager_introspection_xml, NULL);
if (!gdbus_mon.daemon_introspection) {
- INM_LOGI("No daemon introspection\n");
+ INM_LOGE("No daemon introspection\n");
return -1;
}
g_dbus_node_info_new_for_xml(inm_wifi_introspection_xml, NULL);
if (!gdbus_mon.wifi_introspection) {
- INM_LOGI("No wifi introspection\n");
+ INM_LOGE("No wifi introspection\n");
if (gdbus_mon.daemon_introspection) {
g_dbus_node_info_unref(gdbus_mon.daemon_introspection);
gdbus_mon.daemon_introspection = NULL;
g_dbus_node_info_new_for_xml(inm_conn_introspection_xml, NULL);
if (!gdbus_mon.wifi_introspection) {
- INM_LOGI("No conn introspection\n");
+ INM_LOGE("No conn introspection\n");
if (gdbus_mon.daemon_introspection) {
g_dbus_node_info_unref(gdbus_mon.daemon_introspection);
gdbus_mon.daemon_introspection = NULL;
gdbus_mon.conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (gdbus_mon.conn == NULL) {
if (error != NULL) {
- INM_LOGI("Error! Failed to connect to the D-BUS daemon: [%s]",
+ INM_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
error->message);
g_error_free(error);
}
INM_LOGI("Get System DBus");
if (__init_introspection() != 0) {
- INM_LOGI("Introspection initialize failed");
+ INM_LOGE("Introspection initialize failed");
g_object_unref(gdbus_mon.conn);
__INM_FUNC_EXIT__;
return INM_GDBUS_ERROR_OPERATION_FAILED;
#define RET_ERR_IF_DATA_NOT_FOUND(ping_data)\
do {\
if (!(ping_data)) {\
- INM_LOGI("ping_data not found");\
+ INM_LOGW("ping_data not found");\
__INM_FUNC_EXIT__;\
return INM_ICMP_PING_ERROR_OPERATION_FAILED;\
}\
ping_data->count--;
ret = util_send_icmp(&(ping_data->inm_util_icmp_data));
if (ret < 0) {
- INM_LOGD("Failed to send ICMP Packet");
+ INM_LOGE("Failed to send ICMP Packet");
__handle_errno(ping_data, ret);
}
ping_data->count--;
ret = util_send_icmp(&(ping_data->inm_util_icmp_data));
if (ret < 0) {
- INM_LOGD("Failed to send ICMP Packet");
+ INM_LOGE("Failed to send ICMP Packet");
__handle_errno(ping_data, ret);
} else {
- INM_LOGD("Sent ICMP packet");
+ INM_LOGI("Sent ICMP packet");
}
ping_data->icmp_interval_timer_source_id =
__start_icmp_ping(0, ping_data, NULL);
if (ping_data->inm_util_icmp_data.sock_source_id == 0) {
- INM_LOGI("Failed to start to ping ICMP");
+ INM_LOGE("Failed to start to ping ICMP");
__stop_icmp_ping(0, ping_data, NULL);
ping_data->in_progress = FALSE;
return INM_ICMP_PING_ERROR_OPERATION_FAILED;
ping_data =
(icmp_ping_data_s *)g_try_malloc0(sizeof(icmp_ping_data_s));
if (!ping_data) {
- INM_LOGI("Error! Failed to allocate memory");
+ INM_LOGE("Error! Failed to allocate memory");
__INM_FUNC_EXIT__;
return NULL;
}
iface_mon_data_s *data = NULL;
int device_status = 0;
if (!user_data) {
- INM_LOGE("user data not available");
+ INM_LOGW("user data not available");
return;
}
data = (iface_mon_data_s *)user_data;
return;
}
- INM_LOGI("Wi-Fi Module State [%d]", device_status);
+ INM_LOGI("<Wi-Fi Module State:%d>", device_status);
if (data->cb)
data->cb(data->iface_name, device_status, NULL);
if (--refcount == 0) {
if (vconf_ignore_key_changed(VCONFKEY_WIFI_DEVICE_STATUS_UEVENT,
__inm_wifi_module_state_changed_cb) < 0) {
- INM_LOGI("Error to de-register vconf callback(%d)", refcount);
+ INM_LOGE("Error to de-register vconf callback(%d)", refcount);
return -1;
} else
INM_LOGI("Successfully de-registered(%d)", refcount);
}
ip_conflict_data->iteration = 0;
- INM_LOGI("ip conflict is detected !\n");
+ INM_LOGI("<ip conflict:detected>");
ip_conflict_data->state = IP_CONFLICT_STATE_CONFLICT_DETECTED;
ip_conflict_data->timeout = BURST_ARP_SEND_TIME;
if (ip_conflict_data->cb)
ip_conflict_data->timer_source_id =
g_timeout_add(ip_conflict_data->timeout, util_send_arp, &(ip_conflict_data->arp_data));
} else {
- INM_LOGD("Sent ARP Packet \n");
+ INM_LOGI("Sent ARP Packet \n");
REMOVE_G_SOURCE(ip_conflict_data->timer_source_id);
if (ip_conflict_data->state == IP_CONFLICT_STATE_CONFLICT_DETECTED ||
__INM_FUNC_ENTER__;
if (!ip_conflict_mon.is_initialized) {
- INM_LOGE("Not intialiezed");
+ INM_LOGW("Not intialiezed");
__INM_FUNC_EXIT__;
return INM_IP_CONFLICT_ERROR_NOT_INITIALIZED;
}
ip_conflict_data =
g_datalist_get_data(&(ip_conflict_mon.ip_conflict_cb_dl), if_name);
if (!ip_conflict_data) {
- INM_LOGI("ip_conflict_data not found");
+ INM_LOGW("ip_conflict_data not found");
__INM_FUNC_EXIT__;
return INM_IP_CONFLICT_ERROR_OPERATION_FAILED;
}
__start_ip_conflict_mon(if_key, ip_conflict_data, NULL);
if (ip_conflict_data->arp_data.sock_source_id == 0) {
- INM_LOGI("Failed to start IP conflict monitoring");
+ INM_LOGE("Failed to start IP conflict monitoring");
__stop_ip_conflict_mon(if_key, ip_conflict_data, NULL);
ip_conflict_data->detection_enabled = FALSE;
ip_conflict_data->state = IP_CONFLICT_STATE_UNKNOWN;
ip_conflict_data =
g_datalist_get_data(&(ip_conflict_mon.ip_conflict_cb_dl), if_name);
if (!ip_conflict_data) {
- INM_LOGI("ip_conflict_data not found");
+ INM_LOGW("ip_conflict_data not found");
__INM_FUNC_EXIT__;
return INM_IP_CONFLICT_ERROR_OPERATION_FAILED;
}
- INM_LOGI("state [%d]", ip_conflict_data->state);
+ INM_LOGI("<Ip conflict state:%d>", ip_conflict_data->state);
*state = ip_conflict_data->state;
__INM_FUNC_EXIT__;
ip_conflict_data =
g_datalist_get_data(&(ip_conflict_mon.ip_conflict_cb_dl), if_name);
if (!ip_conflict_data) {
- INM_LOGI("ip_conflict_data not found");
+ INM_LOGW("ip_conflict_data not found");
__INM_FUNC_EXIT__;
return INM_IP_CONFLICT_ERROR_OPERATION_FAILED;
}
ip_conflict_data =
(ip_conflict_data_s *)g_try_malloc0(sizeof(ip_conflict_data_s));
if (!ip_conflict_data) {
- INM_LOGI("Error! Failed to allocate memory");
+ INM_LOGE("Error! Failed to allocate memory");
__INM_FUNC_EXIT__;
return NULL;
}
ip_conflict_data =
g_datalist_get_data(&(ip_conflict_mon.ip_conflict_cb_dl), if_name);
if (!ip_conflict_data) {
- INM_LOGI("ip_conflict_data not found");
+ INM_LOGW("ip_conflict_data not found");
__INM_FUNC_EXIT__;
return INM_IP_CONFLICT_ERROR_OPERATION_FAILED;
}
__INM_FUNC_ENTER__;
ret = inm_iface_mon_get_iface_state(IF_NAME_ETH, &value);
if (ret < 0) {
- INM_LOGI("get iface %s state failed", IF_NAME_ETH);
+ INM_LOGE("get iface %s state failed", IF_NAME_ETH);
__INM_FUNC_EXIT__;
return -1;
}
__INM_FUNC_ENTER__;
ret = inm_iface_mon_get_iface_state(IF_NAME_WLAN, &value);
if (ret < 0) {
- INM_LOGI("get iface %s state failed", IF_NAME_WLAN);
+ INM_LOGE("get iface %s state failed", IF_NAME_WLAN);
__INM_FUNC_EXIT__;
return -1;
}
__INM_FUNC_ENTER__;
ret = inm_connman_tech_get_state(CONNMAN_SERVICE_TYPE_CELLULAR, &value);
if (ret != 0) {
- INM_LOGI("Failed to get cellular state");
+ INM_LOGW("Failed to get cellular state");
__INM_FUNC_EXIT__;
return -1;
}
__INM_FUNC_ENTER__;
ret = inm_connman_tech_get_state(CONNMAN_SERVICE_TYPE_WIFI, &value);
if (ret != 0) {
- INM_LOGI("Failed to get wifi state");
+ INM_LOGW("Failed to get wifi state");
__INM_FUNC_EXIT__;
return -1;
}
__INM_FUNC_ENTER__;
ret = inm_connman_tech_get_state(CONNMAN_SERVICE_TYPE_ETHERNET, &value);
if (ret != 0) {
- INM_LOGI("Failed to get ethernet state");
+ INM_LOGW("Failed to get ethernet state");
__INM_FUNC_EXIT__;
return -1;
}
ret = inm_arping_start(ifname, target_ip, timeout, FALSE);
if (ret != 0) {
- INM_LOGI("Failed to start arping");
+ INM_LOGW("Failed to start arping");
if (ret == INM_ARPING_ERROR_IN_PROGRESS)
ret = INM_MANAGER_ERROR_IN_PROGRESS;
ret = inm_arping_stop(ifname, target_ip);
if (ret != 0) {
- INM_LOGI("Failed to stop arping");
+ INM_LOGW("Failed to stop arping");
ret = -1;
}
ret = inm_arping_start(ifname, gateway_ip, GATEWAY_CHECK_TIMEOUT, TRUE);
if (ret != 0) {
- INM_LOGI("Failed to start arping");
+ INM_LOGW("Failed to start arping");
if (ret == INM_ARPING_ERROR_IN_PROGRESS)
ret = INM_MANAGER_ERROR_IN_PROGRESS;
ret = inm_arping_stop(ifname, gateway_ip);
if (ret != 0)
- INM_LOGI("Failed to stop arping");
+ INM_LOGW("Failed to stop arping");
g_free(ifname);
g_free(gateway_ip);
ret = inm_reacher_add_url(url);
if (ret != 0) {
- INM_LOGI("Failed to add url");
+ INM_LOGW("Failed to add url");
if (ret == INM_REACHER_ERROR_IN_PROGRESS)
ret = INM_MANAGER_ERROR_IN_PROGRESS;
ret = inm_reacher_remove_url(url);
if (ret != 0) {
- INM_LOGI("Failed to remove url");
+ INM_LOGW("Failed to remove url");
if (ret == INM_REACHER_ERROR_IN_PROGRESS)
ret = INM_MANAGER_ERROR_IN_PROGRESS;
if (!url)
return;
- INM_LOGI("URL : %s is %s", url, found ? "Found" : "Not Found");
+ INM_LOGI("<URL %s:%s>", url, found ? "Found" : "Not Found");
inm_gdbus_emit_reacher_result(found, url);
return;
ret = inm_reacher_start(type, TRUE, __reacher_callback, NULL);
if (ret != 0) {
- INM_LOGI("Failed to start reacher");
+ INM_LOGW("Failed to start reacher");
if (ret == INM_REACHER_ERROR_IN_PROGRESS)
ret = INM_MANAGER_ERROR_IN_PROGRESS;
ret = inm_reacher_stop(type);
if (ret != 0) {
- INM_LOGI("Failed to stop reacher");
+ INM_LOGW("Failed to stop reacher");
__INM_FUNC_EXIT__;
return -1;
ret = inm_reacher_is_running(is_running);
if (ret != 0) {
- INM_LOGI("Failed to get reacher is running");
+ INM_LOGW("Failed to get reacher is running");
__INM_FUNC_EXIT__;
return -1;
{
__INM_FUNC_ENTER__;
if (ip_conflict_detection_init() < 0) {
- INM_LOGI("ip conflict detection init failed");
+ INM_LOGW("ip conflict detection init failed");
__INM_FUNC_EXIT__;
return;
}
ip_conflict_unset_callback(IF_NAME_WLAN);
if (ip_conflict_detection_deinit() < 0)
- INM_LOGI("ip conflict detection deinit failed");
+ INM_LOGW("ip conflict detection deinit failed");
__INM_FUNC_EXIT__;
return;
if (!if_name || !ip)
return;
- INM_LOGI("arping callback IP : %s is %s", if_name, found ? "Found" : "Not Found");
+ INM_LOGI("Arping IP %s:%s>", if_name, found ? "Found" : "Not Found");
if (is_gateway)
inm_gdbus_emit_gateway_check_result(found, ip);
else
{
__INM_FUNC_ENTER__;
if (inm_arping_init() < 0) {
- INM_LOGI("arping init failed");
+ INM_LOGW("arping init failed");
__INM_FUNC_EXIT__;
return;
}
inm_arping_unset_callback();
if (inm_arping_deinit() < 0)
- INM_LOGI("arping deinit failed");
+ INM_LOGW("arping deinit failed");
__INM_FUNC_EXIT__;
return;
{
__INM_FUNC_ENTER__;
if (inm_reacher_init() < 0) {
- INM_LOGI("reacher init failed");
+ INM_LOGW("reacher init failed");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
if (inm_reacher_deinit() < 0)
- INM_LOGI("reacher deinit failed");
+ INM_LOGW("reacher deinit failed");
__INM_FUNC_EXIT__;
return;
is_attached = state == 1;
- INM_LOGI("%s is %s", IF_NAME_ETH, is_attached ? "Attached" : "Detached");
+ INM_LOGI("<Ethernet cable %s:%s>", IF_NAME_ETH, is_attached ? "Attached" : "Detached");
inm_gdbus_emit_ethernet_cable_state(is_attached);
}
is_attached = state == 1;
- INM_LOGI("%s is %s", IF_NAME_WLAN, is_attached ? "Attached" : "Detached");
+ INM_LOGI("<WiFi module %s:%s>", IF_NAME_WLAN, is_attached ? "Attached" : "Detached");
inm_gdbus_emit_wifi_module_state(is_attached);
}
{
__INM_FUNC_ENTER__;
if (inm_iface_mon_init() < 0) {
- INM_LOGI("inm_iface_mon_init failed");
+ INM_LOGW("inm_iface_mon_init failed");
__INM_FUNC_EXIT__;
return;
}
if (inm_iface_mon_start_monitor(IF_NAME_ETH,
__ethernet_cable_state_changed_cb,
NULL) < 0)
- INM_LOGI("inm_iface_mon_start_monitor %s failed", IF_NAME_ETH);
+ INM_LOGW("inm_iface_mon_start_monitor %s failed", IF_NAME_ETH);
if (inm_iface_mon_start_monitor(IF_NAME_WLAN,
__wifi_module_state_changed_cb,
NULL) < 0)
- INM_LOGI("inm_iface_mon_start_monitor %s failed", IF_NAME_WLAN);
+ INM_LOGW("inm_iface_mon_start_monitor %s failed", IF_NAME_WLAN);
__INM_FUNC_EXIT__;
}
__INM_FUNC_ENTER__;
if (inm_iface_mon_stop_monitor(IF_NAME_ETH) < 0)
- INM_LOGI("inm_iface_mon_start_monitor %s failed", IF_NAME_ETH);
+ INM_LOGW("inm_iface_mon_start_monitor %s failed", IF_NAME_ETH);
if (inm_iface_mon_stop_monitor(IF_NAME_WLAN) < 0)
- INM_LOGI("inm_iface_mon_start_monitor %s failed", IF_NAME_WLAN);
+ INM_LOGW("inm_iface_mon_start_monitor %s failed", IF_NAME_WLAN);
if (inm_iface_mon_deinit() < 0)
- INM_LOGI("inm_iface_mon_deinit failed");
+ INM_LOGW("inm_iface_mon_deinit failed");
__INM_FUNC_EXIT__;
}
__INM_FUNC_ENTER__;
ret = inm_retry_tx_rate_monitor_start(__retry_tx_rate_cb, NULL);
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_retry_tx_rate_monitor_start failed");
+ INM_LOGW("inm_retry_tx_rate_monitor_start failed");
}
static inline void __deinit_retry_tx_rate_monitor()
__INM_FUNC_ENTER__;
ret = inm_retry_tx_rate_monitor_stop();
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_retry_tx_rate_monitor_stop failed");
+ INM_LOGW("inm_retry_tx_rate_monitor_stop failed");
}
void __channel_interference_cb(int freq, double channel_interference, gpointer user_data)
__INM_FUNC_ENTER__;
ret = inm_channel_interference_monitor_start(__channel_interference_cb, NULL);
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_channel_interference_monitor_start failed");
+ INM_LOGW("inm_channel_interference_monitor_start failed");
}
static inline void __deinit_channel_interference_monitor()
__INM_FUNC_ENTER__;
ret = inm_channel_interference_monitor_stop();
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_channel_interference_monitor_stop failed");
+ INM_LOGW("inm_channel_interference_monitor_stop failed");
}
void __congestion_mon_cb(int congestion_level, gpointer user_data)
__INM_FUNC_ENTER__;
ret = inm_congestion_mon_init();
if (ret != INM_MANAGER_ERROR_NONE) {
- INM_LOGI("inm_congestion_mon_init failed");
+ INM_LOGW("inm_congestion_mon_init failed");
__INM_FUNC_EXIT__;
return;
}
ret = inm_congestion_monitor_start(__congestion_mon_cb, NULL);
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_congestion_monitor_start failed");
+ INM_LOGW("inm_congestion_monitor_start failed");
__INM_FUNC_EXIT__;
}
__INM_FUNC_ENTER__;
ret = inm_congestion_monitor_stop();
if (ret != INM_MANAGER_ERROR_NONE) {
- INM_LOGI("inm_congestion_monitor_stop failed");
+ INM_LOGW("inm_congestion_monitor_stop failed");
__INM_FUNC_EXIT__;
return;
}
ret = inm_congestion_mon_deinit();
if (ret != INM_MANAGER_ERROR_NONE)
- INM_LOGI("inm_congestion_mon_deinit failed");
+ INM_LOGW("inm_congestion_mon_deinit failed");
__INM_FUNC_EXIT__;
}
if (state == CONNMAN_TECH_STATE_CONNECTED) {
ret = inm_ip_conflict_enable_detection(ifname, TRUE);
if (ret == INM_IP_CONFLICT_ERROR_NONE)
- INM_LOGI("Enable ip confilct %s detection", ifname);
+ INM_LOGW("Enable ip confilct %s detection", ifname);
} else {
ret = inm_ip_conflict_is_detection_enabled(ifname, &enabled);
if (ret == INM_IP_CONFLICT_ERROR_NONE && enabled)
ret = inm_ip_conflict_enable_detection(ifname, FALSE);
if (ret == INM_IP_CONFLICT_ERROR_NONE)
- INM_LOGI("Disable ip confilct %s detection", ifname);
+ INM_LOGW("Disable ip confilct %s detection", ifname);
}
}
static void __tech_changed_cb(connman_service_type_e type,
connman_tech_state_e state)
{
- INM_LOGI("Tech changed %d %d", type, state);
+ INM_LOGI("<Tech state changed %d:%d>", type, state);
if (type == CONNMAN_SERVICE_TYPE_ETHERNET) {
inm_gdbus_emit_ethernet_state(state);
__set_ip_detection(IF_NAME_ETH, state);
__INM_FUNC_ENTER__;
ret = inm_connman_init();
if (ret < 0) {
- INM_LOGI("Init connman failed");
+ INM_LOGW("Init connman failed");
__INM_FUNC_EXIT__;
return;
}
ret = inm_connman_set_tech_changed_callback(__tech_changed_cb);
if (ret < 0) {
inm_connman_deinit();
- INM_LOGI("Set tech changed cb failed");
+ INM_LOGW("Set tech changed cb failed");
}
ret = inm_connman_set_conn_changed_callback(__conn_changed_cb);
if (ret < 0) {
inm_connman_deinit();
- INM_LOGI("Set connection changed cb failed");
+ INM_LOGW("Set connection changed cb failed");
}
ret = inm_connman_set_conn_error_callback(__conn_error_cb);
if (ret < 0) {
inm_connman_deinit();
- INM_LOGI("Set connection error cb failed");
+ INM_LOGW("Set connection error cb failed");
}
__INM_FUNC_EXIT__;
ret = inm_connman_unset_tech_changed_callback();
if (ret < 0)
- INM_LOGI("Unset tech changed cb failed");
+ INM_LOGW("Unset tech changed cb failed");
ret = inm_connman_unset_conn_changed_callback();
if (ret < 0)
- INM_LOGI("Unset conn changed cb failed");
+ INM_LOGW("Unset conn changed cb failed");
ret = inm_connman_unset_conn_error_callback();
if (ret < 0)
- INM_LOGI("Unset connection error cb failed");
+ INM_LOGW("Unset connection error cb failed");
ret = inm_connman_deinit();
if (ret < 0) {
- INM_LOGI("Deinit connman failed");
+ INM_LOGW("Deinit connman failed");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
ret = inm_supplicant_init();
if (ret < 0) {
- INM_LOGI("Init supplicant failed");
+ INM_LOGW("Init supplicant failed");
__INM_FUNC_EXIT__;
return;
}
ret = inm_supplicant_iface_set_prop_changed_cb(__supplicant_iface_changed, NULL);
if (ret < 0) {
inm_supplicant_deinit();
- INM_LOGI("Set supplicant iface changed cb failed");
+ INM_LOGW("Set supplicant iface changed cb failed");
}
__INM_FUNC_EXIT__;
ret = inm_supplicant_iface_unset_prop_changed_cb();
if (ret < 0) {
inm_supplicant_deinit();
- INM_LOGI("Set supplicant iface changed cb failed");
+ INM_LOGW("Set supplicant iface changed cb failed");
}
ret = inm_supplicant_deinit();
if (ret < 0) {
- INM_LOGI("Denit supplicant failed");
+ INM_LOGW("Denit supplicant failed");
__INM_FUNC_EXIT__;
return;
}
static void __wpasupplicant_watching_cb(gboolean appeared)
{
- INM_LOGI("wpasupplicant is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Wpasupplicant:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_wpasupplicant_enabled = appeared;
}
static void __connman_watching_cb(gboolean appeared)
{
- INM_LOGI("connman is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Connman:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_connman_enabled = appeared;
}
static void __telephony_watching_cb(gboolean appeared)
{
- INM_LOGI("telephony is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Telephony:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_telephony_enabled = appeared;
}
static void __wfd_manager_watching_cb(gboolean appeared)
{
- INM_LOGI("wfd_manager is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Wfd_manager:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_wfd_manager_enabled = appeared;
}
static void __mobileap_watching_cb(gboolean appeared)
{
- INM_LOGI("mobileap is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Mobileap:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_mobileap_enabled = appeared;
}
static void __stc_manager_watching_cb(gboolean appeared)
{
- INM_LOGI("stc_manager is %s", appeared ? "Enabled" : "Disabled");
+ INM_LOGI("<Stc_manager:%s>", appeared ? "Enabled" : "Disabled");
g_inm_manager->is_stc_manager_enabled = appeared;
}
__INM_FUNC_ENTER__;
g_inm_manager = g_try_malloc0(sizeof(inm_manager_s));
if (!g_inm_manager) {
- INM_LOGI("Failed to allocate memory for daemon");
+ INM_LOGE("Failed to allocate memory for daemon");
__INM_FUNC_EXIT__;
return -1;
}
ret = inm_gdbus_init(__gdbus_name_aquired, __gdbus_name_lost);
if (ret != 0) {
- INM_LOGI("Failed to initialize gdbus");
+ INM_LOGW("Failed to initialize gdbus");
__INM_FUNC_EXIT__;
return -1;
}
int i = 0;
if (!txt || !mac) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return -1;
}
g_variant_get(parameters, "(&s&s&s)", &name, &old, &new);
if (g_strcmp0(name, MOBILEAP_SERVICE) == 0 && *new == '\0')
- INM_LOGI("wfd-manager destroyed: name %s, old %s, new %s", name, old, new);
+ INM_LOGI("Mobileap destroyed: name %s, old %s, new %s", name, old, new);
__INM_FUNC_EXIT__;
return;
const guint32 time = 0;
if (!parameters) {
- INM_LOGI("Invalid parameters");
+ INM_LOGW("Invalid parameters");
return;
}
&event, &type, &ip_addr, &mac_addr, &name, &time);
if (!event || !ip_addr || !mac_addr || !name) {
- INM_LOGI("failed to get parameters");
+ INM_LOGW("failed to get parameters");
return;
}
if (!mobileap_mon.tether.sta_info) {
- INM_LOGI("hash table empty");
+ INM_LOGW("hash table empty");
return;
}
sta = g_try_malloc0(sizeof(mobileap_sta_s));
if (!sta) {
- INM_LOGI("malloc failed");
+ INM_LOGE("malloc failed");
return;
}
const guint32 time = 0;
if (!parameters) {
- INM_LOGI("Invalid parameters");
+ INM_LOGW("Invalid parameters");
return;
}
&event, &ip_addr, &mac_addr, &name, &time);
if (!event || !ip_addr || !mac_addr || !name) {
- INM_LOGI("failed to get parameters");
+ INM_LOGW("failed to get parameters");
return;
}
if (!mobileap_mon.softap.sta_info) {
- INM_LOGI("hash table empty");
+ INM_LOGW("hash table empty");
return;
}
sta = g_try_malloc0(sizeof(mobileap_sta_s));
if (!sta) {
- INM_LOGI("malloc failed");
+ INM_LOGE("malloc failed");
return;
}
signal_idx < MOBILEAP_SIGNAL_MAX; signal_idx++) {
ret = inm_gdbus_subscribe_signal(&(mobileap_signal_param[signal_idx]));
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to subscribe signal");
+ INM_LOGE("Failed to subscribe signal");
}
__INM_FUNC_EXIT__;
ret = inm_gdbus_unsubscribe_signal(&(mobileap_signal_param[signal_idx]));
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to unsubscribe signal");
+ INM_LOGE("Failed to unsubscribe signal");
else
mobileap_signal_param[signal_idx].subscriber_id = 0;
}
return 0;
}
- INM_LOGD("Download speed %.0f bytes/sec", speed);
+ INM_LOGI("<Download speed:%.0f bytes/sec>", speed);
conn->speed = speed;
ret = curl_easy_getinfo(easy_handle, CURLINFO_SIZE_DOWNLOAD, &download);
return 0;
}
- INM_LOGD("Download byte %.0f bytes", download);
+ INM_LOGI("<Download byte:%.0f bytes>", download);
conn->download_byte = download;
ret = curl_easy_getinfo(easy_handle, CURLINFO_NAMELOOKUP_TIME, &namelookup);
return 0;
}
- INM_LOGD("name lookup Time: %.6f", namelookup);
+ INM_LOGI("<Name lookup Time:%.6f>", namelookup);
conn->resolved_time = namelookup;
ret = curl_easy_getinfo(easy_handle, CURLINFO_APPCONNECT_TIME, &connect);
return 0;
}
- INM_LOGD("Time from start until SSL/SSH handshake completed: %.6f", connect);
+ INM_LOGI("Time from start until SSL/SSH handshake completed: %.6f", connect);
ret = curl_easy_getinfo(easy_handle, CURLINFO_TOTAL_TIME, &total);
/* Check for errors */
return 0;
}
- INM_LOGD("Total Time: %.6f", total);
+ INM_LOGI("<Curl total Time:%.6f>", total);
conn->total_time = total;
return 0;
url,
__compare_url);
if (!node) {
- INM_LOGI("URL not found");
+ INM_LOGW("URL not found");
return;
}
if (g_reacher->running) {
__INM_FUNC_EXIT__;
- INM_LOGD("Already running");
+ INM_LOGI("Already running");
return INM_REACHER_ERROR_IN_PROGRESS;
}
return;
if_index = rtnl_addr_get_ifindex(p_rtnl_addr);
- INM_LOGI("Iface %d %s", if_index, if_indextoname(if_index, buf));
+ INM_LOGI("<Rtnl addr iface %d:%s>", if_index, if_indextoname(if_index, buf));
p_nl_addr = rtnl_addr_get_local(p_rtnl_addr);
- INM_LOGI("Addr family %s",
+ INM_LOGI("<Rtnl addr family:%s>",
nl_af2str(nl_addr_get_family(p_nl_addr), buf, sizeof(buf)));
- INM_LOGI("Addr %s", nl_addr2str(p_nl_addr, buf, sizeof(buf)));
+ INM_LOGI("Rtnl addr address:%s>", nl_addr2str(p_nl_addr, buf, sizeof(buf)));
}
static void __addr_recv_cb(gboolean added,
return;
}
- INM_LOGI("OBJ Addr %s", added ? "added" : "deleted");
+ INM_LOGI("<Rtnl addr obj:%s>", added ? "added" : "deleted");
__parse_rtnl_addr((struct rtnl_addr *)obj);
__INM_FUNC_EXIT__;
int i;
for (i = 0; rtnl_link_stat_str_s[i].str; ++i) {
- INM_LOGI("%s: %lu",
+ INM_LOGI("<Rtnl link states %s:%lu>",
rtnl_link_stat_str_s[i].str,
rtnl_link_get_stat(p_rtnl_link, rtnl_link_stat_str_s[i].stat_num));
}
p_str_buf = rtnl_link_get_name(p_rtnl_link);
if (p_str_buf)
- INM_LOGI("name : %s", p_str_buf);
- INM_LOGI("Index %d", rtnl_link_get_ifindex(p_rtnl_link));
+ INM_LOGI("<Rtnl link name:%s>", p_str_buf);
+ INM_LOGI("<Rtnl link index:%d>", rtnl_link_get_ifindex(p_rtnl_link));
p_str_buf = nl_addr2str(rtnl_link_get_addr(p_rtnl_link), buf, sizeof(buf));
if (p_str_buf)
- INM_LOGI("Hw addr %s", p_str_buf);
+ INM_LOGI("<Rtnl link hw addr:%s>", p_str_buf);
p_str_buf = nl_addr2str(rtnl_link_get_broadcast(p_rtnl_link), buf, sizeof(buf));
if (p_str_buf)
- INM_LOGI("Bcast addr %s", p_str_buf);
- INM_LOGI("MTU %u", rtnl_link_get_mtu(p_rtnl_link));
- INM_LOGI("Flags %s", rtnl_link_flags2str(rtnl_link_get_flags(p_rtnl_link), buf, sizeof(buf)));
- INM_LOGI("Operstate %s", rtnl_link_operstate2str(rtnl_link_get_operstate(p_rtnl_link), buf, sizeof(buf)));
- INM_LOGI("Link_mode %s", rtnl_link_mode2str(rtnl_link_get_linkmode(p_rtnl_link), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl link broadcast addr:%s>", p_str_buf);
+ INM_LOGI("<Rtnl link MTU:%u>", rtnl_link_get_mtu(p_rtnl_link));
+ INM_LOGI("<Rtnl link flags:%s>", rtnl_link_flags2str(rtnl_link_get_flags(p_rtnl_link), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl link operstate:%s>", rtnl_link_operstate2str(rtnl_link_get_operstate(p_rtnl_link), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl link link_mode:%s>", rtnl_link_mode2str(rtnl_link_get_linkmode(p_rtnl_link), buf, sizeof(buf)));
#if LIBNL_VER_NUM >= 3
- INM_LOGI("Group %u", rtnl_link_get_group(p_rtnl_link));
- INM_LOGI("Carrier %s", rtnl_link_carrier2str(rtnl_link_get_carrier(p_rtnl_link), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl link group:%u>", rtnl_link_get_group(p_rtnl_link));
+ INM_LOGI("<Rtnl link carrier:%s>", rtnl_link_carrier2str(rtnl_link_get_carrier(p_rtnl_link), buf, sizeof(buf)));
#endif
p_str_buf = nl_llproto2str(rtnl_link_get_arptype(p_rtnl_link), buf, sizeof(buf));
if (p_str_buf)
- INM_LOGI("Hw type %s", p_str_buf);
+ INM_LOGI("<Rtnl link hw type:%s>", p_str_buf);
__print_link_stats(p_rtnl_link);
}
return;
}
- INM_LOGI("OBJ Addr %s", added ? "added" : "deleted");
+ INM_LOGI("<Rtnl obj link:%s>", added ? "added" : "deleted");
__parse_rtnl_link((struct rtnl_link *)obj);
__INM_FUNC_EXIT__;
if (!p_rtnl_neigh)
return;
- INM_LOGI("Iface idx %d %s",
+ INM_LOGI("<Rtnl neigh iface idx: %d %s>",
rtnl_neigh_get_ifindex(p_rtnl_neigh),
if_indextoname(rtnl_neigh_get_ifindex(p_rtnl_neigh), buf));
- INM_LOGI("State %s", rtnl_neigh_state2str(rtnl_neigh_get_state(p_rtnl_neigh), buf, sizeof(buf)));
- INM_LOGI("Flags %s", rtnl_neigh_flags2str(rtnl_neigh_get_flags(p_rtnl_neigh), buf, sizeof(buf)));
- INM_LOGI("LL addr %s", nl_addr2str(rtnl_neigh_get_lladdr(p_rtnl_neigh), buf, sizeof(buf)));
- INM_LOGI("Dst addr %s", nl_addr2str(rtnl_neigh_get_dst(p_rtnl_neigh), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl neigh state:%s>",
+ rtnl_neigh_state2str(rtnl_neigh_get_state(p_rtnl_neigh), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl neigh Flags:%s>",
+ rtnl_neigh_flags2str(rtnl_neigh_get_flags(p_rtnl_neigh), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl neigh LL addr:%s>",
+ nl_addr2str(rtnl_neigh_get_lladdr(p_rtnl_neigh), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl neigh Dst addr:%s>",
+ nl_addr2str(rtnl_neigh_get_dst(p_rtnl_neigh), buf, sizeof(buf)));
}
static void __neigh_recv_cb(gboolean added,
return;
}
- INM_LOGI("OBJ Addr %s", added ? "added" : "deleted");
+ INM_LOGI("<Rtnl obj neigh:%s>", added ? "added" : "deleted");
__parse_rtnl_neigh((struct rtnl_neigh *)obj);
__INM_FUNC_EXIT__;
if (!p_rtnl_route)
return;
- INM_LOGI("Route");
- INM_LOGI("Table name %s", rtnl_route_table2str(rtnl_route_get_table(p_rtnl_route), buf, sizeof(buf)));
- INM_LOGI("Proto name %s", rtnl_route_proto2str(rtnl_route_get_protocol(p_rtnl_route), buf, sizeof(buf)));
- INM_LOGI("Scope %u", rtnl_route_get_scope(p_rtnl_route));
- INM_LOGI("Prio %u", rtnl_route_get_priority(p_rtnl_route));
- INM_LOGI("TOS %u", rtnl_route_get_tos(p_rtnl_route));
- INM_LOGI("Family %u", rtnl_route_get_family(p_rtnl_route));
- INM_LOGI("dst addr %s", nl_addr2str(rtnl_route_get_dst(p_rtnl_route), buf, sizeof(buf)));
- INM_LOGI("src addr %s", nl_addr2str(rtnl_route_get_src(p_rtnl_route), buf, sizeof(buf)));
- INM_LOGI("type %u", rtnl_route_get_type(p_rtnl_route));
- INM_LOGI("flags %u", rtnl_route_get_flags(p_rtnl_route));
+ INM_LOGI("<Rtnl route table name:%s>", rtnl_route_table2str(rtnl_route_get_table(p_rtnl_route), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl route proto name:%s>", rtnl_route_proto2str(rtnl_route_get_protocol(p_rtnl_route), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl route scope:%u>", rtnl_route_get_scope(p_rtnl_route));
+ INM_LOGI("<Rtnl route prio:%u>", rtnl_route_get_priority(p_rtnl_route));
+ INM_LOGI("<Rtnl route TOS:%u>", rtnl_route_get_tos(p_rtnl_route));
+ INM_LOGI("<Rtnl route family:%u>", rtnl_route_get_family(p_rtnl_route));
+ INM_LOGI("<Rtnl route dst addr:%s>", nl_addr2str(rtnl_route_get_dst(p_rtnl_route), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl route src addr:%s>", nl_addr2str(rtnl_route_get_src(p_rtnl_route), buf, sizeof(buf)));
+ INM_LOGI("<Rtnl route type:%u>", rtnl_route_get_type(p_rtnl_route));
+ INM_LOGI("<Rtnl route flags:%u>", rtnl_route_get_flags(p_rtnl_route));
//INM_LOGI("metric %s", rtnl_route_metric2str(rtnl_route_get_metric(p_rtnl_route), p_buf, sizeof(p_buf)));
- INM_LOGI("iif %s", if_indextoname(rtnl_route_get_iif(p_rtnl_route), buf));
+ INM_LOGI("<Rtnl route iif:%s>", if_indextoname(rtnl_route_get_iif(p_rtnl_route), buf));
}
static void __route_recv_cb(gboolean added,
__INM_FUNC_EXIT__;
return;
}
- INM_LOGI("OBJ Addr %s", added ? "added" : "deleted");
+ INM_LOGI("<Rtnl obj route:%s>", added ? "added" : "deleted");
__parse_rtnl_route((struct rtnl_route *)obj);
fp = fopen(INM_PROC_DEV, "r");
if (fp == NULL) {
- INM_LOGI("Failed to open %s", INM_PROC_DEV);
+ INM_LOGE("Failed to open %s", INM_PROC_DEV);
__INM_FUNC_EXIT__;
return TRUE;
}
#include "inm-supplicant.h"
#include "inm-supplicant-internal.h"
-#define DEBUG_G_VARIANT(str, parameters)\
- do {\
- gchar *parameters_debug_str = NULL;\
- if (parameters)\
- parameters_debug_str = g_variant_print(parameters, TRUE);\
- INM_LOGI("%s[%s]", str, parameters_debug_str ? parameters_debug_str : "NULL");\
- g_free(parameters_debug_str);\
- } while (0)
-#define DEBUG_SIGNAL(sender_name, object_path, interface_name, signal_name, parameters)\
- do {\
- INM_LOGI("signal sender name [%s]", sender_name);\
- INM_LOGI("signal object path [%s]", object_path);\
- INM_LOGI("signal interface name [%s]", interface_name);\
- INM_LOGI("signal signal name [%s]", signal_name);\
- DEBUG_G_VARIANT("signal params ", parameters);\
- INM_LOGI("signal params type [%s]", g_variant_get_type_string(parameters));\
- } while (0)
-
typedef enum {
BSS_SIGNAL_PROPERTIESCHANGED,
BSS_SIGNAL_MAX,
int res = FALSE;
if (!dst || !src || size == 0) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return FALSE;
}
g_variant_get(src, "ay", &iter);
if (iter == NULL) {
- INM_LOGI("failed to get iterator");
+ INM_LOGW("failed to get iterator");
return FALSE;
}
bss = (supplicant_bss_s *)g_try_malloc0(sizeof(supplicant_bss_s));
if (!bss) {
- INM_LOGI("Error! Failed to allocate bss");
+ INM_LOGE("Error! Failed to allocate bss");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
bss = (supplicant_bss_s *)g_try_malloc0(sizeof(supplicant_bss_s));
if (!bss) {
- INM_LOGI("Error! Failed to allocate bss");
+ INM_LOGE("Error! Failed to allocate bss");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
iface_signal_params[signal_idx].object_path = path;
ret = inm_gdbus_subscribe_signal(&(iface_signal_params[signal_idx]));
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to subscribe signal");
+ INM_LOGW("Error! Failed to subscribe signal");
else
iface_data->subscriber_id[signal_idx] =
iface_signal_params[signal_idx].subscriber_id;
iface_signal_params[signal_idx].subscriber_id = iface_data->subscriber_id[signal_idx];
ret = inm_gdbus_unsubscribe_signal(&(iface_signal_params[signal_idx]));
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to unsubscribe signal");
+ INM_LOGW("Error! Failed to unsubscribe signal");
else
iface_data->subscriber_id[signal_idx] = 0;
}
else if (g_strcmp0(str, "completed") == 0)
iface->state = IFACE_STATE_COMPLETED;
- INM_LOGI("state [%s]", str);
+ INM_LOGI("<Supplicant iface state:%s>", str);
}
static inline void __get_iface_scanning(GVariant *value, inm_supplicant_iface_s *iface)
{
g_variant_get(value, "b", &(iface->scanning));
- INM_LOGI("%s", (iface->scanning) ? "Scanning" : "Not scanning");
+ INM_LOGI("<Supplicant Scanning state:%s>", (iface->scanning) ? "Scanning" : "Not scanning");
}
static inline void __get_iface_ifname(GVariant *value, inm_supplicant_iface_s *iface)
g_variant_get(value, "&s", &str);
g_strlcpy(iface->Ifname, str, IFNAME_MAX + 1);
- INM_LOGI("state [%s]", str);
+ INM_LOGI("<Supplicant iface name:%s>", str);
}
static inline void __get_iface_current_bss(GVariant *value, inm_supplicant_iface_s *iface)
g_variant_get(value, "ao", &iter);
if (!iter || !iface) {
- INM_LOGI("Invalid params");
+ INM_LOGW("Invalid params");
__INM_FUNC_EXIT__;
return;
}
iface = (inm_supplicant_iface_s *)g_try_malloc0(sizeof(inm_supplicant_iface_s));
if (!iface) {
- INM_LOGI("Error! Failed to allocate iface");
+ INM_LOGE("Error! Failed to allocate iface");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
#include "inm-supplicant.h"
#include "inm-supplicant-internal.h"
-#define DEBUG_G_VARIANT(str, parameters)\
- do {\
- gchar *parameters_debug_str = NULL;\
- if (parameters)\
- parameters_debug_str = g_variant_print(parameters, TRUE);\
- INM_LOGI("%s[%s]", str, parameters_debug_str ? parameters_debug_str : "NULL");\
- g_free(parameters_debug_str);\
- } while (0)
-
-#define DEBUG_SIGNAL(sender_name, object_path, interface_name, signal_name, parameters)\
- do {\
- INM_LOGI("signal sender name [%s]", sender_name);\
- INM_LOGI("signal object path [%s]", object_path);\
- INM_LOGI("signal interface name [%s]", interface_name);\
- INM_LOGI("signal signal name [%s]", signal_name);\
- DEBUG_G_VARIANT("signal params ", parameters);\
- INM_LOGI("signal params type [%s]", g_variant_get_type_string(parameters));\
- } while (0)
typedef enum {
NETWORK_SIGNAL_PROPERTIESCHANGED,
NETWORK_SIGNAL_MAX,
key = g_strdup(path);
if (!key) {
- INM_LOGI("Error! Failed to get key");
+ INM_LOGE("Error! Failed to get key");
__INM_FUNC_EXIT__;
return -1;
}
net = (supplicant_network_s *)g_try_malloc0(sizeof(supplicant_network_s));
if (!net) {
- INM_LOGI("Error! Failed to allocate net");
+ INM_LOGE("Error! Failed to allocate net");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
if (__init_net(path, net) < 0) {
- INM_LOGI("Error! Failed to init net");
+ INM_LOGW("Error! Failed to init net");
g_free(net);
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
__get_network_properties,
(gpointer)net);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get property all failure");
+ INM_LOGW("get property all failure");
__INM_FUNC_EXIT__;
return;
if (!path) {
- INM_LOGI("NULL obj");
+ INM_LOGW("NULL obj");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_INVALID_PARAM;
}
net = (supplicant_network_s *)g_try_malloc0(sizeof(supplicant_network_s));
if (!net) {
- INM_LOGI("Error! Failed to allocate net");
+ INM_LOGE("Error! Failed to allocate net");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
p2p_signal_params[signal_idx].object_path = path;
ret = inm_gdbus_subscribe_signal_with_data(&(p2p_signal_params[signal_idx]), data);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to subscribe signal");
+ INM_LOGW("Error! Failed to subscribe signal");
else
data->subscriber_id[signal_idx] =
p2p_signal_params[signal_idx].subscriber_id;
p2p_signal_params[signal_idx].subscriber_id = data->subscriber_id[signal_idx];
ret = inm_gdbus_unsubscribe_signal(&(p2p_signal_params[signal_idx]));
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Error! Failed to unsubscribe signal");
+ INM_LOGW("Error! Failed to unsubscribe signal");
else
data->subscriber_id[signal_idx] = 0;
}
p2p_data = (supplicant_p2p_s *)g_try_malloc0(sizeof(supplicant_p2p_s));
if (!p2p_data) {
- INM_LOGI("Error! Failed to allocate net");
+ INM_LOGE("Error! Failed to allocate net");
__INM_FUNC_EXIT__;
return INM_SUPPLICANT_ERROR_OPERATION_FAILED;
}
);
if (!p2p_data->peers) {
- INM_LOGI("Error! Failed to allocate bss tbl");
+ INM_LOGE("Error! Failed to allocate bss tbl");
g_free(p2p_data);
__INM_FUNC_EXIT__;
return -1;
p2p_data = (supplicant_p2p_s *)p2p;
ret = __unsubscribe_p2p_signal(p2p_data);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("__unsubscribe_p2p_signal failed");
+ INM_LOGW("__unsubscribe_p2p_signal failed");
g_hash_table_destroy(p2p_data->peers);
int res = FALSE;
if (!dst || !src || size == 0) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return FALSE;
}
g_variant_get(src, "ay", &iter);
if (iter == NULL) {
- INM_LOGI("failed to get iterator");
+ INM_LOGW("failed to get iterator");
return FALSE;
}
g_variant_iter_free(iter);
if (length < size) {
- INM_LOGI("array is shorter than size");
+ INM_LOGW("array is shorter than size");
res = FALSE;
}
if (path && iter)
inm_supplicant_iface_add(path, iter);
else
- INM_LOGI("NULL path or variants");
+ INM_LOGW("NULL path or variants");
g_variant_iter_free(iter);
__INM_FUNC_EXIT__;
if (path)
inm_supplicant_iface_remove(path);
else
- INM_LOGI("NULL path");
+ INM_LOGW("NULL path");
__INM_FUNC_EXIT__;
return;
g_variant_get(reply, "(a{sa{ss}})", &iter);
while (g_variant_iter_loop(iter, "{sa{ss}}", &modem_path, &modem_properties)) {
*modem_path_list = g_slist_append(*modem_path_list, g_strdup(modem_path));
- INM_LOGI("modem object path: %s", modem_path);
+ INM_LOGI("<Modem object path:%s>", modem_path);
}
g_variant_iter_free(iter);
__get_modem_properties,
(gpointer)modem_path_list);
if (ret != INM_GDBUS_ERROR_NONE) {
- INM_LOGI("Failed to get modem paths");
+ INM_LOGE("Failed to get modem paths");
__INM_FUNC_EXIT__;
return -1;
}
ret = __get_modem_object_path(&modem_path_list);
if (ret < 0) {
- INM_LOGI("Failed to get modems path list");
+ INM_LOGE("Failed to get modems path list");
g_slist_free_full(modem_path_list, g_free);
__INM_FUNC_EXIT__;
__get_profiles,
(gpointer)&profile_list);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("Failed to get profiles: %s", path);
+ INM_LOGE("Failed to get profiles: %s", path);
}
g_slist_free_full(modem_path_list, g_free);
}
if (p_profile_name == NULL) {
- INM_LOGI("Failed to allocate memory");
+ INM_LOGE("Failed to allocate memory");
*profile_cnt = 0;
ret = -1;
goto out;
/* Get pdp profile list from telephony service */
ret = __get_profile_names(&profile_list, &profile_cnt);
if (ret < 0) {
- INM_LOGI("Failed to get profile list from telephony service");
+ INM_LOGW("Failed to get profile list from telephony service");
__INM_FUNC_EXIT__;
return -1;
}
if (profile_list == NULL || profile_cnt <= 0) {
- INM_LOGI("There is no PDP profiles");
+ INM_LOGW("There is no PDP profiles");
g_free(profile_list);
__INM_FUNC_EXIT__;
return -1;
/* Find matching profile */
idx = __find_matching_profile(profile_name, profile_list, profile_cnt);
if (idx >= profile_cnt) {
- INM_LOGI("There is no matching PDP profiles");
+ INM_LOGW("There is no matching PDP profiles");
ret = -1;;
} else {
g_strlcpy(profile_info->profile_name,
__INM_FUNC_ENTER__;
if (profile_info == NULL) {
- INM_LOGI("Invalid parameter!");
+ INM_LOGW("Invalid parameter!");
__INM_FUNC_EXIT__;
return -1;
}
__get_profile_properties,
(gpointer)profile_info);
if (ret != INM_GDBUS_ERROR_NONE) {
- INM_LOGI("Failed to get profile");
+ INM_LOGE("Failed to get profile");
__INM_FUNC_EXIT__;
return -1;
}
sock_io_channel = g_io_channel_unix_new(sock);
if (!sock_io_channel) {
- INM_LOGI("Failed to create channel");
+ INM_LOGE("Failed to create channel");
return NULL;
}
__trace_route_receive,
p_trace_route);
- INM_LOGD("socket %d source_id %d",
+ INM_LOGI("socket %d source_id %d",
p_trace_route->sock,
p_trace_route->sock_source_id);
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
+#include <sys/stat.h>
#include <netinet/in.h>
#include <linux/if.h>
#define RET_IF_SOCK_FAILURE(sock) \
do {\
if ((sock) < 0) {\
- INM_LOGI("socket Failed");\
+ INM_LOGW("socket Failed");\
__INM_FUNC_EXIT__;\
return;\
}\
if (g_io_channel_read_chars(source, buf, ARP_PACKET_SIZE,
&bytes_read, &error) != G_IO_STATUS_NORMAL) {
- INM_LOGI("Failure received arp packet[%d]:[%s]",
+ INM_LOGE("Failure received arp packet[%d]:[%s]",
error->code, error->message);
g_error_free(error);
return TRUE;
if ((arp_data->sock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP))) == -1) {
INM_LOGI("socket %d", arp_data->sock);
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("socket Failed. Error = %s\n", error_buf);
+ INM_LOGE("socket Failed. Error = %s\n", error_buf);
}
return arp_data->sock;
__INM_FUNC_ENTER__;
if (!arp_data || arp_data->sock <= 0) {
- INM_LOGE("Invalid data");
+ INM_LOGW("Invalid data");
__INM_FUNC_EXIT__;
return FALSE;
}
sock_io_channel = g_io_channel_unix_new(sock);
if (!sock_io_channel) {
- INM_LOGI("Failed to create channel");
+ INM_LOGE("Failed to create channel");
return NULL;
}
gint sock = -1;
if (!arp_data) {
- INM_LOGI("NULL data");
+ INM_LOGW("NULL data");
__INM_FUNC_EXIT__;
return;
}
arp_data->sock = sock;
arp_data->sock_io_channel = __set_socket_channel(sock);
if (!arp_data->sock_io_channel) {
- INM_LOGI("Failed to create channel");
+ INM_LOGE("Failed to create channel");
arp_data->sock = -1;
close(sock);
__INM_FUNC_EXIT__;
g_io_add_watch(arp_data->sock_io_channel, G_IO_IN,
__check_arp_receive, arp_data);
- INM_LOGD("socket %d source_id %d", sock, arp_data->sock_source_id);
+ INM_LOGI("socket %d source_id %d", sock, arp_data->sock_source_id);
__INM_FUNC_EXIT__;
return;
gint ret = 0;
if (!inm_util_icmp_data || inm_util_icmp_data->sock <= 0) {
- INM_LOGE("invalid parameter");
+ INM_LOGW("invalid parameter");
return -1;
}
if (g_io_channel_read_chars(source, buf, 128,
&bytes_read, &error) != G_IO_STATUS_NORMAL) {
- INM_LOGI("Failure received icmp packet[%d]:[%s]",
+ INM_LOGE("Failure received icmp packet[%d]:[%s]",
error->code, error->message);
g_error_free(error);
return TRUE;
inm_util_icmp_data->sock = sock;
inm_util_icmp_data->sock_io_channel = __set_socket_channel(sock);
if (!inm_util_icmp_data->sock_io_channel) {
- INM_LOGI("Failed to create channel");
+ INM_LOGE("Failed to create channel");
inm_util_icmp_data->sock = -1;
close(sock);
__INM_FUNC_EXIT__;
g_io_add_watch(inm_util_icmp_data->sock_io_channel, G_IO_IN,
__check_icmp_receive, inm_util_icmp_data);
- INM_LOGD("socket %d source_id %d", sock, inm_util_icmp_data->sock_source_id);
+ INM_LOGI("socket %d source_id %d", sock, inm_util_icmp_data->sock_source_id);
__INM_FUNC_EXIT__;
return;
errno = 0;
if (execve(file_path, args, envs) == -1) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("Fail to execute command (%s)", error_buf);
+ INM_LOGE("Fail to execute command (%s)", error_buf);
exit(1);
}
} else if (pid > 0) {
}
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("failed to fork(%s)", error_buf);
+ INM_LOGE("failed to fork(%s)", error_buf);
__INM_FUNC_EXIT__;
return -EIO;
}
errno = 0;
if (execvp(file_path, args) == -1) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("Fail to execute command (%s)", error_buf);
+ INM_LOGE("Fail to execute command (%s)", error_buf);
__INM_FUNC_EXIT__;
return -1;
}
ret = access(file_path, F_OK);
if (ret < 0) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("Could not access %s [%s]", file_path, error_buf);
+ INM_LOGE("Could not access %s [%s]", file_path, error_buf);
__INM_FUNC_EXIT__;
return -1;
}
fd = fopen(file_path, "r");
if (fd == NULL) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("Could not open %s [%s]", file_path, error_buf);
+ INM_LOGE("Could not open %s [%s]", file_path, error_buf);
__INM_FUNC_EXIT__;
return -1;
}
ret = fscanf(fd, "%d", &carrier);
if (ret < 0) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- INM_LOGI("Could not scan [%s]", error_buf);
+ INM_LOGE("Could not scan [%s]", error_buf);
fclose(fd);
__INM_FUNC_EXIT__;
return -1;
int i;
if (!p_nl_cache || !p_nl_src_obj) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
return FALSE;
}
nl_cache_cnt = nl_cache_nitems(p_nl_cache);
added = __obj_is_existed(cache, obj);
if (added)
- INM_LOGI("OBJ exists");
+ INM_LOGI("<OBJ:exist>");
else
- INM_LOGI("OBJ doesn't exists");
+ INM_LOGI("<OBJ:doesn't exists>");
nl_data = (inm_util_nl_data_s *)data;
if (nl_data->obj_recv_func)
break;
default:
{
- INM_LOGE("Invalid type");
+ INM_LOGW("Invalid type");
ret = -1;
}
break;
__INM_FUNC_ENTER__;
if (!nl_data) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return 0;
}
break;
default:
{
- INM_LOGE("Invalid type");
+ INM_LOGW("Invalid type");
return -1;
}
break;
__INM_FUNC_ENTER__;
if (!nl_data) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return 0;
}
fd = nl_cache_mngr_get_fd(p_nl_cm);
nl_data->sock_io_channel = __set_socket_channel(fd);
if (!nl_data->sock_io_channel) {
- INM_LOGI("Failed to create channel");
+ INM_LOGE("Failed to create channel");
nl_cache_mngr_free(p_nl_cm);
nl_socket_free(p_nl_sock);
__INM_FUNC_EXIT__;
{
__INM_FUNC_ENTER__;
if (!nl_data) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return;
}
{
__INM_FUNC_ENTER__;
if (!nl_data) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return;
}
{
__INM_FUNC_ENTER__;
if (!nl_data) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_ENTER__;
if (!cb || !nl_data || !nl_data->p_nl_cache) {
- INM_LOGI("Null data");
+ INM_LOGW("Null data");
__INM_FUNC_EXIT__;
return;
}
__INM_FUNC_EXIT__;
return;
}
-
int i = 0;
if (!txt || !mac) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return -1;
}
int res = FALSE;
if (!dst || !src || size == 0) {
- INM_LOGI("Invalid parameter");
+ INM_LOGW("Invalid parameter");
return FALSE;
}
g_variant_get(src, "ay", &iter);
if (iter == NULL) {
- INM_LOGI("failed to get iterator");
+ INM_LOGW("failed to get iterator");
return FALSE;
}
__get_go_intent,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get go intent failure");
+ INM_LOGW("get go intent failure");
return;
}
__get_max_client,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get max_client failure");
+ INM_LOGW("get max_client failure");
return;
}
__get_req_wps_mode,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get requested wps mode failure");
+ INM_LOGW("get requested wps mode failure");
return;
}
__get_device_name,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get mac address failure");
+ INM_LOGW("get mac address failure");
return;
}
__get_mac_addr,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get mac address failure");
+ INM_LOGW("get mac address failure");
return;
}
__get_op_channel,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get op channel failure");
+ INM_LOGW("get op channel failure");
return;
}
__get_ip_addr,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get mac address failure");
+ INM_LOGW("get mac address failure");
return;
}
__get_subnet_mask,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get mac address failure");
+ INM_LOGW("get mac address failure");
return;
}
__get_gateway,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get gateway address failure");
+ INM_LOGW("get gateway address failure");
return;
}
__is_group_owner,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get device role failure");
+ INM_LOGW("get device role failure");
return;
}
__get_connected_peers,
(gpointer)&wfd_manager_mon);
if (ret != INM_GDBUS_ERROR_NONE)
- INM_LOGI("get connected failure");
+ INM_LOGW("get connected failure");
return;
}
__INM_FUNC_ENTER__;
if (!wfd_manager_mon.connected_peer) {
- INM_LOGI("Wired, there's no connected");
+ INM_LOGW("Wired, there's no connected");
__INM_FUNC_EXIT__;
return;
}
g_variant_get(parameters, "(&s&s)", &peer_mac, &peer_ip);
if (!peer_mac || !peer_ip) {
- INM_LOGI("Invalied parameters");
+ INM_LOGW("Invalied parameters");
__INM_FUNC_EXIT__;
return;
}
peer = g_hash_table_lookup(wfd_manager_mon.connected_peer, peer_mac);
if (!peer) {
- INM_LOGI("Peer %s not matched", peer_mac);
+ INM_LOGW("Peer %s not matched", peer_mac);
__INM_FUNC_EXIT__;
return;
}
g_variant_get(parameters, "(ii&s)", &ret, &state, &peer_mac);
if (!g_hash_table_remove(wfd_manager_mon.connected_peer, peer_mac)) {
- INM_LOGI("there's no peer [%s]", peer_mac);
+ INM_LOGW("there's no peer [%s]", peer_mac);
__INM_FUNC_EXIT__;
return;
}
projects / platform / core / connectivity / inm-manager.git / commitdiff