1 | /* GIO - GLib Input, Output and Streaming Library |
2 | * |
3 | * Copyright (C) 2006-2007 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.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 <http://www.gnu.org/licenses/>. |
17 | * |
18 | * Author: Alexander Larsson <alexl@redhat.com> |
19 | */ |
20 | |
21 | #include "config.h" |
22 | |
23 | #include <unistd.h> |
24 | #include <errno.h> |
25 | #include <stdio.h> |
26 | |
27 | #include <glib.h> |
28 | #include <glib/gstdio.h> |
29 | #include <glib/glib-unix.h> |
30 | #include "gioerror.h" |
31 | #include "gunixinputstream.h" |
32 | #include "gcancellable.h" |
33 | #include "gasynchelper.h" |
34 | #include "gfiledescriptorbased.h" |
35 | #include "glibintl.h" |
36 | #include "giounix-private.h" |
37 | |
38 | |
39 | /** |
40 | * SECTION:gunixinputstream |
41 | * @short_description: Streaming input operations for UNIX file descriptors |
42 | * @include: gio/gunixinputstream.h |
43 | * @see_also: #GInputStream |
44 | * |
45 | * #GUnixInputStream implements #GInputStream for reading from a UNIX |
46 | * file descriptor, including asynchronous operations. (If the file |
47 | * descriptor refers to a socket or pipe, this will use poll() to do |
48 | * asynchronous I/O. If it refers to a regular file, it will fall back |
49 | * to doing asynchronous I/O in another thread.) |
50 | * |
51 | * Note that `<gio/gunixinputstream.h>` belongs to the UNIX-specific GIO |
52 | * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config |
53 | * file when using it. |
54 | */ |
55 | |
56 | enum { |
57 | PROP_0, |
58 | PROP_FD, |
59 | PROP_CLOSE_FD |
60 | }; |
61 | |
62 | struct _GUnixInputStreamPrivate { |
63 | int fd; |
64 | guint close_fd : 1; |
65 | guint can_poll : 1; |
66 | }; |
67 | |
68 | static void g_unix_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface); |
69 | static void g_unix_input_stream_file_descriptor_based_iface_init (GFileDescriptorBasedIface *iface); |
70 | |
71 | G_DEFINE_TYPE_WITH_CODE (GUnixInputStream, g_unix_input_stream, G_TYPE_INPUT_STREAM, |
72 | G_ADD_PRIVATE (GUnixInputStream) |
73 | G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_INPUT_STREAM, |
74 | g_unix_input_stream_pollable_iface_init) |
75 | G_IMPLEMENT_INTERFACE (G_TYPE_FILE_DESCRIPTOR_BASED, |
76 | g_unix_input_stream_file_descriptor_based_iface_init) |
77 | ) |
78 | |
79 | static void g_unix_input_stream_set_property (GObject *object, |
80 | guint prop_id, |
81 | const GValue *value, |
82 | GParamSpec *pspec); |
83 | static void g_unix_input_stream_get_property (GObject *object, |
84 | guint prop_id, |
85 | GValue *value, |
86 | GParamSpec *pspec); |
87 | static gssize g_unix_input_stream_read (GInputStream *stream, |
88 | void *buffer, |
89 | gsize count, |
90 | GCancellable *cancellable, |
91 | GError **error); |
92 | static gboolean g_unix_input_stream_close (GInputStream *stream, |
93 | GCancellable *cancellable, |
94 | GError **error); |
95 | static void g_unix_input_stream_skip_async (GInputStream *stream, |
96 | gsize count, |
97 | int io_priority, |
98 | GCancellable *cancellable, |
99 | GAsyncReadyCallback callback, |
100 | gpointer data); |
101 | static gssize g_unix_input_stream_skip_finish (GInputStream *stream, |
102 | GAsyncResult *result, |
103 | GError **error); |
104 | |
105 | static gboolean g_unix_input_stream_pollable_can_poll (GPollableInputStream *stream); |
106 | static gboolean g_unix_input_stream_pollable_is_readable (GPollableInputStream *stream); |
107 | static GSource *g_unix_input_stream_pollable_create_source (GPollableInputStream *stream, |
108 | GCancellable *cancellable); |
109 | |
110 | static void |
111 | g_unix_input_stream_class_init (GUnixInputStreamClass *klass) |
112 | { |
113 | GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
114 | GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass); |
115 | |
116 | gobject_class->get_property = g_unix_input_stream_get_property; |
117 | gobject_class->set_property = g_unix_input_stream_set_property; |
118 | |
119 | stream_class->read_fn = g_unix_input_stream_read; |
120 | stream_class->close_fn = g_unix_input_stream_close; |
121 | if (0) |
122 | { |
123 | /* TODO: Implement instead of using fallbacks */ |
124 | stream_class->skip_async = g_unix_input_stream_skip_async; |
125 | stream_class->skip_finish = g_unix_input_stream_skip_finish; |
126 | } |
127 | |
128 | /** |
129 | * GUnixInputStream:fd: |
130 | * |
131 | * The file descriptor that the stream reads from. |
132 | * |
133 | * Since: 2.20 |
134 | */ |
135 | g_object_class_install_property (oclass: gobject_class, |
136 | property_id: PROP_FD, |
137 | pspec: g_param_spec_int (name: "fd" , |
138 | P_("File descriptor" ), |
139 | P_("The file descriptor to read from" ), |
140 | G_MININT, G_MAXINT, default_value: -1, |
141 | flags: G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); |
142 | |
143 | /** |
144 | * GUnixInputStream:close-fd: |
145 | * |
146 | * Whether to close the file descriptor when the stream is closed. |
147 | * |
148 | * Since: 2.20 |
149 | */ |
150 | g_object_class_install_property (oclass: gobject_class, |
151 | property_id: PROP_CLOSE_FD, |
152 | pspec: g_param_spec_boolean (name: "close-fd" , |
153 | P_("Close file descriptor" ), |
154 | P_("Whether to close the file descriptor when the stream is closed" ), |
155 | TRUE, |
156 | flags: G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); |
157 | } |
158 | |
159 | static void |
160 | g_unix_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface) |
161 | { |
162 | iface->can_poll = g_unix_input_stream_pollable_can_poll; |
163 | iface->is_readable = g_unix_input_stream_pollable_is_readable; |
164 | iface->create_source = g_unix_input_stream_pollable_create_source; |
165 | } |
166 | |
167 | static void |
168 | g_unix_input_stream_file_descriptor_based_iface_init (GFileDescriptorBasedIface *iface) |
169 | { |
170 | iface->get_fd = (int (*) (GFileDescriptorBased *))g_unix_input_stream_get_fd; |
171 | } |
172 | |
173 | static void |
174 | g_unix_input_stream_set_property (GObject *object, |
175 | guint prop_id, |
176 | const GValue *value, |
177 | GParamSpec *pspec) |
178 | { |
179 | GUnixInputStream *unix_stream; |
180 | |
181 | unix_stream = G_UNIX_INPUT_STREAM (object); |
182 | |
183 | switch (prop_id) |
184 | { |
185 | case PROP_FD: |
186 | unix_stream->priv->fd = g_value_get_int (value); |
187 | unix_stream->priv->can_poll = _g_fd_is_pollable (fd: unix_stream->priv->fd); |
188 | break; |
189 | case PROP_CLOSE_FD: |
190 | unix_stream->priv->close_fd = g_value_get_boolean (value); |
191 | break; |
192 | default: |
193 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
194 | break; |
195 | } |
196 | } |
197 | |
198 | static void |
199 | g_unix_input_stream_get_property (GObject *object, |
200 | guint prop_id, |
201 | GValue *value, |
202 | GParamSpec *pspec) |
203 | { |
204 | GUnixInputStream *unix_stream; |
205 | |
206 | unix_stream = G_UNIX_INPUT_STREAM (object); |
207 | |
208 | switch (prop_id) |
209 | { |
210 | case PROP_FD: |
211 | g_value_set_int (value, v_int: unix_stream->priv->fd); |
212 | break; |
213 | case PROP_CLOSE_FD: |
214 | g_value_set_boolean (value, v_boolean: unix_stream->priv->close_fd); |
215 | break; |
216 | default: |
217 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
218 | } |
219 | } |
220 | |
221 | static void |
222 | g_unix_input_stream_init (GUnixInputStream *unix_stream) |
223 | { |
224 | unix_stream->priv = g_unix_input_stream_get_instance_private (self: unix_stream); |
225 | unix_stream->priv->fd = -1; |
226 | unix_stream->priv->close_fd = TRUE; |
227 | } |
228 | |
229 | /** |
230 | * g_unix_input_stream_new: |
231 | * @fd: a UNIX file descriptor |
232 | * @close_fd: %TRUE to close the file descriptor when done |
233 | * |
234 | * Creates a new #GUnixInputStream for the given @fd. |
235 | * |
236 | * If @close_fd is %TRUE, the file descriptor will be closed |
237 | * when the stream is closed. |
238 | * |
239 | * Returns: a new #GUnixInputStream |
240 | **/ |
241 | GInputStream * |
242 | g_unix_input_stream_new (gint fd, |
243 | gboolean close_fd) |
244 | { |
245 | GUnixInputStream *stream; |
246 | |
247 | g_return_val_if_fail (fd != -1, NULL); |
248 | |
249 | stream = g_object_new (G_TYPE_UNIX_INPUT_STREAM, |
250 | first_property_name: "fd" , fd, |
251 | "close-fd" , close_fd, |
252 | NULL); |
253 | |
254 | return G_INPUT_STREAM (stream); |
255 | } |
256 | |
257 | /** |
258 | * g_unix_input_stream_set_close_fd: |
259 | * @stream: a #GUnixInputStream |
260 | * @close_fd: %TRUE to close the file descriptor when done |
261 | * |
262 | * Sets whether the file descriptor of @stream shall be closed |
263 | * when the stream is closed. |
264 | * |
265 | * Since: 2.20 |
266 | */ |
267 | void |
268 | g_unix_input_stream_set_close_fd (GUnixInputStream *stream, |
269 | gboolean close_fd) |
270 | { |
271 | g_return_if_fail (G_IS_UNIX_INPUT_STREAM (stream)); |
272 | |
273 | close_fd = close_fd != FALSE; |
274 | if (stream->priv->close_fd != close_fd) |
275 | { |
276 | stream->priv->close_fd = close_fd; |
277 | g_object_notify (G_OBJECT (stream), property_name: "close-fd" ); |
278 | } |
279 | } |
280 | |
281 | /** |
282 | * g_unix_input_stream_get_close_fd: |
283 | * @stream: a #GUnixInputStream |
284 | * |
285 | * Returns whether the file descriptor of @stream will be |
286 | * closed when the stream is closed. |
287 | * |
288 | * Returns: %TRUE if the file descriptor is closed when done |
289 | * |
290 | * Since: 2.20 |
291 | */ |
292 | gboolean |
293 | g_unix_input_stream_get_close_fd (GUnixInputStream *stream) |
294 | { |
295 | g_return_val_if_fail (G_IS_UNIX_INPUT_STREAM (stream), FALSE); |
296 | |
297 | return stream->priv->close_fd; |
298 | } |
299 | |
300 | /** |
301 | * g_unix_input_stream_get_fd: |
302 | * @stream: a #GUnixInputStream |
303 | * |
304 | * Return the UNIX file descriptor that the stream reads from. |
305 | * |
306 | * Returns: The file descriptor of @stream |
307 | * |
308 | * Since: 2.20 |
309 | */ |
310 | gint |
311 | g_unix_input_stream_get_fd (GUnixInputStream *stream) |
312 | { |
313 | g_return_val_if_fail (G_IS_UNIX_INPUT_STREAM (stream), -1); |
314 | |
315 | return stream->priv->fd; |
316 | } |
317 | |
318 | static gssize |
319 | g_unix_input_stream_read (GInputStream *stream, |
320 | void *buffer, |
321 | gsize count, |
322 | GCancellable *cancellable, |
323 | GError **error) |
324 | { |
325 | GUnixInputStream *unix_stream; |
326 | gssize res = -1; |
327 | GPollFD poll_fds[2]; |
328 | int nfds; |
329 | int poll_ret; |
330 | |
331 | unix_stream = G_UNIX_INPUT_STREAM (stream); |
332 | |
333 | poll_fds[0].fd = unix_stream->priv->fd; |
334 | poll_fds[0].events = G_IO_IN; |
335 | if (unix_stream->priv->can_poll && |
336 | g_cancellable_make_pollfd (cancellable, pollfd: &poll_fds[1])) |
337 | nfds = 2; |
338 | else |
339 | nfds = 1; |
340 | |
341 | while (1) |
342 | { |
343 | int errsv; |
344 | |
345 | poll_fds[0].revents = poll_fds[1].revents = 0; |
346 | do |
347 | { |
348 | poll_ret = g_poll (fds: poll_fds, nfds, timeout: -1); |
349 | errsv = errno; |
350 | } |
351 | while (poll_ret == -1 && errsv == EINTR); |
352 | |
353 | if (poll_ret == -1) |
354 | { |
355 | g_set_error (err: error, G_IO_ERROR, |
356 | code: g_io_error_from_errno (err_no: errsv), |
357 | _("Error reading from file descriptor: %s" ), |
358 | g_strerror (errnum: errsv)); |
359 | break; |
360 | } |
361 | |
362 | if (g_cancellable_set_error_if_cancelled (cancellable, error)) |
363 | break; |
364 | |
365 | if (!poll_fds[0].revents) |
366 | continue; |
367 | |
368 | res = read (fd: unix_stream->priv->fd, buf: buffer, nbytes: count); |
369 | if (res == -1) |
370 | { |
371 | int errsv = errno; |
372 | |
373 | if (errsv == EINTR || errsv == EAGAIN) |
374 | continue; |
375 | |
376 | g_set_error (err: error, G_IO_ERROR, |
377 | code: g_io_error_from_errno (err_no: errsv), |
378 | _("Error reading from file descriptor: %s" ), |
379 | g_strerror (errnum: errsv)); |
380 | } |
381 | |
382 | break; |
383 | } |
384 | |
385 | if (nfds == 2) |
386 | g_cancellable_release_fd (cancellable); |
387 | return res; |
388 | } |
389 | |
390 | static gboolean |
391 | g_unix_input_stream_close (GInputStream *stream, |
392 | GCancellable *cancellable, |
393 | GError **error) |
394 | { |
395 | GUnixInputStream *unix_stream; |
396 | int res; |
397 | |
398 | unix_stream = G_UNIX_INPUT_STREAM (stream); |
399 | |
400 | if (!unix_stream->priv->close_fd) |
401 | return TRUE; |
402 | |
403 | /* This might block during the close. Doesn't seem to be a way to avoid it though. */ |
404 | res = close (fd: unix_stream->priv->fd); |
405 | if (res == -1) |
406 | { |
407 | int errsv = errno; |
408 | |
409 | g_set_error (err: error, G_IO_ERROR, |
410 | code: g_io_error_from_errno (err_no: errsv), |
411 | _("Error closing file descriptor: %s" ), |
412 | g_strerror (errnum: errsv)); |
413 | } |
414 | |
415 | return res != -1; |
416 | } |
417 | |
418 | static void |
419 | g_unix_input_stream_skip_async (GInputStream *stream, |
420 | gsize count, |
421 | int io_priority, |
422 | GCancellable *cancellable, |
423 | GAsyncReadyCallback callback, |
424 | gpointer data) |
425 | { |
426 | g_warn_if_reached (); |
427 | /* TODO: Not implemented */ |
428 | } |
429 | |
430 | static gssize |
431 | g_unix_input_stream_skip_finish (GInputStream *stream, |
432 | GAsyncResult *result, |
433 | GError **error) |
434 | { |
435 | g_warn_if_reached (); |
436 | return 0; |
437 | /* TODO: Not implemented */ |
438 | } |
439 | |
440 | static gboolean |
441 | g_unix_input_stream_pollable_can_poll (GPollableInputStream *stream) |
442 | { |
443 | return G_UNIX_INPUT_STREAM (stream)->priv->can_poll; |
444 | } |
445 | |
446 | static gboolean |
447 | g_unix_input_stream_pollable_is_readable (GPollableInputStream *stream) |
448 | { |
449 | GUnixInputStream *unix_stream = G_UNIX_INPUT_STREAM (stream); |
450 | GPollFD poll_fd; |
451 | gint result; |
452 | |
453 | poll_fd.fd = unix_stream->priv->fd; |
454 | poll_fd.events = G_IO_IN; |
455 | poll_fd.revents = 0; |
456 | |
457 | do |
458 | result = g_poll (fds: &poll_fd, nfds: 1, timeout: 0); |
459 | while (result == -1 && errno == EINTR); |
460 | |
461 | return poll_fd.revents != 0; |
462 | } |
463 | |
464 | static GSource * |
465 | g_unix_input_stream_pollable_create_source (GPollableInputStream *stream, |
466 | GCancellable *cancellable) |
467 | { |
468 | GUnixInputStream *unix_stream = G_UNIX_INPUT_STREAM (stream); |
469 | GSource *inner_source, *cancellable_source, *pollable_source; |
470 | |
471 | pollable_source = g_pollable_source_new (G_OBJECT (stream)); |
472 | |
473 | inner_source = g_unix_fd_source_new (fd: unix_stream->priv->fd, condition: G_IO_IN); |
474 | g_source_set_dummy_callback (source: inner_source); |
475 | g_source_add_child_source (source: pollable_source, child_source: inner_source); |
476 | g_source_unref (source: inner_source); |
477 | |
478 | if (cancellable) |
479 | { |
480 | cancellable_source = g_cancellable_source_new (cancellable); |
481 | g_source_set_dummy_callback (source: cancellable_source); |
482 | g_source_add_child_source (source: pollable_source, child_source: cancellable_source); |
483 | g_source_unref (source: cancellable_source); |
484 | } |
485 | |
486 | return pollable_source; |
487 | } |
488 | |