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