summaryrefslogtreecommitdiff
path: root/libsoup/auth/soup-tls-interaction.c
blob: d6511fa58953878512d6790f7c9a91a5a8664b8f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/*
 * soup-tls-interaction.c: TLS interaction implementation
 *
 * Copyright (C) 2021 Igalia S.L.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "soup-tls-interaction.h"

struct _SoupTlsInteraction {
        GTlsInteraction parent;
};

typedef struct {
        GWeakRef conn;
} SoupTlsInteractionPrivate;

G_DEFINE_FINAL_TYPE_WITH_PRIVATE (SoupTlsInteraction, soup_tls_interaction, G_TYPE_TLS_INTERACTION)

static void
soup_tls_interaction_request_certificate_async (GTlsInteraction             *tls_interaction,
                                                GTlsConnection              *connection,
                                                GTlsCertificateRequestFlags  flags,
                                                GCancellable                *cancellable,
                                                GAsyncReadyCallback          callback,
                                                gpointer                     user_data)
{
        SoupTlsInteractionPrivate *priv = soup_tls_interaction_get_instance_private (SOUP_TLS_INTERACTION (tls_interaction));
        GTask *task;
        SoupConnection *conn = g_weak_ref_get (&priv->conn);

        task = g_task_new (tls_interaction, cancellable, callback, user_data);
        g_task_set_source_tag (task, soup_tls_interaction_request_certificate_async);
        if (conn) {
                soup_connection_request_tls_certificate (conn, connection, task);
                g_object_unref (conn);
        } else {
                g_task_return_int (task, G_TLS_INTERACTION_FAILED);
        }
        g_object_unref (task);
}

static GTlsInteractionResult
soup_tls_interaction_request_certificate_finish (GTlsInteraction *tls_interaction,
                                                 GAsyncResult    *result,
                                                 GError         **error)
{
        int task_result;

        task_result = g_task_propagate_int (G_TASK (result), error);
        return task_result != -1 ? task_result : G_TLS_INTERACTION_FAILED;
}

static void
soup_tls_interaction_ask_password_async (GTlsInteraction    *tls_interaction,
                                         GTlsPassword       *password,
                                         GCancellable       *cancellable,
                                         GAsyncReadyCallback callback,
                                         gpointer            user_data)
{
        SoupTlsInteractionPrivate *priv = soup_tls_interaction_get_instance_private (SOUP_TLS_INTERACTION (tls_interaction));
        GTask *task;
        SoupConnection *conn = g_weak_ref_get (&priv->conn);

        task = g_task_new (tls_interaction, cancellable, callback, user_data);
        g_task_set_source_tag (task, soup_tls_interaction_ask_password_async);
        if (conn) {
                soup_connection_request_tls_certificate_password (conn, password, task);
                g_object_unref (conn);
        } else {
                g_task_return_int (task, G_TLS_INTERACTION_FAILED);
        }
        g_object_unref (task);
}

static GTlsInteractionResult
soup_tls_interaction_ask_password_finish (GTlsInteraction *tls_interaction,
                                          GAsyncResult    *result,
                                          GError         **error)
{
        int task_result;

        task_result = g_task_propagate_int (G_TASK (result), error);
        return task_result != -1 ? task_result : G_TLS_INTERACTION_FAILED;
}

static void
soup_tls_interaction_finalize (GObject *object)
{
        SoupTlsInteractionPrivate *priv = soup_tls_interaction_get_instance_private (SOUP_TLS_INTERACTION (object));

        g_weak_ref_clear (&priv->conn);

        G_OBJECT_CLASS (soup_tls_interaction_parent_class)->finalize (object);
}

static void
soup_tls_interaction_init (SoupTlsInteraction *interaction)
{
        SoupTlsInteractionPrivate *priv = soup_tls_interaction_get_instance_private (interaction);

        g_weak_ref_init (&priv->conn, NULL);
}

static void
soup_tls_interaction_class_init (SoupTlsInteractionClass *klass)
{
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
        GTlsInteractionClass *interaction_class = G_TLS_INTERACTION_CLASS (klass);

        object_class->finalize = soup_tls_interaction_finalize;

        interaction_class->request_certificate_async = soup_tls_interaction_request_certificate_async;
        interaction_class->request_certificate_finish = soup_tls_interaction_request_certificate_finish;
        interaction_class->ask_password_async = soup_tls_interaction_ask_password_async;
        interaction_class->ask_password_finish = soup_tls_interaction_ask_password_finish;
}

GTlsInteraction *
soup_tls_interaction_new (SoupConnection *conn)
{
        GTlsInteraction *interaction;
        SoupTlsInteractionPrivate *priv;

        interaction = g_object_new (SOUP_TYPE_TLS_INTERACTION, NULL);
        priv = soup_tls_interaction_get_instance_private (SOUP_TLS_INTERACTION (interaction));
        g_weak_ref_set (&priv->conn, conn);

        return interaction;
}