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;
}
