client_connmanctl_SOURCES += client/mesh.c client/mesh.h
endif
+if TIZEN_EXT_INS
+client_connmanctl_SOURCES += client/ins.c client/ins.h
+endif
+
client_connmanctl_LDADD = gdbus/libgdbus-internal.la @DBUS_LIBS@ @GLIB_LIBS@ \
-lreadline -ldl -lncurses
endif
#include "dbus_helpers.h"
#include "input.h"
#include "services.h"
+#if defined TIZEN_EXT_INS
+#include "ins.h"
+#endif
#include "tethering.h"
#include "peers.h"
#include "commands.h"
return 0;
}
+#if defined TIZEN_EXT_INS
+static int ins_list(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *filter = user_data;
+
+ if (!error) {
+ __connmanctl_ins_list(iter, filter);
+ fprintf(stdout, "\n");
+ } else {
+ fprintf(stderr, "Error: %s\n", error);
+ }
+
+ g_free(filter);
+
+ return 0;
+}
+#endif
+
static int peers_list(DBusMessageIter *iter,
const char *error, void *user_data)
{
object_properties, path, NULL, NULL);
}
+#if defined TIZEN_EXT_INS
+static int cmd_ins(char *args[], int num, struct connman_option *options)
+{
+ char *filter = NULL;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num == 2)
+ filter = g_strdup(args[1]);
+
+ return __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetINS",
+ ins_list, filter, NULL, NULL);
+}
+#endif
+
static int cmd_peers(char *args[], int num, struct connman_option *options)
{
char *peer_name = NULL;
{ NULL, }
};
+#if defined TIZEN_EXT_INS
+static struct connman_option ins_options[] = {
+ {"all", 'a', ""},
+ {"filter-ssid", 's', "ssid"},
+ {"filter-name", 'n', "[<service_name>]"},
+ { NULL, }
+};
+#endif
+
static struct connman_option config_options[] = {
{"nameservers", 'n', "<dns1> [<dns2>] [<dns3>]"},
{"timeservers", 't', "<ntp1> [<ntp2>] [...]"},
"Display tethering clients", NULL },
{ "services", "[<service>]", service_options, cmd_services,
"Display services", lookup_service_arg },
+#if defined TIZEN_EXT_INS
+ { "ins", NULL, ins_options, cmd_ins,
+ "Display intelligent network selection", NULL },
+#endif
{ "peers", "[peer]", NULL, cmd_peers,
"Display peers", lookup_peer_arg },
{ "scan", "<technology>", NULL, cmd_scan,
--- /dev/null
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2020 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include "ins.h"
+
+struct bssid_info_s {
+ char *bssid;
+ unsigned int strength;
+ unsigned int frequency;
+ int score_ins;
+ int score_last_connected;
+ int score_assoc_reject;
+ int score_frequency;
+ int score_strength;
+};
+
+static void print_bssid_info(gpointer value, gpointer user_data)
+{
+ struct bssid_info_s *bssid_info = value;
+ int *bssid_rank = user_data;
+
+ fprintf(stdout, " %2d) %-20s total[%2d] last_conn[%2d] "
+ "assoc_reject[%2d] freq[%2d(%4d)] strength[%2d(%2d)]\n",
+ *bssid_rank, bssid_info->bssid, bssid_info->score_ins,
+ bssid_info->score_last_connected, bssid_info->score_assoc_reject,
+ bssid_info->score_frequency, bssid_info->frequency,
+ bssid_info->score_strength, bssid_info->strength);
+
+ (*bssid_rank)++;
+}
+
+static GSList *get_bssid_list(DBusMessageIter *iter)
+{
+ char *property;
+ DBusMessageIter entry, val;
+ GSList *bssid_list = NULL;
+ struct bssid_info_s *bssid_info = NULL;
+
+ while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &property);
+
+ if (strcmp(property, "BSSID") == 0) {
+ bssid_info = g_try_new0(struct bssid_info_s, 1);
+ if (!bssid_info)
+ continue;
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->bssid));
+
+ } else if (strcmp(property, "ScoreINS") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->score_ins));
+
+ } else if (strcmp(property, "ScoreLastConnected") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->score_last_connected));
+
+ } else if (strcmp(property, "ScoreAssocReject") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->score_assoc_reject));
+
+ } else if (strcmp(property, "Frequency") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->frequency));
+
+ } else if (strcmp(property, "ScoreFrequency") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->score_frequency));
+
+ } else if (strcmp(property, "Strength") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->strength));
+
+ } else if (strcmp(property, "ScoreStrength") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &(bssid_info->score_strength));
+
+ bssid_list = g_slist_append(bssid_list, bssid_info);
+ }
+
+ dbus_message_iter_next(iter);
+ }
+
+ return bssid_list;
+}
+
+static void print_ins_info(int *rank, char *path, char *filter, DBusMessageIter *iter)
+{
+ char *name = "";
+ char *security;
+ char *str = NULL;
+ int count = 0;
+ char *property;
+ unsigned char strength;
+ unsigned int frequency;
+ int score_INS;
+ int score_last_user_selection;
+ int score_last_connected;
+ int score_frequency;
+ int score_security_priority;
+ int score_internet_connection;
+ int score_strength;
+ GSList *bssid_list = NULL;
+ DBusMessageIter entry, val, dict;
+
+ while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &property);
+
+ if (strcmp(property, "Name") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &name);
+
+ } else if (strcmp(property, "ScoreINS") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_INS);
+
+ } else if (strcmp(property, "ScoreLastUserSelection") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_last_user_selection);
+
+ } else if (strcmp(property, "ScoreLastConnected") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_last_connected);
+
+ } else if (strcmp(property, "Security") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &security);
+
+ } else if (strcmp(property, "ScoreSecurityPriority") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_security_priority);
+
+ } else if (strcmp(property, "Strength") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &strength);
+
+ } else if (strcmp(property, "ScoreStrength") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_strength);
+
+ } else if (strcmp(property, "ScoreInternetConnection") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_internet_connection);
+
+ } else if (strcmp(property, "Frequency") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &frequency);
+
+ } else if (strcmp(property, "ScoreFrequency") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &score_frequency);
+
+ } else if (strcmp(property, "BSSID.List") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ if (dbus_message_iter_get_arg_type(&val)
+ == DBUS_TYPE_ARRAY) {
+ dbus_message_iter_recurse(&val, &dict);
+ bssid_list = get_bssid_list(&dict);
+ }
+
+ }
+
+ count++;
+ dbus_message_iter_next(iter);
+ }
+
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ if (count > 0) {
+ if (!filter || strcmp(filter, name) == 0 || strcmp(filter, "ssid") == 0) {
+ fprintf(stdout, " [%2d] %-20s total[%2d] last_usr[%2d] last_conn[%2d] "
+ "internet[%2d] sec[%2d(%9s)] freq[%2d(%4d)] strength[%2d(%2d)]\n %s\n",
+ *rank, name, score_INS, score_last_user_selection, score_last_connected,
+ score_internet_connection, score_security_priority, security,
+ score_frequency, frequency, score_strength, strength, str);
+
+ if (!filter || strcmp(filter, "ssid") != 0) {
+ int bssid_rank = 1;
+ g_slist_foreach(bssid_list, print_bssid_info, &bssid_rank);
+ }
+
+ (*rank)++;
+ }
+
+ } else {
+ fprintf(stdout, "%-24s %s", "unchanged\n", str);
+ }
+
+}
+
+static void list_ins_array(DBusMessageIter *iter, char *filter)
+{
+ DBusMessageIter array, dict;
+ char *path = NULL;
+ int rank = 1;
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
+
+ dbus_message_iter_recurse(iter, &array);
+ if (dbus_message_iter_get_arg_type(&array)
+ != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&array, &path);
+
+ dbus_message_iter_next(&array);
+ if (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_ARRAY) {
+ dbus_message_iter_recurse(&array, &dict);
+ print_ins_info(&rank, path, filter, &dict);
+ }
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+void __connmanctl_ins_list(DBusMessageIter *iter, char *filter)
+{
+ DBusMessageIter array;
+ char *path;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ list_ins_array(&array, filter);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ fprintf(stdout, "\n}, {");
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_OBJECT_PATH) {
+ dbus_message_iter_get_basic(&array, &path);
+ fprintf(stdout, "\n%-24s %s", "removed", path);
+
+ dbus_message_iter_next(&array);
+ }
+
+}
--- /dev/null
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2020 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_INS_H
+#define __CONNMANCTL_INS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __connmanctl_ins_list(DBusMessageIter *iter, char *filter);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_INS_H */
fi])
AM_CONDITIONAL(TIZEN_EXT, test "${enable-tizen-ext}" != "no")
+AC_ARG_ENABLE(tizen-ext-ins,
+ AC_HELP_STRING([--enable-tizen-ext-ins], [enable TIZEN extensions for INS]),
+ [CFLAGS="$CFLAGS -DTIZEN_EXT_INS"], [enable_tizen_ext_ins="no"])
+AM_CONDITIONAL(TIZEN_EXT_INS, test "${enable_tizen_ext_ins}" != "no")
+
AC_ARG_ENABLE(tizen-ext-wifi-mesh,
AC_HELP_STRING([--enable-tizen-ext-wifi-mesh], [enable TIZEN extensions for Wi-Fi Mesh]),
[CFLAGS="$CFLAGS -DTIZEN_EXT_WIFI_MESH"], [enable_tizen_ext_wifi_mesh="no"])
#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
#define BSS_UNKNOWN_STRENGTH -90
uint16_t frequency;
uint16_t assoc_reject_cnt;
bool is_last_connected;
+#if defined TIZEN_EXT_INS
+ int score_last_connected_bssid;
+ int score_assoc_reject;
+ int score_frequency;
+ int score_strength;
+#endif
int ins_score;
};
return assoc_count.assoc_count;
}
-static void update_bssid_list(gpointer key, gpointer value, gpointer user_data)
+static int calculate_score_last_connected_bssid(bool is_last_connected)
{
- struct g_supplicant_bss *bss = value;
- struct g_connman_bssids *bssids = NULL;
- struct update_bssid_data *bssid_data = (struct update_bssid_data *)user_data;
-
- bssids = (struct g_connman_bssids *)g_try_malloc0(sizeof(struct g_connman_bssids));
-
- if (bssids) {
- memcpy(bssids->bssid, bss->bssid, WIFI_BSSID_LEN_MAX);
-
- bssids->strength = bss->signal;
- bssids->strength += 120;
+ int score = 0;
- if (bssids->strength > 100)
- bssids->strength = 100;
+ if (ins_settings.last_connected_bssid) {
+ if (is_last_connected)
+ score += ins_settings.last_connected_bssid_score;
+ }
- bssids->frequency = bss->frequency;
+ return score;
+}
- bssids->assoc_reject_cnt = get_assoc_reject_cnt(bssid_data->assoc_reject_table, bssids->bssid);
+static int calculate_score_assoc_reject(uint16_t assoc_reject_cnt)
+{
+ int score = 0;
- bssids->is_last_connected = compare_bssid(bssids->bssid, bssid_data->last_connected_bssid);
+ if (ins_settings.assoc_reject)
+ score -= (assoc_reject_cnt * ins_settings.assoc_reject_score);
- bssid_data->bssid_list = g_slist_append(bssid_data->bssid_list, bssids);
- } else
- SUPPLICANT_DBG("Failed to allocate memory");
+ return score;
}
-static int calculate_score(dbus_int16_t strength, dbus_uint16_t frequency,
- uint16_t assoc_reject_cnt, bool is_last_connected)
+static int calculate_score_frequency(dbus_int16_t strength, dbus_uint16_t frequency)
{
int score = 0;
- /* 5GHz & Signal >= RSSI Level 3 */
switch (ins_settings.preferred_freq_bssid) {
case G_SUPPLICANT_INS_PREFERRED_FREQ_24GHZ:
if ((frequency >= FREQ_RANGE_24GHZ_CHANNEL_1 &&
break;
}
- /* Last connected BSSID */
- if (ins_settings.last_connected_bssid) {
- if (is_last_connected)
- score += ins_settings.last_connected_bssid_score;
- }
+ return score;
+}
- /* Assoc reject */
- if (ins_settings.assoc_reject)
- score -= (assoc_reject_cnt * ins_settings.assoc_reject_score);
+static int calculate_score_strength(dbus_int16_t strength)
+{
+ int score = 0;
- /* Signal */
if (ins_settings.signal_bssid)
score += (((strength > -60) ? -60 : strength) + 85);
return score;
}
+static int calculate_score(bool is_last_connected, uint16_t assoc_reject_cnt,
+ dbus_int16_t strength, dbus_uint16_t frequency)
+{
+ int score = 0;
+
+ score += calculate_score_last_connected_bssid(is_last_connected);
+ score += calculate_score_assoc_reject(assoc_reject_cnt);
+ score += calculate_score_frequency(strength, frequency);
+ score += calculate_score_strength(strength);
+
+ return score;
+}
+
+static void update_bssid_list(gpointer key, gpointer value, gpointer user_data)
+{
+ struct g_supplicant_bss *bss = value;
+ struct g_connman_bssids *bssids = NULL;
+ struct update_bssid_data *bssid_data = (struct update_bssid_data *)user_data;
+
+ bssids = (struct g_connman_bssids *)g_try_malloc0(sizeof(struct g_connman_bssids));
+
+ if (bssids) {
+ memcpy(bssids->bssid, bss->bssid, WIFI_BSSID_LEN_MAX);
+
+ bssids->strength = bss->signal;
+ bssids->strength += 120;
+
+ if (bssids->strength > 100)
+ bssids->strength = 100;
+
+ bssids->frequency = bss->frequency;
+
+ bssids->assoc_reject_cnt = get_assoc_reject_cnt(bssid_data->assoc_reject_table, bssids->bssid);
+
+ bssids->is_last_connected = compare_bssid(bssids->bssid, bssid_data->last_connected_bssid);
+
+#if defined TIZEN_EXT_INS
+ bssids->score_last_connected_bssid = calculate_score_last_connected_bssid(bssids->is_last_connected);
+ bssids->score_assoc_reject = calculate_score_assoc_reject(bssids->assoc_reject_cnt);
+ bssids->score_frequency = calculate_score_frequency(bss->signal, bssids->frequency);
+ bssids->score_strength = calculate_score_strength(bssids->strength);
+#endif
+
+ bssids->ins_score = calculate_score(bssids->is_last_connected,
+ bssids->assoc_reject_cnt, bssids->frequency, bss->signal);
+
+ bssid_data->bssid_list = g_slist_append(bssid_data->bssid_list, bssids);
+ } else
+ SUPPLICANT_DBG("Failed to allocate memory");
+}
+
static gint cmp_bss(gconstpointer a, gconstpointer b)
{
struct g_connman_bssids *entry_a = (struct g_connman_bssids *)a;
struct g_connman_bssids *entry_b = (struct g_connman_bssids *)b;
- int score_a = calculate_score(entry_a->strength - 120, entry_a->frequency,
- entry_a->assoc_reject_cnt, entry_a->is_last_connected);
- int score_b = calculate_score(entry_b->strength - 120, entry_b->frequency,
- entry_b->assoc_reject_cnt, entry_b->is_last_connected);
-
- entry_a->ins_score = score_a;
- entry_b->ins_score = score_b;
- if (score_a > score_b)
+ if (entry_a->ins_score > entry_b->ins_score)
return -1;
- if (score_a < score_b)
+ if (entry_a->ins_score < entry_b->ins_score)
return 1;
return 0;
{
struct g_connman_bssids *bssids = data;
- SUPPLICANT_DBG("bssid[%02x:%02x:%02x:%02x:%02x:%02x] score[%d] "
- "strength[%d] freq[%d] assoc_reject[%d] last_conn[%d]",
- bssids->bssid[0], bssids->bssid[1], bssids->bssid[2],
- bssids->bssid[3], bssids->bssid[4], bssids->bssid[5],
- bssids->ins_score, bssids->strength, bssids->frequency,
- bssids->assoc_reject_cnt, bssids->is_last_connected);
+ SUPPLICANT_DBG("bssid[" MACSTR "] total[%2d] freq[%2d] "
+ "last_conn[%2d] assoc_reject[%2d] strength[%2d]",
+ MAC2STR(bssids->bssid), bssids->ins_score,
+ bssids->score_frequency, bssids->score_last_connected_bssid,
+ bssids->score_assoc_reject, bssids->score_strength);
}
#endif
memcpy(network->last_connected_bssid, bssid, WIFI_BSSID_LEN_MAX);
- SUPPLICANT_DBG("last connected bssid [%02x:%02x:%02x:%02x:%02x:%02x]",
- bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
+ SUPPLICANT_DBG("last connected bssid [" MACSTR "]", MAC2STR(bssid));
}
const unsigned char *g_supplicant_network_get_last_connected_bssid(GSupplicantNetwork *network)
int score_new;
int score_best;
- score_new = calculate_score(bss->signal, bss->frequency,
+ score_new = calculate_score(
+ compare_bssid(bss->bssid, network->last_connected_bssid),
get_assoc_reject_cnt(network->assoc_reject_table, bss->bssid),
- compare_bssid(bss->bssid, network->last_connected_bssid));
- score_best = calculate_score(network->best_bss->signal, network->best_bss->frequency,
+ bss->frequency, bss->signal);
+ score_best = calculate_score(
+ compare_bssid(network->best_bss->bssid, network->last_connected_bssid),
get_assoc_reject_cnt(network->assoc_reject_table, network->best_bss->bssid),
- compare_bssid(network->best_bss->bssid, network->last_connected_bssid));
+ network->best_bss->frequency, network->best_bss->signal);
if (score_new > score_best) {
- SUPPLICANT_DBG("new[%02x:%02x:%02x:%02x:%02x:%02x][%u] : "
- "best[%02x:%02x:%02x:%02x:%02x:%02x][%u]",
- bss->bssid[0], bss->bssid[1], bss->bssid[2],
- bss->bssid[3], bss->bssid[4], bss->bssid[5],
- score_new,
- network->best_bss->bssid[0], network->best_bss->bssid[1],
- network->best_bss->bssid[2], network->best_bss->bssid[3],
- network->best_bss->bssid[4], network->best_bss->bssid[5],
- score_best);
+ SUPPLICANT_DBG("new[" MACSTR "][%u] : best[" MACSTR "][%u]",
+ MAC2STR(bss->bssid), score_new,
+ MAC2STR(network->best_bss->bssid), score_best);
network->signal = bss->signal;
network->frequency = bss->frequency;
last_connected_bss_timeout = g_timeout_add_seconds(LAST_CONNECTED_TIMEOUT,
last_connected_timeout, interface);
- SUPPLICANT_DBG("Add timer for last connected bssid "
- "[%02x:%02x:%02x:%02x:%02x:%02x]",
- best_bss->bssid[0], best_bss->bssid[1], best_bss->bssid[2],
- best_bss->bssid[3], best_bss->bssid[4], best_bss->bssid[5]);
+ SUPPLICANT_DBG("Add timer for last connected bssid [" MACSTR "]",
+ MAC2STR(best_bss->bssid));
}
}
}
}
if (ssid->bssid_for_connect_len) {
- snprintf(bssid, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
- ssid->bssid_for_connect[0], ssid->bssid_for_connect[1], ssid->bssid_for_connect[2],
- ssid->bssid_for_connect[3], ssid->bssid_for_connect[4], ssid->bssid_for_connect[5]);
+ snprintf(bssid, 18, MACSTR, MAC2STR(ssid->bssid_for_connect));
memcpy(interface->add_network_bssid, ssid->bssid_for_connect, WIFI_BSSID_LEN_MAX);
} else {
- snprintf(bssid, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
- ssid->bssid[0], ssid->bssid[1], ssid->bssid[2],
- ssid->bssid[3], ssid->bssid[4], ssid->bssid[5]);
+ snprintf(bssid, 18, MACSTR, MAC2STR(ssid->bssid));
memcpy(interface->add_network_bssid, ssid->bssid, WIFI_BSSID_LEN_MAX);
}
- SUPPLICANT_DBG("bssid [%02x:%02x:%02x:%02x:%02x:%02x]",
- interface->add_network_bssid[0], interface->add_network_bssid[1],
- interface->add_network_bssid[2], interface->add_network_bssid[3],
- interface->add_network_bssid[4], interface->add_network_bssid[5]);
+ SUPPLICANT_DBG("bssid [" MACSTR "]", MAC2STR(interface->add_network_bssid));
supplicant_dbus_dict_append_basic(&dict, "bssid",
DBUS_TYPE_STRING, &bssid);
unsigned char bssid[WIFI_BSSID_LEN_MAX];
uint16_t strength;
uint16_t frequency;
+ uint16_t assoc_reject_cnt;
+ bool is_last_connected;
+#if defined TIZEN_EXT_INS
+ int score_last_connected_bssid;
+ int score_assoc_reject;
+ int score_frequency;
+ int score_strength;
+#endif
+ int ins_score;
};
/* Backward compatible
Name: connman
Version: 1.37
-Release: 36
+Release: 37
License: GPL-2.0+
Summary: Connection Manager
Url: http://connman.net
--sysconfdir=/etc \
--enable-client \
--enable-tizen-ext \
+ --disable-tizen-ext-ins \
--enable-pacrunner \
--enable-wifi=builtin \
%if %{with connman_openconnect}
int __connman_service_load_modifiable(struct connman_service *service);
void __connman_service_list_struct(DBusMessageIter *iter);
+#if defined TIZEN_EXT_INS
+void __connman_ins_list_struct(DBusMessageIter *iter);
+#endif
#if defined TIZEN_EXT
int connman_service_get_ipv6_dns_method(struct connman_service *service);
return reply;
}
+#if defined TIZEN_EXT_INS
+static void append_ins_structs(DBusMessageIter *iter, void *user_data)
+{
+ __connman_ins_list_struct(iter);
+}
+
+static DBusMessage *get_ins(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ __connman_dbus_append_objpath_dict_array(reply,
+ append_ins_structs, NULL);
+
+ return reply;
+}
+#endif
+
static void append_peer_structs(DBusMessageIter *iter, void *user_data)
{
__connman_peer_list_struct(iter);
{ GDBUS_METHOD("GetServices",
NULL, GDBUS_ARGS({ "services", "a(oa{sv})" }),
get_services) },
+#if defined TIZEN_EXT_INS
+ { GDBUS_METHOD("GetINS",
+ NULL, GDBUS_ARGS({ "services", "a(oa{sv})" }),
+ get_ins) },
+#endif
{ GDBUS_METHOD("GetPeers",
NULL, GDBUS_ARGS({ "peers", "a(oa{sv})" }),
get_peers) },
#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;
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
};
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);
}
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_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;
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;
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);
+ if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return;
- /* 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);
-
- 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
projects / platform / upstream / connman.git / commitdiff