static void portal_manage_status(GWebResult *result,
struct connman_wispr_portal_context *wp_context)
{
enum connman_ipconfig_type type = wp_context->type;
struct connman_service *service;
const char *str = NULL;
DBG("");
/* We currently don't do anything with this info */
if (g_web_result_get_header(result, "X-ConnMan-Client-IP",
&str))
DBG("Client-IP: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Country",
&str))
DBG("Client-Country: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Region",
&str))
DBG("Client-Region: %s", str);
if (g_web_result_get_header(result, "X-ConnMan-Client-Timezone",
&str))
DBG("Client-Timezone: %s", str);
/* __connman_service_ipconfig_indicate_state may end up calling
* __connman_wispr_start which would reinitialize the wispr context
* so we better free it beforehand to avoid deallocating it twice. */
service = connman_service_ref(wp_context->service);
free_connman_wispr_portal_context(wp_context);
__connman_service_ipconfig_indicate_state(service,
CONNMAN_SERVICE_STATE_ONLINE, type);
connman_service_unref(service);
}
unsigned int connman_proxy_lookup(const char *interface, const char *url,
struct connman_service *service,
connman_proxy_lookup_cb cb,
void *user_data)
{
struct proxy_lookup *lookup;
DBG("interface %s url %s", interface, url);
if (!interface)
return 0;
lookup = g_try_new0(struct proxy_lookup, 1);
if (!lookup)
return 0;
lookup->token = next_lookup_token++;
lookup->cb = cb;
lookup->user_data = user_data;
lookup->url = g_strdup(url);
lookup->service = connman_service_ref(service);
lookup->watch = g_timeout_add_seconds(0, lookup_callback, lookup);
if (lookup->watch == 0) {
g_free(lookup->url);
g_free(lookup);
return 0;
}
DBG("token %u", lookup->token);
lookup_list = g_slist_prepend(lookup_list, lookup);
return lookup->token;
}
int __connman_wpad_start(struct connman_service *service)
{
struct connman_wpad *wpad;
const char *domainname;
char **nameservers;
int index;
int i;
DBG("service %p", service);
if (!wpad_list)
return -EINVAL;
index = __connman_service_get_index(service);
if (index < 0)
return -EINVAL;
domainname = connman_service_get_domainname(service);
if (!domainname)
return -EINVAL;
nameservers = connman_service_get_nameservers(service);
if (!nameservers)
return -EINVAL;
wpad = g_try_new0(struct connman_wpad, 1);
if (!wpad) {
g_strfreev(nameservers);
return -ENOMEM;
}
wpad->service = service;
wpad->resolv = g_resolv_new(index);
if (!wpad->resolv) {
g_strfreev(nameservers);
g_free(wpad);
return -ENOMEM;
}
if (getenv("CONNMAN_RESOLV_DEBUG"))
g_resolv_set_debug(wpad->resolv, resolv_debug, "RESOLV");
for (i = 0; nameservers[i]; i++)
g_resolv_add_nameserver(wpad->resolv, nameservers[i], 53, 0);
g_strfreev(nameservers);
wpad->hostname = g_strdup_printf("wpad.%s", domainname);
DBG("hostname %s", wpad->hostname);
g_resolv_lookup_hostname(wpad->resolv, wpad->hostname,
wpad_result, wpad);
connman_service_ref(service);
g_hash_table_replace(wpad_list, GINT_TO_POINTER(index), wpad);
return 0;
}
int __connman_agent_report_error(struct connman_service *service,
const char *error,
report_error_cb_t callback, void *user_data)
{
DBusMessage *message;
DBusMessageIter iter;
const char *path;
struct report_error_data *report_error;
DBusPendingCall *call;
if (service == NULL || agent_path == NULL || error == NULL ||
callback == NULL)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"ReportError");
if (message == NULL)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
path = __connman_service_get_path(service);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING, &error);
report_error = g_try_new0(struct report_error_data, 1);
if (report_error == NULL) {
dbus_message_unref(message);
return -ENOMEM;
}
if (dbus_connection_send_with_reply(connection, message,
&call, -1) == FALSE) {
dbus_message_unref(message);
g_free(report_error);
return -ESRCH;
}
if (call == NULL) {
dbus_message_unref(message);
g_free(report_error);
return -ESRCH;
}
report_error->service = connman_service_ref(service);
report_error->callback = callback;
report_error->user_data = user_data;
dbus_pending_call_set_notify(call, report_error_reply,
report_error, NULL);
dbus_message_unref(message);
return -EIO;
}
/**
* @brief Add the network associated to its qmi device
*/
static void add_network(struct qmi_data *qmi)
{
struct connman_network *network = NULL;
int index;
struct connman_service *service = NULL;
g_return_if_fail(qmi);
DBG("data %p", qmi);
if(qmi->network != NULL) {
DBG("network %p already exists.", qmi->network);
return;
}
/* Create an new qmi network */
network = connman_network_create(qmi->devpath, CONNMAN_NETWORK_TYPE_QMI);
if(network == NULL) {
connman_error("Network could not be created.");
return;
}
DBG("network %p", qmi->network);
/* Set network properties */
index = connman_device_get_index(qmi->device);
connman_network_set_index(network, index);
connman_network_set_data(network, qmi);
connman_network_set_strength(network, qmi->strength);
connman_network_set_group(network, qmi->group);
if(qmi->provider)
g_free(qmi->provider);
qmi->provider = g_strdup("no-name");
connman_network_set_name(network, qmi->provider);
/* Add the created network */
if (connman_device_add_network(qmi->device, network) < 0) {
connman_error("Network not added to the device.");
connman_network_unref(network);
network = NULL;
return;
}
qmi->network = network;
/* Get configured values from the created *.config file */
service = connman_service_lookup_from_network(network);
DBG("service %p", service);
if(service == NULL) {
connman_error("No service available");
return;
}
service = connman_service_ref(service);
if(qmi->apn)
g_free(qmi->apn);
qmi->apn = g_strdup(connman_service_get_string(service, "APN"));
if(qmi->passphrase)
g_free(qmi->passphrase);
qmi->passphrase = g_strdup(connman_service_get_string(service, "Passphrase"));
if(qmi->username)
g_free(qmi->username);
qmi->username = g_strdup(connman_service_get_string(service, "Username"));
if(qmi->provider)
g_free(qmi->provider);
qmi->provider = g_strdup(connman_service_get_string(service, "Provider"));
if(qmi->provider == NULL)
qmi->provider = g_strdup("no-name");
connman_network_set_name(network, qmi->provider);
connman_network_update(qmi->network);
DBG("network %p IMSI %s APN %s PW %s Username %s", qmi->network, qmi->imsi, qmi->apn, qmi->passphrase, qmi->username);
connman_service_unref(service);
if((qmi->imsi == NULL) || (qmi->apn == NULL) || (qmi->passphrase == NULL)) {
connman_error("There are not all required parameters available");
return;
}
}
int __connman_agent_request_input(struct connman_service *service,
authentication_cb_t callback, void *user_data)
{
DBusMessage *message;
const char *path;
DBusMessageIter iter;
DBusMessageIter dict;
DBusPendingCall *call;
struct request_input_reply *passphrase_reply;
if (service == NULL || agent_path == NULL || callback == NULL)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"RequestInput");
if (message == NULL)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
path = __connman_service_get_path(service);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
connman_dbus_dict_open(&iter, &dict);
if (__connman_service_get_security(service) ==
CONNMAN_SERVICE_SECURITY_8021X) {
connman_dbus_dict_append_dict(&dict, "Identity",
request_input_append_identity, service);
}
connman_dbus_dict_append_dict(&dict, "Passphrase",
request_input_append_passphrase, service);
if (__connman_service_wps_enabled(service) == TRUE) {
connman_dbus_dict_append_dict(&dict, "WPS",
request_input_append_wps, NULL);
}
connman_dbus_dict_close(&iter, &dict);
passphrase_reply = g_try_new0(struct request_input_reply, 1);
if (passphrase_reply == NULL) {
dbus_message_unref(message);
return -ENOMEM;
}
if (dbus_connection_send_with_reply(connection, message,
&call, -1) == FALSE) {
dbus_message_unref(message);
g_free(passphrase_reply);
return -ESRCH;
}
if (call == NULL) {
dbus_message_unref(message);
g_free(passphrase_reply);
return -ESRCH;
}
passphrase_reply->service = connman_service_ref(service);
passphrase_reply->callback = callback;
passphrase_reply->user_data = user_data;
dbus_pending_call_set_notify(call, request_input_passphrase_reply,
passphrase_reply, NULL);
dbus_message_unref(message);
return -EIO;
}
static int request_lookup(struct connman_service *service, const char *url)
{
DBusMessage *msg;
DBusPendingCall *call;
dbus_bool_t result;
char *host;
struct proxy_data *data;
DBG("");
if (daemon_running == FALSE)
return -EINVAL;
msg = dbus_message_new_method_call(PACRUNNER_SERVICE,
PACRUNNER_CLIENT_PATH,
PACRUNNER_CLIENT_INTERFACE,
"FindProxyForURL");
if (msg == NULL)
return -1;
host = parse_url(url);
if (host == NULL) {
dbus_message_unref(msg);
return -EINVAL;
}
data = g_try_new0(struct proxy_data, 1);
if (data == NULL) {
dbus_message_unref(msg);
g_free(host);
return -ENOMEM;
}
data->url = g_strdup(url);
data->service = connman_service_ref(service);
dbus_message_set_auto_start(msg, FALSE);
dbus_message_append_args(msg, DBUS_TYPE_STRING, &url,
DBUS_TYPE_STRING, &host,
DBUS_TYPE_INVALID);
result = dbus_connection_send_with_reply(connection, msg,
&call, DBUS_TIMEOUT);
dbus_message_unref(msg);
if (result == FALSE || call == NULL) {
g_free(host);
g_free(data->url);
g_free(data);
return -EINVAL;
}
dbus_pending_call_set_notify(call, request_lookup_reply,
data, NULL);
dbus_pending_call_unref(call);
g_free(host);
return 0;
}
static struct gateway_data *add_gateway(struct connman_service *service,
int index, const char *gateway,
enum connman_ipconfig_type type)
{
struct gateway_data *data, *old;
struct gateway_config *config;
if (!gateway || strlen(gateway) == 0)
return NULL;
data = g_try_new0(struct gateway_data, 1);
if (!data)
return NULL;
data->index = index;
config = g_try_new0(struct gateway_config, 1);
if (!config) {
g_free(data);
return NULL;
}
config->gateway = g_strdup(gateway);
config->vpn_ip = NULL;
config->vpn_phy_ip = NULL;
config->vpn = false;
config->vpn_phy_index = -1;
config->active = false;
if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
data->ipv4_gateway = config;
else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
data->ipv6_gateway = config;
else {
g_free(config->gateway);
g_free(config);
g_free(data);
return NULL;
}
data->service = service;
data->order = __connman_service_get_order(service);
/*
* If the service is already in the hash, then we
* must not replace it blindly but disable the gateway
* of the type we are replacing and take the other type
* from old gateway settings.
*/
old = g_hash_table_lookup(gateway_hash, service);
if (old) {
DBG("Replacing gw %p ipv4 %p ipv6 %p", old,
old->ipv4_gateway, old->ipv6_gateway);
disable_gateway(old, type);
if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
data->ipv6_gateway = old->ipv6_gateway;
old->ipv6_gateway = NULL;
} else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
data->ipv4_gateway = old->ipv4_gateway;
old->ipv4_gateway = NULL;
}
} else {
/*
* Only take a ref if we are adding new stuff to hash.
*/
connman_service_ref(service);
}
g_hash_table_replace(gateway_hash, service, data);
return data;
}