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 | #include <sys/uio.h> |
27 | |
28 | #include <glib.h> |
29 | #include <glib/gstdio.h> |
30 | #include <glib/glib-unix.h> |
31 | #include "gioerror.h" |
32 | #include "gunixoutputstream.h" |
33 | #include "gcancellable.h" |
34 | #include "gasynchelper.h" |
35 | #include "gfiledescriptorbased.h" |
36 | #include "glibintl.h" |
37 | #include "gioprivate.h" |
38 | #include "giounix-private.h" |
39 | |
40 | |
41 | /** |
42 | * SECTION:gunixoutputstream |
43 | * @short_description: Streaming output operations for UNIX file descriptors |
44 | * @include: gio/gunixoutputstream.h |
45 | * @see_also: #GOutputStream |
46 | * |
47 | * #GUnixOutputStream implements #GOutputStream for writing to a UNIX |
48 | * file descriptor, including asynchronous operations. (If the file |
49 | * descriptor refers to a socket or pipe, this will use poll() to do |
50 | * asynchronous I/O. If it refers to a regular file, it will fall back |
51 | * to doing asynchronous I/O in another thread.) |
52 | * |
53 | * Note that `<gio/gunixoutputstream.h>` belongs to the UNIX-specific GIO |
54 | * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file |
55 | * when using it. |
56 | */ |
57 | |
58 | enum { |
59 | PROP_0, |
60 | PROP_FD, |
61 | PROP_CLOSE_FD |
62 | }; |
63 | |
64 | struct _GUnixOutputStreamPrivate { |
65 | int fd; |
66 | guint close_fd : 1; |
67 | guint can_poll : 1; |
68 | }; |
69 | |
70 | static void g_unix_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface); |
71 | static void g_unix_output_stream_file_descriptor_based_iface_init (GFileDescriptorBasedIface *iface); |
72 | |
73 | G_DEFINE_TYPE_WITH_CODE (GUnixOutputStream, g_unix_output_stream, G_TYPE_OUTPUT_STREAM, |
74 | G_ADD_PRIVATE (GUnixOutputStream) |
75 | G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM, |
76 | g_unix_output_stream_pollable_iface_init) |
77 | G_IMPLEMENT_INTERFACE (G_TYPE_FILE_DESCRIPTOR_BASED, |
78 | g_unix_output_stream_file_descriptor_based_iface_init) |
79 | ) |
80 | |
81 | static void g_unix_output_stream_set_property (GObject *object, |
82 | guint prop_id, |
83 | const GValue *value, |
84 | GParamSpec *pspec); |
85 | static void g_unix_output_stream_get_property (GObject *object, |
86 | guint prop_id, |
87 | GValue *value, |
88 | GParamSpec *pspec); |
89 | static gssize g_unix_output_stream_write (GOutputStream *stream, |
90 | const void *buffer, |
91 | gsize count, |
92 | GCancellable *cancellable, |
93 | GError **error); |
94 | static gboolean g_unix_output_stream_writev (GOutputStream *stream, |
95 | const GOutputVector *vectors, |
96 | gsize n_vectors, |
97 | gsize *bytes_written, |
98 | GCancellable *cancellable, |
99 | GError **error); |
100 | static gboolean g_unix_output_stream_close (GOutputStream *stream, |
101 | GCancellable *cancellable, |
102 | GError **error); |
103 | |
104 | static gboolean g_unix_output_stream_pollable_can_poll (GPollableOutputStream *stream); |
105 | static gboolean g_unix_output_stream_pollable_is_writable (GPollableOutputStream *stream); |
106 | static GSource *g_unix_output_stream_pollable_create_source (GPollableOutputStream *stream, |
107 | GCancellable *cancellable); |
108 | static GPollableReturn g_unix_output_stream_pollable_writev_nonblocking (GPollableOutputStream *stream, |
109 | const GOutputVector *vectors, |
110 | gsize n_vectors, |
111 | gsize *bytes_written, |
112 | GError **error); |
113 | |
114 | static void |
115 | g_unix_output_stream_class_init (GUnixOutputStreamClass *klass) |
116 | { |
117 | GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
118 | GOutputStreamClass *stream_class = G_OUTPUT_STREAM_CLASS (klass); |
119 | |
120 | gobject_class->get_property = g_unix_output_stream_get_property; |
121 | gobject_class->set_property = g_unix_output_stream_set_property; |
122 | |
123 | stream_class->write_fn = g_unix_output_stream_write; |
124 | stream_class->writev_fn = g_unix_output_stream_writev; |
125 | stream_class->close_fn = g_unix_output_stream_close; |
126 | |
127 | /** |
128 | * GUnixOutputStream:fd: |
129 | * |
130 | * The file descriptor that the stream writes to. |
131 | * |
132 | * Since: 2.20 |
133 | */ |
134 | g_object_class_install_property (oclass: gobject_class, |
135 | property_id: PROP_FD, |
136 | pspec: g_param_spec_int (name: "fd" , |
137 | P_("File descriptor" ), |
138 | P_("The file descriptor to write to" ), |
139 | G_MININT, G_MAXINT, default_value: -1, |
140 | flags: G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); |
141 | |
142 | /** |
143 | * GUnixOutputStream:close-fd: |
144 | * |
145 | * Whether to close the file descriptor when the stream is closed. |
146 | * |
147 | * Since: 2.20 |
148 | */ |
149 | g_object_class_install_property (oclass: gobject_class, |
150 | property_id: PROP_CLOSE_FD, |
151 | pspec: g_param_spec_boolean (name: "close-fd" , |
152 | P_("Close file descriptor" ), |
153 | P_("Whether to close the file descriptor when the stream is closed" ), |
154 | TRUE, |
155 | flags: G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); |
156 | } |
157 | |
158 | static void |
159 | g_unix_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface) |
160 | { |
161 | iface->can_poll = g_unix_output_stream_pollable_can_poll; |
162 | iface->is_writable = g_unix_output_stream_pollable_is_writable; |
163 | iface->create_source = g_unix_output_stream_pollable_create_source; |
164 | iface->writev_nonblocking = g_unix_output_stream_pollable_writev_nonblocking; |
165 | } |
166 | |
167 | static void |
168 | g_unix_output_stream_file_descriptor_based_iface_init (GFileDescriptorBasedIface *iface) |
169 | { |
170 | iface->get_fd = (int (*) (GFileDescriptorBased *))g_unix_output_stream_get_fd; |
171 | } |
172 | |
173 | static void |
174 | g_unix_output_stream_set_property (GObject *object, |
175 | guint prop_id, |
176 | const GValue *value, |
177 | GParamSpec *pspec) |
178 | { |
179 | GUnixOutputStream *unix_stream; |
180 | |
181 | unix_stream = G_UNIX_OUTPUT_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_output_stream_get_property (GObject *object, |
200 | guint prop_id, |
201 | GValue *value, |
202 | GParamSpec *pspec) |
203 | { |
204 | GUnixOutputStream *unix_stream; |
205 | |
206 | unix_stream = G_UNIX_OUTPUT_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_output_stream_init (GUnixOutputStream *unix_stream) |
223 | { |
224 | unix_stream->priv = g_unix_output_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_output_stream_new: |
231 | * @fd: a UNIX file descriptor |
232 | * @close_fd: %TRUE to close the file descriptor when done |
233 | * |
234 | * Creates a new #GUnixOutputStream for the given @fd. |
235 | * |
236 | * If @close_fd, is %TRUE, the file descriptor will be closed when |
237 | * the output stream is destroyed. |
238 | * |
239 | * Returns: a new #GOutputStream |
240 | **/ |
241 | GOutputStream * |
242 | g_unix_output_stream_new (gint fd, |
243 | gboolean close_fd) |
244 | { |
245 | GUnixOutputStream *stream; |
246 | |
247 | g_return_val_if_fail (fd != -1, NULL); |
248 | |
249 | stream = g_object_new (G_TYPE_UNIX_OUTPUT_STREAM, |
250 | first_property_name: "fd" , fd, |
251 | "close-fd" , close_fd, |
252 | NULL); |
253 | |
254 | return G_OUTPUT_STREAM (stream); |
255 | } |
256 | |
257 | /** |
258 | * g_unix_output_stream_set_close_fd: |
259 | * @stream: a #GUnixOutputStream |
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_output_stream_set_close_fd (GUnixOutputStream *stream, |
269 | gboolean close_fd) |
270 | { |
271 | g_return_if_fail (G_IS_UNIX_OUTPUT_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_output_stream_get_close_fd: |
283 | * @stream: a #GUnixOutputStream |
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_output_stream_get_close_fd (GUnixOutputStream *stream) |
294 | { |
295 | g_return_val_if_fail (G_IS_UNIX_OUTPUT_STREAM (stream), FALSE); |
296 | |
297 | return stream->priv->close_fd; |
298 | } |
299 | |
300 | /** |
301 | * g_unix_output_stream_get_fd: |
302 | * @stream: a #GUnixOutputStream |
303 | * |
304 | * Return the UNIX file descriptor that the stream writes to. |
305 | * |
306 | * Returns: The file descriptor of @stream |
307 | * |
308 | * Since: 2.20 |
309 | */ |
310 | gint |
311 | g_unix_output_stream_get_fd (GUnixOutputStream *stream) |
312 | { |
313 | g_return_val_if_fail (G_IS_UNIX_OUTPUT_STREAM (stream), -1); |
314 | |
315 | return stream->priv->fd; |
316 | } |
317 | |
318 | static gssize |
319 | g_unix_output_stream_write (GOutputStream *stream, |
320 | const void *buffer, |
321 | gsize count, |
322 | GCancellable *cancellable, |
323 | GError **error) |
324 | { |
325 | GUnixOutputStream *unix_stream; |
326 | gssize res = -1; |
327 | GPollFD poll_fds[2]; |
328 | int nfds = 0; |
329 | int poll_ret; |
330 | |
331 | unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
332 | |
333 | poll_fds[0].fd = unix_stream->priv->fd; |
334 | poll_fds[0].events = G_IO_OUT; |
335 | nfds++; |
336 | |
337 | if (unix_stream->priv->can_poll && |
338 | g_cancellable_make_pollfd (cancellable, pollfd: &poll_fds[1])) |
339 | nfds++; |
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 writing to 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 = write (fd: unix_stream->priv->fd, buf: buffer, n: count); |
369 | errsv = errno; |
370 | if (res == -1) |
371 | { |
372 | if (errsv == EINTR || errsv == EAGAIN) |
373 | continue; |
374 | |
375 | g_set_error (err: error, G_IO_ERROR, |
376 | code: g_io_error_from_errno (err_no: errsv), |
377 | _("Error writing to file descriptor: %s" ), |
378 | g_strerror (errnum: errsv)); |
379 | } |
380 | |
381 | break; |
382 | } |
383 | |
384 | if (nfds == 2) |
385 | g_cancellable_release_fd (cancellable); |
386 | return res; |
387 | } |
388 | |
389 | /* Macro to check if struct iovec and GOutputVector have the same ABI */ |
390 | #define G_OUTPUT_VECTOR_IS_IOVEC (sizeof (struct iovec) == sizeof (GOutputVector) && \ |
391 | G_SIZEOF_MEMBER (struct iovec, iov_base) == G_SIZEOF_MEMBER (GOutputVector, buffer) && \ |
392 | G_STRUCT_OFFSET (struct iovec, iov_base) == G_STRUCT_OFFSET (GOutputVector, buffer) && \ |
393 | G_SIZEOF_MEMBER (struct iovec, iov_len) == G_SIZEOF_MEMBER (GOutputVector, size) && \ |
394 | G_STRUCT_OFFSET (struct iovec, iov_len) == G_STRUCT_OFFSET (GOutputVector, size)) |
395 | |
396 | static gboolean |
397 | g_unix_output_stream_writev (GOutputStream *stream, |
398 | const GOutputVector *vectors, |
399 | gsize n_vectors, |
400 | gsize *bytes_written, |
401 | GCancellable *cancellable, |
402 | GError **error) |
403 | { |
404 | GUnixOutputStream *unix_stream; |
405 | gssize res = -1; |
406 | GPollFD poll_fds[2]; |
407 | int nfds = 0; |
408 | int poll_ret; |
409 | struct iovec *iov; |
410 | |
411 | if (bytes_written) |
412 | *bytes_written = 0; |
413 | |
414 | /* Clamp the number of vectors if more given than we can write in one go. |
415 | * The caller has to handle short writes anyway. |
416 | */ |
417 | if (n_vectors > G_IOV_MAX) |
418 | n_vectors = G_IOV_MAX; |
419 | |
420 | unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
421 | |
422 | if (G_OUTPUT_VECTOR_IS_IOVEC) |
423 | { |
424 | /* ABI is compatible */ |
425 | iov = (struct iovec *) vectors; |
426 | } |
427 | else |
428 | { |
429 | gsize i; |
430 | |
431 | /* ABI is incompatible */ |
432 | iov = g_newa (struct iovec, n_vectors); |
433 | for (i = 0; i < n_vectors; i++) |
434 | { |
435 | iov[i].iov_base = (void *)vectors[i].buffer; |
436 | iov[i].iov_len = vectors[i].size; |
437 | } |
438 | } |
439 | |
440 | poll_fds[0].fd = unix_stream->priv->fd; |
441 | poll_fds[0].events = G_IO_OUT; |
442 | nfds++; |
443 | |
444 | if (unix_stream->priv->can_poll && |
445 | g_cancellable_make_pollfd (cancellable, pollfd: &poll_fds[1])) |
446 | nfds++; |
447 | |
448 | while (1) |
449 | { |
450 | int errsv; |
451 | |
452 | poll_fds[0].revents = poll_fds[1].revents = 0; |
453 | do |
454 | { |
455 | poll_ret = g_poll (fds: poll_fds, nfds, timeout: -1); |
456 | errsv = errno; |
457 | } |
458 | while (poll_ret == -1 && errsv == EINTR); |
459 | |
460 | if (poll_ret == -1) |
461 | { |
462 | g_set_error (err: error, G_IO_ERROR, |
463 | code: g_io_error_from_errno (err_no: errsv), |
464 | _("Error writing to file descriptor: %s" ), |
465 | g_strerror (errnum: errsv)); |
466 | break; |
467 | } |
468 | |
469 | if (g_cancellable_set_error_if_cancelled (cancellable, error)) |
470 | break; |
471 | |
472 | if (!poll_fds[0].revents) |
473 | continue; |
474 | |
475 | res = writev (fd: unix_stream->priv->fd, iovec: iov, count: n_vectors); |
476 | errsv = errno; |
477 | if (res == -1) |
478 | { |
479 | if (errsv == EINTR || errsv == EAGAIN) |
480 | continue; |
481 | |
482 | g_set_error (err: error, G_IO_ERROR, |
483 | code: g_io_error_from_errno (err_no: errsv), |
484 | _("Error writing to file descriptor: %s" ), |
485 | g_strerror (errnum: errsv)); |
486 | } |
487 | |
488 | if (bytes_written) |
489 | *bytes_written = res; |
490 | |
491 | break; |
492 | } |
493 | |
494 | if (nfds == 2) |
495 | g_cancellable_release_fd (cancellable); |
496 | return res != -1; |
497 | } |
498 | |
499 | static gboolean |
500 | g_unix_output_stream_close (GOutputStream *stream, |
501 | GCancellable *cancellable, |
502 | GError **error) |
503 | { |
504 | GUnixOutputStream *unix_stream; |
505 | int res; |
506 | |
507 | unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
508 | |
509 | if (!unix_stream->priv->close_fd) |
510 | return TRUE; |
511 | |
512 | /* This might block during the close. Doesn't seem to be a way to avoid it though. */ |
513 | res = close (fd: unix_stream->priv->fd); |
514 | if (res == -1) |
515 | { |
516 | int errsv = errno; |
517 | |
518 | g_set_error (err: error, G_IO_ERROR, |
519 | code: g_io_error_from_errno (err_no: errsv), |
520 | _("Error closing file descriptor: %s" ), |
521 | g_strerror (errnum: errsv)); |
522 | } |
523 | |
524 | return res != -1; |
525 | } |
526 | |
527 | static gboolean |
528 | g_unix_output_stream_pollable_can_poll (GPollableOutputStream *stream) |
529 | { |
530 | return G_UNIX_OUTPUT_STREAM (stream)->priv->can_poll; |
531 | } |
532 | |
533 | static gboolean |
534 | g_unix_output_stream_pollable_is_writable (GPollableOutputStream *stream) |
535 | { |
536 | GUnixOutputStream *unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
537 | GPollFD poll_fd; |
538 | gint result; |
539 | |
540 | poll_fd.fd = unix_stream->priv->fd; |
541 | poll_fd.events = G_IO_OUT; |
542 | poll_fd.revents = 0; |
543 | |
544 | do |
545 | result = g_poll (fds: &poll_fd, nfds: 1, timeout: 0); |
546 | while (result == -1 && errno == EINTR); |
547 | |
548 | return poll_fd.revents != 0; |
549 | } |
550 | |
551 | static GSource * |
552 | g_unix_output_stream_pollable_create_source (GPollableOutputStream *stream, |
553 | GCancellable *cancellable) |
554 | { |
555 | GUnixOutputStream *unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
556 | GSource *inner_source, *cancellable_source, *pollable_source; |
557 | |
558 | pollable_source = g_pollable_source_new (G_OBJECT (stream)); |
559 | |
560 | inner_source = g_unix_fd_source_new (fd: unix_stream->priv->fd, condition: G_IO_OUT); |
561 | g_source_set_dummy_callback (source: inner_source); |
562 | g_source_add_child_source (source: pollable_source, child_source: inner_source); |
563 | g_source_unref (source: inner_source); |
564 | |
565 | if (cancellable) |
566 | { |
567 | cancellable_source = g_cancellable_source_new (cancellable); |
568 | g_source_set_dummy_callback (source: cancellable_source); |
569 | g_source_add_child_source (source: pollable_source, child_source: cancellable_source); |
570 | g_source_unref (source: cancellable_source); |
571 | } |
572 | |
573 | return pollable_source; |
574 | } |
575 | |
576 | static GPollableReturn |
577 | g_unix_output_stream_pollable_writev_nonblocking (GPollableOutputStream *stream, |
578 | const GOutputVector *vectors, |
579 | gsize n_vectors, |
580 | gsize *bytes_written, |
581 | GError **error) |
582 | { |
583 | GUnixOutputStream *unix_stream = G_UNIX_OUTPUT_STREAM (stream); |
584 | struct iovec *iov; |
585 | gssize res = -1; |
586 | |
587 | if (!g_pollable_output_stream_is_writable (stream)) |
588 | { |
589 | *bytes_written = 0; |
590 | return G_POLLABLE_RETURN_WOULD_BLOCK; |
591 | } |
592 | |
593 | /* Clamp the number of vectors if more given than we can write in one go. |
594 | * The caller has to handle short writes anyway. |
595 | */ |
596 | if (n_vectors > G_IOV_MAX) |
597 | n_vectors = G_IOV_MAX; |
598 | |
599 | if (G_OUTPUT_VECTOR_IS_IOVEC) |
600 | { |
601 | /* ABI is compatible */ |
602 | iov = (struct iovec *) vectors; |
603 | } |
604 | else |
605 | { |
606 | gsize i; |
607 | |
608 | /* ABI is incompatible */ |
609 | iov = g_newa (struct iovec, n_vectors); |
610 | for (i = 0; i < n_vectors; i++) |
611 | { |
612 | iov[i].iov_base = (void *)vectors[i].buffer; |
613 | iov[i].iov_len = vectors[i].size; |
614 | } |
615 | } |
616 | |
617 | while (1) |
618 | { |
619 | int errsv; |
620 | |
621 | res = writev (fd: unix_stream->priv->fd, iovec: iov, count: n_vectors); |
622 | errsv = errno; |
623 | if (res == -1) |
624 | { |
625 | if (errsv == EINTR) |
626 | continue; |
627 | |
628 | g_set_error (err: error, G_IO_ERROR, |
629 | code: g_io_error_from_errno (err_no: errsv), |
630 | _("Error writing to file descriptor: %s" ), |
631 | g_strerror (errnum: errsv)); |
632 | } |
633 | |
634 | if (bytes_written) |
635 | *bytes_written = res; |
636 | |
637 | break; |
638 | } |
639 | |
640 | return res != -1 ? G_POLLABLE_RETURN_OK : G_POLLABLE_RETURN_FAILED; |
641 | } |
642 | |