583 lines
22 KiB
C
583 lines
22 KiB
C
/*
|
||
* This file is part of matrix-glib-sdk
|
||
*
|
||
* matrix-glib-sdk 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 3 of the License, or (at your option) any later version.
|
||
*
|
||
* matrix-glib-sdk 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 matrix-glib-sdk. If not, see
|
||
* <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#include "matrix-event-room-third-party-invite.h"
|
||
#include "matrix-types.h"
|
||
#include "config.h"
|
||
|
||
/**
|
||
* SECTION:matrix-event-room-third-party-invite
|
||
* @short_description: event to hold 3rd party invites
|
||
*
|
||
* This is the default event handler for `m.room.third_party_invite` events.
|
||
*
|
||
* Acts as an `m.room.member` invite event (see #MatrixEventRoomMember), where there isn’t a
|
||
* target Matrix ID to invite. This event contains a token and a public key whose private key
|
||
* must be used to sign the token. Any user who can present that signature may use this
|
||
* invitation to join the target room.
|
||
*/
|
||
struct _MatrixThirdPartyInvitePublicKey {
|
||
gchar* key;
|
||
gchar* validity_url;
|
||
|
||
guint refcount;
|
||
};
|
||
|
||
/**
|
||
* MatrixThirdPartyInvitePublicKey:
|
||
*/
|
||
G_DEFINE_BOXED_TYPE(MatrixThirdPartyInvitePublicKey, matrix_third_party_invite_public_key, (GBoxedCopyFunc)matrix_third_party_invite_public_key_ref, (GBoxedFreeFunc)matrix_third_party_invite_public_key_unref);
|
||
|
||
MatrixThirdPartyInvitePublicKey *
|
||
matrix_third_party_invite_public_key_new(void)
|
||
{
|
||
MatrixThirdPartyInvitePublicKey *ret = g_new0(MatrixThirdPartyInvitePublicKey, 1);
|
||
|
||
ret->refcount = 1;
|
||
|
||
return ret;
|
||
}
|
||
|
||
MatrixThirdPartyInvitePublicKey *
|
||
matrix_third_party_invite_public_key_ref(MatrixThirdPartyInvitePublicKey *matrix_third_party_invite_public_key)
|
||
{
|
||
g_return_val_if_fail(matrix_third_party_invite_public_key != NULL, NULL);
|
||
|
||
++matrix_third_party_invite_public_key->refcount;
|
||
|
||
return matrix_third_party_invite_public_key;
|
||
}
|
||
|
||
void
|
||
matrix_third_party_invite_public_key_unref(MatrixThirdPartyInvitePublicKey *matrix_third_party_invite_public_key)
|
||
{
|
||
g_return_if_fail(matrix_third_party_invite_public_key != NULL);
|
||
|
||
if (--(matrix_third_party_invite_public_key->refcount) == 0) {
|
||
g_free(matrix_third_party_invite_public_key->key);
|
||
g_free(matrix_third_party_invite_public_key->validity_url);
|
||
g_free(matrix_third_party_invite_public_key);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* matrix_third_party_invite_public_key_get_key:
|
||
* @third_party_invite_public_key: a #MatrixThirdPartyInvitePublicKey
|
||
*
|
||
* Get the public key from the 3rd party invite.
|
||
*
|
||
* Returns: (nullable) (transfer none): the public key
|
||
*/
|
||
const gchar *
|
||
matrix_third_party_invite_public_key_get_key(MatrixThirdPartyInvitePublicKey *third_party_invite_public_key)
|
||
{
|
||
g_return_val_if_fail(third_party_invite_public_key != NULL, NULL);
|
||
|
||
return third_party_invite_public_key->key;
|
||
}
|
||
|
||
void
|
||
matrix_third_party_invite_public_key_set_key(MatrixThirdPartyInvitePublicKey *matrix_third_party_invite_public_key, const gchar *key)
|
||
{
|
||
g_return_if_fail(matrix_third_party_invite_public_key != NULL);
|
||
|
||
g_free(matrix_third_party_invite_public_key->key);
|
||
matrix_third_party_invite_public_key->key = g_strdup(key);
|
||
}
|
||
|
||
const gchar *
|
||
matrix_third_party_invite_public_key_get_validity_url(MatrixThirdPartyInvitePublicKey *matrix_third_party_invite_public_key)
|
||
{
|
||
g_return_val_if_fail(matrix_third_party_invite_public_key != NULL, NULL);
|
||
|
||
return matrix_third_party_invite_public_key->validity_url;
|
||
}
|
||
|
||
void
|
||
matrix_third_party_invite_public_key_set_validity_url(MatrixThirdPartyInvitePublicKey *matrix_third_party_invite_public_key, const gchar *validity_url)
|
||
{
|
||
g_return_if_fail(matrix_third_party_invite_public_key != NULL);
|
||
|
||
g_free(matrix_third_party_invite_public_key->validity_url);
|
||
matrix_third_party_invite_public_key->validity_url = g_strdup(validity_url);
|
||
}
|
||
|
||
enum {
|
||
PROP_0,
|
||
PROP_DISPLAY_NAME,
|
||
PROP_KEY_VALIDITY_URL,
|
||
PROP_PUBLIC_KEY,
|
||
PROP_TOKEN,
|
||
NUM_PROPERTIES
|
||
};
|
||
|
||
static GParamSpec *matrix_event_room_third_party_invite_properties[NUM_PROPERTIES];
|
||
|
||
typedef struct {
|
||
gchar* _display_name;
|
||
gchar* _key_validity_url;
|
||
gchar* _public_key;
|
||
MatrixThirdPartyInvitePublicKey **_public_keys;
|
||
gint _public_keys_len;
|
||
} MatrixEventRoomThirdPartyInvitePrivate;
|
||
|
||
/**
|
||
* MatrixEventRoomThirdPartyInvite:
|
||
*/
|
||
G_DEFINE_TYPE_WITH_PRIVATE(MatrixEventRoomThirdPartyInvite, matrix_event_room_third_party_invite, MATRIX_EVENT_TYPE_STATE);
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_real_from_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
JsonObject *root;
|
||
JsonObject *content_root;
|
||
JsonNode *content_node;
|
||
JsonNode *node;
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(MATRIX_EVENT_ROOM_THIRD_PARTY_INVITE(matrix_event_base));
|
||
root = json_node_get_object(json_data);
|
||
content_node = json_object_get_member(root, "content");
|
||
content_root = json_node_get_object(content_node);
|
||
|
||
if ((node = json_object_get_member(content_root, "display_name")) != NULL) {
|
||
g_free(priv->_display_name);
|
||
priv->_display_name = g_strdup(json_node_get_string(node));
|
||
} else {
|
||
g_warning("content.display_name is missing from a m.room.third_party_invite event");
|
||
}
|
||
|
||
if ((node = json_object_get_member(content_root, "public_key")) != NULL) {
|
||
g_free(priv->_public_key);
|
||
priv->_public_key = g_strdup(json_node_get_string(node));
|
||
} else {
|
||
g_warning("content.public_key is missing from a m.room.third_party_invite event");
|
||
}
|
||
|
||
if ((node = json_object_get_member(content_root, "key_validity_url")) != NULL) {
|
||
g_free(priv->_key_validity_url);
|
||
priv->_key_validity_url = g_strdup(json_node_get_string(node));
|
||
} else {
|
||
g_warning("content.key_validity_url is missing from a m.room.third_party_invite event");
|
||
}
|
||
|
||
if ((node = json_object_get_member(content_root, "public_keys")) != NULL) {
|
||
JsonArray *public_key_list = json_node_get_array(node);
|
||
priv->_public_keys_len = json_array_get_length(public_key_list);
|
||
priv->_public_keys = g_new0(MatrixThirdPartyInvitePublicKey *, priv->_public_keys_len);
|
||
|
||
for (gint i = 0; i < priv->_public_keys_len; i++) {
|
||
JsonNode *member_node = json_array_get_element(public_key_list, i);
|
||
JsonObject *member_root = json_node_get_object(member_node);
|
||
priv->_public_keys[i] = matrix_third_party_invite_public_key_new();
|
||
|
||
if ((node = json_object_get_member(member_root, "public_key")) != NULL) {
|
||
priv->_public_keys[i]->key = g_strdup(json_node_get_string(node));
|
||
} else {
|
||
g_warning("content.public_keys[].public_key is missing from an m.room.third_party_invite event");
|
||
}
|
||
|
||
if ((node = json_object_get_member(member_root, "validity_url")) != NULL) {
|
||
priv->_public_keys[i]->validity_url = g_strdup(json_node_get_string(node));
|
||
} else {
|
||
g_warning("content.public_keys[].validity_url is missing from an m.room.third_party_invite event");
|
||
}
|
||
}
|
||
}
|
||
|
||
MATRIX_EVENT_BASE_CLASS(matrix_event_room_third_party_invite_parent_class)->from_json((MatrixEventBase*)matrix_event_base, json_data, error);
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_real_to_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
JsonObject *root;
|
||
JsonObject *content_root;
|
||
JsonArray *key_list;
|
||
JsonNode *content_node;
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(MATRIX_EVENT_ROOM_THIRD_PARTY_INVITE(matrix_event_base));
|
||
root = json_node_get_object(json_data);
|
||
content_node = json_object_get_member(root, "content");
|
||
content_root = json_node_get_object(content_node);
|
||
|
||
if (priv->_display_name == NULL) {
|
||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||
"Won't generate a m.room.third_party_invite event without display_name");
|
||
|
||
return;
|
||
}
|
||
|
||
if (priv->_public_key == NULL) {
|
||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||
"Won't generate a m.room.third_party_invite without public_key");
|
||
|
||
return;
|
||
}
|
||
|
||
if (priv->_key_validity_url == NULL) {
|
||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||
"Won't generate a m.room.third_party_invite without key_validity_url");
|
||
|
||
return;
|
||
}
|
||
|
||
json_object_set_string_member(content_root, "display_name", priv->_display_name);
|
||
json_object_set_string_member(content_root, "public_key", priv->_public_key);
|
||
json_object_set_string_member(content_root, "key_validity_url", priv->_key_validity_url);
|
||
|
||
key_list = json_array_new();
|
||
|
||
for (gint i = 0; i < priv->_public_keys_len; i++) {
|
||
JsonObject *key_root;
|
||
JsonNode *key_node;
|
||
MatrixThirdPartyInvitePublicKey *entry = priv->_public_keys[i];
|
||
|
||
if (entry->key == NULL) {
|
||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||
"Won't generate a m.room.third_party_invite with a missing key under public_keys");
|
||
|
||
return;
|
||
}
|
||
|
||
key_root = json_object_new();
|
||
key_node = json_node_new(JSON_NODE_OBJECT);
|
||
json_node_set_object(key_node, key_root);
|
||
json_object_set_string_member(key_root, "public_key", entry->key);
|
||
|
||
if (entry->validity_url != NULL) {
|
||
json_object_set_string_member(key_root, "key_validity_url", entry->validity_url);
|
||
}
|
||
|
||
json_array_add_element(key_list, key_node);
|
||
}
|
||
|
||
if (json_array_get_length(key_list) > 0) {
|
||
JsonNode *keys_node = json_node_new(JSON_NODE_ARRAY);
|
||
|
||
json_node_set_array(keys_node, key_list);
|
||
json_object_set_member(content_root, "public_keys", keys_node);
|
||
}
|
||
|
||
MATRIX_EVENT_BASE_CLASS(matrix_event_room_third_party_invite_parent_class)->to_json(matrix_event_base, json_data, error);
|
||
}
|
||
|
||
MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite_new(void)
|
||
{
|
||
return (MatrixEventRoomThirdPartyInvite *)matrix_event_state_construct(MATRIX_EVENT_TYPE_ROOM_THIRD_PARTY_INVITE);
|
||
}
|
||
|
||
const gchar *
|
||
matrix_event_room_third_party_invite_get_display_name(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_val_if_fail(matrix_event_room_third_party_invite != NULL, NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
return priv->_display_name;
|
||
}
|
||
|
||
void
|
||
matrix_event_room_third_party_invite_set_display_name(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, const gchar *display_name)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_if_fail(matrix_event_room_third_party_invite != NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
if (g_strcmp0(display_name, priv->_display_name) != 0) {
|
||
g_free(priv->_display_name);
|
||
priv->_display_name = g_strdup(display_name);
|
||
|
||
g_object_notify_by_pspec((GObject *)matrix_event_room_third_party_invite, matrix_event_room_third_party_invite_properties[PROP_DISPLAY_NAME]);
|
||
}
|
||
}
|
||
|
||
const gchar *
|
||
matrix_event_room_third_party_invite_get_key_validity_url(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_val_if_fail(matrix_event_room_third_party_invite != NULL, NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
return priv->_key_validity_url;
|
||
}
|
||
|
||
void
|
||
matrix_event_room_third_party_invite_set_key_validity_url(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, const gchar *key_validity_url)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_if_fail(matrix_event_room_third_party_invite != NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
if (g_strcmp0(key_validity_url, priv->_key_validity_url) != 0) {
|
||
g_free(priv->_key_validity_url);
|
||
priv->_key_validity_url = g_strdup(key_validity_url);
|
||
|
||
g_object_notify_by_pspec((GObject *)matrix_event_room_third_party_invite, matrix_event_room_third_party_invite_properties[PROP_KEY_VALIDITY_URL]);
|
||
}
|
||
}
|
||
|
||
const gchar *
|
||
matrix_event_room_third_party_invite_get_public_key(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_val_if_fail(matrix_event_room_third_party_invite != NULL, NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
return priv->_public_key;
|
||
}
|
||
|
||
void
|
||
matrix_event_room_third_party_invite_set_public_key(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, const gchar *public_key)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_if_fail(matrix_event_room_third_party_invite != NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
if (g_strcmp0(public_key, priv->_public_key) != 0) {
|
||
g_free(priv->_public_key);
|
||
priv->_public_key = g_strdup(public_key);
|
||
|
||
g_object_notify_by_pspec((GObject *)matrix_event_room_third_party_invite, matrix_event_room_third_party_invite_properties[PROP_PUBLIC_KEY]);
|
||
}
|
||
}
|
||
|
||
const MatrixThirdPartyInvitePublicKey **
|
||
matrix_event_room_third_party_invite_get_public_keys(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, int *n_public_keys)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_val_if_fail(matrix_event_room_third_party_invite != NULL, NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
if (n_public_keys != NULL) {
|
||
*n_public_keys = priv->_public_keys_len;
|
||
}
|
||
|
||
return (const MatrixThirdPartyInvitePublicKey **)priv->_public_keys;
|
||
}
|
||
|
||
void
|
||
matrix_event_room_third_party_invite_set_public_keys(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, MatrixThirdPartyInvitePublicKey **public_keys, int n_public_keys)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv;
|
||
|
||
g_return_if_fail(matrix_event_room_third_party_invite != NULL);
|
||
|
||
priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
for (gint i = 0; i < priv->_public_keys_len; i++) {
|
||
matrix_third_party_invite_public_key_unref(priv->_public_keys[i]);
|
||
}
|
||
|
||
g_free(priv->_public_keys);
|
||
|
||
priv->_public_keys = g_new0(MatrixThirdPartyInvitePublicKey *, n_public_keys);
|
||
|
||
for (gint i = 0; i < n_public_keys; i++) {
|
||
priv->_public_keys[i] = matrix_third_party_invite_public_key_ref(public_keys[i]);
|
||
}
|
||
|
||
priv->_public_keys_len = n_public_keys;
|
||
}
|
||
|
||
const gchar *
|
||
matrix_event_room_third_party_invite_get_token(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite)
|
||
{
|
||
g_return_val_if_fail(matrix_event_room_third_party_invite != NULL, NULL);
|
||
|
||
return matrix_event_state_get_state_key(MATRIX_EVENT_STATE(matrix_event_room_third_party_invite));
|
||
}
|
||
|
||
void
|
||
matrix_event_room_third_party_invite_set_token(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite, const gchar *token)
|
||
{
|
||
const gchar *state_key;
|
||
|
||
g_return_if_fail(matrix_event_room_third_party_invite != NULL);
|
||
|
||
state_key = matrix_event_state_get_state_key(MATRIX_EVENT_STATE(matrix_event_room_third_party_invite));
|
||
|
||
if (g_strcmp0(token, state_key) != 0) {
|
||
matrix_event_state_set_state_key(MATRIX_EVENT_STATE(matrix_event_room_third_party_invite), token);
|
||
|
||
g_object_notify_by_pspec ((GObject *) matrix_event_room_third_party_invite, matrix_event_room_third_party_invite_properties[PROP_TOKEN]);
|
||
}
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_finalize(GObject *gobject)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv = matrix_event_room_third_party_invite_get_instance_private(MATRIX_EVENT_ROOM_THIRD_PARTY_INVITE(gobject));
|
||
|
||
g_free(priv->_display_name);
|
||
g_free(priv->_key_validity_url);
|
||
g_free(priv->_public_key);
|
||
|
||
for (gint i = 0; i < priv->_public_keys_len; i++) {
|
||
matrix_third_party_invite_public_key_unref(priv->_public_keys[i]);
|
||
}
|
||
|
||
g_free(priv->_public_keys);
|
||
|
||
G_OBJECT_CLASS (matrix_event_room_third_party_invite_parent_class)->finalize(gobject);
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_get_property(GObject *gobject, guint property_id, GValue *value, GParamSpec *pspec)
|
||
{
|
||
MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite = MATRIX_EVENT_ROOM_THIRD_PARTY_INVITE(gobject);
|
||
|
||
switch (property_id) {
|
||
case PROP_DISPLAY_NAME:
|
||
g_value_set_string(value, matrix_event_room_third_party_invite_get_display_name(matrix_event_room_third_party_invite));
|
||
|
||
break;
|
||
case PROP_KEY_VALIDITY_URL:
|
||
g_value_set_string(value, matrix_event_room_third_party_invite_get_key_validity_url(matrix_event_room_third_party_invite));
|
||
|
||
break;
|
||
case PROP_PUBLIC_KEY:
|
||
g_value_set_string(value, matrix_event_room_third_party_invite_get_public_key(matrix_event_room_third_party_invite));
|
||
|
||
break;
|
||
case PROP_TOKEN:
|
||
g_value_set_string(value, matrix_event_room_third_party_invite_get_token(matrix_event_room_third_party_invite));
|
||
|
||
break;
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_set_property(GObject *gobject, guint property_id, const GValue *value, GParamSpec *pspec) {
|
||
MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite = MATRIX_EVENT_ROOM_THIRD_PARTY_INVITE(gobject);
|
||
|
||
switch(property_id) {
|
||
case PROP_DISPLAY_NAME:
|
||
matrix_event_room_third_party_invite_set_display_name(matrix_event_room_third_party_invite, g_value_get_string(value));
|
||
|
||
break;
|
||
case PROP_KEY_VALIDITY_URL:
|
||
matrix_event_room_third_party_invite_set_key_validity_url(matrix_event_room_third_party_invite, g_value_get_string(value));
|
||
|
||
break;
|
||
case PROP_PUBLIC_KEY:
|
||
matrix_event_room_third_party_invite_set_public_key(matrix_event_room_third_party_invite, g_value_get_string(value));
|
||
|
||
break;
|
||
case PROP_TOKEN:
|
||
matrix_event_room_third_party_invite_set_token(matrix_event_room_third_party_invite, g_value_get_string(value));
|
||
|
||
break;
|
||
default:
|
||
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_class_init(MatrixEventRoomThirdPartyInviteClass *klass)
|
||
{
|
||
((MatrixEventBaseClass *)klass)->from_json = matrix_event_room_third_party_invite_real_from_json;
|
||
((MatrixEventBaseClass *)klass)->to_json = matrix_event_room_third_party_invite_real_to_json;
|
||
G_OBJECT_CLASS(klass)->get_property = matrix_event_room_third_party_invite_get_property;
|
||
G_OBJECT_CLASS(klass)->set_property = matrix_event_room_third_party_invite_set_property;
|
||
G_OBJECT_CLASS(klass)->finalize = matrix_event_room_third_party_invite_finalize;
|
||
|
||
/**
|
||
* MatrixEventRoomThirdPartyInvite:display-name:
|
||
*
|
||
* A user-readable string which represents the user who has been
|
||
* invited. This should not contain the user's third party ID, as
|
||
* otherwise when the invite is accepted it would leak the
|
||
* association between the matrix ID and the third party ID.
|
||
*/
|
||
matrix_event_room_third_party_invite_properties[PROP_DISPLAY_NAME] = g_param_spec_string(
|
||
"display-name", "display-name", "display-name",
|
||
NULL,
|
||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
||
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_DISPLAY_NAME, matrix_event_room_third_party_invite_properties[PROP_DISPLAY_NAME]);
|
||
|
||
/**
|
||
* MatrixEventRoomThirdPartyInvite:key-validity-url:
|
||
*
|
||
* A URL which can be fetched, with querystring
|
||
* public_key=public_key, to validate whether the key has been
|
||
* revoked. The URL must return a JSON object containing a boolean
|
||
* property named valid.
|
||
*/
|
||
matrix_event_room_third_party_invite_properties[PROP_KEY_VALIDITY_URL] = g_param_spec_string(
|
||
"key-validity-url", "key-validity-url", "key-validity-url",
|
||
NULL,
|
||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
||
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_KEY_VALIDITY_URL, matrix_event_room_third_party_invite_properties[PROP_KEY_VALIDITY_URL]);
|
||
|
||
/**
|
||
* MatrixEventRoomThirdPartyInvite:public-key:
|
||
*
|
||
* A base64-encoded ed25519 key with which token must be signed
|
||
* (though a signature from any entry in public_keys is also
|
||
* sufficient). This exists for backwards compatibility.
|
||
*/
|
||
matrix_event_room_third_party_invite_properties[PROP_PUBLIC_KEY] = g_param_spec_string(
|
||
"public-key", "public-key", "public-key",
|
||
NULL,
|
||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
||
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_PUBLIC_KEY, matrix_event_room_third_party_invite_properties[PROP_PUBLIC_KEY]);
|
||
|
||
/**
|
||
* MatrixEventRoomThirdPartyInvite:token:
|
||
*
|
||
* The token, of which a signature must be produced in order to
|
||
* join the room.
|
||
*/
|
||
matrix_event_room_third_party_invite_properties[PROP_TOKEN] = g_param_spec_string(
|
||
"token", "token", "token",
|
||
NULL,
|
||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
|
||
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TOKEN, matrix_event_room_third_party_invite_properties[PROP_TOKEN]);
|
||
}
|
||
|
||
static void
|
||
matrix_event_room_third_party_invite_init(MatrixEventRoomThirdPartyInvite *matrix_event_room_third_party_invite)
|
||
{
|
||
MatrixEventRoomThirdPartyInvitePrivate *priv = matrix_event_room_third_party_invite_get_instance_private(matrix_event_room_third_party_invite);
|
||
|
||
priv->_display_name = NULL;
|
||
priv->_key_validity_url = NULL;
|
||
priv->_public_key = NULL;
|
||
}
|