static void connect_reply(DBusPendingCall *call, void *user_data)
{
char *path = user_data;
struct connman_network *network;
DBusMessage *reply;
DBusError error;
const char *interface = NULL;
int index;
network = g_hash_table_lookup(bluetooth_networks, path);
if (!network)
return;
DBG("network %p", network);
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply)) {
connman_error("%s", error.message);
dbus_error_free(&error);
goto err;
}
if (!dbus_message_get_args(reply, &error, DBUS_TYPE_STRING,
&interface, DBUS_TYPE_INVALID)) {
if (dbus_error_is_set(&error)) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for connect");
goto err;
}
if (!interface)
goto err;
DBG("interface %s", interface);
index = connman_inet_ifindex(interface);
connman_network_set_index(network, index);
connman_network_set_connected(network, true);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
return;
err:
connman_network_set_connected(network, false);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static void connect_reply(DBusPendingCall *call, void *user_data)
{
struct connman_network *network = user_data;
DBusMessage *reply;
DBusError error;
const char *interface = NULL;
int index;
DBG("network %p", network);
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
goto err;
}
if (dbus_message_get_args(reply, &error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_INVALID) == FALSE) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for connect");
goto err;
}
if (interface == NULL)
goto err;
DBG("interface %s", interface);
index = connman_inet_ifindex(interface);
connman_network_set_index(network, index);
connman_network_set_connected(network, TRUE);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
return;
err:
connman_network_set_connected(network, FALSE);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
/**
* __connman_network_disconnect:
* @network: network structure
*
* Disconnect network
*/
int __connman_network_disconnect(struct connman_network *network)
{
int err;
DBG("network %p", network);
if (network->connected == FALSE && network->connecting == FALSE &&
network->associating == FALSE)
return -ENOTCONN;
if (network->driver == NULL)
return -EUNATCH;
if (network->driver->disconnect == NULL)
return -ENOSYS;
network->connecting = FALSE;
err = network->driver->disconnect(network);
if (err == 0) {
connman_network_set_connected(network, FALSE);
set_connected(network);
}
return err;
}
static connman_bool_t pan_connect(struct bluetooth_pan *pan,
const char *iface)
{
int index;
if (iface == NULL) {
if (proxy_get_bool(pan->btnetwork_proxy, "Connected") == FALSE)
return FALSE;
iface = proxy_get_string(pan->btnetwork_proxy, "Interface");
}
if (iface == NULL)
return FALSE;
index = connman_inet_ifindex(iface);
if (index < 0) {
DBG("network %p invalid index %d", pan->network, index);
return FALSE;
}
connman_network_set_index(pan->network, index);
connman_network_set_connected(pan->network, TRUE);
return TRUE;
}
/**
* @brief Disconnect the associated modem
*/
static int network_disconnect(struct connman_network *network)
{
struct qmi_data *qmi = connman_network_get_data(network);
DBG("Network %p %p", network, qmi);
qmi = connman_network_get_data(network);
if(!qmi) {
connman_error("Could not get device data.");
return -ENODEV;
}
DBG("Network %p %p", network, qmi);
qmi->modem_connected = FALSE;
if(qmi->network)
connman_network_set_connected(qmi->network, FALSE);
//FIXME Hack NAT enable by default
__connman_nat_disable("qmi");
g_assert(qmi->qmi_proxy_device);
/* Request disconnect */
g_dbus_proxy_method_call( qmi->qmi_proxy_device,
DISCONNECT_DEVICE,
NULL,
network_disconnect_callback,
qmi,
NULL);
return 0;
}
static bool pan_connect(struct bluetooth_pan *pan,
const char *iface)
{
int index;
if (!iface) {
if (!proxy_get_bool(pan->btnetwork_proxy, "Connected"))
return false;
iface = proxy_get_string(pan->btnetwork_proxy, "Interface");
}
if (!iface)
return false;
index = connman_inet_ifindex(iface);
if (index < 0) {
DBG("network %p invalid index %d", pan->network, index);
return false;
}
connman_network_set_index(pan->network, index);
connman_network_set_connected(pan->network, true);
return true;
}
static void network_remove(struct connman_network *network)
{
DBG("network %p name %s", network, network->name);
if (network->driver == NULL)
return;
connman_network_set_connected(network, FALSE);
switch (network->type) {
case CONNMAN_NETWORK_TYPE_UNKNOWN:
case CONNMAN_NETWORK_TYPE_VENDOR:
break;
case CONNMAN_NETWORK_TYPE_ETHERNET:
case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
case CONNMAN_NETWORK_TYPE_CELLULAR:
case CONNMAN_NETWORK_TYPE_WIFI:
case CONNMAN_NETWORK_TYPE_WIMAX:
if (network->group != NULL) {
__connman_service_remove_from_network(network);
g_free(network->group);
network->group = NULL;
}
break;
}
if (network->driver->remove)
network->driver->remove(network);
network->driver = NULL;
}
/**
* @brief Signal handler for qmi disconnect signal from qmi-dbus.
*
* Will be called, if qmi-dbus stopped.
*/
static void on_handle_qmi_disconnect(DBusConnection *conn, gpointer unused) {
GHashTableIter iter;
gpointer key, value;
DBG("");
/* qmi-dbus was stopped */
qmi_service_connected = FALSE;
g_hash_table_iter_init(&iter, qmi_hash);
while(g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
/* Set all parameter to default */
struct qmi_data *qmi = (struct qmi_data *)value;
if(qmi->network)
connman_network_set_connected(qmi->network, FALSE);
qmi->modem_opened = FALSE;
qmi->modem_opening = FALSE;
qmi->modem_connected = FALSE;
/* Delete connman network */
delete_network(qmi);
}
/* Required for terminating init thread */
sem_post(&new_device_sem);
pthread_join(init_modems_id, NULL);
}
static void btnetwork_property_change(GDBusProxy *proxy, const char *name,
DBusMessageIter *iter, void *user_data)
{
struct bluetooth_pan *pan;
dbus_bool_t connected;
bool proxy_connected, network_connected;
if (strcmp(name, "Connected") != 0)
return;
pan = g_hash_table_lookup(networks, g_dbus_proxy_get_path(proxy));
if (!pan || !pan->network)
return;
dbus_message_iter_get_basic(iter, &connected);
proxy_connected = connected;
network_connected = connman_network_get_connected(pan->network);
DBG("network %p network connected %d proxy connected %d",
pan->network, network_connected, proxy_connected);
if (network_connected != proxy_connected)
connman_network_set_connected(pan->network, proxy_connected);
}
static int cable_disconnect(struct connman_network *network)
{
DBG("network %p", network);
connman_network_set_connected(network, FALSE);
return 0;
}
/**
* @brief Callback connecting network
*/
static void
network_connect_callback(DBusMessage *message, void *user_data) {
struct qmi_data *qmi = (struct qmi_data *)user_data;
DBG("qmi data %p DBusmessage %p", qmi, message);
g_return_if_fail(qmi);
if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
const char *dbus_error = dbus_message_get_error_name(message);
/*Failure during connecting */
qmi->modem_connected = FALSE;
if(qmi->network)
connman_network_set_connected(qmi->network, FALSE);
connman_error("%s", dbus_error);
return;
}
/* Connected successfully */
qmi->modem_connected = TRUE;
connman_network_set_connected(qmi->network, TRUE);
DBG("Device %s connected %d", qmi->devpath, qmi->modem_connected);
g_assert(qmi->qmi_proxy_device);
/* Request all available properties */
g_dbus_proxy_method_call( qmi->qmi_proxy_device,
GET_PROPERTIES,
NULL,
get_properties_callback,
qmi,
NULL);
//FIXME Hack NAT enable by default
__connman_nat_enable("qmi", NULL, 0);
}
static void mbm_newlink(unsigned flags, unsigned change, void *user_data)
{
struct connman_device *device = user_data;
struct mbm_data *data = connman_device_get_data(device);
if (data->network == NULL)
goto done;
_DBG_MBM("device %p flags %d change %d", device, flags, change);
if ((data->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
if (flags & IFF_LOWER_UP) {
printf("==> connected\n");
connman_network_set_connected(data->network, TRUE);
} else {
printf("==> disconnected\n");
connman_network_set_connected(data->network, FALSE);
}
}
done:
data->flags = flags;
}
int connman_device_disconnect_service(struct connman_device *device)
{
DBG("device %p", device);
device->reconnect = false;
if (device->network) {
struct connman_service *service =
connman_service_lookup_from_network(device->network);
if (service)
__connman_service_disconnect(service);
else
connman_network_set_connected(device->network, false);
}
return 0;
}
int __connman_device_disable(struct connman_device *device)
{
int err;
DBG("device %p", device);
if (!device->driver || !device->driver->disable)
return -EOPNOTSUPP;
/* Ongoing power enable request */
if (device->powered_pending == PENDING_ENABLE)
return -EBUSY;
if (device->powered_pending == PENDING_DISABLE)
return -EALREADY;
if (device->powered_pending == PENDING_NONE && device->powered == FALSE)
return -EALREADY;
device->powered_pending = PENDING_DISABLE;
device->reconnect = FALSE;
if (device->network) {
struct connman_service *service =
connman_service_lookup_from_network(device->network);
if (service != NULL)
__connman_service_disconnect(service);
else
connman_network_set_connected(device->network, FALSE);
}
err = device->driver->disable(device);
if (err == 0 || err == -EALREADY) {
connman_device_set_powered(device, FALSE);
goto done;
}
if (err == -EINPROGRESS)
device->pending_timeout = g_timeout_add_seconds(4,
device_pending_reset, device);
done:
return err;
}
static void disconnect_reply(DBusPendingCall *call, void *user_data)
{
char *path = user_data;
struct connman_network *network;
DBusMessage *reply;
DBusError error;
network = g_hash_table_lookup(bluetooth_networks, path);
if (!network)
return;
DBG("network %p", network);
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply)) {
connman_error("%s", error.message);
dbus_error_free(&error);
goto done;
}
if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID)) {
if (dbus_error_is_set(&error)) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for disconnect");
goto done;
}
connman_network_set_connected(network, false);
done:
dbus_message_unref(reply);
dbus_pending_call_unref(call);
connman_network_unref(network);
}
static void pan_disconnect_cb(DBusMessage *message, void *user_data)
{
const char *path = user_data;
struct bluetooth_pan *pan;
pan = g_hash_table_lookup(networks, path);
if (!pan || !pan->network) {
DBG("network already removed");
return;
}
if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
const char *dbus_error = dbus_message_get_error_name(message);
DBG("network %p %s", pan->network, dbus_error);
}
DBG("network %p", pan->network);
connman_network_set_connected(pan->network, false);
}
int __connman_device_disable(struct connman_device *device)
{
int err;
enum connman_service_type type;
DBG("device %p", device);
if (!device->driver || !device->driver->disable)
return -EOPNOTSUPP;
if (device->powered == FALSE)
return -ENOLINK;
if (device->powered_pending == FALSE)
return -EALREADY;
device->reconnect = FALSE;
clear_scan_trigger(device);
if (device->network)
connman_network_set_connected(device->network, FALSE);
err = device->driver->disable(device);
if (err < 0 && err != -EALREADY) {
if (err == -EINPROGRESS)
device->powered_pending = FALSE;
return err;
}
g_hash_table_remove_all(device->networks);
device->powered_pending = FALSE;
device->powered = FALSE;
type = __connman_device_get_service_type(device);
__connman_technology_disable(type);
return 0;
}
static void disconnect_reply(DBusPendingCall *call, void *user_data)
{
struct connman_network *network = user_data;
DBusMessage *reply;
DBusError error;
DBG("network %p", network);
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
goto done;
}
if (dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) == FALSE) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for disconnect");
goto done;
}
connman_network_set_connected(network, FALSE);
done:
dbus_message_unref(reply);
dbus_pending_call_unref(call);
connman_network_unref(network);
}
static gboolean network_changed(DBusConnection *conn,
DBusMessage *message, void *user_data)
{
const char *path = dbus_message_get_path(message);
struct connman_network *network;
DBusMessageIter iter, value;
const char *key;
DBG("path %s", path);
network = g_hash_table_lookup(bluetooth_networks, path);
if (network == NULL)
return TRUE;
if (dbus_message_iter_init(message, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &value);
if (g_str_equal(key, "Connected") == TRUE) {
dbus_bool_t connected;
dbus_message_iter_get_basic(&value, &connected);
if (connected == TRUE)
return TRUE;
connman_network_set_associating(network, FALSE);
connman_network_set_connected(network, FALSE);
}
return TRUE;
}
/**
* @brief Set the newly replied key/ value properties
*/
static gboolean
update_network(struct qmi_data *qmi, DBusMessageIter *entry_iter) {
DBusMessageIter variant_iter;
gboolean updating_strength = FALSE;
gboolean updating_others = FALSE;
gchar *key;
gchar *help;
if(dbus_message_iter_get_arg_type(entry_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(entry_iter, &key);
DBG("Property %s", key);
if(key != NULL) {
dbus_message_iter_next(entry_iter);
if(dbus_message_iter_get_arg_type(entry_iter) != DBUS_TYPE_VARIANT)
return FALSE;
dbus_message_iter_recurse(entry_iter, &variant_iter);
if(g_strcmp0(key, "IMSI") == 0) {
/* Set new IMSI */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(qmi->imsi)
g_free(qmi->imsi);
qmi->imsi = g_strdup(help);
}
else if(g_strcmp0(key, "RSRQ") == 0) {
/* Set new RSRQ */
guint8 help = 0;
if(qmi->network == NULL)
return FALSE;
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_INT32)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &qmi->rsrq);
help = calculate_signal_strength(qmi->rsrq);
if(help != qmi->strength) {
qmi->strength = help;
/* Set new calculated strength */
connman_network_set_strength(qmi->network, qmi->strength);
updating_strength = TRUE;
}
}
else if(g_strcmp0(key, "PacketStatus") == 0) {
/* Set new packet status */
if(qmi->network == NULL)
return FALSE;
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->packet_status, help) != 0) {
if(qmi->packet_status)
g_free(qmi->packet_status);
qmi->packet_status = g_strdup(help);
/* Check new packet status and change network status if required */
if(g_strcmp0(qmi->packet_status, "connected") == 0) {
connman_network_set_connected(qmi->network, TRUE);
}
else {
connman_network_set_connected(qmi->network, FALSE);
}
}
}
else if(g_strcmp0(key, "NetworkType") == 0) {
/* Set new network type */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->network_type, help) != 0) {
if(qmi->network_type)
g_free(qmi->network_type);
qmi->network_type = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "MCC") == 0) {
/* Set new MCC */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->mcc, help) != 0) {
if(qmi->mcc)
g_free(qmi->mcc);
qmi->mcc = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "MNC") == 0) {
/* Set new MNC */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->mnc, help) != 0) {
if(qmi->mnc)
g_free(qmi->mnc);
qmi->mnc = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "RAT") == 0) {
/*Set new RAT */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->rat, help) != 0) {
if(qmi->rat)
g_free(qmi->rat);
qmi->rat = g_strdup(help);
updating_others = TRUE;
}
}
/* Check whether network already exists, because some properties as IMSI or IMEI are set before network is added */
if(qmi->network) {
if(updating_strength == TRUE) {
/* Just update new strength property */
connman_network_update(qmi->network);
}
else if(updating_others == TRUE) {
/* Build a new network name and update it */
if(qmi->provider)
g_free(qmi->provider);
qmi->provider = g_strdup_printf("%s-%s-%s", qmi->mnc, qmi->mcc, qmi->rat);
connman_network_set_name(qmi->network, qmi->provider);
connman_network_update(qmi->network);
}
}
}
return TRUE;
}
static void state_change(struct supplicant_task *task, DBusMessage *msg)
{
DBusError error;
const char *newstate, *oldstate;
unsigned char bssid[ETH_ALEN];
unsigned int bssid_len;
enum supplicant_state state, ostate;
dbus_error_init(&error);
if (dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &newstate,
DBUS_TYPE_STRING, &oldstate,
DBUS_TYPE_INVALID) == FALSE) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for state change");
return;
}
connman_info("%s state change %s -> %s%s", task->ifname,
oldstate, newstate,
task->scanning == TRUE ? " (scanning)" : "");
state = string2state(newstate);
if (state == WPA_INVALID)
return;
if (task->scanning == TRUE && state != WPA_SCANNING) {
connman_device_set_scanning(task->device, FALSE);
task->scanning = FALSE;
}
ostate = task->state;
task->state = state;
if (task->network == NULL)
return;
switch (task->state) {
case WPA_COMPLETED:
if (ostate != WPA_ASSOCIATED && ostate != WPA_GROUP_HANDSHAKE)
goto badstate;
/* reset bg scan reschedule */
connman_device_reset_scan(task->device);
if (get_bssid(task->device, bssid, &bssid_len) == 0)
connman_network_set_address(task->network,
bssid, bssid_len);
/* carrier on */
connman_network_set_connected(task->network, TRUE);
break;
case WPA_ASSOCIATING:
if (ostate != WPA_SCANNING && ostate != WPA_COMPLETED)
goto badstate;
if (ostate == WPA_SCANNING)
connman_network_set_associating(task->network, TRUE);
break;
case WPA_INACTIVE:
if (ostate != WPA_SCANNING && ostate != WPA_DISCONNECTED)
goto badstate;
/* fall thru... */
case WPA_DISCONNECTED:
/* carrier off */
connman_network_set_connected(task->network, FALSE);
if (task->disconnecting == TRUE) {
connman_network_unref(task->network);
task->disconnecting = FALSE;
if (task->pending_network != NULL) {
task->network = task->pending_network;
task->pending_network = NULL;
task_connect(task);
} else
task->network = NULL;
}
break;
default:
connman_network_set_associating(task->network, FALSE);
break;
}
return;
badstate:
connman_error("%s invalid state change %s -> %s%s", task->ifname,
oldstate, newstate,
task->scanning == TRUE ? " (scanning)" : "");
}
