static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
{
struct connman_device *device = user_data;
struct wifi_data *wifi = connman_device_get_data(device);
if (wifi == NULL)
return;
DBG("index %d flags %d change %d", wifi->index, flags, change);
if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
if (flags & IFF_UP)
DBG("interface up");
else
DBG("interface down");
}
if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
if (flags & IFF_LOWER_UP) {
DBG("carrier on");
handle_tethering(wifi);
} else
DBG("carrier off");
}
wifi->flags = flags;
}
static int mk3_enable(struct connman_device *device) {
int err = 0;
struct mk3_data *mk3 = NULL;
DBG("device %p", device);
g_return_val_if_fail(device, -ENODEV);
mk3 = connman_device_get_data(device);
if(!mk3) {
connman_error("No device data available");
return -ENODEV;
}
DBG("device %p data %p", device, mk3);
err = connman_inet_ifup(mk3->index);
if(err < 0) {
connman_error("QMI device could not getting up with ifup");
return err;
}
add_network(mk3);
return 0;
}
static void mk3_remove(struct connman_device *device) {
struct mk3_data *mk3 = NULL;
DBG("device %p", device);
g_return_if_fail(device);
mk3 = connman_device_get_data(device);
if(!mk3) {
connman_error("Could not get device data");
return;
}
DBG("device %p data %p", device, mk3);
delete_network(mk3);
connman_device_set_data(device, NULL);
connman_device_unref(mk3->device);
g_free(mk3->devname);
g_free(mk3->group);
g_free(mk3->name);
g_free(mk3->ident);
g_free(mk3);
}
static int mk3_disable(struct connman_device *device) {
int err = 0;
struct mk3_data *mk3 = NULL;
DBG("device %p", device);
g_return_val_if_fail(device, -ENODEV);
mk3 = connman_device_get_data(device);
if(!mk3) {
connman_error("Could not get device data");
return -ENODEV;
}
DBG("device %p data %p", device, mk3);
err = connman_inet_ifdown(mk3->index);
if(err < 0) {
connman_error("QMI device could not getting down with ifdown");
return err;
}
delete_network(mk3);
return 0;
}
/**
* @brief Enable qmi device and add network if modem opened
*/
static int qmi_enable(struct connman_device *device)
{
int err = 0;
struct qmi_data *qmi = NULL;
DBG("device %p", device);
g_return_val_if_fail(device, -ENODEV);
qmi = connman_device_get_data(device);
if(!qmi) {
connman_error("No device data available");
return -ENODEV;
}
DBG("device %p data %p", device, qmi);
/* Add new qmi network interface */
err = connman_inet_ifup(qmi->index);
if(err < 0) {
connman_error("QMI device could not getting up with ifup");
return err;
}
if(qmi->modem_opened == TRUE) {
add_network(qmi);
}
return 0;
}
/**
* @brief Disable qmi device and delete the associated network
*/
static int qmi_disable(struct connman_device *device)
{
int err = 0;
struct qmi_data *qmi = NULL;
DBG("device %p", device);
g_return_val_if_fail(device, -ENODEV);
qmi = connman_device_get_data(device);
if(!qmi) {
connman_error("Could not get device data");
return -ENODEV;
}
DBG("device %p data %p", device, qmi);
/* Remove qmi network interface */
err = connman_inet_ifdown(qmi->index);
if(err < 0) {
connman_error("QMI device could not getting down with ifdown");
return err;
}
/* Delete associated qmi network */
delete_network(qmi);
return 0;
}
static void ethernet_newlink(unsigned flags, unsigned change, void *user_data)
{
struct connman_device *device = user_data;
struct ethernet_data *ethernet = connman_device_get_data(device);
_DBG_ETHERNET("index %d flags %d change %d", ethernet->index, flags, change);
if ((ethernet->flags & IFF_UP) != (flags & IFF_UP)) {
if (flags & IFF_UP) {
_DBG_ETHERNET("power on");
connman_device_set_powered(device, TRUE);
} else {
_DBG_ETHERNET("power off");
connman_device_set_powered(device, FALSE);
}
}
if ((ethernet->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
if (flags & IFF_LOWER_UP) {
_DBG_ETHERNET("carrier on");
connman_device_set_carrier(device, TRUE);
} else {
_DBG_ETHERNET("carrier off");
connman_device_set_carrier(device, FALSE);
}
}
ethernet->flags = flags;
}
static int ethernet_disable(struct connman_device *device)
{
struct ethernet_data *ethernet = connman_device_get_data(device);
_DBG_ETHERNET("device %p", device);
return connman_inet_ifdown(ethernet->index);
}
static int ethernet_enable(struct connman_device *device)
{
struct ethernet_data *ethernet = connman_device_get_data(device);
DBG("device %p", device);
return connman_inet_ifup(ethernet->index);
}
static int mbm_enable(struct connman_device *device)
{
struct mbm_data *data = connman_device_get_data(device);
const char *devnode;
GIOChannel *channel;
struct termios ti;
int fd, index;
_DBG_MBM("device %p", device);
devnode = connman_device_get_control(device);
if (devnode == NULL)
return -EIO;
fd = open(devnode, O_RDWR | O_NOCTTY);
if (fd < 0)
return -ENODEV;
tcflush(fd, TCIOFLUSH);
/* Switch TTY to raw mode */
memset(&ti, 0, sizeof(ti));
cfmakeraw(&ti);
tcsetattr(fd, TCSANOW, &ti);
channel = g_io_channel_unix_new(fd);
if (channel == NULL) {
close(fd);
return -ENOMEM;
}
data->chat = g_at_chat_new(channel, 0);
if (data->chat == NULL)
return -EIO;
g_io_channel_unref(channel);
g_at_chat_register(data->chat, "*EMRDY:", notify_callback,
FALSE, NULL, NULL);
g_at_chat_register(data->chat, "*EMWI:", notify_callback,
FALSE, NULL, NULL);
g_at_chat_register(data->chat, "+PACSP", notify_callback,
FALSE, NULL, NULL);
index = connman_device_get_index(device);
connman_inet_ifup(index);
g_at_chat_send(data->chat, "AT&F E0 V1 X4 &C1 +CMEE=1", NULL,
generic_callback, NULL, NULL);
g_at_chat_send(data->chat, "AT+CFUN?", cfun_prefix,
cfun_callback, device, NULL);
g_at_chat_send(data->chat, "AT+CFUN=1", NULL,
cfun_callback, device, NULL);
return -EINPROGRESS;
}
static int ethernet_disconnect(struct connman_device *device)
{
struct ethernet_data *ethernet = connman_device_get_data(device);
_DBG_ETHERNET("device %p", device);
if (!(ethernet->flags & IFF_LOWER_UP))
return -ENOTCONN;
return connman_device_set_connected(device, FALSE);
}
static void device_free(gpointer data)
{
struct connman_device *device = data;
GDBusProxy *proxy = connman_device_get_data(device);
connman_device_set_data(device, NULL);
if (proxy)
g_dbus_proxy_unref(proxy);
connman_device_unregister(device);
connman_device_unref(device);
}
static void mbm_remove(struct connman_device *device)
{
struct mbm_data *data = connman_device_get_data(device);
_DBG_MBM("device %p", device);
connman_device_set_data(device, NULL);
connman_rtnl_remove_watch(data->watch);
g_free(data);
}
static void ethernet_remove(struct connman_device *device)
{
struct ethernet_data *ethernet = connman_device_get_data(device);
_DBG_ETHERNET("device %p", device);
connman_device_set_data(device, NULL);
connman_rtnl_remove_watch(ethernet->watch);
g_free(ethernet);
}
static int mbm_disable(struct connman_device *device)
{
struct mbm_data *data = connman_device_get_data(device);
int index;
_DBG_MBM("device %p", device);
g_at_chat_send(data->chat, "AT+CFUN=4", NULL,
cfun_callback, NULL, NULL);
index = connman_device_get_index(device);
connman_inet_ifdown(index);
g_at_chat_unref(data->chat);
data->chat = NULL;
return -EINPROGRESS;
}
static int network_probe(struct connman_network *network)
{
struct connman_device *device = connman_network_get_device(network);
struct mbm_data *data;
_DBG_MBM("network %p", network);
data = connman_device_get_data(device);
connman_network_set_data(network, data);
g_at_chat_send(data->chat, "AT+CGDCONT=1,\"IP\",\"internet.com\"",
NULL, generic_callback, NULL, NULL);
g_at_chat_send(data->chat, "AT*ENAP?", NULL,
generic_callback, NULL, NULL);
return 0;
}
static void cfun_callback(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct connman_device *device = user_data;
struct mbm_data *data = connman_device_get_data(device);
GAtResultIter iter;
int status;
if (ok == FALSE)
return;
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+CFUN:") == FALSE)
return;
g_at_result_iter_next_number(&iter, &status);
if (status == 1) {
connman_device_set_powered(device, TRUE);
data->network = connman_network_create("internet",
CONNMAN_NETWORK_TYPE_MBM);
if (data->network != NULL) {
int index;
index = connman_device_get_index(device);
connman_network_set_index(data->network, index);
connman_network_set_protocol(data->network,
CONNMAN_NETWORK_PROTOCOL_IP);
connman_network_set_group(data->network, "internet");
connman_device_add_network(device, data->network);
}
} else {
connman_device_set_powered(device, FALSE);
data->network = NULL;
}
}
/**
* @brief Remove qmi device
*/
static void qmi_remove(struct connman_device *device)
{
struct qmi_data *qmi = NULL;
DBG("device %p", device);
g_return_if_fail(device);
qmi = connman_device_get_data(device);
if(!qmi) {
connman_error("Could not get device data");
return;
}
/*
* Just delete the qmi device entry in the hash table.
* Modem can not be closed, because modem is not available anymore.
*/
g_hash_table_remove(qmi_hash, qmi->devpath);
}
static void reset_autoscan(struct connman_device *device)
{
struct wifi_data *wifi = connman_device_get_data(device);
struct autoscan_params *autoscan;
DBG("");
if (wifi == NULL || wifi->autoscan == NULL)
return;
autoscan = wifi->autoscan;
if (autoscan->timeout == 0 && autoscan->interval == 0)
return;
g_source_remove(autoscan->timeout);
autoscan->timeout = 0;
autoscan->interval = 0;
connman_device_unref(device);
}
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;
}
static int bluetooth_device_disable(struct connman_device *device)
{
GDBusProxy *proxy = connman_device_get_data(device);
dbus_bool_t device_powered = FALSE;
const char *path;
if (!proxy)
return 0;
path = g_dbus_proxy_get_path(proxy);
if (!proxy_get_bool(proxy, "Powered")) {
DBG("already disabled %p %s", device, path);
return -EALREADY;
}
DBG("device %p %s", device, path);
g_dbus_proxy_set_property_basic(proxy, "Powered",
DBUS_TYPE_BOOLEAN, &device_powered,
device_disable_cb, g_strdup(path), NULL);
return -EINPROGRESS;
}
static void wifi_remove(struct connman_device *device)
{
struct wifi_data *wifi = connman_device_get_data(device);
DBG("device %p wifi %p", device, wifi);
if (wifi == NULL)
return;
iface_list = g_list_remove(iface_list, wifi);
remove_networks(device, wifi);
connman_device_set_powered(device, FALSE);
connman_device_set_data(device, NULL);
connman_device_unref(wifi->device);
connman_rtnl_remove_watch(wifi->watch);
g_supplicant_interface_set_data(wifi->interface, NULL);
g_free(wifi->autoscan);
g_free(wifi->identifier);
g_free(wifi);
}
