void HttpClient::on_connected(gpointer data, bool succeeded) { HttpClient *oHttpClient = (HttpClient *)data; if (!succeeded) { gchar *mes = g_strdup_printf("Can not connect to %s: %s\n", oHttpClient->host_.c_str(), Socket::get_error_msg().c_str()); on_error_.emit(oHttpClient, mes); g_free(mes); return; } #ifdef _WIN32 oHttpClient->channel_ = g_io_channel_win32_new_socket(oHttpClient->sd_); #else oHttpClient->channel_ = g_io_channel_unix_new(oHttpClient->sd_); #endif g_io_channel_set_encoding(oHttpClient->channel_, NULL, NULL); /* make sure that the channel is non-blocking */ int flags = g_io_channel_get_flags(oHttpClient->channel_); flags |= G_IO_FLAG_NONBLOCK; GError *err = NULL; g_io_channel_set_flags(oHttpClient->channel_, GIOFlags(flags), &err); if (err) { gchar *str = g_strdup_printf("Unable to set the channel as non-blocking: %s", err->message); on_error_.emit(oHttpClient, str); g_free(str); g_error_free(err); return; } if (oHttpClient->SendGetRequest()) return; oHttpClient->out_source_id_ = g_io_add_watch(oHttpClient->channel_, GIOCondition(G_IO_OUT), on_io_out_event, oHttpClient); oHttpClient->in_source_id_ = g_io_add_watch(oHttpClient->channel_, GIOCondition(G_IO_IN | G_IO_ERR), on_io_in_event, oHttpClient); }
int __connman_rfkill_init(void) { GIOFlags flags; int fd; DBG(""); fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC); if (fd < 0) { connman_error("Failed to open RFKILL control device"); return -EIO; } channel = g_io_channel_unix_new(fd); g_io_channel_set_close_on_unref(channel, TRUE); g_io_channel_set_encoding(channel, NULL, NULL); g_io_channel_set_buffered(channel, FALSE); flags = g_io_channel_get_flags(channel); flags |= G_IO_FLAG_NONBLOCK; g_io_channel_set_flags(channel, flags, NULL); /* Process current RFKILL events sent on device open */ while (rfkill_process(channel) == G_IO_STATUS_NORMAL); g_io_add_watch(channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR, rfkill_event, NULL); return 0; }
static gboolean check_connection(GIOChannel *chan) { gchar fake_buf[4096]; gsize bytes_read; GError *tmp_error = NULL; GIOFlags flags; GIOStatus ret, iostat; flags = g_io_channel_get_flags(chan); /* set non-blocking */ ret = g_io_channel_set_flags(chan, flags | G_IO_FLAG_NONBLOCK, NULL); if (ret == G_IO_STATUS_ERROR) { return FALSE; } iostat = g_io_channel_read_chars(chan, fake_buf, sizeof(fake_buf), &bytes_read, &tmp_error); ret = g_io_channel_set_flags(chan, flags, NULL); if (ret == G_IO_STATUS_ERROR) { return FALSE; } /* this makes us disconnect from bad servers (those that send us information without us asking for it) */ return iostat == G_IO_STATUS_AGAIN; }
void seahorse_unix_signal_register (int sig, signal_handler handler) { g_return_if_fail (sig < MAX_SIGNAL); g_return_if_fail (handler != NULL); /* Setup the signal channel */ if (signal_channel == NULL) { memset (&signal_handlers, 0, sizeof (signal_handlers)); if (pipe (signal_pipe)) { g_critical ("can't create signal pipe: %s", strerror (errno)); return; } /* Non blocking to prevent deadlock */ fcntl (signal_pipe[1], F_SETFL, fcntl (signal_pipe[1], F_GETFL) | O_NONBLOCK); /* convert the reading end of the pipe into a GIOChannel */ signal_channel = g_io_channel_unix_new (signal_pipe[0]); g_io_channel_set_encoding (signal_channel, NULL, NULL); g_io_channel_set_flags (signal_channel, g_io_channel_get_flags (signal_channel) | G_IO_FLAG_NONBLOCK, NULL); /* register the reading end with the event loop */ signal_watch_id = g_io_add_watch (signal_channel, G_IO_IN | G_IO_PRI | G_IO_HUP, deliver_signal, NULL); g_atexit (cleanup_signals); } /* Handle some signals */ signal (sig, pipe_signals); signal_handlers[sig] = handler; }
static void mux_setup_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct mux_setup_data *msd = user_data; GIOFlags flags; GIOChannel *channel; GAtMux *mux = NULL; if (!ok) goto error; channel = g_at_chat_get_channel(msd->chat); channel = g_io_channel_ref(channel); g_at_chat_unref(msd->chat); msd->chat = NULL; flags = g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK; g_io_channel_set_flags(channel, flags, NULL); g_io_channel_set_encoding(channel, NULL, NULL); g_io_channel_set_buffered(channel, FALSE); if (msd->mode == 0) mux = g_at_mux_new_gsm0710_basic(channel, msd->frame_size); else mux = g_at_mux_new_gsm0710_advanced(channel, msd->frame_size); g_io_channel_unref(channel); error: msd->func(mux, msd->user); if (msd->destroy) msd->destroy(msd->user); }
/* Return value must be unref'd with g_io_channel_unref(). Exits on failure. */ static GIOChannel * open_file (const char *filename) { /* open the file */ GError *error = NULL; GIOChannel *io_channel = g_io_channel_new_file (filename, "r", &error); if (io_channel == NULL) { g_printerr ("bin-search: g_io_channel_new_file (\"%s\"): %s\n", filename, error->message); exit (3); } /* treat as binary */ error = NULL; GIOStatus status = g_io_channel_set_encoding (io_channel, NULL, &error); if (status == G_IO_STATUS_ERROR) { g_printerr ("bin-search: g_io_channel_set_encoding: %s\n", error->message); exit (4); } g_assert (status == G_IO_STATUS_NORMAL); /* make sure it's seekable */ if ((g_io_channel_get_flags (io_channel) & G_IO_FLAG_IS_SEEKABLE) != G_IO_FLAG_IS_SEEKABLE) { g_printerr ("bin-search: File %s is not seekable (perhaps it's a directory?)\n", filename); exit (9); } return io_channel; }
int _gpgme_io_set_nonblocking (int fd) { GIOChannel *chan; GIOStatus status; TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd); chan = find_channel (fd); if (!chan) { errno = EIO; return TRACE_SYSRES (-1); } status = g_io_channel_set_flags (chan, g_io_channel_get_flags (chan) | G_IO_FLAG_NONBLOCK, NULL); if (status != G_IO_STATUS_NORMAL) { #if 0 /* glib 1.9.2 does not implement set_flags and returns an error. */ errno = EIO; return TRACE_SYSRES (-1); #else TRACE_LOG1 ("g_io_channel_set_flags failed: status=%d (ignored)", status); #endif } return TRACE_SYSRES (0); }
static gboolean event_connection_setup (NMNetlinkMonitor *self, GError **error) { NMNetlinkMonitorPrivate *priv = NM_NETLINK_MONITOR_GET_PRIVATE (self); GError *channel_error = NULL; GIOFlags channel_flags; int fd; g_return_val_if_fail (priv->io_channel == NULL, FALSE); /* Set up the event listener connection */ priv->nlh_event = nl_socket_alloc (); if (!priv->nlh_event) { g_set_error (error, NM_NETLINK_MONITOR_ERROR, NM_NETLINK_MONITOR_ERROR_NETLINK_ALLOC_HANDLE, _("unable to allocate netlink handle for monitoring link status: %s"), nl_geterror (ENOMEM)); goto error; } if (!nlh_setup (priv->nlh_event, event_msg_ready, self, error)) goto error; nl_socket_disable_seq_check (priv->nlh_event); /* Subscribe to the LINK group for internal carrier signals */ if (!nm_netlink_monitor_subscribe (self, RTNLGRP_LINK, error)) goto error; fd = nl_socket_get_fd (priv->nlh_event); priv->io_channel = g_io_channel_unix_new (fd); g_io_channel_set_encoding (priv->io_channel, NULL, &channel_error); /* Encoding is NULL, so no conversion error can possibly occur */ g_assert (channel_error == NULL); g_io_channel_set_close_on_unref (priv->io_channel, TRUE); channel_flags = g_io_channel_get_flags (priv->io_channel); channel_error = NULL; g_io_channel_set_flags (priv->io_channel, channel_flags | G_IO_FLAG_NONBLOCK, &channel_error); if (channel_error != NULL) { g_propagate_error (error, channel_error); goto error; } return TRUE; error: if (priv->io_channel) nm_netlink_monitor_close_connection (self); if (priv->nlh_event) { nl_socket_free (priv->nlh_event); priv->nlh_event = NULL; } return FALSE; }
static GIOChannel * brasero_process_setup_channel (BraseroProcess *process, int pipe, gint *watch, GIOFunc function) { GIOChannel *channel; fcntl (pipe, F_SETFL, O_NONBLOCK); channel = g_io_channel_unix_new (pipe); /* It'd be good if we were allowed to add some to the default line * separator */ // g_io_channel_set_line_term (channel, "\b", -1); g_io_channel_set_flags (channel, g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, NULL); g_io_channel_set_encoding (channel, NULL, NULL); *watch = g_io_add_watch (channel, (G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL), function, process); g_io_channel_set_close_on_unref (channel, TRUE); return channel; }
static GIOStatus g_io_gnutls_read(GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_read, GError **err) { GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel; GIOStatus status; ssize_t result; DBG("channel %p count %zu", channel, count); *bytes_read = 0; again: status = check_handshake(channel, err); if (status != G_IO_STATUS_NORMAL) return status; result = gnutls_record_recv(gnutls_channel->session, buf, count); DBG("result %zd", result); if (result == GNUTLS_E_REHANDSHAKE) { gnutls_channel->established = FALSE; goto again; } if (result == GNUTLS_E_INTERRUPTED || result == GNUTLS_E_AGAIN) { GIOFlags flags = g_io_channel_get_flags(channel); if (gnutls_channel->again == TRUE) return G_IO_STATUS_AGAIN; if (flags & G_IO_FLAG_NONBLOCK) return G_IO_STATUS_AGAIN; goto again; } if (result == GNUTLS_E_UNEXPECTED_PACKET_LENGTH) return G_IO_STATUS_EOF; if (result < 0) { g_set_error(err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Stream corrupted"); return G_IO_STATUS_ERROR; } *bytes_read = result; return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF; }
static gboolean maki_dcc_send_out_listen (GIOChannel* source, GIOCondition condition, gpointer data) { gint fd; makiDCCSend* dcc = data; if (condition & (G_IO_HUP | G_IO_ERR)) { goto error; } fd = g_io_channel_unix_get_fd(source); fd = accept(fd, NULL, NULL); fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); dcc->channel.connection = g_io_channel_unix_new(fd); g_io_channel_set_flags(dcc->channel.connection, g_io_channel_get_flags(dcc->channel.connection) | G_IO_FLAG_NONBLOCK, NULL); g_io_channel_set_close_on_unref(dcc->channel.connection, TRUE); g_io_channel_set_encoding(dcc->channel.connection, NULL, NULL); g_get_current_time(&dcc->start_time); dcc->status |= s_running; dcc->d.out.sources[s_out_listen] = 0; dcc->d.out.sources[s_out_read] = g_io_add_watch(dcc->channel.connection, G_IO_IN | G_IO_HUP | G_IO_ERR, maki_dcc_send_out_read, dcc); dcc->d.out.sources[s_out_write] = g_io_add_watch(dcc->channel.connection, G_IO_OUT | G_IO_HUP | G_IO_ERR, maki_dcc_send_out_write, dcc); g_io_channel_unref(source); maki_dcc_send_emit(dcc); return FALSE; error: dcc->status |= s_error; dcc->status &= ~s_running; maki_dcc_send_close(dcc); dcc->d.out.sources[s_out_listen] = 0; maki_dcc_send_emit(dcc); return FALSE; }
void signal_handler_setup() { GIOChannel *g_signal_in; GError *error = NULL; /* handle errors */ long fd_flags; /* used to change the pipe into non-blocking mode */ g_assert(pipe(signal_pipe) == 0); fd_flags = fcntl(signal_pipe[1], F_GETFL); g_assert(fd_flags != -1); g_assert(fcntl(signal_pipe[1], F_SETFL, fd_flags | O_NONBLOCK) != -1); signal(SIGWINCH, pipe_signals); signal(SIGINT, pipe_signals); signal(SIGTERM, pipe_signals); signal(SIGABRT, pipe_signals); g_signal_in = g_io_channel_unix_new(signal_pipe[0]); /* * we only read raw binary data from the pipe, * therefore clear any encoding on the channel */ g_io_channel_set_encoding(g_signal_in, NULL, &error); if (error != NULL) { /* handle potential errors */ g_error("g_io_channel_set_encoding failed %s\n", error->message); } /* * put the reading end also into non-blocking mode */ g_io_channel_set_flags(g_signal_in, g_io_channel_get_flags(g_signal_in) | G_IO_FLAG_NONBLOCK, &error); if (error != NULL) { /* tread errors */ g_error("g_io_set_flags failed %s\n", error->message); } /* * register the reading end with the event loop */ g_io_add_watch(g_signal_in, G_IO_IN | G_IO_PRI, deliver_signal, NULL); }
int main ( int argc, char **argv ) { int ifd = fileno( stdin ); int ofd = fileno( stdout ); GMainLoop *gmloop = g_main_loop_new( NULL, FALSE ); GError *error = NULL; GIOChannel *in ; GIOFlags flags ; GIOStatus status ; #ifdef G_PLATFORM_WIN32 // no idea if this works or not. in = g_io_channel_win32_new_socket( (HANDLE)win32_get_osfhandle(ifd) ); out = g_io_channel_win32_new_socket( (HANDLE)win32_get_osfhandle(ofd) ); #else in = g_io_channel_unix_new( ifd ); out = g_io_channel_unix_new( ofd ); #endif // *********************************************************************** g_queue_init( &out_queue ); // *********************************************************************** flags = g_io_channel_get_flags( in ); status = g_io_channel_set_flags( in, flags | G_IO_FLAG_NONBLOCK, &error ); if( status != G_IO_STATUS_NORMAL ) { fprintf( stderr , "Setting O_NONBLOCK on stdin: [%d] %s\n" , error->code, error->message ); g_clear_error( &error ); exit( error->code ); } // *********************************************************************** g_io_add_watch ( in, IO_IN , (GIOFunc)sexp_handler, NULL ); g_io_add_watch ( in, IO_ERR, (GIOFunc)quit_handler, gmloop ); //g_timeout_add ( 1000, _heartbeat, NULL ); sexp_init ( &parser ); g_main_loop_run ( gmloop ); sexp_exit ( &parser ); purple_plugins_unload_all(); purple_core_quit(); exit( 0 ); }
void DictClient::on_resolved(gpointer data, struct hostent *ret) { DictClient *oDictClient = (DictClient *)data; oDictClient->sd_ = Socket::socket(); if (oDictClient->sd_ == -1) { on_error_.emit("Can not create socket: " + Socket::get_error_msg()); return; } #ifdef _WIN32 oDictClient->channel_ = g_io_channel_win32_new_socket(oDictClient->sd_); #else oDictClient->channel_ = g_io_channel_unix_new(oDictClient->sd_); #endif /* RFC2229 mandates the usage of UTF-8, so we force this encoding */ g_io_channel_set_encoding(oDictClient->channel_, "UTF-8", NULL); g_io_channel_set_line_term(oDictClient->channel_, "\r\n", 2); /* make sure that the channel is non-blocking */ int flags = g_io_channel_get_flags(oDictClient->channel_); flags |= G_IO_FLAG_NONBLOCK; GError *err = NULL; g_io_channel_set_flags(oDictClient->channel_, GIOFlags(flags), &err); if (err) { g_io_channel_unref(oDictClient->channel_); oDictClient->channel_ = NULL; on_error_.emit("Unable to set the channel as non-blocking: " + std::string(err->message)); g_error_free(err); return; } if (!Socket::connect(oDictClient->sd_, ret, oDictClient->port_)) { gchar *mes = g_strdup_printf("Can not connect to %s: %s\n", oDictClient->host_.c_str(), Socket::get_error_msg().c_str()); on_error_.emit(mes); g_free(mes); return; } oDictClient->source_id_ = g_io_add_watch(oDictClient->channel_, GIOCondition(G_IO_IN | G_IO_ERR), on_io_event, oDictClient); }
int bot_signal_pipe_attach_glib (bot_signal_pipe_glib_handler_t func, gpointer user_data) { if (! g_sp_initialized) return -1; if (g_sp.ioc) return -1; g_sp.ioc = g_io_channel_unix_new (g_sp.fds[0]); g_io_channel_set_flags (g_sp.ioc, g_io_channel_get_flags (g_sp.ioc) | G_IO_FLAG_NONBLOCK, NULL); g_sp.ios = g_io_add_watch (g_sp.ioc, G_IO_IN | G_IO_PRI, (GIOFunc) bot_signal_handler_glib, NULL); g_sp.userfunc = func; g_sp.userdata = user_data; return 0; }
TemuPty *temu_pty_new_execve( GIOFunc data_func, GIOFunc err_func, gpointer data, const char *path, char *const argv[], char *const envp[] ) { TemuPty *pty; pid_t pid; int master; GIOFlags flags; struct termios ti; GSList *fds; init_term_with_defaults(&ti); pid = forkpty(&master, NULL, &ti, NULL); if (pid == -1) return NULL; if (!pid) { for (fds = pty_fds; fds; fds = g_slist_next(fds)) close(GPOINTER_TO_INT(fds->data)); execve(path, argv, envp); exit(127); } pty = g_new(TemuPty, 1); pty_fds = g_slist_prepend(pty_fds, GINT_TO_POINTER(master)); /* Whoever decided to screw with the data by _DEFAULT_ loses. */ pty->master = g_io_channel_unix_new(master); g_io_channel_set_encoding(pty->master, NULL, NULL); g_io_channel_set_buffered(pty->master, FALSE); flags = g_io_channel_get_flags(pty->master) | G_IO_FLAG_NONBLOCK; g_io_channel_set_flags(pty->master, flags, NULL); pty->data_watch = g_io_add_watch_full(pty->master, G_PRIORITY_HIGH, G_IO_IN|G_IO_PRI, data_func, data, NULL); pty->err_watch = g_io_add_watch(pty->master, G_IO_ERR|G_IO_HUP, err_func, data); return pty; }
static void mce_determine_io_monitor_seekable(iomon_struct *iomon) { gboolean glib = FALSE, kernel = FALSE; /* glib assumes ... */ if (g_io_channel_get_flags(iomon->iochan) & G_IO_FLAG_IS_SEEKABLE) { glib = TRUE; } /* ... kernel knows */ if (lseek64(g_io_channel_unix_get_fd(iomon->iochan), 0, SEEK_CUR) != -1) { kernel = TRUE; } /* report the difference */ if (kernel != glib) { mce_log(LL_DEBUG, "%s: is %sseekable, while glib thinks it is %sseekable", iomon->file, kernel ? "" : "NOT ", glib ? "" : "NOT "); } iomon->seekable = kernel; }
void StarDictClient::on_connected(gpointer data, bool succeeded) { StarDictClient *oStarDictClient = (StarDictClient *)data; if (!succeeded) { static bool showed_once = false; if (!showed_once) { showed_once = true; gchar *mes = g_strdup_printf(_("Can not connect to %s: %s\n"), oStarDictClient->host_.c_str(), Socket::get_error_msg().c_str()); on_error_.emit(mes); g_free(mes); } return; } #ifdef _WIN32 oStarDictClient->channel_ = g_io_channel_win32_new_socket(oStarDictClient->sd_); #else oStarDictClient->channel_ = g_io_channel_unix_new(oStarDictClient->sd_); #endif g_io_channel_set_encoding(oStarDictClient->channel_, NULL, NULL); /* make sure that the channel is non-blocking */ int flags = g_io_channel_get_flags(oStarDictClient->channel_); flags |= G_IO_FLAG_NONBLOCK; GError *err = NULL; g_io_channel_set_flags(oStarDictClient->channel_, GIOFlags(flags), &err); if (err) { g_io_channel_unref(oStarDictClient->channel_); oStarDictClient->channel_ = NULL; gchar *str = g_strdup_printf(_("Unable to set the channel as non-blocking: %s"), err->message); on_error_.emit(str); g_free(str); g_error_free(err); return; } oStarDictClient->is_connected_ = true; oStarDictClient->waiting_banner_ = true; oStarDictClient->reading_type_ = READ_LINE; oStarDictClient->in_source_id_ = g_io_add_watch(oStarDictClient->channel_, GIOCondition(G_IO_IN | G_IO_ERR), on_io_in_event, oStarDictClient); }
static void dz_set_signal_handlers(void) { GIOChannel *sig_channel; long fd_flags; int ret; ret = pipe(dz.sig_pipe); if ( ret < 0 ) { perror("pipe"); exit(1); } fd_flags = fcntl(dz.sig_pipe[1], F_GETFL); if ( fd_flags < 0 ) { perror("Read descriptor flags"); exit(1); } ret = fcntl(dz.sig_pipe[1], F_SETFL, fd_flags | O_NONBLOCK); if ( ret < 0 ) { perror("Write descriptor flags"); exit(1); } /* Install the unix signal handler */ signal(SIGINT, dz_sig_handler); signal(SIGQUIT, dz_sig_handler); signal(SIGTERM, dz_sig_handler); /* Convert the reading end of the pipe into a GIOChannel */ sig_channel = g_io_channel_unix_new(dz.sig_pipe[0]); g_io_channel_set_encoding(sig_channel, NULL, NULL); g_io_channel_set_flags(sig_channel, g_io_channel_get_flags(sig_channel) | G_IO_FLAG_NONBLOCK, NULL); g_io_add_watch(sig_channel, G_IO_IN | G_IO_PRI, dz_process_signal, NULL); return; }
static GIOStatus check_handshake(GIOChannel *channel, GError **err) { GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel; int result; DBG("channel %p", channel); if (gnutls_channel->established == TRUE) return G_IO_STATUS_NORMAL; again: result = gnutls_handshake(gnutls_channel->session); if (result == GNUTLS_E_INTERRUPTED || result == GNUTLS_E_AGAIN) { GIOFlags flags = g_io_channel_get_flags(channel); if (gnutls_channel->again == TRUE) return G_IO_STATUS_AGAIN; if (flags & G_IO_FLAG_NONBLOCK) return G_IO_STATUS_AGAIN; goto again; } if (result < 0) { g_set_error(err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Handshake failed"); return G_IO_STATUS_ERROR; } gnutls_channel->established = TRUE; DBG("handshake done"); return G_IO_STATUS_NORMAL; }
static gboolean gst_avdtp_sink_conf_recv_stream_fd( GstAvdtpSink *self) { struct bluetooth_data *data = self->data; gint ret; GIOError err; GError *gerr = NULL; GIOStatus status; GIOFlags flags; gsize read; ret = gst_avdtp_sink_bluetooth_recvmsg_fd(self); if (ret < 0) return FALSE; if (!self->stream) { GST_ERROR_OBJECT(self, "Error while configuring device: " "could not acquire audio socket"); return FALSE; } /* set stream socket to nonblock */ GST_LOG_OBJECT(self, "setting stream socket to nonblock"); flags = g_io_channel_get_flags(self->stream); flags |= G_IO_FLAG_NONBLOCK; status = g_io_channel_set_flags(self->stream, flags, &gerr); if (status != G_IO_STATUS_NORMAL) { if (gerr) GST_WARNING_OBJECT(self, "Error while " "setting server socket to nonblock: " "%s", gerr->message); else GST_WARNING_OBJECT(self, "Error while " "setting server " "socket to nonblock"); } /* It is possible there is some outstanding data in the pipe - we have to empty it */ GST_LOG_OBJECT(self, "emptying stream pipe"); while (1) { err = g_io_channel_read(self->stream, data->buffer, (gsize) data->link_mtu, &read); if (err != G_IO_ERROR_NONE || read <= 0) break; } /* set stream socket to block */ GST_LOG_OBJECT(self, "setting stream socket to block"); flags = g_io_channel_get_flags(self->stream); flags &= ~G_IO_FLAG_NONBLOCK; status = g_io_channel_set_flags(self->stream, flags, &gerr); if (status != G_IO_STATUS_NORMAL) { if (gerr) GST_WARNING_OBJECT(self, "Error while " "setting server socket to block:" "%s", gerr->message); else GST_WARNING_OBJECT(self, "Error while " "setting server " "socket to block"); } memset(data->buffer, 0, sizeof(data->buffer)); return TRUE; }
static gboolean try_to_connect(NautilusDropboxHookserv *hookserv) { /* create socket */ hookserv->socket = socket(PF_UNIX, SOCK_STREAM, 0); /* set native non-blocking, for connect timeout */ { unsigned int flags; if ((flags = fcntl(hookserv->socket, F_GETFL, 0)) < 0) { goto FAIL_CLEANUP; } if (fcntl(hookserv->socket, F_SETFL, flags | O_NONBLOCK) < 0) { goto FAIL_CLEANUP; } } /* connect to server, might fail of course */ { struct sockaddr_un addr; socklen_t addr_len; /* intialize address structure */ addr.sun_family = AF_UNIX; g_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/.dropbox/iface_socket", g_get_home_dir()); addr_len = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path); /* if there was an error we have to try again later */ if (connect(hookserv->socket, (struct sockaddr *) &addr, addr_len) < 0) { if (errno == EINPROGRESS) { fd_set writers; struct timeval tv = {1, 0}; FD_ZERO(&writers); FD_SET(hookserv->socket, &writers); /* if nothing was ready after 3 seconds, fail out homie */ if (select(hookserv->socket+1, NULL, &writers, NULL, &tv) == 0) { goto FAIL_CLEANUP; } if (connect(hookserv->socket, (struct sockaddr *) &addr, addr_len) < 0) { debug("couldn't connect to hook server after 1 second"); goto FAIL_CLEANUP; } } else { goto FAIL_CLEANUP; } } } /* lol sometimes i write funny codez */ if (FALSE) { FAIL_CLEANUP: close(hookserv->socket); g_timeout_add_seconds(1, (GSourceFunc) try_to_connect, hookserv); return FALSE; } /* great we connected!, let's create the channel and wait on it */ hookserv->chan = g_io_channel_unix_new(hookserv->socket); g_io_channel_set_line_term(hookserv->chan, "\n", -1); g_io_channel_set_close_on_unref(hookserv->chan, TRUE); /*debug("create channel"); */ /* Set non-blocking ;) (again just in case) */ { GIOFlags flags; GIOStatus iostat; flags = g_io_channel_get_flags(hookserv->chan); iostat = g_io_channel_set_flags(hookserv->chan, flags | G_IO_FLAG_NONBLOCK, NULL); if (iostat == G_IO_STATUS_ERROR) { g_io_channel_unref(hookserv->chan); g_timeout_add_seconds(1, (GSourceFunc) try_to_connect, hookserv); return FALSE; } } /*debug("set non blocking"); */ /* this is fun, async io watcher */ hookserv->hhsi.line = 0; hookserv->hhsi.command_args = NULL; hookserv->hhsi.command_name = NULL; hookserv->event_source = g_io_add_watch_full(hookserv->chan, G_PRIORITY_DEFAULT, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL, (GIOFunc) handle_hook_server_input, hookserv, (GDestroyNotify) watch_killer); debug("hook client connected"); hookserv->connected = TRUE; g_hook_list_invoke(&(hookserv->onconnect_hooklist), FALSE); /*debug("added watch");*/ return FALSE; }
int _gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen) { GIOChannel *chan; int sockfd; int res; GIOFlags flags; GIOStatus status; GError *err = NULL; TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd, "addr=%p, addrlen=%i", addr, addrlen); chan = find_channel (fd); if (! chan) { errno = EINVAL; return TRACE_SYSRES (-1); } flags = g_io_channel_get_flags (chan); if (flags & G_IO_FLAG_NONBLOCK) { status = g_io_channel_set_flags (chan, flags & ~G_IO_FLAG_NONBLOCK, &err); if (err) { TRACE_LOG1 ("setting flags error: %s", err->message); g_error_free (err); err = NULL; } if (status != G_IO_STATUS_NORMAL) { errno = EIO; return TRACE_SYSRES (-1); } } sockfd = giochannel_table[fd].socket; if (sockfd == INVALID_SOCKET) { errno = EINVAL; return TRACE_SYSRES (-1); } TRACE_LOG1 ("connect sockfd=0x%x", sockfd); res = connect (sockfd, addr, addrlen); /* FIXME: Error ignored here. */ if (! (flags & G_IO_FLAG_NONBLOCK)) g_io_channel_set_flags (chan, flags, NULL); if (res) { TRACE_LOG2 ("connect failed: %i %i", res, WSAGetLastError ()); errno = wsa2errno (WSAGetLastError ()); return TRACE_SYSRES (-1); } return TRACE_SUC (); }
gint main (gint argc, gchar * argv[]) { GIOChannel *gio_r, *gio_w ; GError *gerr = NULL; GString *buffer; char *filename; char *srcdir = getenv ("srcdir"); gint rlength = 0; glong wlength = 0; gsize length_out; const gchar encoding[] = "ISO-8859-5"; GIOStatus status; GIOFlags flags; #ifdef SYMBIAN g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL); g_set_print_handler(mrtPrintHandler); #endif /*SYMBIAN*/ if (!srcdir) srcdir = "c:"; filename = g_strconcat (srcdir, G_DIR_SEPARATOR_S, "iochannel-test-infile", NULL); setbuf (stdout, NULL); /* For debugging */ gio_r = g_io_channel_new_file (filename, "r", &gerr); if (gerr) { g_warning ("Unable to open file %s: %s", filename, gerr->message); g_error_free (gerr); g_assert(FALSE && "iochannel-test failed"); #if SYMBIAN testResultXml("iochannel-test"); #endif /* EMULATOR */ return 1; } gio_w = g_io_channel_new_file ("c:\\iochannel-test-outfile", "w", &gerr); if (gerr) { g_warning ("Unable to open file %s: %s", "iochannel-test-outfile", gerr->message); g_error_free (gerr); g_assert(FALSE && "iochannel-test failed"); #if SYMBIAN testResultXml("iochannel-test"); #endif /* EMULATOR */ return 1; } g_io_channel_set_encoding (gio_r, encoding, &gerr); if (gerr) { g_warning (gerr->message); g_error_free (gerr); g_assert(FALSE && "iochannel-test failed"); #if SYMBIAN testResultXml("iochannel-test"); #endif /* EMULATOR */ return 1; } g_io_channel_set_buffer_size (gio_r, BUFFER_SIZE); status = g_io_channel_set_flags (gio_r, G_IO_FLAG_NONBLOCK, &gerr); if (status == G_IO_STATUS_ERROR) { g_warning (gerr->message); g_assert(FALSE && "iochannel-test failed"); g_error_free (gerr); gerr = NULL; } flags = g_io_channel_get_flags (gio_r); buffer = g_string_sized_new (BUFFER_SIZE); while (TRUE) { do status = g_io_channel_read_line_string (gio_r, buffer, NULL, &gerr); while (status == G_IO_STATUS_AGAIN); if (status != G_IO_STATUS_NORMAL) break; rlength += buffer->len; do status = g_io_channel_write_chars (gio_w, buffer->str, buffer->len, &length_out, &gerr); while (status == G_IO_STATUS_AGAIN); if (status != G_IO_STATUS_NORMAL) break; wlength += length_out; if (length_out < buffer->len) { g_warning ("Only wrote part of the line."); g_assert(FALSE && "iochannel-test failed"); } #ifdef VERBOSE g_print ("%s", buffer->str); #endif g_string_truncate (buffer, 0); } switch (status) { case G_IO_STATUS_EOF: break; case G_IO_STATUS_ERROR: g_warning (gerr->message); g_error_free (gerr); gerr = NULL; break; default: g_warning ("Abnormal exit from write loop."); g_assert(FALSE && "iochannel-test failed"); break; } do status = g_io_channel_flush (gio_w, &gerr); while (status == G_IO_STATUS_AGAIN); if (status == G_IO_STATUS_ERROR) { g_warning (gerr->message); g_assert(FALSE && "iochannel-test failed"); g_error_free (gerr); gerr = NULL; } #ifdef VERBOSE g_print ("read %d bytes, wrote %ld bytes\n", rlength, wlength); #endif g_io_channel_unref(gio_r); g_io_channel_unref(gio_w); #if SYMBIAN testResultXml("iochannel-test"); #endif /* EMULATOR */ return 0; }
static int connect_session_transport(struct web_session *session) { GIOFlags flags; int sk; sk = socket(session->addr->ai_family, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP); if (sk < 0) return -EIO; if (session->web->index > 0) { if (bind_socket(sk, session->web->index, session->addr->ai_family) < 0) { debug(session->web, "bind() %s", strerror(errno)); close(sk); return -EIO; } } if (session->flags & SESSION_FLAG_USE_TLS) { debug(session->web, "using TLS encryption"); session->transport_channel = g_io_channel_gnutls_new(sk); } else { debug(session->web, "no encryption"); session->transport_channel = g_io_channel_unix_new(sk); } if (session->transport_channel == NULL) { debug(session->web, "channel missing"); close(sk); return -ENOMEM; } flags = g_io_channel_get_flags(session->transport_channel); g_io_channel_set_flags(session->transport_channel, flags | G_IO_FLAG_NONBLOCK, NULL); g_io_channel_set_encoding(session->transport_channel, NULL, NULL); g_io_channel_set_buffered(session->transport_channel, FALSE); g_io_channel_set_close_on_unref(session->transport_channel, TRUE); if (connect(sk, session->addr->ai_addr, session->addr->ai_addrlen) < 0) { if (errno != EINPROGRESS) { debug(session->web, "connect() %s", strerror(errno)); close(sk); return -EIO; } } session->transport_watch = g_io_add_watch(session->transport_channel, G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR, received_data, session); session->send_watch = g_io_add_watch(session->transport_channel, G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR, send_data, session); return 0; }
gint main (gint argc, gchar * argv[]) { GIOChannel *gio_r, *gio_w ; GError *gerr = NULL; GString *buffer; char *filename; char *srcdir = getenv ("srcdir"); gint rlength = 0; glong wlength = 0; gsize length_out; const gchar encoding[] = "EUC-JP"; GIOStatus status; GIOFlags flags; if (!srcdir) srcdir = "."; filename = g_strconcat (srcdir, G_DIR_SEPARATOR_S, "iochannel-test-infile", NULL); setbuf (stdout, NULL); /* For debugging */ gio_r = g_io_channel_new_file (filename, "r", &gerr); if (gerr) { g_warning ("Unable to open file %s: %s", filename, gerr->message); g_error_free (gerr); return 1; } gio_w = g_io_channel_new_file ("iochannel-test-outfile", "w", &gerr); if (gerr) { g_warning ("Unable to open file %s: %s", "iochannel-test-outfile", gerr->message); g_error_free (gerr); return 1; } g_io_channel_set_encoding (gio_r, encoding, &gerr); if (gerr) { g_warning (gerr->message); g_error_free (gerr); return 1; } g_io_channel_set_buffer_size (gio_r, BUFFER_SIZE); status = g_io_channel_set_flags (gio_r, G_IO_FLAG_NONBLOCK, &gerr); if (status == G_IO_STATUS_ERROR) { g_warning (gerr->message); g_error_free (gerr); gerr = NULL; } flags = g_io_channel_get_flags (gio_r); buffer = g_string_sized_new (BUFFER_SIZE); while (TRUE) { do status = g_io_channel_read_line_string (gio_r, buffer, NULL, &gerr); while (status == G_IO_STATUS_AGAIN); if (status != G_IO_STATUS_NORMAL) break; rlength += buffer->len; do status = g_io_channel_write_chars (gio_w, buffer->str, buffer->len, &length_out, &gerr); while (status == G_IO_STATUS_AGAIN); if (status != G_IO_STATUS_NORMAL) break; wlength += length_out; if (length_out < buffer->len) g_warning ("Only wrote part of the line."); #ifdef VERBOSE g_print ("%s", buffer->str); #endif g_string_truncate (buffer, 0); } switch (status) { case G_IO_STATUS_EOF: break; case G_IO_STATUS_ERROR: g_warning (gerr->message); g_error_free (gerr); gerr = NULL; break; default: g_warning ("Abnormal exit from write loop."); break; } do status = g_io_channel_flush (gio_w, &gerr); while (status == G_IO_STATUS_AGAIN); if (status == G_IO_STATUS_ERROR) { g_warning (gerr->message); g_error_free (gerr); gerr = NULL; } #ifdef VERBOSE g_print ("read %d bytes, wrote %ld bytes\n", rlength, wlength); #endif g_io_channel_unref(gio_r); g_io_channel_unref(gio_w); test_small_writes (); return 0; }
static int connect_session_transport(struct web_session *session) { GIOFlags flags; int sk; sk = socket(session->addr->ai_family, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP); if (sk < 0) return -EIO; if (session->web->index > 0) { char interface[IF_NAMESIZE]; memset(interface, 0, IF_NAMESIZE); if (if_indextoname(session->web->index, interface) != NULL) { if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE, interface, IF_NAMESIZE) < 0) { close(sk); return -EIO; } debug(session->web, "Use interface %s", interface); } } if (session->flags & SESSION_FLAG_USE_TLS) { debug(session->web, "using TLS encryption"); session->transport_channel = g_io_channel_gnutls_new(sk); } else { debug(session->web, "no encryption"); session->transport_channel = g_io_channel_unix_new(sk); } if (session->transport_channel == NULL) { close(sk); return -ENOMEM; } flags = g_io_channel_get_flags(session->transport_channel); g_io_channel_set_flags(session->transport_channel, flags | G_IO_FLAG_NONBLOCK, NULL); g_io_channel_set_encoding(session->transport_channel, NULL, NULL); g_io_channel_set_buffered(session->transport_channel, FALSE); g_io_channel_set_close_on_unref(session->transport_channel, TRUE); if (connect(sk, session->addr->ai_addr, session->addr->ai_addrlen) < 0) { if (errno != EINPROGRESS) { close(sk); return -EIO; } } session->transport_watch = g_io_add_watch(session->transport_channel, G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR, received_data, session); session->send_watch = g_io_add_watch(session->transport_channel, G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR, send_data, session); return 0; }
static int tist_init(void) { GIOStatus status = G_IO_STATUS_NORMAL; GIOFlags flags; unsigned int install_state; char buf[8]; int fd, err; gsize len; err = read_uart_name(uart_dev_name, sizeof(uart_dev_name)); if (err < 0) { connman_error("Could not read the UART name"); return err; } err = read_baud_rate(&baud_rate); if (err < 0) { connman_error("Could not read the baud rate"); return err; } fd = open(TIST_SYSFS_INSTALL, O_RDONLY); if (fd < 0) { connman_error("Failed to open TI ST sysfs install file"); return -EIO; } install_channel = g_io_channel_unix_new(fd); g_io_channel_set_close_on_unref(install_channel, TRUE); g_io_channel_set_encoding(install_channel, NULL, NULL); g_io_channel_set_buffered(install_channel, FALSE); flags = g_io_channel_get_flags(install_channel); flags |= G_IO_FLAG_NONBLOCK; g_io_channel_set_flags(install_channel, flags, NULL); status = g_io_channel_read_chars(install_channel, (gchar *) buf, 8, &len, NULL); if (status != G_IO_STATUS_NORMAL) { g_io_channel_shutdown(install_channel, TRUE, NULL); g_io_channel_unref(install_channel); return status; } status = g_io_channel_seek_position(install_channel, 0, G_SEEK_SET, NULL); if (status != G_IO_STATUS_NORMAL) { connman_error("Initial seek failed"); g_io_channel_shutdown(install_channel, TRUE, NULL); g_io_channel_unref(install_channel); return -EIO; } install_state = atoi(buf); DBG("Initial state %d", install_state); install_watch = g_io_add_watch_full(install_channel, G_PRIORITY_HIGH, G_IO_PRI | G_IO_ERR, install_event, NULL, NULL); if (install_state) { g_atomic_int_set(&install_count, 1); err = install_ldisc(install_channel, TRUE); if (err < 0) { connman_error("ldisc installtion failed"); return err; } } return 0; }
static int install_ldisc(GIOChannel *channel, gboolean install) { int uart_fd, err; struct speed_change_cmd cmd; GIOFlags flags; DBG("%d %p", install, uart_channel); if (install == FALSE) { g_atomic_int_set(&install_count, 0); if (uart_channel == NULL) { DBG("UART channel is NULL"); return 0; } g_io_channel_shutdown(uart_channel, TRUE, NULL); g_io_channel_unref(uart_channel); uart_channel = NULL; return 0; } if (uart_channel != NULL) { g_io_channel_shutdown(uart_channel, TRUE, NULL); g_io_channel_unref(uart_channel); uart_channel = NULL; } DBG("opening %s custom baud %lu", uart_dev_name, baud_rate); uart_fd = open(uart_dev_name, O_RDWR); if (uart_fd < 0) return -EIO; uart_channel = g_io_channel_unix_new(uart_fd); g_io_channel_set_close_on_unref(uart_channel, TRUE); g_io_channel_set_encoding(uart_channel, NULL, NULL); g_io_channel_set_buffered(uart_channel, FALSE); flags = g_io_channel_get_flags(uart_channel); flags |= G_IO_FLAG_NONBLOCK; g_io_channel_set_flags(uart_channel, flags, NULL); err = set_default_baud_rate(uart_fd); if (err < 0) { g_io_channel_shutdown(uart_channel, TRUE, NULL); g_io_channel_unref(uart_channel); uart_channel = NULL; return err; } if (baud_rate == 115200) { int ldisc; ldisc = N_TI_WL; if (ioctl(uart_fd, TIOCSETD, &ldisc) < 0) { g_io_channel_shutdown(uart_channel, TRUE, NULL); g_io_channel_unref(uart_channel); uart_channel = NULL; } g_atomic_int_set(&install_count, 0); return 0; } cmd.uart_prefix = HCI_COMMAND_PKT; cmd.opcode = HCI_HDR_OPCODE; cmd.plen = sizeof(unsigned long); cmd.speed = baud_rate; uart_watch = g_io_add_watch(uart_channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR, uart_event, NULL); err = write(uart_fd, &cmd, sizeof(cmd)); if (err < 0) { connman_error("Write failed %d", err); g_io_channel_shutdown(uart_channel, TRUE, NULL); g_io_channel_unref(uart_channel); uart_channel = NULL; } return err; }
GIOChannel* i_io_channel_unix_new_listen (gchar const* address, guint port, gboolean nonblocking) { GIOChannel* channel; gint fd = -1; gchar* port_str; struct addrinfo* ai; struct addrinfo* p; struct addrinfo hints; g_return_val_if_fail(port != 0, NULL); memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_PASSIVE; port_str = g_strdup_printf("%u", port); if (getaddrinfo(address, port_str, &hints, &ai) != 0) { g_free(port_str); return NULL; } g_free(port_str); for (p = ai; p != NULL; p = p->ai_next) { if ((fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) { continue; } if (nonblocking) { fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); } if (bind(fd, p->ai_addr, p->ai_addrlen) < 0) { close(fd); fd = -1; continue; } break; } freeaddrinfo(ai); if (fd < 0) { return NULL; } if (listen(fd, 128) < 0) { close(fd); return NULL; } channel = g_io_channel_unix_new(fd); if (nonblocking) { g_io_channel_set_flags(channel, g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK, NULL); } return channel; }