tls/gnutls/gtlsoutputstream-gnutls.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright 2010 Red Hat, Inc.
   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 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
  23 #include "config.h"
  24 #include "gtlsoutputstream-gnutls.h"
  25
  26 static void g_tls_output_stream_gnutls_pollable_iface_init (GPollableOutputStreamInterface *iface);
  27
  28 G_DEFINE_TYPE_WITH_CODE (GTlsOutputStreamGnutls, g_tls_output_stream_gnutls, G_TYPE_OUTPUT_STREAM,
  29                          G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM, g_tls_output_stream_gnutls_pollable_iface_init)
  30                          )
  31
  32 struct _GTlsOutputStreamGnutlsPrivate
  33 {
  34   GWeakRef weak_conn;
  35 };
  36
  37 static void
  38 g_tls_output_stream_gnutls_dispose (GObject *object)
  39 {
  40   GTlsOutputStreamGnutls *stream = G_TLS_OUTPUT_STREAM_GNUTLS (object);
  41
  42   g_weak_ref_set (&stream->priv->weak_conn, NULL);
  43
  44   G_OBJECT_CLASS (g_tls_output_stream_gnutls_parent_class)->dispose (object);
  45 }
  46
  47 static void
  48 g_tls_output_stream_gnutls_finalize (GObject *object)
  49 {
  50   GTlsOutputStreamGnutls *stream = G_TLS_OUTPUT_STREAM_GNUTLS (object);
  51
  52   g_weak_ref_clear (&stream->priv->weak_conn);
  53
  54   G_OBJECT_CLASS (g_tls_output_stream_gnutls_parent_class)->finalize (object);
  55 }
  56
  57 static gssize
  58 g_tls_output_stream_gnutls_write (GOutputStream  *stream,
  59                                   const void     *buffer,
  60                                   gsize           count,
  61                                   GCancellable   *cancellable,
  62                                   GError        **error)
  63 {
  64   GTlsOutputStreamGnutls *tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (stream);
  65   GTlsConnectionGnutls *conn;
  66   gssize ret;
  67
  68   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
  69   g_return_val_if_fail (conn != NULL, -1);
  70
  71   ret = g_tls_connection_gnutls_write (conn, buffer, count, TRUE,
  72                                        cancellable, error);
  73   g_object_unref (conn);
  74   return ret;
  75 }
  76
  77 static gboolean
  78 g_tls_output_stream_gnutls_pollable_is_writable (GPollableOutputStream *pollable)
  79 {
  80   GTlsOutputStreamGnutls *tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (pollable);
  81   GTlsConnectionGnutls *conn;
  82   gboolean ret;
  83
  84   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
  85   g_return_val_if_fail (conn != NULL, FALSE);
  86
  87   ret = g_tls_connection_gnutls_check (conn, G_IO_OUT);
  88
  89   g_object_unref (conn);
  90
  91   return ret;
  92 }
  93
  94 static GSource *
  95 g_tls_output_stream_gnutls_pollable_create_source (GPollableOutputStream *pollable,
  96                                                    GCancellable         *cancellable)
  97 {
  98   GTlsOutputStreamGnutls *tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (pollable);
  99   GTlsConnectionGnutls *conn;
 100   GSource *ret;
 101
 102   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
 103   g_return_val_if_fail (conn != NULL, NULL);
 104
 105   ret = g_tls_connection_gnutls_create_source (conn,
 106                                                G_IO_OUT,
 107                                                cancellable);
 108   g_object_unref (conn);
 109   return ret;
 110 }
 111
 112 static gssize
 113 g_tls_output_stream_gnutls_pollable_write_nonblocking (GPollableOutputStream  *pollable,
 114                                                        const void             *buffer,
 115                                                        gsize                   size,
 116                                                        GError                **error)
 117 {
 118   GTlsOutputStreamGnutls *tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (pollable);
 119   GTlsConnectionGnutls *conn;
 120   gssize ret;
 121
 122   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
 123   g_return_val_if_fail (conn != NULL, -1);
 124
 125   ret = g_tls_connection_gnutls_write (conn, buffer, size, FALSE, NULL, error);
 126
 127   g_object_unref (conn);
 128   return ret;
 129 }
 130
 131 static gboolean
 132 g_tls_output_stream_gnutls_close (GOutputStream            *stream,
 133                                   GCancellable             *cancellable,
 134                                   GError                  **error)
 135 {
 136   GTlsOutputStreamGnutls *tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (stream);
 137   GIOStream *conn;
 138   gboolean ret;
 139
 140   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
 141
 142   /* Special case here because this is called by the finalize
 143    * of the main GTlsConnection object.
 144    */
 145   if (conn == NULL)
 146     return TRUE;
 147
 148   ret = g_tls_connection_gnutls_close_internal (conn, G_TLS_DIRECTION_WRITE,
 149                                                 cancellable, error);
 150
 151   g_object_unref (conn);
 152   return ret;
 153 }
 154
 155 /* We do async close as synchronous-in-a-thread so we don't need to
 156  * implement G_IO_IN/G_IO_OUT flip-flopping just for this one case
 157  * (since handshakes are also done synchronously now).
 158  */
 159 static void
 160 close_thread (GTask        *task,
 161               gpointer      object,
 162               gpointer      task_data,
 163               GCancellable *cancellable)
 164 {
 165   GTlsOutputStreamGnutls *tls_stream = object;
 166   GError *error = NULL;
 167   GIOStream *conn;
 168
 169   conn = g_weak_ref_get (&tls_stream->priv->weak_conn);
 170
 171   if (conn && !g_tls_connection_gnutls_close_internal (conn,
 172                                                        G_TLS_DIRECTION_WRITE,
 173                                                        cancellable, &error))
 174     g_task_return_error (task, error);
 175   else
 176     g_task_return_boolean (task, TRUE);
 177
 178   if (conn)
 179     g_object_unref (conn);
 180 }
 181
 182
 183 static void
 184 g_tls_output_stream_gnutls_close_async (GOutputStream            *stream,
 185                                         int                       io_priority,
 186                                         GCancellable             *cancellable,
 187                                         GAsyncReadyCallback       callback,
 188                                         gpointer                  user_data)
 189 {
 190   GTask *task;
 191
 192   task = g_task_new (stream, cancellable, callback, user_data);
 193   g_task_set_source_tag (task, g_tls_output_stream_gnutls_close_async);
 194   g_task_set_priority (task, io_priority);
 195   g_task_run_in_thread (task, close_thread);
 196   g_object_unref (task);
 197 }
 198
 199 static gboolean
 200 g_tls_output_stream_gnutls_close_finish (GOutputStream            *stream,
 201                                          GAsyncResult             *result,
 202                                          GError                  **error)
 203 {
 204   g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
 205   g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) ==
 206                         g_tls_output_stream_gnutls_close_async, FALSE);
 207
 208   return g_task_propagate_boolean (G_TASK (result), error);
 209 }
 210
 211 static void
 212 g_tls_output_stream_gnutls_class_init (GTlsOutputStreamGnutlsClass *klass)
 213 {
 214   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 215   GOutputStreamClass *output_stream_class = G_OUTPUT_STREAM_CLASS (klass);
 216
 217   g_type_class_add_private (klass, sizeof (GTlsOutputStreamGnutlsPrivate));
 218
 219   gobject_class->dispose = g_tls_output_stream_gnutls_dispose;
 220   gobject_class->finalize = g_tls_output_stream_gnutls_finalize;
 221
 222   output_stream_class->write_fn = g_tls_output_stream_gnutls_write;
 223   output_stream_class->close_fn = g_tls_output_stream_gnutls_close;
 224   output_stream_class->close_async = g_tls_output_stream_gnutls_close_async;
 225   output_stream_class->close_finish = g_tls_output_stream_gnutls_close_finish;
 226 }
 227
 228 static void
 229 g_tls_output_stream_gnutls_pollable_iface_init (GPollableOutputStreamInterface *iface)
 230 {
 231   iface->is_writable = g_tls_output_stream_gnutls_pollable_is_writable;
 232   iface->create_source = g_tls_output_stream_gnutls_pollable_create_source;
 233   iface->write_nonblocking = g_tls_output_stream_gnutls_pollable_write_nonblocking;
 234 }
 235
 236 static void
 237 g_tls_output_stream_gnutls_init (GTlsOutputStreamGnutls *stream)
 238 {
 239   stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, G_TYPE_TLS_OUTPUT_STREAM_GNUTLS, GTlsOutputStreamGnutlsPrivate);
 240 }
 241
 242 GOutputStream *
 243 g_tls_output_stream_gnutls_new (GTlsConnectionGnutls *conn)
 244 {
 245   GTlsOutputStreamGnutls *tls_stream;
 246
 247   tls_stream = g_object_new (G_TYPE_TLS_OUTPUT_STREAM_GNUTLS, NULL);
 248   g_weak_ref_init (&tls_stream->priv->weak_conn, conn);
 249
 250   return G_OUTPUT_STREAM (tls_stream);
 251 }