tls/tests/mock-interaction.c

   1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /*
   3  * Copyright (C) 2011 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see
  17  * <http://www.gnu.org/licenses/>.
  18  *
  19  * In addition, when the library is used with OpenSSL, a special
  20  * exception applies. Refer to the LICENSE_EXCEPTION file for details.
  21  *
  22  * Author: Stef Walter <stefw@collabora.co.uk>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <gio/gio.h>
  29
  30 #include "mock-interaction.h"
  31
  32 struct _MockInteraction
  33 {
  34   GTlsInteraction parent_instance;
  35
  36   gchar *static_password;
  37   GTlsCertificate *static_certificate;
  38   GError *static_error;
  39 };
  40
  41 G_DEFINE_TYPE (MockInteraction, mock_interaction, G_TYPE_TLS_INTERACTION);
  42
  43 static void
  44 mock_interaction_ask_password_async (GTlsInteraction    *interaction,
  45                                      GTlsPassword       *password,
  46                                      GCancellable       *cancellable,
  47                                      GAsyncReadyCallback callback,
  48                                      gpointer            user_data)
  49 {
  50   MockInteraction *self = MOCK_INTERACTION (interaction);
  51   GTask *task;
  52
  53   task = g_task_new (interaction, cancellable, callback, user_data);
  54   g_task_set_source_tag (task, mock_interaction_ask_password_async);
  55   g_task_set_name (task, "[glib-networking] mock_interaction_ask_password_async");
  56
  57   if (self->static_error)
  58     g_task_return_error (task, g_error_copy (self->static_error));
  59   else
  60     g_tls_password_set_value (password, (const guchar *)self->static_password, -1);
  61   g_task_return_boolean (task, TRUE);
  62   g_object_unref (task);
  63 }
  64
  65 static GTlsInteractionResult
  66 mock_interaction_ask_password_finish (GTlsInteraction    *interaction,
  67                                       GAsyncResult       *result,
  68                                       GError            **error)
  69 {
  70   g_return_val_if_fail (g_task_is_valid (result, interaction),
  71                         G_TLS_INTERACTION_UNHANDLED);
  72   g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == mock_interaction_ask_password_async,
  73                         G_TLS_INTERACTION_UNHANDLED);
  74
  75   if (g_task_had_error (G_TASK (result)))
  76     {
  77       g_task_propagate_boolean (G_TASK (result), error);
  78       return G_TLS_INTERACTION_FAILED;
  79     }
  80   else
  81     return G_TLS_INTERACTION_HANDLED;
  82 }
  83
  84 static GTlsInteractionResult
  85 mock_interaction_ask_password (GTlsInteraction    *interaction,
  86                                GTlsPassword       *password,
  87                                GCancellable       *cancellable,
  88                                GError            **error)
  89 {
  90   MockInteraction *self = MOCK_INTERACTION (interaction);
  91
  92   if (g_cancellable_set_error_if_cancelled (cancellable, error))
  93     return G_TLS_INTERACTION_FAILED;
  94
  95   if (self->static_error)
  96     {
  97       g_propagate_error (error, g_error_copy (self->static_error));
  98       return G_TLS_INTERACTION_FAILED;
  99     }
 100   else
 101     {
 102       g_tls_password_set_value (password, (const guchar *)self->static_password, -1);
 103       return G_TLS_INTERACTION_HANDLED;
 104     }
 105 }
 106
 107 static void
 108 mock_interaction_request_certificate_async (GTlsInteraction            *interaction,
 109                                             GTlsConnection             *connection,
 110                                             GTlsCertificateRequestFlags flags,
 111                                             GCancellable               *cancellable,
 112                                             GAsyncReadyCallback         callback,
 113                                             gpointer                    user_data)
 114 {
 115   MockInteraction *self = MOCK_INTERACTION (interaction);
 116   GTask *task;
 117
 118   task = g_task_new (interaction, cancellable, callback, user_data);
 119   g_task_set_source_tag (task, mock_interaction_request_certificate_async);
 120   g_task_set_name (task, "[glib-networking] mock_interaction_request_certificate_async");
 121
 122   if (self->static_error)
 123     g_task_return_error (task, g_error_copy (self->static_error));
 124   else
 125     {
 126       g_tls_connection_set_certificate (connection, self->static_certificate);
 127       g_task_return_boolean (task, TRUE);
 128     }
 129   g_object_unref (task);
 130 }
 131
 132 static GTlsInteractionResult
 133 mock_interaction_request_certificate_finish (GTlsInteraction    *interaction,
 134                                              GAsyncResult       *result,
 135                                              GError            **error)
 136 {
 137   g_return_val_if_fail (g_task_is_valid (result, interaction),
 138                         G_TLS_INTERACTION_UNHANDLED);
 139   g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == mock_interaction_request_certificate_async,
 140                         G_TLS_INTERACTION_UNHANDLED);
 141
 142   if (!g_task_propagate_boolean (G_TASK (result), error))
 143     return G_TLS_INTERACTION_FAILED;
 144   else
 145     return G_TLS_INTERACTION_HANDLED;
 146 }
 147
 148 static GTlsInteractionResult
 149 mock_interaction_request_certificate (GTlsInteraction            *interaction,
 150                                       GTlsConnection             *connection,
 151                                       GTlsCertificateRequestFlags flags,
 152                                       GCancellable               *cancellable,
 153                                       GError                    **error)
 154 {
 155   MockInteraction *self = MOCK_INTERACTION (interaction);
 156
 157   if (g_cancellable_set_error_if_cancelled (cancellable, error))
 158     return G_TLS_INTERACTION_FAILED;
 159
 160   if (self->static_error)
 161     {
 162       g_propagate_error (error, g_error_copy (self->static_error));
 163       return G_TLS_INTERACTION_FAILED;
 164     }
 165   else
 166     {
 167       g_tls_connection_set_certificate (connection, self->static_certificate);
 168       return G_TLS_INTERACTION_HANDLED;
 169     }
 170 }
 171
 172 static void
 173 mock_interaction_init (MockInteraction *self)
 174 {
 175
 176 }
 177
 178 static void
 179 mock_interaction_finalize (GObject *object)
 180 {
 181   MockInteraction *self = MOCK_INTERACTION (object);
 182
 183   g_free (self->static_password);
 184   g_clear_object (&self->static_certificate);
 185   g_clear_error (&self->static_error);
 186
 187   G_OBJECT_CLASS (mock_interaction_parent_class)->finalize (object);
 188 }
 189
 190 static void
 191 mock_interaction_class_init (MockInteractionClass *klass)
 192 {
 193   GObjectClass         *object_class = G_OBJECT_CLASS (klass);
 194   GTlsInteractionClass *interaction_class = G_TLS_INTERACTION_CLASS (klass);
 195
 196   object_class->finalize     = mock_interaction_finalize;
 197
 198   interaction_class->ask_password = mock_interaction_ask_password;
 199   interaction_class->ask_password_async = mock_interaction_ask_password_async;
 200   interaction_class->ask_password_finish = mock_interaction_ask_password_finish;
 201   interaction_class->request_certificate = mock_interaction_request_certificate;
 202   interaction_class->request_certificate_async = mock_interaction_request_certificate_async;
 203   interaction_class->request_certificate_finish = mock_interaction_request_certificate_finish;
 204 }
 205
 206 GTlsInteraction *
 207 mock_interaction_new_static_password (const gchar *password)
 208 {
 209   MockInteraction *self;
 210
 211   self = g_object_new (MOCK_TYPE_INTERACTION, NULL);
 212
 213   self->static_password = g_strdup (password);
 214   return G_TLS_INTERACTION (self);
 215 }
 216
 217 GTlsInteraction *
 218 mock_interaction_new_static_certificate (GTlsCertificate *cert)
 219 {
 220   MockInteraction *self;
 221
 222   self = g_object_new (MOCK_TYPE_INTERACTION, NULL);
 223
 224   self->static_certificate = cert ? g_object_ref (cert) : NULL;
 225   return G_TLS_INTERACTION (self);
 226 }
 227
 228 GTlsInteraction *
 229 mock_interaction_new_static_error (GQuark domain,
 230                                    gint code,
 231                                    const gchar *message)
 232 {
 233   MockInteraction *self;
 234
 235   self = g_object_new (MOCK_TYPE_INTERACTION, NULL);
 236
 237   self->static_error = g_error_new (domain, code, "%s", message);
 238   return G_TLS_INTERACTION (self);
 239 }