#define FREQ_RANGE_24GHZ_CHANNEL_14 2484
#define FREQ_RANGE_5GHZ_CHANNEL_32 5160
#define FREQ_RANGE_5GHZ_CHANNEL_165 5825
+
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
#endif
static DBusConnection *connection = NULL;
int disconnect_reason;
int assoc_status_code;
/*
- * Only for EAP-FAST
+ * Only for EAP-FAST and EAP-PEAP in EAPoL.
*/
char *phase1;
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ /*
+ * Only for EAP-FAST
+ */
+ char *pac_file;
+#endif
/*
* Description: To indicate that disconnection triggered by user.
*/
unsigned char last_connected_bssid[WIFI_BSSID_LEN_MAX];
bool is_internet_connection;
int assoc_reject_count;
+#if defined TIZEN_EXT_INS
+ int score_last_user_selection;
+ int score_last_connected;
+ int score_frequency;
+ int score_security_priority;
+ int score_internet_connection;
+ int score_strength;
+#endif
int ins_score;
#endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ /*
+ * To indicate use of EAP over Ethernet.
+ */
+ bool use_eapol;
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
};
static bool allow_property_changed(struct connman_service *service);
return 0;
}
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+static void __connman_service_cleanup_8021x(struct connman_service *service)
+{
+ if (service == NULL)
+ return;
+
+ DBG("service %p ", service);
+
+ __connman_service_set_string(service, "EAP", NULL);
+ __connman_service_set_string(service, "Identity", NULL);
+ __connman_service_set_string(service, "Passphrase", NULL);
+ __connman_service_set_string(service, "AnonymousIdentity", NULL);
+ __connman_service_set_string(service, "CACertFile", NULL);
+ __connman_service_set_string(service, "ClientCertFile", NULL);
+ __connman_service_set_string(service, "PrivateKeyFile", NULL);
+ __connman_service_set_string(service, "PrivateKeyPassphrase", NULL);
+ __connman_service_set_string(service, "Phase1", NULL);
+ __connman_service_set_string(service, "Phase2", NULL);
+ __connman_service_set_string(service, "PacFile", NULL);
+}
+
+static int connman_service_set_eapol_property(struct connman_service *service,
+ DBusMessageIter *array)
+{
+ DBusMessageIter dict;
+ char *str = NULL;
+
+ __connman_service_cleanup_8021x(service);
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while(dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(&entry, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(key, "UseEapol")) {
+ dbus_bool_t use_eapol;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &use_eapol);
+ service->use_eapol = use_eapol;
+
+ } else if (g_str_equal(key, "EAP")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "EAP", str);
+
+ } else if (g_str_equal(key, "Identity")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "Identity", str);
+
+ } else if (g_str_equal(key, "AnonymousIdentity")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "AnonymousIdentity", str);
+
+ } else if (g_str_equal(key, "CACertFile")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "CACertFile", str);
+ } else if (g_str_equal(key, "ClientCertFile")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "ClientCertFile", str);
+ } else if (g_str_equal(key, "PrivateKeyFile")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "PrivateKeyFile", str);
+ } else if (g_str_equal(key, "PrivateKeyPassphrase")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "PrivateKeyPassphrase", str);
+ } else if (g_str_equal(key, "Phase2")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "Phase2", str);
+ } else if (g_str_equal(key, "Phase1")) {
+ int val;
+ char phase1[5] = {0,};
+
+ if (type != DBUS_TYPE_INT32)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &val);
+ sprintf(phase1, "%d", val);
+ __connman_service_set_string(service, "Phase1", phase1);
+ } else if (g_str_equal(key, "PacFile")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ __connman_service_set_string(service, "PacFile", str);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ return 0;
+}
+#endif
+
#if defined TIZEN_EXT
static void save_assoc_reject(gpointer key, gpointer value, gpointer user_data)
{
int i;
int err = 0;
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
if (!service->network)
continue;
}
- memset(reject_data, 0, sizeof(struct assoc_reject_data));
reject_data->bssid = g_strdup(bssid);
g_hash_table_insert(reject_table, reject_data->bssid, reject_data);
}
#if defined TIZEN_EXT
bool internet_connection;
#endif
-
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ bool use_eapol;
+#endif
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
keyfile = connman_storage_load_service(service->identifier);
if (!error)
service->autoconnect = autoconnect;
g_clear_error(&error);
+
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ use_eapol = g_key_file_get_boolean(keyfile,
+ service->identifier, "UseEapol", &error);
+ if (!error)
+ service->use_eapol = use_eapol;
+ g_clear_error(&error);
+#endif
break;
}
service->identifier, "Hidden", NULL);
#if defined TIZEN_EXT
- if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
- service->security == CONNMAN_SERVICE_SECURITY_8021X) {
+ if ((service->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ service->security == CONNMAN_SERVICE_SECURITY_8021X)
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ || (service->type == CONNMAN_SERVICE_TYPE_ETHERNET && service->use_eapol)
+#endif
+ ) {
str = g_key_file_get_string(keyfile,
service->identifier, "EAP", NULL);
if (str != NULL) {
service->identity = str;
}
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "AnonymousIdentity", NULL);
+ if (str != NULL) {
+ g_free(service->anonymous_identity);
+ service->anonymous_identity = str;
+ }
+#endif
str = g_key_file_get_string(keyfile,
service->identifier, "CACertFile", NULL);
if (str != NULL) {
g_free(service->private_key_passphrase);
service->private_key_passphrase = str;
}
+
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Phase1", NULL);
+ if (str != NULL) {
+ g_free(service->phase1);
+ service->phase1 = str;
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "PacFile", NULL);
+ if (str != NULL) {
+ g_free(service->pac_file);
+ service->pac_file = str;
+ }
+#endif
}
#endif
#if defined TIZEN_EXT
if (service->favorite)
g_key_file_set_boolean(keyfile, service->identifier,
"AutoConnect", service->autoconnect);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ g_key_file_set_boolean(keyfile, service->identifier,
+ "UseEapol", service->use_eapol);
+#endif
break;
}
"Config.ident", service->config_entry);
#if defined TIZEN_EXT
- if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
- service->security == CONNMAN_SERVICE_SECURITY_8021X) {
+ if ((service->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ service->security == CONNMAN_SERVICE_SECURITY_8021X)
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ || (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+#endif
+ ) {
if (service->eap != NULL && strlen(service->eap) > 0)
g_key_file_set_string(keyfile, service->identifier,
"EAP", service->eap);
else
g_key_file_remove_key(keyfile, service->identifier,
"Identity", NULL);
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ if (service->anonymous_identity != NULL && strlen(service->anonymous_identity) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "AnonymousIdentity", service->anonymous_identity);
+ else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "AnonymousIdentity", NULL);
+#endif
if (service->ca_cert_file != NULL && strlen(service->ca_cert_file) > 0)
g_key_file_set_string(keyfile, service->identifier,
else
g_key_file_remove_key(keyfile, service->identifier,
"PrivateKeyPassphrase", NULL);
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+ if (service->phase1 != NULL && strlen(service->phase1) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Phase1", service->phase1);
+ else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Phase1", NULL);
+ if (service->pac_file != NULL && strlen(service->pac_file) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "PacFile", service->pac_file);
+ else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "PacFile", NULL);
+#endif
}
+
if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
service->security == CONNMAN_SERVICE_SECURITY_DPP) {
if (service->connector != NULL && strlen(service->connector) > 0)
static void default_changed(void)
{
+#if defined TIZEN_EXT
+ struct connman_service *service = connman_service_get_default_connection();
+#else
struct connman_service *service = connman_service_get_default();
+#endif
if (service == current_default)
return;
iter);
}
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+static void append_eap_over_ethernet(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ dbus_bool_t val;
+
+ val = service->use_eapol;
+ connman_dbus_dict_append_basic(iter, "UseEapol",
+ DBUS_TYPE_BOOLEAN, &val);
+ if (service->use_eapol) {
+ if (service->eap)
+ connman_dbus_dict_append_basic(iter, "EAP",
+ DBUS_TYPE_STRING, &service->eap);
+
+ if (service->identity)
+ connman_dbus_dict_append_basic(iter, "Identity",
+ DBUS_TYPE_STRING, &service->identity);
+
+ if (service->anonymous_identity)
+ connman_dbus_dict_append_basic(iter, "AnonymousIdentity",
+ DBUS_TYPE_STRING, &service->anonymous_identity);
+
+ if (service->ca_cert_file)
+ connman_dbus_dict_append_basic(iter, "CACertFile",
+ DBUS_TYPE_STRING, &service->ca_cert_file);
+
+ if (service->client_cert_file)
+ connman_dbus_dict_append_basic(iter, "ClientCertFile",
+ DBUS_TYPE_STRING, &service->client_cert_file);
+
+ if (service->private_key_file)
+ connman_dbus_dict_append_basic(iter, "PrivateKeyFile",
+ DBUS_TYPE_STRING, &service->private_key_file);
+
+ if (service->phase2)
+ connman_dbus_dict_append_basic(iter, "Phase2",
+ DBUS_TYPE_STRING, &service->phase2);
+
+ if (service->phase1)
+ connman_dbus_dict_append_basic(iter, "Phase1",
+ DBUS_TYPE_STRING, &service->phase1);
+
+ if (service->pac_file)
+ connman_dbus_dict_append_basic(iter, "PacFile",
+ DBUS_TYPE_STRING, &service->pac_file);
+
+ /* Should we include passphrase? */
+ }
+}
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
+
static void append_ipv4(DBusMessageIter *iter, void *user_data)
{
struct connman_service *service = user_data;
country_code = connman_network_get_countrycode(network);
connection_mode = connman_network_get_connection_mode(network);
- snprintf(bssid_str, WIFI_BSSID_STR_LEN, "%02x:%02x:%02x:%02x:%02x:%02x",
- bssid[0], bssid[1], bssid[2],
- bssid[3], bssid[4], bssid[5]);
+ snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
snprintf(country_code_str, (WIFI_COUNTRY_CODE_LEN + 1), "%c%c",
country_code[0], country_code[1]);
GSList *list;
for (list = bssid_list; list; list = list->next) {
bssids = (struct connman_bssids *)list->data;
- g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, "%02x:%02x:%02x:%02x:%02x:%02x",
- bssids->bssid[0], bssids->bssid[1], bssids->bssid[2],
- bssids->bssid[3], bssids->bssid[4], bssids->bssid[5]);
+ g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, MACSTR, MAC2STR(bssids->bssid));
connman_dbus_dict_append_basic(iter, "BSSID",
DBUS_TYPE_STRING, &bssid_str);
connman_dbus_dict_append_basic(dict, "AssocStatusCode",
DBUS_TYPE_INT32, &service->assoc_status_code);
+ val = service->hidden_service;
connman_dbus_dict_append_basic(dict, "Hidden",
- DBUS_TYPE_BOOLEAN, &service->hidden_service);
+ DBUS_TYPE_BOOLEAN, &val);
break;
#endif
case CONNMAN_SERVICE_TYPE_ETHERNET:
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ connman_dbus_dict_append_dict(dict, "EapOverEthernet",
+ append_eap_over_ethernet, service);
+ /* fall through */
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
case CONNMAN_SERVICE_TYPE_BLUETOOTH:
case CONNMAN_SERVICE_TYPE_GADGET:
connman_dbus_dict_append_dict(dict, "Ethernet",
connman_network_append_acddbus(dict, service->network);
}
+#if defined TIZEN_EXT_INS
+static void append_ins_bssid_info(DBusMessageIter *iter, void *user_data)
+{
+ GSList *bssid_list = NULL;
+ struct connman_network *network = user_data;
+ struct connman_bssids *bssids;
+ char bssid_buf[MAC_ADDRESS_LENGTH] = {0,};
+ char *bssid_str = bssid_buf;
+
+ bssid_list = (GSList *)connman_network_get_bssid_list(network);
+ if(bssid_list) {
+ GSList *list;
+ for (list = bssid_list; list; list = list->next) {
+ bssids = (struct connman_bssids *)list->data;
+ g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, MACSTR, MAC2STR(bssids->bssid));
+
+ connman_dbus_dict_append_basic(iter, "BSSID",
+ DBUS_TYPE_STRING, &bssid_str);
+
+ connman_dbus_dict_append_basic(iter, "ScoreINS",
+ DBUS_TYPE_INT32, &bssids->ins_score);
+
+ connman_dbus_dict_append_basic(iter, "ScoreLastConnected",
+ DBUS_TYPE_INT32, &bssids->score_last_connected_bssid);
+
+ connman_dbus_dict_append_basic(iter, "ScoreAssocReject",
+ DBUS_TYPE_INT32, &bssids->score_assoc_reject);
+
+ connman_dbus_dict_append_basic(iter, "Frequency",
+ DBUS_TYPE_UINT16, &bssids->frequency);
+
+ connman_dbus_dict_append_basic(iter, "ScoreFrequency",
+ DBUS_TYPE_INT32, &bssids->score_frequency);
+
+ connman_dbus_dict_append_basic(iter, "Strength",
+ DBUS_TYPE_UINT16, &bssids->strength);
+
+ connman_dbus_dict_append_basic(iter, "ScoreStrength",
+ DBUS_TYPE_INT32, &bssids->score_strength);
+ }
+ }
+}
+
+static void append_ins_properties(DBusMessageIter *dict,
+ struct connman_service *service)
+{
+ const char *str;
+ unsigned int frequency = 0U;
+
+ if (service->name)
+ connman_dbus_dict_append_basic(dict, "Name",
+ DBUS_TYPE_STRING, &service->name);
+
+ connman_dbus_dict_append_basic(dict, "ScoreINS",
+ DBUS_TYPE_INT32, &service->ins_score);
+
+ connman_dbus_dict_append_basic(dict, "ScoreLastUserSelection",
+ DBUS_TYPE_INT32, &service->score_last_user_selection);
+
+ connman_dbus_dict_append_basic(dict, "ScoreLastConnected",
+ DBUS_TYPE_INT32, &service->score_last_connected);
+
+ str = security2string(service->security);
+ if (str)
+ connman_dbus_dict_append_basic(dict, "Security",
+ DBUS_TYPE_STRING, &str);
+
+ connman_dbus_dict_append_basic(dict, "ScoreSecurityPriority",
+ DBUS_TYPE_INT32, &service->score_security_priority);
+
+ connman_dbus_dict_append_basic(dict, "Strength",
+ DBUS_TYPE_BYTE, &service->strength);
+
+ connman_dbus_dict_append_basic(dict, "ScoreStrength",
+ DBUS_TYPE_INT32, &service->score_strength);
+
+ connman_dbus_dict_append_basic(dict, "ScoreInternetConnection",
+ DBUS_TYPE_INT32, &service->score_internet_connection);
+
+ if (service->network) {
+ frequency = connman_network_get_frequency(service->network);
+ connman_dbus_dict_append_basic(dict, "Frequency",
+ DBUS_TYPE_UINT16, &frequency);
+
+ connman_dbus_dict_append_basic(dict, "ScoreFrequency",
+ DBUS_TYPE_INT32, &service->score_frequency);
+
+ connman_dbus_dict_append_dict(dict, "BSSID.List",
+ append_ins_bssid_info, service->network);
+ }
+}
+#endif
+
static void append_struct_service(DBusMessageIter *iter,
connman_dbus_append_cb_t function,
struct connman_service *service)
g_list_foreach(service_list, append_struct, iter);
}
+#if defined TIZEN_EXT_INS
+static void append_dict_ins_properties(DBusMessageIter *dict, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ append_ins_properties(dict, service);
+}
+
+static void append_ins_struct(gpointer value, gpointer user_data)
+{
+ struct connman_service *service = value;
+ DBusMessageIter *iter = user_data;
+
+ if (!service->path)
+ return;
+
+ if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return;
+
+ append_struct_service(iter, append_dict_ins_properties, service);
+}
+
+void __connman_ins_list_struct(DBusMessageIter *iter)
+{
+ g_list_foreach(service_list, append_ins_struct, iter);
+}
+#endif
+
bool __connman_service_is_hidden(struct connman_service *service)
{
return service->hidden;
return service->is_internet_connection;
}
+
+DBusMessage *connman_service_get_defaut_info(DBusMessage *msg,
+ struct connman_service *service)
+{
+ DBusMessage *reply;
+ DBusMessageIter array, dict;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &array);
+
+ if (service)
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
+ &service->path);
+
+ connman_dbus_dict_open(&array, &dict);
+ if (service)
+ append_properties(&dict, FALSE, service);
+ connman_dbus_dict_close(&array, &dict);
+
+ return reply;
+}
#endif
void __connman_service_set_proxy_autoconfig(struct connman_service *service,
return service->passphrase;
}
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+int __connman_service_get_use_eapol(struct connman_service *service)
+{
+ if (!service) {
+ DBG("Service is NULL");
+ return -1;
+ }
+
+ return service->use_eapol;
+}
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
+
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
__connman_service_set_passphrase(service, passphrase);
#endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ } else if (g_str_equal(name, "EapOverEthernet")) {
+ int err = connman_service_set_eapol_property(service, &value);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ service_save(service);
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
} else
return __connman_error_invalid_property(msg);
tech_data->preferred_list =
g_list_append(tech_data->preferred_list, service);
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("type %d service %p %s", tech_data->type, service,
service->name);
}
bool ignore[MAX_CONNMAN_SERVICE_TYPES] = { };
bool autoconnecting = false;
GList *list;
+#if defined TIZEN_EXT
+ GSList *wifi_ignore = NULL;
+#endif
DBG("preferred %d sessions %d reason %s", preferred, active_count,
reason2string(reason));
for (list = services; list; list = list->next) {
service = list->data;
+#if defined TIZEN_EXT
+ if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ int index = connman_network_get_index(service->network);
+ if (g_slist_find(wifi_ignore, GINT_TO_POINTER(index)) != NULL)
+ continue;
+ } else
+#endif
if (ignore[service->type]) {
DBG("service %p type %s ignore", service,
__connman_service_type2string(service->type));
if (service->pending ||
is_connecting(service->state) ||
is_connected(service->state)) {
+#if defined TIZEN_EXT
+ if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ int index = connman_network_get_index(service->network);
+ wifi_ignore = g_slist_prepend(wifi_ignore, GINT_TO_POINTER(index));
+
+ autoconnecting = true;
+ continue;
+ }
+#else
if (autoconnect_no_session_active(service))
return true;
-
+#endif
ignore[service->type] = true;
autoconnecting = true;
#if defined TIZEN_EXT
DBG("Service is not favorite, autoconnecting %d",
autoconnecting);
+ g_slist_free(wifi_ignore);
#endif
return autoconnecting;
}
if (is_ignore(service) || service->state !=
CONNMAN_SERVICE_STATE_IDLE)
continue;
-
+#if defined TIZEN_EXT
+ if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+#endif
if (autoconnect_already_connecting(service, autoconnecting)) {
DBG("service %p type %s has no users", service,
__connman_service_type2string(service->type));
(preferred) ? "preferred" : reason2string(reason));
__connman_service_connect(service, reason);
-
+#if !defined TIZEN_EXT
if (autoconnect_no_session_active(service))
return true;
-
+#endif
ignore[service->type] = true;
}
-
+#if defined TIZEN_EXT
+ g_slist_free(wifi_ignore);
+#endif
return autoconnecting;
}
append_struct(service, iter);
g_hash_table_remove(services_notify->add, service->path);
} else {
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("changed %s", service->path);
append_struct_service(iter, NULL, service);
static void service_schedule_added(struct connman_service *service)
{
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
g_hash_table_remove(services_notify->remove, service->path);
g_free(service->phase2);
g_free(service->config_file);
g_free(service->config_entry);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ g_free(service->pac_file);
+ g_free(service->phase1);
+#endif
+
#if defined TIZEN_EXT
g_free(service->connector);
g_free(service->c_sign_key);
static void service_initialize(struct connman_service *service)
{
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
service->refcount = 1;
service->user_pdn_connection_refcount = 0;
__sync_synchronize();
#endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ service->use_eapol = false;
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
}
/**
static int calculate_score(struct connman_service *service)
{
+ int score_last_user_selection;
+ int score_last_connected;
+ int score_frequency;
+ int score_security_priority;
+ int score_internet_connection;
+ int score_strength;
int score = 0;
if (service->type != CONNMAN_SERVICE_TYPE_WIFI) {
return score;
}
- score += calculate_score_last_user_selection(service);
- score += calculate_score_last_connected(service);
- score += calculate_score_frequency(service);
- score += calculate_score_security_priority(service);
- score += calculate_score_internet_connection(service);
- score += calculate_score_strength(service);
+ score_last_user_selection = calculate_score_last_user_selection(service);
+ score_last_connected = calculate_score_last_connected(service);
+ score_frequency = calculate_score_frequency(service);
+ score_security_priority = calculate_score_security_priority(service);
+ score_internet_connection = calculate_score_internet_connection(service);
+ score_strength = calculate_score_strength(service);
+
+ score = score_last_user_selection + score_last_connected +
+ score_frequency + score_security_priority +
+ score_internet_connection + score_strength;
+
+#if defined TIZEN_EXT_INS
+ service->score_last_user_selection = score_last_user_selection;
+ service->score_last_connected = score_last_connected;
+ service->score_frequency = score_frequency;
+ service->score_security_priority = score_security_priority;
+ service->score_internet_connection = score_internet_connection;
+ service->score_strength = score_strength;
+#endif
service->ins_score = score;
return score;
a_connected = is_connected(state_a);
b_connected = is_connected(state_b);
+#if defined TIZEN_EXT
+ if ((a_connected && b_connected) &&
+ state_a == state_b &&
+ service_a->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ service_b->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ const char *default_interface =
+ connman_option_get_string("DefaultWifiInterface");
+ const char *ifname_a = connman_device_get_string(
+ connman_network_get_device(service_a->network), "Interface");
+ const char *ifname_b = connman_device_get_string(
+ connman_network_get_device(service_b->network), "Interface");
+
+ if (g_strcmp0(default_interface, ifname_a) == 0)
+ return -1;
+ else if (g_strcmp0(default_interface, ifname_b) == 0)
+ return 1;
+ }
+#endif
+
if (a_connected && b_connected) {
if (service_a->order > service_b->order)
return -1;
static void print_service_sort(gpointer data, gpointer user_data)
{
struct connman_service *service = data;
- struct connman_device *device;
- const char *last_user_selection_ident;
- const char *last_connected_ident;
- unsigned int frequency;
- time_t ref_time;
- struct tm* timeinfo;
- time_t last_user_selection_time;
-
- device = connman_network_get_device(service->network);
- last_user_selection_ident = connman_device_get_last_user_selection_ident(device);
- last_user_selection_time = connman_device_get_last_user_selection_time(device);
- last_connected_ident = connman_device_get_last_connected_ident(device);
- frequency = connman_network_get_frequency(service->network);
- /* Only events that occur within 8 hours are checked. */
- ref_time = time(NULL);
- timeinfo = localtime(&ref_time);
- timeinfo->tm_hour -= 8;
- ref_time = mktime(timeinfo);
+ if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return;
- DBG("name[%s] score[%d] strength[%d] freq[%d] last_usr[%d] last_conn[%d] internet[%d]",
- service->name, service->ins_score, service->strength, frequency,
- (g_strcmp0(last_user_selection_ident, service->identifier) == 0 &&
- last_user_selection_time > ref_time) ? 1 : 0,
- g_strcmp0(last_connected_ident, service->identifier) == 0 ? 1 : 0,
- service->is_internet_connection);
+ DBG("name[%-20s] total[%2d] last_usr[%2d] last_conn[%2d] "
+ "freq[%2d] sec[%2d] internet[%2d] strength[%2d]",
+ service->name, service->ins_score, service->score_last_user_selection,
+ service->score_last_connected, service->score_frequency,
+ service->score_security_priority, service->score_internet_connection,
+ service->score_strength);
}
#endif
service->phase2 = g_strdup(value);
} else if (g_str_equal(key, "Passphrase"))
__connman_service_set_passphrase(service, value);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+ else if (g_str_equal(key, "Phase1")) {
+ g_free(service->phase1);
+ service->phase1 = g_strdup(value);
+ } else if (g_str_equal(key, "PacFile")) {
+ g_free(service->pac_file);
+ service->pac_file = g_strdup(value);
+ }
+#endif
#if defined TIZEN_EXT
else if (g_str_equal(key, "Connector")) {
g_free(service->connector);
searchdomain_remove_all(service);
service->state = new_state;
+#if defined TIZEN_EXT
+ if (!is_connected(old_state) && is_connected(new_state))
+ connman_device_send_connected_signal(
+ connman_network_get_device(service->network), true);
+ else if (is_connected(old_state) && !is_connected(new_state))
+ connman_device_send_connected_signal(
+ connman_network_get_device(service->network), false);
+#endif
state_changed(service);
if (!is_connected(old_state) && is_connected(new_state))
service = connman_service_create();
if (!service)
return NULL;
-
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
service->identifier = g_strdup(identifier);
static int service_register(struct connman_service *service)
{
+#if defined TIZEN_EXT
+ if (!simplified_log)
+#endif
DBG("service %p", service);
if (service->path)
if (ret == -ERANGE)
service_ext_save(service);
ret = __connman_config_provision_service(service);
- if (ret < 0)
+ if (ret < 0 && simplified_log)
DBG("Failed to provision service");
#else
if (__connman_config_provision_service(service) < 0)
return;
service->strength = strength;
- DBG("Strength %d", strength);
+ if (!simplified_log)
+ DBG("Strength %d", strength);
strength_changed(service);
service_list_sort();
}
ins_settings.last_connected = connman_setting_get_bool("INSLastConnected");
string = connman_option_get_string("INSPreferredFreq");
- if (g_str_equal(string, "5GHz"))
+ if (g_strcmp0(string, "5GHz") == 0)
ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_5GHZ;
- else if (g_str_equal(string, "2.4GHz"))
+ else if (g_strcmp0(string, "2.4GHz") == 0)
ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_24GHZ;
else
ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_UNKNOWN;
for (i = 0; string_list && string_list[i]; i++) {
unsigned int security_score = string_count * ins_settings.security_priority_score;
- if (g_str_equal(string_list[i], "WEP"))
+ if (g_strcmp0(string_list[i], "WEP") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_WEP] = security_score;
- else if (g_str_equal(string_list[i], "PSK"))
+ else if (g_strcmp0(string_list[i], "PSK") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_PSK] = security_score;
- else if (g_str_equal(string_list[i], "8021X"))
+ else if (g_strcmp0(string_list[i], "8021X") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_8021X] = security_score;
- else if (g_str_equal(string_list[i], "WPA"))
+ else if (g_strcmp0(string_list[i], "WPA") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_WPA] = security_score;
- else if (g_str_equal(string_list[i], "RSN"))
+ else if (g_strcmp0(string_list[i], "RSN") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_RSN] = security_score;
- else if (g_str_equal(string_list[i], "SAE"))
+ else if (g_strcmp0(string_list[i], "SAE") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_SAE] = security_score;
- else if (g_str_equal(string_list[i], "OWE"))
+ else if (g_strcmp0(string_list[i], "OWE") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_OWE] = security_score;
- else if (g_str_equal(string_list[i], "DPP"))
+ else if (g_strcmp0(string_list[i], "DPP") == 0)
ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_DPP] = security_score;
string_count--;