static void
simple_connect_ready (MMModemSimple *self,
GAsyncResult *res,
ConnectContext *ctx)
{
GError *error = NULL;
gchar *bearer_path = NULL;
if (!mm_gdbus_modem_simple_call_connect_finish (self,
&bearer_path,
res,
&error)) {
g_simple_async_result_take_error (ctx->result, error);
connect_context_complete_and_free (ctx);
return;
}
mm_gdbus_bearer_proxy_new (
g_dbus_proxy_get_connection (
G_DBUS_PROXY (self)),
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
MM_DBUS_SERVICE,
bearer_path,
ctx->cancellable,
(GAsyncReadyCallback)new_bearer_ready,
ctx);
}
static void
qmi_port_allocate_client_ready (MMQmiPort *qmi,
GAsyncResult *res,
ConnectContext *ctx)
{
GError *error = NULL;
g_assert (ctx->running_ipv4 || ctx->running_ipv6);
g_assert (!(ctx->running_ipv4 && ctx->running_ipv6));
if (!mm_qmi_port_allocate_client_finish (qmi, res, &error)) {
g_simple_async_result_take_error (ctx->result, error);
connect_context_complete_and_free (ctx);
return;
}
if (ctx->running_ipv4)
ctx->client_ipv4 = QMI_CLIENT_WDS (mm_qmi_port_get_client (qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV4));
else
ctx->client_ipv6 = QMI_CLIENT_WDS (mm_qmi_port_get_client (qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV6));
/* Keep on */
ctx->step++;
connect_context_step (ctx);
}
static void
qmi_port_open_ready (MMQmiPort *qmi,
GAsyncResult *res,
ConnectContext *ctx)
{
GError *error = NULL;
if (!mm_qmi_port_open_finish (qmi, res, &error)) {
g_simple_async_result_take_error (ctx->result, error);
connect_context_complete_and_free (ctx);
return;
}
/* Keep on */
ctx->step++;
connect_context_step (ctx);
}
static void
new_bearer_ready (GDBusConnection *connection,
GAsyncResult *res,
ConnectContext *ctx)
{
GError *error = NULL;
MMBearer *bearer;
bearer = mm_gdbus_bearer_proxy_new_finish (res, &error);
if (error)
g_simple_async_result_take_error (ctx->result, error);
else
g_simple_async_result_set_op_res_gpointer (ctx->result,
bearer,
(GDestroyNotify)g_object_unref);
connect_context_complete_and_free (ctx);
}
static void
_connect (MMBearer *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMBearerProperties *properties = NULL;
ConnectContext *ctx;
MMBaseModem *modem = NULL;
MMPort *data;
MMQmiPort *qmi;
GError *error = NULL;
g_object_get (self,
MM_BEARER_MODEM, &modem,
NULL);
g_assert (modem);
/* Grab a data port */
data = mm_base_modem_get_best_data_port (modem);
if (!data) {
g_simple_async_report_error_in_idle (
G_OBJECT (self),
callback,
user_data,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"No valid data port found to launch connection");
g_object_unref (modem);
return;
}
/* Each data port has a single QMI port associated */
qmi = mm_base_modem_get_port_qmi_for_data (modem, data, &error);
if (!qmi) {
g_simple_async_report_take_gerror_in_idle (
G_OBJECT (self),
callback,
user_data,
error);
g_object_unref (data);
g_object_unref (modem);
return;
}
g_object_unref (modem);
mm_dbg ("Launching connection with QMI port (%s/%s) and data port (%s/%s)",
mm_port_subsys_get_string (mm_port_get_subsys (MM_PORT (qmi))),
mm_port_get_device (MM_PORT (qmi)),
mm_port_subsys_get_string (mm_port_get_subsys (data)),
mm_port_get_device (data));
ctx = g_slice_new0 (ConnectContext);
ctx->self = g_object_ref (self);
ctx->qmi = qmi;
ctx->data = data;
ctx->cancellable = g_object_ref (cancellable);
ctx->step = CONNECT_STEP_FIRST;
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
connect);
g_object_get (self,
MM_BEARER_CONFIG, &properties,
NULL);
if (properties) {
MMBearerAllowedAuth auth;
ctx->apn = g_strdup (mm_bearer_properties_get_apn (properties));
ctx->user = g_strdup (mm_bearer_properties_get_user (properties));
ctx->password = g_strdup (mm_bearer_properties_get_password (properties));
switch (mm_bearer_properties_get_ip_type (properties)) {
case MM_BEARER_IP_FAMILY_IPV4:
ctx->ipv4 = TRUE;
ctx->ipv6 = FALSE;
break;
case MM_BEARER_IP_FAMILY_IPV6:
ctx->ipv4 = FALSE;
ctx->ipv6 = TRUE;
break;
case MM_BEARER_IP_FAMILY_IPV4V6:
ctx->ipv4 = TRUE;
ctx->ipv6 = TRUE;
break;
case MM_BEARER_IP_FAMILY_UNKNOWN:
default:
mm_dbg ("No specific IP family requested, defaulting to IPv4");
ctx->no_ip_family_preference = TRUE;
ctx->ipv4 = TRUE;
ctx->ipv6 = FALSE;
break;
}
auth = mm_bearer_properties_get_allowed_auth (properties);
g_object_unref (properties);
if (auth == MM_BEARER_ALLOWED_AUTH_UNKNOWN) {
mm_dbg ("Using default (PAP) authentication method");
ctx->auth = QMI_WDS_AUTHENTICATION_PAP;
} else if (auth & (MM_BEARER_ALLOWED_AUTH_PAP |
MM_BEARER_ALLOWED_AUTH_CHAP |
MM_BEARER_ALLOWED_AUTH_NONE)) {
/* Only PAP and/or CHAP or NONE are supported */
ctx->auth = mm_bearer_allowed_auth_to_qmi_authentication (auth);
} else {
gchar *str;
str = mm_bearer_allowed_auth_build_string_from_mask (auth);
g_simple_async_result_set_error (
ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot use any of the specified authentication methods (%s)",
str);
g_free (str);
connect_context_complete_and_free (ctx);
return;
}
}
/* Run! */
connect_context_step (ctx);
}
static void
connect_context_step (ConnectContext *ctx)
{
/* If cancelled, complete */
if (g_cancellable_is_cancelled (ctx->cancellable)) {
g_simple_async_result_set_error (ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_CANCELLED,
"Connection setup operation has been cancelled");
connect_context_complete_and_free (ctx);
return;
}
switch (ctx->step) {
case CONNECT_STEP_FIRST:
g_assert (ctx->ipv4 || ctx->ipv6);
/* Fall down */
ctx->step++;
case CONNECT_STEP_OPEN_QMI_PORT:
if (!mm_qmi_port_is_open (ctx->qmi)) {
mm_qmi_port_open (ctx->qmi,
TRUE,
ctx->cancellable,
(GAsyncReadyCallback)qmi_port_open_ready,
ctx);
return;
}
/* If already open, just fall down */
ctx->step++;
case CONNECT_STEP_IPV4:
/* If no IPv4 setup needed, jump to IPv6 */
if (!ctx->ipv4) {
ctx->step = CONNECT_STEP_IPV6;
connect_context_step (ctx);
return;
}
/* Start IPv4 setup */
mm_dbg ("Running IPv4 connection setup");
ctx->running_ipv4 = TRUE;
ctx->running_ipv6 = FALSE;
/* Just fall down */
ctx->step++;
case CONNECT_STEP_WDS_CLIENT_IPV4: {
QmiClient *client;
client = mm_qmi_port_get_client (ctx->qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV4);
if (!client) {
mm_dbg ("Allocating IPv4-specific WDS client");
mm_qmi_port_allocate_client (ctx->qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV4,
ctx->cancellable,
(GAsyncReadyCallback)qmi_port_allocate_client_ready,
ctx);
return;
}
ctx->client_ipv4 = QMI_CLIENT_WDS (client);
/* Just fall down */
ctx->step++;
}
case CONNECT_STEP_IP_FAMILY_IPV4:
/* If client is new enough, select IP family */
if (!ctx->no_ip_family_preference &&
qmi_client_check_version (QMI_CLIENT (ctx->client_ipv4), 1, 9)) {
QmiMessageWdsSetIpFamilyInput *input;
mm_dbg ("Setting default IP family to: IPv4");
input = qmi_message_wds_set_ip_family_input_new ();
qmi_message_wds_set_ip_family_input_set_preference (input, QMI_WDS_IP_FAMILY_IPV4, NULL);
qmi_client_wds_set_ip_family (ctx->client_ipv4,
input,
10,
ctx->cancellable,
(GAsyncReadyCallback)set_ip_family_ready,
ctx);
qmi_message_wds_set_ip_family_input_unref (input);
return;
}
ctx->default_ip_family_set = FALSE;
/* Just fall down */
ctx->step++;
case CONNECT_STEP_START_NETWORK_IPV4: {
QmiMessageWdsStartNetworkInput *input;
mm_dbg ("Starting IPv4 connection...");
input = build_start_network_input (ctx);
qmi_client_wds_start_network (ctx->client_ipv4,
input,
45,
ctx->cancellable,
(GAsyncReadyCallback)start_network_ready,
ctx);
qmi_message_wds_start_network_input_unref (input);
return;
}
case CONNECT_STEP_IPV6:
/* If no IPv6 setup needed, jump to last */
if (!ctx->ipv6) {
ctx->step = CONNECT_STEP_GET_CURRENT_SETTINGS;
connect_context_step (ctx);
return;
}
/* Start IPv6 setup */
mm_dbg ("Running IPv6 connection setup");
ctx->running_ipv4 = FALSE;
ctx->running_ipv6 = TRUE;
/* Just fall down */
ctx->step++;
case CONNECT_STEP_WDS_CLIENT_IPV6: {
QmiClient *client;
client = mm_qmi_port_get_client (ctx->qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV6);
if (!client) {
mm_dbg ("Allocating IPv6-specific WDS client");
mm_qmi_port_allocate_client (ctx->qmi,
QMI_SERVICE_WDS,
MM_QMI_PORT_FLAG_WDS_IPV6,
ctx->cancellable,
(GAsyncReadyCallback)qmi_port_allocate_client_ready,
ctx);
return;
}
ctx->client_ipv6 = QMI_CLIENT_WDS (client);
/* Just fall down */
ctx->step++;
}
case CONNECT_STEP_IP_FAMILY_IPV6:
g_assert (ctx->no_ip_family_preference == FALSE);
/* If client is new enough, select IP family */
if (qmi_client_check_version (QMI_CLIENT (ctx->client_ipv6), 1, 9)) {
QmiMessageWdsSetIpFamilyInput *input;
mm_dbg ("Setting default IP family to: IPv6");
input = qmi_message_wds_set_ip_family_input_new ();
qmi_message_wds_set_ip_family_input_set_preference (input, QMI_WDS_IP_FAMILY_IPV6, NULL);
qmi_client_wds_set_ip_family (ctx->client_ipv6,
input,
10,
ctx->cancellable,
(GAsyncReadyCallback)set_ip_family_ready,
ctx);
qmi_message_wds_set_ip_family_input_unref (input);
return;
}
ctx->default_ip_family_set = FALSE;
/* Just fall down */
ctx->step++;
case CONNECT_STEP_START_NETWORK_IPV6: {
QmiMessageWdsStartNetworkInput *input;
mm_dbg ("Starting IPv6 connection...");
input = build_start_network_input (ctx);
qmi_client_wds_start_network (ctx->client_ipv6,
input,
45,
ctx->cancellable,
(GAsyncReadyCallback)start_network_ready,
ctx);
qmi_message_wds_start_network_input_unref (input);
return;
}
case CONNECT_STEP_GET_CURRENT_SETTINGS: {
QmiMessageWdsGetCurrentSettingsInput *input;
QmiClientWds *client;
if (ctx->running_ipv4)
client = ctx->client_ipv4;
else if (ctx->running_ipv6)
client = ctx->client_ipv6;
else
g_assert_not_reached ();
mm_dbg ("Getting IP configuration...");
input = build_get_current_settings_input (ctx);
qmi_client_wds_get_current_settings (client,
input,
45,
ctx->cancellable,
(GAsyncReadyCallback)get_current_settings_ready,
ctx);
qmi_message_wds_get_current_settings_input_unref (input);
return;
}
case CONNECT_STEP_LAST:
/* If one of IPv4 or IPv6 succeeds, we're connected */
if (ctx->packet_data_handle_ipv4 || ctx->packet_data_handle_ipv6) {
MMBearerIpConfig *config;
ConnectResult *result;
/* Port is connected; update the state */
mm_port_set_connected (MM_PORT (ctx->data), TRUE);
/* Keep connection related data */
g_assert (ctx->self->priv->data == NULL);
ctx->self->priv->data = g_object_ref (ctx->data);
g_assert (ctx->self->priv->packet_data_handle_ipv4 == 0);
g_assert (ctx->self->priv->client_ipv4 == NULL);
if (ctx->packet_data_handle_ipv4) {
ctx->self->priv->packet_data_handle_ipv4 = ctx->packet_data_handle_ipv4;
ctx->self->priv->client_ipv4 = g_object_ref (ctx->client_ipv4);
}
g_assert (ctx->self->priv->packet_data_handle_ipv6 == 0);
g_assert (ctx->self->priv->client_ipv6 == NULL);
if (ctx->packet_data_handle_ipv6) {
ctx->self->priv->packet_data_handle_ipv6 = ctx->packet_data_handle_ipv6;
ctx->self->priv->client_ipv6 = g_object_ref (ctx->client_ipv6);
}
/* Build IP config; always DHCP based */
config = mm_bearer_ip_config_new ();
mm_bearer_ip_config_set_method (config, MM_BEARER_IP_METHOD_DHCP);
/* Build result */
result = g_slice_new0 (ConnectResult);
result->data = g_object_ref (ctx->data);
if (ctx->packet_data_handle_ipv4)
result->ipv4_config = g_object_ref (config);
if (ctx->packet_data_handle_ipv6)
result->ipv6_config = g_object_ref (config);
g_object_unref (config);
/* Set operation result */
g_simple_async_result_set_op_res_gpointer (ctx->result,
result,
(GDestroyNotify)connect_result_free);
} else {
GError *error;
/* No connection, set error. If both set, IPv4 error preferred */
if (ctx->error_ipv4) {
error = ctx->error_ipv4;
ctx->error_ipv4 = NULL;
} else {
error = ctx->error_ipv6;
ctx->error_ipv6 = NULL;
}
g_simple_async_result_take_error (ctx->result, error);
}
connect_context_complete_and_free (ctx);
return;
}
}
