nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * giounix.c: IO Channels using unix file descriptors
5 * Copyright 1998 Owen Taylor
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 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 Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20  
21 /*
22 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
23 * file for a list of people on the GLib Team. See the ChangeLog
24 * files for a list of changes. These files are distributed with
25 * GLib at ftp://ftp.gtk.org/pub/gtk/.
26 */
27  
28 /*
29 * MT safe
30 */
31  
32 #include "config.h"
33  
34 #define _POSIX_SOURCE /* for SSIZE_MAX */
35  
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <stdio.h>
39 #include <unistd.h>
40 #include <errno.h>
41 #include <string.h>
42 #include <fcntl.h>
43 #include <glib/gstdio.h>
44  
45 #include "giochannel.h"
46  
47 #include "gerror.h"
48 #include "gfileutils.h"
49 #include "gstrfuncs.h"
50 #include "gtestutils.h"
51  
52 /*
53 * Unix IO Channels
54 */
55  
56 typedef struct _GIOUnixChannel GIOUnixChannel;
57 typedef struct _GIOUnixWatch GIOUnixWatch;
58  
59 struct _GIOUnixChannel
60 {
61 GIOChannel channel;
62 gint fd;
63 };
64  
65 struct _GIOUnixWatch
66 {
67 GSource source;
68 GPollFD pollfd;
69 GIOChannel *channel;
70 GIOCondition condition;
71 };
72  
73  
74 static GIOStatus g_io_unix_read (GIOChannel *channel,
75 gchar *buf,
76 gsize count,
77 gsize *bytes_read,
78 GError **err);
79 static GIOStatus g_io_unix_write (GIOChannel *channel,
80 const gchar *buf,
81 gsize count,
82 gsize *bytes_written,
83 GError **err);
84 static GIOStatus g_io_unix_seek (GIOChannel *channel,
85 gint64 offset,
86 GSeekType type,
87 GError **err);
88 static GIOStatus g_io_unix_close (GIOChannel *channel,
89 GError **err);
90 static void g_io_unix_free (GIOChannel *channel);
91 static GSource* g_io_unix_create_watch (GIOChannel *channel,
92 GIOCondition condition);
93 static GIOStatus g_io_unix_set_flags (GIOChannel *channel,
94 GIOFlags flags,
95 GError **err);
96 static GIOFlags g_io_unix_get_flags (GIOChannel *channel);
97  
98 static gboolean g_io_unix_prepare (GSource *source,
99 gint *timeout);
100 static gboolean g_io_unix_check (GSource *source);
101 static gboolean g_io_unix_dispatch (GSource *source,
102 GSourceFunc callback,
103 gpointer user_data);
104 static void g_io_unix_finalize (GSource *source);
105  
106 GSourceFuncs g_io_watch_funcs = {
107 g_io_unix_prepare,
108 g_io_unix_check,
109 g_io_unix_dispatch,
110 g_io_unix_finalize
111 };
112  
113 static GIOFuncs unix_channel_funcs = {
114 g_io_unix_read,
115 g_io_unix_write,
116 g_io_unix_seek,
117 g_io_unix_close,
118 g_io_unix_create_watch,
119 g_io_unix_free,
120 g_io_unix_set_flags,
121 g_io_unix_get_flags,
122 };
123  
124 static gboolean
125 g_io_unix_prepare (GSource *source,
126 gint *timeout)
127 {
128 GIOUnixWatch *watch = (GIOUnixWatch *)source;
129 GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
130  
131 *timeout = -1;
132  
133 /* Only return TRUE here if _all_ bits in watch->condition will be set
134 */
135 return ((watch->condition & buffer_condition) == watch->condition);
136 }
137  
138 static gboolean
139 g_io_unix_check (GSource *source)
140 {
141 GIOUnixWatch *watch = (GIOUnixWatch *)source;
142 GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
143 GIOCondition poll_condition = watch->pollfd.revents;
144  
145 return ((poll_condition | buffer_condition) & watch->condition);
146 }
147  
148 static gboolean
149 g_io_unix_dispatch (GSource *source,
150 GSourceFunc callback,
151 gpointer user_data)
152  
153 {
154 GIOFunc func = (GIOFunc)callback;
155 GIOUnixWatch *watch = (GIOUnixWatch *)source;
156 GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
157  
158 if (!func)
159 {
160 g_warning ("IO watch dispatched without callback\n"
161 "You must call g_source_connect().");
162 return FALSE;
163 }
164  
165 return (*func) (watch->channel,
166 (watch->pollfd.revents | buffer_condition) & watch->condition,
167 user_data);
168 }
169  
170 static void
171 g_io_unix_finalize (GSource *source)
172 {
173 GIOUnixWatch *watch = (GIOUnixWatch *)source;
174  
175 g_io_channel_unref (watch->channel);
176 }
177  
178 static GIOStatus
179 g_io_unix_read (GIOChannel *channel,
180 gchar *buf,
181 gsize count,
182 gsize *bytes_read,
183 GError **err)
184 {
185 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
186 gssize result;
187  
188 if (count > SSIZE_MAX) /* At least according to the Debian manpage for read */
189 count = SSIZE_MAX;
190  
191 retry:
192 result = read (unix_channel->fd, buf, count);
193  
194 if (result < 0)
195 {
196 int errsv = errno;
197 *bytes_read = 0;
198  
199 switch (errsv)
200 {
201 #ifdef EINTR
202 case EINTR:
203 goto retry;
204 #endif
205 #ifdef EAGAIN
206 case EAGAIN:
207 return G_IO_STATUS_AGAIN;
208 #endif
209 default:
210 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
211 g_io_channel_error_from_errno (errsv),
212 g_strerror (errsv));
213 return G_IO_STATUS_ERROR;
214 }
215 }
216  
217 *bytes_read = result;
218  
219 return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
220 }
221  
222 static GIOStatus
223 g_io_unix_write (GIOChannel *channel,
224 const gchar *buf,
225 gsize count,
226 gsize *bytes_written,
227 GError **err)
228 {
229 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
230 gssize result;
231  
232 retry:
233 result = write (unix_channel->fd, buf, count);
234  
235 if (result < 0)
236 {
237 int errsv = errno;
238 *bytes_written = 0;
239  
240 switch (errsv)
241 {
242 #ifdef EINTR
243 case EINTR:
244 goto retry;
245 #endif
246 #ifdef EAGAIN
247 case EAGAIN:
248 return G_IO_STATUS_AGAIN;
249 #endif
250 default:
251 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
252 g_io_channel_error_from_errno (errsv),
253 g_strerror (errsv));
254 return G_IO_STATUS_ERROR;
255 }
256 }
257  
258 *bytes_written = result;
259  
260 return G_IO_STATUS_NORMAL;
261 }
262  
263 static GIOStatus
264 g_io_unix_seek (GIOChannel *channel,
265 gint64 offset,
266 GSeekType type,
267 GError **err)
268 {
269 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
270 int whence;
271 off_t tmp_offset;
272 off_t result;
273  
274 switch (type)
275 {
276 case G_SEEK_SET:
277 whence = SEEK_SET;
278 break;
279 case G_SEEK_CUR:
280 whence = SEEK_CUR;
281 break;
282 case G_SEEK_END:
283 whence = SEEK_END;
284 break;
285 default:
286 whence = -1; /* Shut the compiler up */
287 g_assert_not_reached ();
288 }
289  
290 tmp_offset = offset;
291 if (tmp_offset != offset)
292 {
293 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
294 g_io_channel_error_from_errno (EINVAL),
295 g_strerror (EINVAL));
296 return G_IO_STATUS_ERROR;
297 }
298  
299 result = lseek (unix_channel->fd, tmp_offset, whence);
300  
301 if (result < 0)
302 {
303 int errsv = errno;
304 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
305 g_io_channel_error_from_errno (errsv),
306 g_strerror (errsv));
307 return G_IO_STATUS_ERROR;
308 }
309  
310 return G_IO_STATUS_NORMAL;
311 }
312  
313  
314 static GIOStatus
315 g_io_unix_close (GIOChannel *channel,
316 GError **err)
317 {
318 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
319  
320 if (close (unix_channel->fd) < 0)
321 {
322 int errsv = errno;
323 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
324 g_io_channel_error_from_errno (errsv),
325 g_strerror (errsv));
326 return G_IO_STATUS_ERROR;
327 }
328  
329 return G_IO_STATUS_NORMAL;
330 }
331  
332 static void
333 g_io_unix_free (GIOChannel *channel)
334 {
335 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
336  
337 g_free (unix_channel);
338 }
339  
340 static GSource *
341 g_io_unix_create_watch (GIOChannel *channel,
342 GIOCondition condition)
343 {
344 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
345 GSource *source;
346 GIOUnixWatch *watch;
347  
348  
349 source = g_source_new (&g_io_watch_funcs, sizeof (GIOUnixWatch));
350 g_source_set_name (source, "GIOChannel (Unix)");
351 watch = (GIOUnixWatch *)source;
352  
353 watch->channel = channel;
354 g_io_channel_ref (channel);
355  
356 watch->condition = condition;
357  
358 watch->pollfd.fd = unix_channel->fd;
359 watch->pollfd.events = condition;
360  
361 g_source_add_poll (source, &watch->pollfd);
362  
363 return source;
364 }
365  
366 static GIOStatus
367 g_io_unix_set_flags (GIOChannel *channel,
368 GIOFlags flags,
369 GError **err)
370 {
371 glong fcntl_flags;
372 GIOUnixChannel *unix_channel = (GIOUnixChannel *) channel;
373  
374 fcntl_flags = 0;
375  
376 if (flags & G_IO_FLAG_APPEND)
377 fcntl_flags |= O_APPEND;
378 if (flags & G_IO_FLAG_NONBLOCK)
379 #ifdef O_NONBLOCK
380 fcntl_flags |= O_NONBLOCK;
381 #else
382 fcntl_flags |= O_NDELAY;
383 #endif
384  
385 if (fcntl (unix_channel->fd, F_SETFL, fcntl_flags) == -1)
386 {
387 int errsv = errno;
388 g_set_error_literal (err, G_IO_CHANNEL_ERROR,
389 g_io_channel_error_from_errno (errsv),
390 g_strerror (errsv));
391 return G_IO_STATUS_ERROR;
392 }
393  
394 return G_IO_STATUS_NORMAL;
395 }
396  
397 static GIOFlags
398 g_io_unix_get_flags (GIOChannel *channel)
399 {
400 GIOFlags flags = 0;
401 glong fcntl_flags;
402 GIOUnixChannel *unix_channel = (GIOUnixChannel *) channel;
403  
404 fcntl_flags = fcntl (unix_channel->fd, F_GETFL);
405  
406 if (fcntl_flags == -1)
407 {
408 int err = errno;
409 g_warning (G_STRLOC "Error while getting flags for FD: %s (%d)\n",
410 g_strerror (err), err);
411 return 0;
412 }
413  
414 if (fcntl_flags & O_APPEND)
415 flags |= G_IO_FLAG_APPEND;
416 #ifdef O_NONBLOCK
417 if (fcntl_flags & O_NONBLOCK)
418 #else
419 if (fcntl_flags & O_NDELAY)
420 #endif
421 flags |= G_IO_FLAG_NONBLOCK;
422  
423 switch (fcntl_flags & (O_RDONLY | O_WRONLY | O_RDWR))
424 {
425 case O_RDONLY:
426 channel->is_readable = TRUE;
427 channel->is_writeable = FALSE;
428 break;
429 case O_WRONLY:
430 channel->is_readable = FALSE;
431 channel->is_writeable = TRUE;
432 break;
433 case O_RDWR:
434 channel->is_readable = TRUE;
435 channel->is_writeable = TRUE;
436 break;
437 default:
438 g_assert_not_reached ();
439 }
440  
441 return flags;
442 }
443  
444 GIOChannel *
445 g_io_channel_new_file (const gchar *filename,
446 const gchar *mode,
447 GError **error)
448 {
449 int fid, flags;
450 mode_t create_mode;
451 GIOChannel *channel;
452 enum { /* Cheesy hack */
453 MODE_R = 1 << 0,
454 MODE_W = 1 << 1,
455 MODE_A = 1 << 2,
456 MODE_PLUS = 1 << 3,
457 MODE_R_PLUS = MODE_R | MODE_PLUS,
458 MODE_W_PLUS = MODE_W | MODE_PLUS,
459 MODE_A_PLUS = MODE_A | MODE_PLUS
460 } mode_num;
461 struct stat buffer;
462  
463 g_return_val_if_fail (filename != NULL, NULL);
464 g_return_val_if_fail (mode != NULL, NULL);
465 g_return_val_if_fail ((error == NULL) || (*error == NULL), NULL);
466  
467 switch (mode[0])
468 {
469 case 'r':
470 mode_num = MODE_R;
471 break;
472 case 'w':
473 mode_num = MODE_W;
474 break;
475 case 'a':
476 mode_num = MODE_A;
477 break;
478 default:
479 g_warning ("Invalid GIOFileMode %s.\n", mode);
480 return NULL;
481 }
482  
483 switch (mode[1])
484 {
485 case '\0':
486 break;
487 case '+':
488 if (mode[2] == '\0')
489 {
490 mode_num |= MODE_PLUS;
491 break;
492 }
493 /* Fall through */
494 default:
495 g_warning ("Invalid GIOFileMode %s.\n", mode);
496 return NULL;
497 }
498  
499 switch (mode_num)
500 {
501 case MODE_R:
502 flags = O_RDONLY;
503 break;
504 case MODE_W:
505 flags = O_WRONLY | O_TRUNC | O_CREAT;
506 break;
507 case MODE_A:
508 flags = O_WRONLY | O_APPEND | O_CREAT;
509 break;
510 case MODE_R_PLUS:
511 flags = O_RDWR;
512 break;
513 case MODE_W_PLUS:
514 flags = O_RDWR | O_TRUNC | O_CREAT;
515 break;
516 case MODE_A_PLUS:
517 flags = O_RDWR | O_APPEND | O_CREAT;
518 break;
519 case MODE_PLUS:
520 default:
521 g_assert_not_reached ();
522 flags = 0;
523 }
524  
525 create_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
526  
527 fid = g_open (filename, flags, create_mode);
528 if (fid == -1)
529 {
530 int err = errno;
531 g_set_error_literal (error, G_FILE_ERROR,
532 g_file_error_from_errno (err),
533 g_strerror (err));
534 return (GIOChannel *)NULL;
535 }
536  
537 if (fstat (fid, &buffer) == -1) /* In case someone opens a FIFO */
538 {
539 int err = errno;
540 close (fid);
541 g_set_error_literal (error, G_FILE_ERROR,
542 g_file_error_from_errno (err),
543 g_strerror (err));
544 return (GIOChannel *)NULL;
545 }
546  
547 channel = (GIOChannel *) g_new (GIOUnixChannel, 1);
548  
549 channel->is_seekable = S_ISREG (buffer.st_mode) || S_ISCHR (buffer.st_mode)
550 || S_ISBLK (buffer.st_mode);
551  
552 switch (mode_num)
553 {
554 case MODE_R:
555 channel->is_readable = TRUE;
556 channel->is_writeable = FALSE;
557 break;
558 case MODE_W:
559 case MODE_A:
560 channel->is_readable = FALSE;
561 channel->is_writeable = TRUE;
562 break;
563 case MODE_R_PLUS:
564 case MODE_W_PLUS:
565 case MODE_A_PLUS:
566 channel->is_readable = TRUE;
567 channel->is_writeable = TRUE;
568 break;
569 case MODE_PLUS:
570 default:
571 g_assert_not_reached ();
572 }
573  
574 g_io_channel_init (channel);
575 channel->close_on_unref = TRUE; /* must be after g_io_channel_init () */
576 channel->funcs = &unix_channel_funcs;
577  
578 ((GIOUnixChannel *) channel)->fd = fid;
579 return channel;
580 }
581  
582 /**
583 * g_io_channel_unix_new:
584 * @fd: a file descriptor.
585 *
586 * Creates a new #GIOChannel given a file descriptor. On UNIX systems
587 * this works for plain files, pipes, and sockets.
588 *
589 * The returned #GIOChannel has a reference count of 1.
590 *
591 * The default encoding for #GIOChannel is UTF-8. If your application
592 * is reading output from a command using via pipe, you may need to set
593 * the encoding to the encoding of the current locale (see
594 * g_get_charset()) with the g_io_channel_set_encoding() function.
595 *
596 * If you want to read raw binary data without interpretation, then
597 * call the g_io_channel_set_encoding() function with %NULL for the
598 * encoding argument.
599 *
600 * This function is available in GLib on Windows, too, but you should
601 * avoid using it on Windows. The domain of file descriptors and
602 * sockets overlap. There is no way for GLib to know which one you mean
603 * in case the argument you pass to this function happens to be both a
604 * valid file descriptor and socket. If that happens a warning is
605 * issued, and GLib assumes that it is the file descriptor you mean.
606 *
607 * Returns: a new #GIOChannel.
608 **/
609 GIOChannel *
610 g_io_channel_unix_new (gint fd)
611 {
612 struct stat buffer;
613 GIOUnixChannel *unix_channel = g_new (GIOUnixChannel, 1);
614 GIOChannel *channel = (GIOChannel *)unix_channel;
615  
616 g_io_channel_init (channel);
617 channel->funcs = &unix_channel_funcs;
618  
619 unix_channel->fd = fd;
620  
621 /* I'm not sure if fstat on a non-file (e.g., socket) works
622 * it should be safe to say if it fails, the fd isn't seekable.
623 */
624 /* Newer UNIX versions support S_ISSOCK(), fstat() will probably
625 * succeed in most cases.
626 */
627 if (fstat (unix_channel->fd, &buffer) == 0)
628 channel->is_seekable = S_ISREG (buffer.st_mode) || S_ISCHR (buffer.st_mode)
629 || S_ISBLK (buffer.st_mode);
630 else /* Assume not seekable */
631 channel->is_seekable = FALSE;
632  
633 g_io_unix_get_flags (channel); /* Sets is_readable, is_writeable */
634  
635 return channel;
636 }
637  
638 /**
639 * g_io_channel_unix_get_fd:
640 * @channel: a #GIOChannel, created with g_io_channel_unix_new().
641 *
642 * Returns the file descriptor of the #GIOChannel.
643 *
644 * On Windows this function returns the file descriptor or socket of
645 * the #GIOChannel.
646 *
647 * Returns: the file descriptor of the #GIOChannel.
648 **/
649 gint
650 g_io_channel_unix_get_fd (GIOChannel *channel)
651 {
652 GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
653 return unix_channel->fd;
654 }