1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /*
3 * GIO - GLib Input, Output and Streaming Library
4 *
5 * Copyright 2010 Red Hat, Inc
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see
19 * <http://www.gnu.org/licenses/>.
20 *
21 * In addition, when the library is used with OpenSSL, a special
22 * exception applies. Refer to the LICENSE_EXCEPTION file for details.
23 */
24
25 #include "config.h"
26 #include "gtlsoutputstream.h"
27
28 #include <glib/gi18n-lib.h>
29
30 struct _GTlsOutputStream
31 {
32 GOutputStream parent_instance;
33
34 GWeakRef weak_conn;
35 };
36
37 static void g_tls_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface);
38
G_DEFINE_TYPE_WITH_CODE(GTlsOutputStream,g_tls_output_stream,G_TYPE_OUTPUT_STREAM,G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM,g_tls_output_stream_pollable_iface_init))39 G_DEFINE_TYPE_WITH_CODE (GTlsOutputStream, g_tls_output_stream, G_TYPE_OUTPUT_STREAM,
40 G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM, g_tls_output_stream_pollable_iface_init)
41 )
42
43 static void
44 g_tls_output_stream_dispose (GObject *object)
45 {
46 GTlsOutputStream *stream = G_TLS_OUTPUT_STREAM (object);
47
48 g_weak_ref_set (&stream->weak_conn, NULL);
49
50 G_OBJECT_CLASS (g_tls_output_stream_parent_class)->dispose (object);
51 }
52
53 static void
g_tls_output_stream_finalize(GObject * object)54 g_tls_output_stream_finalize (GObject *object)
55 {
56 GTlsOutputStream *stream = G_TLS_OUTPUT_STREAM (object);
57
58 g_weak_ref_clear (&stream->weak_conn);
59
60 G_OBJECT_CLASS (g_tls_output_stream_parent_class)->finalize (object);
61 }
62
63 static gssize
g_tls_output_stream_write(GOutputStream * stream,const void * buffer,gsize count,GCancellable * cancellable,GError ** error)64 g_tls_output_stream_write (GOutputStream *stream,
65 const void *buffer,
66 gsize count,
67 GCancellable *cancellable,
68 GError **error)
69 {
70 GTlsOutputStream *tls_stream = G_TLS_OUTPUT_STREAM (stream);
71 GTlsConnectionBase *conn;
72 gssize ret;
73
74 conn = g_weak_ref_get (&tls_stream->weak_conn);
75 if (!conn)
76 {
77 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
78 _("Connection is closed"));
79 return -1;
80 }
81
82 ret = g_tls_connection_base_write (conn, buffer, count, -1 /* blocking */,
83 cancellable, error);
84 g_object_unref (conn);
85 return ret;
86 }
87
88 static gboolean
g_tls_output_stream_pollable_is_writable(GPollableOutputStream * pollable)89 g_tls_output_stream_pollable_is_writable (GPollableOutputStream *pollable)
90 {
91 GTlsOutputStream *tls_stream = G_TLS_OUTPUT_STREAM (pollable);
92 GTlsConnectionBase *conn;
93 gboolean ret;
94
95 conn = g_weak_ref_get (&tls_stream->weak_conn);
96 if (!conn)
97 return FALSE;
98
99 ret = g_tls_connection_base_check (conn, G_IO_OUT);
100
101 g_object_unref (conn);
102
103 return ret;
104 }
105
106 static GSource *
g_tls_output_stream_pollable_create_source(GPollableOutputStream * pollable,GCancellable * cancellable)107 g_tls_output_stream_pollable_create_source (GPollableOutputStream *pollable,
108 GCancellable *cancellable)
109 {
110 GTlsOutputStream *tls_stream = G_TLS_OUTPUT_STREAM (pollable);
111 GTlsConnectionBase *conn;
112 GSource *ret;
113
114 conn = g_weak_ref_get (&tls_stream->weak_conn);
115 if (!conn)
116 {
117 ret = g_idle_source_new ();
118 g_source_set_name (ret, "[glib-networking] g_tls_output_stream_pollable_create_source dummy source");
119 return ret;
120 }
121
122 ret = g_tls_connection_base_create_source (conn,
123 G_IO_OUT,
124 cancellable);
125 g_object_unref (conn);
126 return ret;
127 }
128
129 static gssize
g_tls_output_stream_pollable_write_nonblocking(GPollableOutputStream * pollable,const void * buffer,gsize size,GError ** error)130 g_tls_output_stream_pollable_write_nonblocking (GPollableOutputStream *pollable,
131 const void *buffer,
132 gsize size,
133 GError **error)
134 {
135 GTlsOutputStream *tls_stream = G_TLS_OUTPUT_STREAM (pollable);
136 GTlsConnectionBase *conn;
137 gssize ret;
138
139 conn = g_weak_ref_get (&tls_stream->weak_conn);
140 if (!conn)
141 {
142 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
143 _("Connection is closed"));
144 return -1;
145 }
146
147 ret = g_tls_connection_base_write (conn, buffer, size,
148 0 /* non-blocking */, NULL, error);
149
150 g_object_unref (conn);
151 return ret;
152 }
153
154 static gboolean
g_tls_output_stream_close(GOutputStream * stream,GCancellable * cancellable,GError ** error)155 g_tls_output_stream_close (GOutputStream *stream,
156 GCancellable *cancellable,
157 GError **error)
158 {
159 GTlsOutputStream *tls_stream = G_TLS_OUTPUT_STREAM (stream);
160 GIOStream *conn;
161 gboolean ret;
162
163 conn = g_weak_ref_get (&tls_stream->weak_conn);
164
165 if (!conn)
166 return TRUE;
167
168 ret = g_tls_connection_base_close_internal (conn, G_TLS_DIRECTION_WRITE,
169 -1, /* blocking */
170 cancellable, error);
171
172 g_object_unref (conn);
173 return ret;
174 }
175
176 /* We do async close as synchronous-in-a-thread so we don't need to
177 * implement G_IO_IN/G_IO_OUT flip-flopping just for this one case
178 * (since handshakes are also done synchronously now).
179 */
180 static void
close_thread(GTask * task,gpointer object,gpointer task_data,GCancellable * cancellable)181 close_thread (GTask *task,
182 gpointer object,
183 gpointer task_data,
184 GCancellable *cancellable)
185 {
186 GTlsOutputStream *tls_stream = object;
187 GError *error = NULL;
188 GIOStream *conn;
189
190 conn = g_weak_ref_get (&tls_stream->weak_conn);
191
192 if (conn && !g_tls_connection_base_close_internal (conn,
193 G_TLS_DIRECTION_WRITE,
194 -1, /* blocking */
195 cancellable, &error))
196 g_task_return_error (task, error);
197 else
198 g_task_return_boolean (task, TRUE);
199
200 if (conn)
201 g_object_unref (conn);
202 }
203
204
205 static void
g_tls_output_stream_close_async(GOutputStream * stream,int io_priority,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)206 g_tls_output_stream_close_async (GOutputStream *stream,
207 int io_priority,
208 GCancellable *cancellable,
209 GAsyncReadyCallback callback,
210 gpointer user_data)
211 {
212 GTask *task;
213
214 task = g_task_new (stream, cancellable, callback, user_data);
215 g_task_set_source_tag (task, g_tls_output_stream_close_async);
216 g_task_set_name (task, "[glib-networking] g_tls_output_stream_close_async");
217 g_task_set_priority (task, io_priority);
218 g_task_run_in_thread (task, close_thread);
219 g_object_unref (task);
220 }
221
222 static gboolean
g_tls_output_stream_close_finish(GOutputStream * stream,GAsyncResult * result,GError ** error)223 g_tls_output_stream_close_finish (GOutputStream *stream,
224 GAsyncResult *result,
225 GError **error)
226 {
227 g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
228 g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == g_tls_output_stream_close_async, FALSE);
229
230 return g_task_propagate_boolean (G_TASK (result), error);
231 }
232
233 static void
g_tls_output_stream_class_init(GTlsOutputStreamClass * klass)234 g_tls_output_stream_class_init (GTlsOutputStreamClass *klass)
235 {
236 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
237 GOutputStreamClass *output_stream_class = G_OUTPUT_STREAM_CLASS (klass);
238
239 gobject_class->dispose = g_tls_output_stream_dispose;
240 gobject_class->finalize = g_tls_output_stream_finalize;
241
242 output_stream_class->write_fn = g_tls_output_stream_write;
243 output_stream_class->close_fn = g_tls_output_stream_close;
244 output_stream_class->close_async = g_tls_output_stream_close_async;
245 output_stream_class->close_finish = g_tls_output_stream_close_finish;
246 }
247
248 static void
g_tls_output_stream_pollable_iface_init(GPollableOutputStreamInterface * iface)249 g_tls_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface)
250 {
251 iface->is_writable = g_tls_output_stream_pollable_is_writable;
252 iface->create_source = g_tls_output_stream_pollable_create_source;
253 iface->write_nonblocking = g_tls_output_stream_pollable_write_nonblocking;
254 }
255
256 static void
g_tls_output_stream_init(GTlsOutputStream * stream)257 g_tls_output_stream_init (GTlsOutputStream *stream)
258 {
259 }
260
261 GOutputStream *
g_tls_output_stream_new(GTlsConnectionBase * conn)262 g_tls_output_stream_new (GTlsConnectionBase *conn)
263 {
264 GTlsOutputStream *tls_stream;
265
266 tls_stream = g_object_new (G_TYPE_TLS_OUTPUT_STREAM, NULL);
267 g_weak_ref_init (&tls_stream->weak_conn, conn);
268
269 return G_OUTPUT_STREAM (tls_stream);
270 }
271