grim/pidgin

Checking in my work in progress
draft keyring-refresh
2020-01-23, Gary Kramlich
a3bb5f0f17ff
Checking in my work in progress
/* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include "purplekeyringbackend.h"
typedef struct {
GObject parent;
gchar *id;
gchar *name;
} PurpleKeyringBackendPrivate;
enum {
PROP_0,
PROP_ID,
PROP_NAME,
N_PROPERTIES,
};
static GParamSpec *properties[N_PROPERTIES] = {NULL, };
/******************************************************************************
* GObject Implementation
*****************************************************************************/
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(PurpleKeyringBackend, purple_keyring_backend, G_TYPE_OBJECT);
static void
purple_keyring_backend_set_id(PurpleKeyringBackend *backend, const gchar *id) {
PurpleKeyringBackendPrivate *priv = purple_keyring_backend_get_instance_private(backend);
g_free(priv->id);
priv->id = g_strdup(id);
}
static void
purple_keyring_backend_set_name(PurpleKeyringBackend *backend,
const gchar *name)
{
PurpleKeyringBackendPrivate *priv = purple_keyring_backend_get_instance_private(backend);
g_free(priv->name);
priv->name = g_strdup(name);
}
static void
purple_keyring_backend_get_property(GObject *obj, guint param_id, GValue *value,
GParamSpec *pspec)
{
PurpleKeyringBackend *backend = PURPLE_KEYRING_BACKEND(obj);
switch(param_id) {
case PROP_ID:
g_value_set_string(value, purple_keyring_backend_get_id(backend));
break;
case PROP_NAME:
g_value_set_string(value, purple_keyring_backend_get_name(backend));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
break;
}
}
static void
purple_keyring_backend_set_property(GObject *obj, guint param_id,
const GValue *value, GParamSpec *pspec)
{
PurpleKeyringBackend *backend = PURPLE_KEYRING_BACKEND(obj);
switch(param_id) {
case PROP_ID:
purple_keyring_backend_set_id(backend, g_value_get_string(value));
break;
case PROP_NAME:
purple_keyring_backend_set_name(backend, g_value_get_string(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
break;
}
}
static void
purple_keyring_backend_finalize(GObject *obj) {
PurpleKeyringBackendPrivate *priv = NULL;
priv = purple_keyring_backend_get_instance_private(PURPLE_KEYRING_BACKEND(obj));
g_free(priv->id);
g_free(priv->name);
G_OBJECT_CLASS(purple_keyring_backend_parent_class)->finalize(obj);
}
static void
purple_keyring_backend_class_init(PurpleKeyringBackendClass *klass) {
GObjectClass *obj_class = G_OBJECT_CLASS(klass);
obj_class->get_property = purple_keyring_backend_get_property;
obj_class->set_property = purple_keyring_backend_set_property;
obj_class->finalize = purple_keyring_backend_finalize;
properties[PROP_ID] =
g_param_spec_string("id", "id",
"The ID of the backend",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
properties[PROP_NAME] =
g_param_spec_string("name", "name",
"The name of the backend",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties(obj_class, N_PROPERTIES, properties);
}
static void
purple_keyring_backend_init(PurpleKeyringBackend *backend) {
}
/******************************************************************************
* API
*****************************************************************************/
const gchar *
purple_keyring_backend_get_id(PurpleKeyringBackend *backend) {
PurpleKeyringBackendPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), NULL);
priv = purple_keyring_backend_get_instance_private(backend);
return priv->id;
}
const gchar *
purple_keyring_backend_get_name(PurpleKeyringBackend *backend) {
PurpleKeyringBackendPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), NULL);
priv = purple_keyring_backend_get_instance_private(backend);
return priv->name;
}
gboolean
purple_keyring_backend_is_valid(PurpleKeyringBackend *backend) {
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), FALSE);
g_return_val_if_fail(purple_keyring_backend_get_id(backend) != NULL, FALSE);
g_return_val_if_fail(purple_keyring_backend_get_name(backend) != NULL, FALSE);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
g_return_val_if_fail(klass->read_password != NULL, FALSE);
g_return_val_if_fail(klass->write_password != NULL, FALSE);
return TRUE;
}
void
purple_keyring_backend_read_password(PurpleKeyringBackend *backend,
PurpleAccount *account,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer data)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_if_fail(PURPLE_IS_KEYRING_BACKEND(backend));
g_return_if_fail(PURPLE_IS_ACCOUNT(account));
g_return_if_fail(callback != NULL);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->read_password) {
klass->read_password(backend, account, cancellable, callback, data);
}
}
gchar *
purple_keyring_backend_read_password_finish(PurpleKeyringBackend *backend,
PurpleAccount *account,
GAsyncResult *result,
GError **error)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), NULL);
g_return_val_if_fail(result != NULL, NULL);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->read_password_finish) {
return klass->read_password_finish(backend, account, result, error);
}
return NULL;
}
void
purple_keyring_backend_write_password(PurpleKeyringBackend *backend,
PurpleAccount *account,
const gchar *password,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer data)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_if_fail(PURPLE_IS_KEYRING_BACKEND(backend));
g_return_if_fail(PURPLE_IS_ACCOUNT(account));
g_return_if_fail(callback != NULL);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->write_password) {
klass->write_password(backend, account, password, cancellable, callback, data);
}
}
gboolean
purple_keyring_backend_write_password_finish(PurpleKeyringBackend *backend,
PurpleAccount *account,
GAsyncResult *result,
GError **error)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), FALSE);
g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
g_return_val_if_fail(result != NULL, FALSE);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->write_password_finish) {
return klass->write_password_finish(backend, account, result, error);
}
return FALSE;
}
void
purple_keyring_backend_clear_password(PurpleKeyringBackend *backend,
PurpleAccount *account,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer data)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_if_fail(PURPLE_IS_KEYRING_BACKEND(backend));
g_return_if_fail(PURPLE_IS_ACCOUNT(account));
g_return_if_fail(callback != NULL);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->clear_password) {
klass->clear_password(backend, account, cancellable, callback, data);
}
}
gboolean
purple_keyring_backend_clear_password_finish(PurpleKeyringBackend *backend,
PurpleAccount *account,
GAsyncResult *result,
GError **error)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), FALSE);
g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
g_return_val_if_fail(result != NULL, FALSE);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->clear_password_finish) {
return klass->clear_password_finish(backend, account, result, error);
}
return FALSE;
}
void
purple_keyring_backend_close(PurpleKeyringBackend *backend) {
PurpleKeyringBackendClass *klass = NULL;
g_return_if_fail(PURPLE_IS_KEYRING_BACKEND(backend));
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->close) {
klass->close(backend);
}
}
PurpleRequestFields *
purple_keyring_backend_read_settings(PurpleKeyringBackend *backend) {
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), NULL);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->read_settings) {
return klass->read_settings(backend);
}
return NULL;
}
gboolean
purple_keyring_backend_write_settings(PurpleKeyringBackend *backend,
PurpleRequestFields *fields)
{
PurpleKeyringBackendClass *klass = NULL;
g_return_val_if_fail(PURPLE_IS_KEYRING_BACKEND(backend), FALSE);
g_return_val_if_fail(fields != NULL, FALSE);
klass = PURPLE_KEYRING_BACKEND_GET_CLASS(backend);
if(klass && klass->write_settings) {
return klass->write_settings(backend, fields);
}
return FALSE;
}