/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright © 2012 – 2017 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see .
*/
#include "config.h"
#include
#include
#include
#include
#include "goaauthflowbutton.h"
#include "goaoauth2provider-priv.h"
#include "goaprovider.h"
#include "goaproviderdialog.h"
#include "goasouplogger.h"
#include "goawebdavprovider.h"
#include "goawebdavprovider-priv.h"
#include "goaobjectskeletonutils.h"
#include "goautils.h"
#include "goaowncloudprovider.h"
#define LOGINFLOW2_PATH "index.php/login/v2"
#define LOGINFLOW2_POLL_INTERVAL (5)
struct _GoaOwncloudProvider
{
GoaWebDavProvider parent_instance;
};
G_DEFINE_TYPE_WITH_CODE (GoaOwncloudProvider, goa_owncloud_provider, GOA_TYPE_WEBDAV_PROVIDER,
goa_provider_ensure_extension_points_registered ();
g_io_extension_point_implement (GOA_PROVIDER_EXTENSION_POINT_NAME,
g_define_type_id,
GOA_OWNCLOUD_NAME,
0));
/* ---------------------------------------------------------------------------------------------------- */
static const gchar *
get_provider_type (GoaProvider *provider)
{
return GOA_OWNCLOUD_NAME;
}
static gchar *
get_provider_name (GoaProvider *provider, GoaObject *object)
{
return g_strdup(_("Nextcloud"));
}
static GoaProviderGroup
get_provider_group (GoaProvider *provider)
{
return GOA_PROVIDER_GROUP_BRANDED;
}
static GoaProviderFeatures
get_provider_features (GoaProvider *provider)
{
return GOA_PROVIDER_FEATURE_BRANDED |
GOA_PROVIDER_FEATURE_CALENDAR |
GOA_PROVIDER_FEATURE_CONTACTS |
GOA_PROVIDER_FEATURE_FILES;
}
static GIcon *
get_provider_icon (GoaProvider *provider, GoaObject *object)
{
return g_themed_icon_new_with_default_fallbacks ("goa-account-owncloud");
}
/* ---------------------------------------------------------------------------------------------------- */
static struct
{
const char *key;
const char *endpoint;
} migration_table[] = {
{
.key = "CalDavUri",
.endpoint = "remote.php/dav",
},
{
.key = "CardDavUri",
.endpoint = "remote.php/dav",
},
{
.key = "Uri",
.endpoint = "remote.php/webdav",
},
};
static gboolean
migrate_account (GKeyFile *key_file,
const char *group,
GError **error)
{
g_autofree char *uri = NULL;
g_autofree char *base_uri = NULL;
g_autofree char *path = NULL;
g_autoptr(GError) warning = NULL;
/* This shouldn't ever fail, but we check anyways */
uri = g_key_file_get_string (key_file, group, "Uri", error);
if (uri == NULL || !g_uri_is_valid (uri, G_URI_FLAGS_PARSE_RELAXED, error))
return FALSE;
/* Only URIs missing "remote.php" need migration */
if (g_strrstr (uri, "remote.php") != NULL)
return TRUE;
if (!g_str_has_suffix (uri, "/"))
base_uri = g_strconcat (uri, "/", NULL);
else
base_uri = g_strdup (uri);
for (size_t i = 0; i < G_N_ELEMENTS (migration_table); i++)
{
g_autofree char *value = NULL;
value = g_strconcat (base_uri, migration_table[i].endpoint, NULL);
g_key_file_set_string (key_file, group, migration_table[i].key, value);
}
path = g_build_filename (g_get_user_config_dir (), "goa-1.0", "accounts.conf", NULL);
if (!g_key_file_save_to_file (key_file, path, &warning))
g_warning ("Failed to save account migration: %s", warning->message);
return TRUE;
}
static gboolean
build_object (GoaProvider *provider,
GoaObjectSkeleton *object,
GKeyFile *key_file,
const char *group,
GDBusConnection *connection,
gboolean just_added,
GError **error)
{
if (!migrate_account (key_file, group, error))
return FALSE;
/* Chain up to WebDAV provider */
return GOA_PROVIDER_CLASS (goa_owncloud_provider_parent_class)->build_object (provider,
object,
key_file,
group,
connection,
just_added,
error);
}
/* ---------------------------------------------------------------------------------------------------- */
typedef struct
{
SoupSession *session;
GCancellable *cancellable;
unsigned int cancellable_id;
GCancellable *req_cancellable;
GoaAuthFlowFlags flags;
gboolean accept_ssl_errors;
char *poll_uri;
char *poll_data;
unsigned int poll_id;
GError *error;
} LoginFlow2Data;
static void loginflow2_poll_timeout_cb (gpointer user_data);
static void
loginflow2_data_free (gpointer user_data)
{
LoginFlow2Data *data = (LoginFlow2Data *)user_data;
if (data->cancellable != NULL)
{
g_cancellable_disconnect (data->cancellable, data->cancellable_id);
g_clear_object (&data->cancellable);
}
if (data->session != NULL)
{
soup_session_abort (data->session);
g_clear_object (&data->session);
}
g_clear_object (&data->req_cancellable);
g_clear_pointer (&data->poll_uri, g_free);
g_clear_pointer (&data->poll_data, g_free);
g_clear_handle_id (&data->poll_id, g_source_remove);
g_free (data);
}
static void
loginflow2_cancelled_cb (GCancellable *cancellable,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
LoginFlow2Data *data = (LoginFlow2Data *) g_task_get_task_data (task);
/* libsoup will call g_cancellable_cancel() on the caller's cancellable
*/
soup_session_abort (data->session);
g_clear_handle_id (&data->poll_id, g_source_remove);
}
static gboolean
loginflow2_accept_certificate (SoupMessage *msg,
GTlsCertificate *cert,
GTlsCertificateFlags cert_flags,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
LoginFlow2Data *data = (LoginFlow2Data *) g_task_get_task_data (task);
if (data->accept_ssl_errors || cert_flags == 0)
return TRUE;
if (data->error == NULL)
goa_utils_set_error_ssl (&data->error, cert_flags);
return FALSE;
}
static void
loginflow2_poll_cb (SoupSession *session,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
LoginFlow2Data *data = (LoginFlow2Data *) g_task_get_task_data (task);
SoupMessage *message = NULL;
g_autoptr(GBytes) body = NULL;
g_autoptr(JsonParser) parser = NULL;
const char *json_data;
size_t json_len;
JsonObject *response;
const char *server;
const char *username;
const char *password;
SoupStatus status = SOUP_STATUS_NONE;
g_autoptr(GError) error = NULL;
/* There may have been error, or we may have been aborted/cancelled
* from another thread.
*/
body = soup_session_send_and_read_finish (session, result, &error);
if (error == NULL && data->error != NULL)
{
g_propagate_error (&error, g_steal_pointer (&data->error));
}
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
message = soup_session_get_async_result_message (session, result);
status = soup_message_get_status (message);
if (status == SOUP_STATUS_NOT_FOUND)
{
/* The endpoint returns a 404 until the request is approved.
*/
data->poll_id = g_timeout_add_seconds_once (LOGINFLOW2_POLL_INTERVAL,
loginflow2_poll_timeout_cb,
g_object_ref (task));
return;
}
else if (status != SOUP_STATUS_OK)
{
goa_utils_set_error_soup (&error, message);
g_task_return_error (task, g_steal_pointer (&error));
return;
}
parser = json_parser_new ();
json_data = g_bytes_get_data (body, &json_len);
if (!json_parser_load_from_data (parser, json_data, json_len, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
response = json_node_get_object (json_parser_get_root (parser));
server = json_object_get_string_member (response, "server");
username = json_object_get_string_member (response, "loginName");
password = json_object_get_string_member (response, "appPassword");
if (server != NULL && username != NULL && password != NULL)
{
g_autoptr(GUri) uri = NULL;
g_autofree char *ret = NULL;
uri = g_uri_parse (server, SOUP_HTTP_URI_FLAGS, &error);
if (uri == NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
ret = g_uri_join_with_user (G_URI_FLAGS_HAS_PASSWORD,
g_uri_get_scheme (uri),
username,
password,
NULL,
g_uri_get_host (uri),
g_uri_get_port (uri),
g_uri_get_path (uri),
g_uri_get_query (uri),
g_uri_get_fragment (uri));
g_task_return_pointer (task, g_steal_pointer (&ret), g_free);
}
else
{
g_task_return_new_error_literal (task,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Could not parse response"));
}
}
static void
loginflow2_poll_timeout_cb (gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
LoginFlow2Data *data = (LoginFlow2Data *) g_task_get_task_data (task);
g_autoptr(SoupMessage) message = NULL;
message = soup_message_new_from_encoded_form (SOUP_METHOD_POST,
data->poll_uri,
g_strdup (data->poll_data));
g_signal_connect_object (message,
"accept-certificate",
G_CALLBACK (loginflow2_accept_certificate),
task,
G_CONNECT_DEFAULT);
soup_session_send_and_read_async (data->session,
message,
G_PRIORITY_DEFAULT,
data->req_cancellable,
(GAsyncReadyCallback) loginflow2_poll_cb,
g_object_ref (task));
data->poll_id = 0;
}
static void
loginflow2_launch_uri_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
LoginFlow2Data *data = (LoginFlow2Data *) g_task_get_task_data (task);
GError *error = NULL;
if (!g_app_info_launch_default_for_uri_finish (result, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
/* Start polling for a response
*/
data->poll_id = g_timeout_add_seconds_once (LOGINFLOW2_POLL_INTERVAL,
loginflow2_poll_timeout_cb,
g_object_ref (task));
}
/*< private >
* goa_loginflow2_authenticate:
* @auth: a `JsonNode`
* @flags: the authentication flags
* @accept_ssl_errors: whether to ignore certificate errors
* @cancellable: (nullable): a `GCancellable`
* @callback: (nullable): a `GAsyncReadyCallback`
* @user_data: user data
*
* Perform Login Flow v2 authentication for @auth.
*
* Call [method@Goa.loginflow2_authenticate_finish] to get the result.
*
* See: https://docs.nextcloud.com/server/latest/developer_manual/client_apis/LoginFlow/
*/
static void
goa_loginflow2_authenticate (JsonNode *auth,
GoaAuthFlowFlags flags,
gboolean accept_ssl_errors,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(GUri) login = NULL;
g_autoptr(SoupLogger) logger = NULL;
JsonObject *auth_data, *poll_data;
const char *login_uri = NULL;
const char *endpoint = NULL;
const char *token = NULL;
LoginFlow2Data *data;
g_return_if_fail (auth == NULL || JSON_NODE_HOLDS_OBJECT (auth));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
/* Extract the login and poll endpoints
*/
auth_data = json_node_get_object (auth);
login_uri = json_object_get_string_member (auth_data, "login");
poll_data = json_object_get_object_member (auth_data, "poll");
endpoint = json_object_get_string_member (poll_data, "endpoint");
token = json_object_get_string_member (poll_data, "token");
data = g_new0 (LoginFlow2Data, 1);
data->flags = flags;
data->accept_ssl_errors = accept_ssl_errors;
data->poll_uri = g_strdup (endpoint);
data->poll_data = g_strdup_printf ("token=%s", token);
data->session = soup_session_new ();
data->req_cancellable = g_cancellable_new ();
soup_session_set_user_agent (data->session, "gnome-online-accounts/" PACKAGE_VERSION " ");
logger = goa_soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger));
task = g_task_new (NULL, cancellable, callback, user_data);
g_task_set_source_tag (task, goa_loginflow2_authenticate);
g_task_set_task_data (task, data, loginflow2_data_free);
if (cancellable != NULL)
{
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (cancellable,
G_CALLBACK (loginflow2_cancelled_cb),
task,
NULL);
}
/* Start the web browser flow
*/
if ((data->flags & GOA_AUTH_FLOW_DO_NOT_LAUNCH_URI) == 0)
{
g_app_info_launch_default_for_uri_async (login_uri,
NULL,
data->req_cancellable,
(GAsyncReadyCallback) loginflow2_launch_uri_cb,
g_object_ref (task));
}
else
{
data->poll_id = g_timeout_add_seconds_once (LOGINFLOW2_POLL_INTERVAL,
loginflow2_poll_timeout_cb,
g_object_ref (task));
}
}
/*< private >
* goa_loginflow2_authenticate_finish:
* @result: a `GAsyncResult`
* @error: (nullable): a `GError`
*
* Get the result of an operation started with [func@Goa.loginflow2_authenticate].
*
* Returns: (transfer full): the server URI with encoded credentials,
* or %NULL with @error set
*/
static char *
goa_loginflow2_authenticate_finish (GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == goa_loginflow2_authenticate, NULL);
return g_task_propagate_pointer (G_TASK (result), error);
}
static void
goa_loginflow2_query_cb (SoupSession *session,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
SoupMessage *message = NULL;
g_autoptr(GBytes) body = NULL;
g_autoptr(JsonParser) parser = NULL;
g_autoptr(JsonNode) response = NULL;
JsonObject *auth_data, *poll_data;
const char *json_data;
size_t json_len;
g_autoptr(GError) error = NULL;
/* There may have been error, or we may have been aborted/cancelled
* from another thread.
*/
body = soup_session_send_and_read_finish (session, result, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
message = soup_session_get_async_result_message (session, result);
if (soup_message_get_status (message) != SOUP_STATUS_OK)
{
g_task_return_new_error_literal (task,
GOA_ERROR,
GOA_ERROR_NOT_SUPPORTED,
_("Not supported"));
return;
}
parser = json_parser_new ();
json_data = g_bytes_get_data (body, &json_len);
if (!json_parser_load_from_data (parser, json_data, json_len, &error))
{
g_debug ("%s(): %s", G_STRFUNC, error->message);
g_task_return_new_error_literal (task,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Could not parse response"));
return;
}
response = json_parser_steal_root (parser);
if (!JSON_NODE_HOLDS_OBJECT (response))
{
g_task_return_new_error_literal (task,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Could not parse response"));
return;
}
auth_data = json_node_get_object (response);
poll_data = json_object_get_object_member (auth_data, "poll");
if (poll_data != NULL
&& json_object_get_string_member (auth_data, "login") != NULL
&& json_object_get_string_member (poll_data, "endpoint") != NULL
&& json_object_get_string_member (poll_data, "token") != NULL)
{
g_task_return_pointer (task,
g_steal_pointer (&response),
(GDestroyNotify)json_node_unref);
}
else
{
g_task_return_new_error_literal (task,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Could not parse response"));
}
}
/*< private >
* goa_loginflow2_query:
* @uri: a Nextcloud URI
* @accept_ssl_errors: whether to ignore certificate errors
* @cancellable: (nullable): a `GCancellable`
* @callback: (nullable): a `GAsyncReadyCallback`
* @user_data: user data
*
* Retrieve a LoginFlow2 token and endpoint for @uri.
*
* Call [method@Goa.loginflow2_query_finish] to get the result.
*
* See: https://docs.nextcloud.com/server/latest/developer_manual/client_apis/LoginFlow/
*/
static void
goa_loginflow2_query (const char *uri,
gboolean accept_ssl_errors,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(SoupLogger) logger = NULL;
g_autoptr(SoupMessage) message = NULL;
LoginFlow2Data *data;
g_return_if_fail (uri != NULL && uri[0] != '\0');
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
if (!g_strrstr (uri, LOGINFLOW2_PATH))
{
g_autofree char *message_uri = NULL;
message_uri = g_uri_resolve_relative (uri,
LOGINFLOW2_PATH,
G_URI_FLAGS_PARSE_RELAXED | G_URI_FLAGS_ENCODED,
NULL);
message = soup_message_new (SOUP_METHOD_POST, message_uri);
}
else
{
message = soup_message_new (SOUP_METHOD_POST, uri);
}
if (message == NULL)
{
g_task_report_new_error (NULL, callback, user_data,
goa_loginflow2_query,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Invalid URI: %s"),
uri);
return;
}
data = g_new0 (LoginFlow2Data, 1);
data->accept_ssl_errors = accept_ssl_errors;
data->session = soup_session_new ();
data->req_cancellable = g_cancellable_new ();
soup_session_set_user_agent (data->session, "gnome-online-accounts/" PACKAGE_VERSION " ");
logger = goa_soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger));
task = g_task_new (NULL, cancellable, callback, user_data);
g_task_set_source_tag (task, goa_loginflow2_query);
g_task_set_task_data (task, data, loginflow2_data_free);
if (cancellable != NULL)
{
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (cancellable,
G_CALLBACK (loginflow2_cancelled_cb),
task,
NULL);
}
g_signal_connect_object (message,
"accept-certificate",
G_CALLBACK (loginflow2_accept_certificate),
task,
G_CONNECT_DEFAULT);
soup_session_send_and_read_async (data->session,
message,
G_PRIORITY_DEFAULT,
data->req_cancellable,
(GAsyncReadyCallback) goa_loginflow2_query_cb,
g_object_ref (task));
}
/*< private >
* goa_loginflow2_query_finish:
* @result: a `GAsyncResult`
* @error: (nullable): a `GError`
*
* Get the result of an operation started with [func@Goa.loginflow2_query].
*
* Returns: the JSON response if Login Flow v2 is supported,
* or %NULL with @error set
*/
static JsonNode *
goa_loginflow2_query_finish (GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == goa_loginflow2_query, FALSE);
return g_task_propagate_pointer (G_TASK (result), error);
}
/* ---------------------------------------------------------------------------------------------------- */
typedef struct
{
GoaProviderDialog *dialog;
GoaClient *client;
GoaObject *object;
GCancellable *cancellable;
char *identity;
gboolean accept_ssl_errors;
GoaAuthFlowFlags flags;
JsonNode *login_info;
GCancellable *discover;
GtkWidget *uri;
GtkWidget *login_button;
GtkWidget *discovery_status;
GtkWidget *discovery_spinner;
unsigned int discovery_id;
} AddAccountData;
static void
add_account_data_free (gpointer user_data)
{
AddAccountData *data = (AddAccountData *)user_data;
g_clear_object (&data->client);
g_clear_object (&data->object);
g_clear_object (&data->cancellable);
g_clear_pointer (&data->identity, g_free);
g_clear_pointer (&data->login_info, json_node_unref);
g_cancellable_cancel (data->discover);
g_clear_object (&data->discover);
g_clear_handle_id (&data->discovery_id, g_source_remove);
g_free (data);
}
/* ---------------------------------------------------------------------------------------------------- */
static void
loginflow2_query_cb (GObject *unused,
GAsyncResult *result,
gpointer user_data)
{
AddAccountData *data = user_data;
g_autoptr(JsonNode) response = NULL;
g_autoptr(GError) error = NULL;
response = goa_loginflow2_query_finish (result, &error);
if (response != NULL)
{
goa_provider_dialog_set_state (data->dialog, GOA_DIALOG_READY);
gtk_widget_set_visible (data->discovery_status, TRUE);
gtk_widget_set_visible (data->discovery_spinner, FALSE);
gtk_accessible_update_state (GTK_ACCESSIBLE (data->uri),
GTK_ACCESSIBLE_STATE_BUSY, FALSE,
-1);
g_clear_pointer (&data->login_info, json_node_unref);
data->login_info = json_node_ref (response);
}
else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
g_debug ("%s(): %s", G_STRFUNC, error->message);
goa_provider_dialog_set_state (data->dialog, GOA_DIALOG_IDLE);
gtk_widget_set_visible (data->discovery_status, FALSE);
gtk_accessible_update_state (GTK_ACCESSIBLE (data->uri),
GTK_ACCESSIBLE_STATE_BUSY, FALSE,
-1);
if (g_error_matches (error, GOA_ERROR, GOA_ERROR_SSL))
{
data->accept_ssl_errors = TRUE;
goa_provider_dialog_report_error (data->dialog, g_steal_pointer (&error));
}
else
{
goa_provider_dialog_add_toast (data->dialog, adw_toast_new (error->message));
}
}
}
static void
loginflow2_query (gpointer user_data)
{
AddAccountData *data = (AddAccountData *)user_data;
const char *uri;
uri = gtk_editable_get_text (GTK_EDITABLE (data->uri));
if (uri != NULL && *uri != '\0')
{
g_autofree char *normalized_uri = NULL;
normalized_uri = goa_utils_normalize_url (uri, NULL, NULL);
if (normalized_uri != NULL)
{
gtk_widget_set_visible (data->discovery_status, TRUE);
gtk_widget_set_visible (data->discovery_spinner, TRUE);
gtk_accessible_update_state (GTK_ACCESSIBLE (data->uri),
GTK_ACCESSIBLE_STATE_BUSY, TRUE,
-1);
data->discover = g_cancellable_new ();
goa_loginflow2_query (normalized_uri,
data->accept_ssl_errors,
data->discover,
(GAsyncReadyCallback) loginflow2_query_cb,
data);
}
}
data->discovery_id = 0;
}
static void
on_entry_changed (GtkEditable *editable,
AddAccountData *data)
{
goa_provider_dialog_set_state (data->dialog, GOA_DIALOG_IDLE);
gtk_widget_set_visible (data->discovery_status, FALSE);
g_cancellable_cancel (data->discover);
g_clear_object (&data->discover);
g_clear_handle_id (&data->discovery_id, g_source_remove);
/* Reset the preference to ignore SSL/TLS errors and start
* discovery after a short delay.
*/
data->accept_ssl_errors = FALSE;
data->discovery_id = g_timeout_add_once (250, loginflow2_query, data);
}
static void
on_copy_activated (GoaAuthflowButton *widget,
AddAccountData *data)
{
const char *login_uri = NULL;
login_uri = json_object_get_string_member (json_node_get_object (data->login_info), "login");
gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (data->dialog)), login_uri);
goa_provider_dialog_add_toast (data->dialog, adw_toast_new (_("Copied to clipboard")));
data->flags |= GOA_AUTH_FLOW_DO_NOT_LAUNCH_URI;
goa_provider_dialog_set_state (data->dialog, GOA_DIALOG_BUSY);
goa_authflow_button_set_active (widget, TRUE);
}
static void
on_link_activated (GoaAuthflowButton *widget,
AddAccountData *data)
{
goa_provider_dialog_set_state (data->dialog, GOA_DIALOG_BUSY);
goa_authflow_button_set_active (widget, TRUE);
}
static void
create_account_details_ui (GoaProvider *provider,
AddAccountData *data,
gboolean new_account)
{
GoaProviderDialog *dialog = GOA_PROVIDER_DIALOG (data->dialog);
GtkWidget *group;
GtkWidget *icon;
goa_provider_dialog_add_page (dialog,
_("Nextcloud"),
_("Add a Nextcloud account by providing your server address"));
group = goa_provider_dialog_add_group (dialog, NULL);
data->uri = goa_provider_dialog_add_entry (dialog, group, _("_Server Address"));
goa_provider_dialog_add_description (dialog, data->uri, _("Examples: example.com, 192.168.0.82"));
g_signal_connect (data->uri,
"changed",
G_CALLBACK (on_entry_changed),
data);
/* Discovery spinner
*/
data->discovery_status = g_object_new (GTK_TYPE_BOX,
"margin-start", 8,
"margin-end", 2,
"width-request", 24,
"height-request", 24,
"visible", FALSE,
NULL);
adw_entry_row_add_suffix (ADW_ENTRY_ROW (data->uri), data->discovery_status);
icon = gtk_image_new_from_icon_name ("emblem-default-symbolic");
gtk_widget_add_css_class (GTK_WIDGET (icon), "success");
gtk_box_append (GTK_BOX (data->discovery_status), GTK_WIDGET (icon));
data->discovery_spinner = gtk_spinner_new ();
g_object_bind_property (data->discovery_spinner, "visible",
icon, "visible",
G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN);
g_object_bind_property (data->discovery_spinner, "visible",
data->discovery_spinner, "spinning",
G_BINDING_SYNC_CREATE);
/* Action Buttons
*/
group = goa_provider_dialog_add_group (dialog, NULL);
data->login_button = goa_authflow_button_new ();
g_signal_connect (data->login_button,
"copy-activated",
G_CALLBACK (on_copy_activated),
data);
g_signal_connect (data->login_button,
"link-activated",
G_CALLBACK (on_link_activated),
data);
adw_preferences_group_add (ADW_PREFERENCES_GROUP (group), data->login_button);
gtk_box_append (GTK_BOX (data->discovery_status), data->discovery_spinner);
/* Set the default widget after it's a child of the window */
adw_dialog_set_default_widget (ADW_DIALOG (dialog), data->login_button);
gtk_widget_set_sensitive (data->login_button, FALSE);
gtk_accessible_update_state (GTK_ACCESSIBLE (data->uri),
GTK_ACCESSIBLE_STATE_BUSY, FALSE,
-1);
if (!new_account)
{
g_autofree char *webdav_uri = NULL;
g_autofree char *server = NULL;
webdav_uri = goa_util_lookup_keyfile_string (data->object, "Uri");
server = g_strndup (webdav_uri, strlen (webdav_uri) - strlen ("/remote.php/webdav"));
gtk_editable_set_text (GTK_EDITABLE (data->uri), server);
gtk_editable_set_editable (GTK_EDITABLE (data->uri), FALSE);
}
}
/* ---------------------------------------------------------------------------------------------------- */
static void
add_account_credentials_cb (GoaManager *manager,
GAsyncResult *res,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
AddAccountData *data = g_task_get_task_data (task);
GDBusObject *ret = NULL;
g_autofree char *object_path = NULL;
g_autoptr(GError) error = NULL;
if (!goa_manager_call_add_account_finish (manager, &object_path, res, &error))
{
goa_provider_task_return_error (task, g_steal_pointer (&error));
return;
}
ret = g_dbus_object_manager_get_object (goa_client_get_object_manager (data->client),
object_path);
goa_provider_task_return_account (task, GOA_OBJECT (ret));
}
static void
add_account_loginflow2_cb (GObject *unused,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
GoaProvider *provider = GOA_PROVIDER (g_task_get_source_object (task));
AddAccountData *data = g_task_get_task_data (task);
GVariantBuilder credentials;
GVariantBuilder details;
const char *username;
const char *password;
g_autoptr(GUri) uri = NULL;
g_autofree char *credentials_uri = NULL;
g_autofree char *base_uri = NULL;
g_autofree char *webdav_path = NULL;
g_autofree char *webdav_uri = NULL;
g_autofree char *dav_path = NULL;
g_autofree char *dav_uri = NULL;
g_autofree char *presentation_identity = NULL;
g_autoptr(GError) error = NULL;
credentials_uri = goa_loginflow2_authenticate_finish (result, &error);
if (credentials_uri == NULL)
{
goa_provider_task_return_error (task, g_steal_pointer (&error));
return;
}
uri = g_uri_parse (credentials_uri, SOUP_HTTP_URI_FLAGS, &error);
if (uri == NULL)
{
goa_provider_task_return_error (task, g_steal_pointer (&error));
return;
}
username = g_uri_get_user (uri);
password = g_uri_get_password (uri);
if (strchr (username, '@') != NULL)
presentation_identity = g_strdup (username);
else
presentation_identity = g_strconcat (username, "@", g_uri_get_host (uri), NULL);
/* The credentials are already authenticated; just populate the URIs.
*/
base_uri = g_uri_join (G_URI_FLAGS_PARSE_RELAXED,
g_uri_get_scheme (uri),
NULL,
g_uri_get_host (uri),
g_uri_get_port (uri),
g_uri_get_path (uri),
g_uri_get_query (uri),
g_uri_get_fragment (uri));
webdav_uri = goa_utils_normalize_url (base_uri, "remote.php/webdav", NULL);
dav_uri = goa_utils_normalize_url (base_uri, "remote.php/dav", NULL);
/* Add the account
*/
g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&credentials, "{sv}", "password", g_variant_new_string (password));
g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}"));
g_variant_builder_add (&details, "{ss}", "Uri", webdav_uri);
g_variant_builder_add (&details, "{ss}", "FilesEnabled", "true");
g_variant_builder_add (&details, "{ss}", "CalendarEnabled", "true");
g_variant_builder_add (&details, "{ss}", "CalDavUri", dav_uri);
g_variant_builder_add (&details, "{ss}", "ContactsEnabled", "true");
g_variant_builder_add (&details, "{ss}", "CardDavUri", dav_uri);
g_variant_builder_add (&details, "{ss}", "AcceptSslErrors", "false");
goa_manager_call_add_account (goa_client_get_manager (data->client),
goa_provider_get_provider_type (provider),
username,
presentation_identity,
g_variant_builder_end (&credentials),
g_variant_builder_end (&details),
data->cancellable,
(GAsyncReadyCallback) add_account_credentials_cb,
g_object_ref (task));
}
static void
add_account_action_cb (GoaProviderDialog *dialog,
GParamSpec *pspec,
GTask *task)
{
AddAccountData *data = g_task_get_task_data (task);
if (goa_provider_dialog_get_state (dialog) == GOA_DIALOG_DONE)
{
g_cancellable_cancel (data->cancellable);
return;
}
if (goa_provider_dialog_get_state (data->dialog) == GOA_DIALOG_BUSY)
{
/* A certificate error was encountered when querying for token
*/
if (data->login_info == NULL && data->accept_ssl_errors)
{
loginflow2_query (data);
return;
}
goa_loginflow2_authenticate (data->login_info,
data->flags,
data->accept_ssl_errors,
data->cancellable,
(GAsyncReadyCallback) add_account_loginflow2_cb,
g_object_ref (task));
}
}
static void
add_account (GoaProvider *provider,
GoaClient *client,
GtkWidget *parent,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
AddAccountData *data;
g_autoptr(GTask) task = NULL;
data = g_new0 (AddAccountData, 1);
data->dialog = goa_provider_dialog_new (provider, client, parent);
data->client = g_object_ref (client);
data->cancellable = g_cancellable_new ();
task = g_task_new (provider, cancellable, callback, user_data);
g_task_set_check_cancellable (task, FALSE);
g_task_set_source_tag (task, add_account);
g_task_set_task_data (task, data, add_account_data_free);
create_account_details_ui (provider, data, TRUE);
g_signal_connect_object (data->dialog,
"notify::state",
G_CALLBACK (add_account_action_cb),
task,
G_CONNECT_DEFAULT);
goa_provider_task_run_in_dialog (task, data->dialog);
}
/* ---------------------------------------------------------------------------------------------------- */
static void
refresh_account_credentials_cb (GoaAccount *account,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
GError *error = NULL;
if (!goa_account_call_ensure_credentials_finish (account, NULL, result, &error))
{
goa_provider_task_return_error (task, g_steal_pointer (&error));
return;
}
g_task_return_boolean (task, TRUE);
}
static void
refresh_account_loginflow2_cb (GObject *unused,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (g_steal_pointer (&user_data));
GoaProvider *provider = GOA_PROVIDER (g_task_get_source_object (task));
AddAccountData *data = g_task_get_task_data (task);
g_autofree char *credentials_uri = NULL;
g_autoptr(GUri) uri = NULL;
GVariantBuilder credentials;
const char *username;
const char *password;
g_autoptr(GError) error = NULL;
credentials_uri = goa_loginflow2_authenticate_finish (result, &error);
if (credentials_uri == NULL)
{
goa_provider_dialog_report_error (data->dialog, error);
return;
}
uri = g_uri_parse (credentials_uri, G_URI_FLAGS_HAS_PASSWORD, &error);
if (uri == NULL)
{
goa_provider_dialog_report_error (data->dialog, error);
return;
}
username = g_uri_get_user (uri);
if (g_strcmp0 (data->identity, username) != 0)
{
g_task_return_new_error (task,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Was asked to log in as %s, but logged in as %s"),
data->identity,
username);
return;
}
/* Update the credentials
*/
password = g_uri_get_password (uri);
g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&credentials, "{sv}", "password", g_variant_new_string (password));
if (!goa_utils_store_credentials_for_object_sync (provider,
data->object,
g_variant_builder_end (&credentials),
data->cancellable,
&error))
{
goa_provider_task_return_error (task, g_steal_pointer (&error));
return;
}
goa_account_call_ensure_credentials (goa_object_peek_account (data->object),
data->cancellable,
(GAsyncReadyCallback) refresh_account_credentials_cb,
g_steal_pointer (&task));
}
static void
refresh_account_action_cb (GoaProviderDialog *dialog,
GParamSpec *pspec,
GTask *task)
{
AddAccountData *data = g_task_get_task_data (task);
if (goa_provider_dialog_get_state (dialog) == GOA_DIALOG_DONE)
{
g_cancellable_cancel (data->cancellable);
return;
}
if (goa_provider_dialog_get_state (data->dialog) == GOA_DIALOG_BUSY)
{
goa_loginflow2_authenticate (data->login_info,
data->flags,
data->accept_ssl_errors,
data->cancellable,
(GAsyncReadyCallback) refresh_account_loginflow2_cb,
g_object_ref (task));
}
}
/* ---------------------------------------------------------------------------------------------------- */
static void
refresh_account (GoaProvider *provider,
GoaClient *client,
GoaObject *object,
GtkWidget *parent,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
AddAccountData *data;
g_autoptr(GTask) task = NULL;
g_assert (GOA_IS_WEBDAV_PROVIDER (provider));
g_assert (GOA_IS_CLIENT (client));
g_assert (GOA_IS_OBJECT (object));
g_assert (parent == NULL || GTK_IS_WIDGET (parent));
g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
data = g_new0 (AddAccountData, 1);
data->dialog = goa_provider_dialog_new (provider, client, parent);
data->client = g_object_ref (client);
data->object = g_object_ref (object);
data->cancellable = g_cancellable_new ();
data->identity = goa_util_lookup_keyfile_string (object, "Identity");
data->accept_ssl_errors = goa_util_lookup_keyfile_boolean (object, "AcceptSslErrors");
task = g_task_new (provider, cancellable, callback, user_data);
g_task_set_check_cancellable (task, FALSE);
g_task_set_source_tag (task, refresh_account);
g_task_set_task_data (task, data, add_account_data_free);
create_account_details_ui (provider, data, FALSE);
g_signal_connect_object (data->dialog,
"notify::state",
G_CALLBACK (refresh_account_action_cb),
task,
G_CONNECT_DEFAULT);
goa_provider_task_run_in_dialog (task, data->dialog);
}
/* ---------------------------------------------------------------------------------------------------- */
static void
goa_owncloud_provider_init (GoaOwncloudProvider *self)
{
}
static void
goa_owncloud_provider_class_init (GoaOwncloudProviderClass *klass)
{
GoaProviderClass *provider_class;
provider_class = GOA_PROVIDER_CLASS (klass);
provider_class->get_provider_type = get_provider_type;
provider_class->get_provider_name = get_provider_name;
provider_class->get_provider_group = get_provider_group;
provider_class->get_provider_features = get_provider_features;
provider_class->get_provider_icon = get_provider_icon;
provider_class->build_object = build_object;
provider_class->add_account = add_account;
provider_class->refresh_account = refresh_account;
}