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;
}
/**
* Initializes the polling system. This must be called before
* any other functions in this module.
*
* @returns TRUE if initialization succeeded, FALSE otherwise
*/
gboolean
gam_dnotify_init(void)
{
struct sigaction act;
int fds[2];
GSource *source;
g_return_val_if_fail(gam_poll_dnotify_init (), FALSE);
if (pipe(fds) < 0) {
g_warning("Could not create pipe.\n");
return FALSE;
}
pipe_read_ioc = g_io_channel_unix_new(fds[0]);
pipe_write_ioc = g_io_channel_unix_new(fds[1]);
g_io_channel_set_flags(pipe_read_ioc, G_IO_FLAG_NONBLOCK, NULL);
g_io_channel_set_flags(pipe_write_ioc, G_IO_FLAG_NONBLOCK, NULL);
source = g_io_create_watch(pipe_read_ioc,
G_IO_IN | G_IO_HUP | G_IO_ERR);
g_source_set_callback(source, gam_dnotify_pipe_handler, NULL, NULL);
g_source_attach(source, NULL);
g_source_unref(source);
/* setup some signal stuff */
act.sa_sigaction = dnotify_signal_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
sigaction(SIGRTMIN, &act, NULL);
/* catch SIGIO as well (happens when the realtime queue fills up) */
act.sa_sigaction = overflow_signal_handler;
sigemptyset(&act.sa_mask);
sigaction(SIGIO, &act, NULL);
changes = g_queue_new();
path_hash = g_hash_table_new(g_str_hash, g_str_equal);
fd_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
GAM_DEBUG(DEBUG_INFO, "dnotify initialized\n");
gam_server_install_kernel_hooks (GAMIN_K_DNOTIFY,
gam_dnotify_add_subscription,
gam_dnotify_remove_subscription,
gam_dnotify_remove_all_for,
gam_dnotify_directory_handler,
gam_dnotify_file_handler);
return TRUE;
}
/*---------------------------------------------------------------------*/
static void
init_io_channels() {
GError *err = NULL;
hop_stdout = g_io_channel_unix_new( hop_pipe_stdout[ 0 ] );
hop_stderr = g_io_channel_unix_new( hop_pipe_stderr[ 0 ] );
g_io_add_watch( hop_stdout, G_IO_IN | G_IO_HUP, watch_output, 0 );
g_io_add_watch( hop_stderr, G_IO_IN | G_IO_HUP, watch_output, 0 );
g_io_channel_set_flags( hop_stdout, G_IO_FLAG_NONBLOCK, &err );
g_io_channel_set_flags( hop_stderr, G_IO_FLAG_NONBLOCK, &err );
}
/**
* Spawn a new process
*
* @param archive Should contain AM_Archive type of data
* @param command Command, which we want to execute
* @param input TRUE If we want to use our standard input, oterwise will be used /dev/null
*
*/
void SpawnAsyncProcess(AM_Archive *archive, gchar *command, gboolean input, gboolean output_flag)
{
GIOChannel *ioc , *err_ioc, *out_ioc;
GError *error = NULL;
gchar **argv;
gint argcp, response;
g_shell_parse_argv ( command , &argcp , &argv , NULL);
if ( ! g_spawn_async_with_pipes (
NULL,
argv,
NULL,
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL,
NULL,
&archive->child_pid,
input ? &input_fd : NULL,
&output_fd,
&error_fd,
&error) )
{
response = ShowGtkMessageDialog (NULL,GTK_DIALOG_MODAL,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK, "Can't run the archiver executable:",error->message);
g_error_free (error);
g_strfreev ( argv );
archive->child_pid = 0;
return;
}
g_strfreev ( argv );
if ( archive->parse_output )
{
ioc = g_io_channel_unix_new ( output_fd );
g_io_channel_set_encoding (ioc, locale , NULL);
g_io_channel_set_flags ( ioc , G_IO_FLAG_NONBLOCK , NULL );
g_io_add_watch (ioc, G_IO_IN|G_IO_PRI|G_IO_ERR|G_IO_HUP|G_IO_NVAL, archive->parse_output, archive);
g_child_watch_add ( archive->child_pid, (GChildWatchFunc)am_a_watch_child, archive);
}
if (output_flag)
{
out_ioc = g_io_channel_unix_new ( output_fd );
g_io_channel_set_encoding (out_ioc, locale , NULL);
g_io_channel_set_flags ( out_ioc , G_IO_FLAG_NONBLOCK , NULL );
g_io_add_watch (out_ioc, G_IO_IN|G_IO_PRI|G_IO_ERR|G_IO_HUP|G_IO_NVAL, am_a_report_child_stderr, NULL);
}
err_ioc = g_io_channel_unix_new ( error_fd );
g_io_channel_set_encoding (err_ioc, locale , NULL);
g_io_channel_set_flags ( err_ioc , G_IO_FLAG_NONBLOCK , NULL );
g_io_add_watch (err_ioc, G_IO_IN|G_IO_PRI|G_IO_ERR|G_IO_HUP|G_IO_NVAL, am_a_report_child_stderr, NULL);
}
static void add_abrt_server_proc(const pid_t pid, int fdout)
{
struct abrt_server_proc *proc = xmalloc(sizeof(*proc));
proc->pid = pid;
proc->fdout = fdout;
proc->dirname = NULL;
proc->type = AS_UKNOWN;
proc->channel = abrt_gio_channel_unix_new(proc->fdout);
proc->watch_id = g_io_add_watch(proc->channel,
G_IO_IN | G_IO_HUP,
abrt_server_output_cb,
proc);
GError *error = NULL;
g_io_channel_set_flags(proc->channel, G_IO_FLAG_NONBLOCK, &error);
if (error != NULL)
error_msg_and_die("g_io_channel_set_flags failed: '%s'", error->message);
g_io_channel_set_buffered(proc->channel, TRUE);
s_processes = g_list_append(s_processes, proc);
if (g_list_length(s_processes) >= MAX_CLIENT_COUNT)
{
error_msg("Too many clients, refusing connections to '%s'", SOCKET_FILE);
/* To avoid infinite loop caused by the descriptor in "ready" state,
* the callback must be disabled.
*/
g_source_remove(channel_id_socket);
channel_id_socket = 0;
}
}
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);
}
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);
}
static GIOChannel *ipc_connect(const char *path, size_t size,
GIOFunc connect_cb, void *user_data)
{
struct sockaddr_un addr;
GIOCondition cond;
GIOChannel *io;
int sk;
sk = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
if (sk < 0) {
error("IPC: failed to create socket: %d (%s)", errno,
strerror(errno));
return NULL;
}
io = g_io_channel_unix_new(sk);
g_io_channel_set_close_on_unref(io, TRUE);
g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, path, size);
connect(sk, (struct sockaddr *) &addr, sizeof(addr));
cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
g_io_add_watch(io, cond, connect_cb, user_data);
return io;
}
static gboolean
accept_server (MilterTestClient *client)
{
MilterTestClientPrivate *priv;
GError *error = NULL;
priv = MILTER_TEST_CLIENT_GET_PRIVATE(client);
priv->server_fd = accept(priv->fd, NULL, NULL);
priv->server_channel = g_io_channel_unix_new(priv->server_fd);
g_io_channel_set_encoding(priv->server_channel, NULL, &error);
gcut_assert_error(error);
g_io_channel_set_flags(priv->server_channel,
G_IO_FLAG_NONBLOCK |
G_IO_FLAG_IS_READABLE |
G_IO_FLAG_IS_WRITEABLE,
&error);
gcut_assert_error(error);
g_io_channel_set_close_on_unref(priv->server_channel, TRUE);
priv->server_watch_id = milter_test_io_add_decode_watch(priv->loop,
priv->server_channel,
priv->decoder);
return TRUE;
}
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 void
setup_io()
{
int result;
channel = g_io_channel_unix_new(STDIN_FILENO);
g_io_channel_set_close_on_unref(channel, TRUE);
#if 0
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_channel_set_buffered(channel, FALSE);
g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL );
#endif
channel_read_callback = result = g_io_add_watch_full(channel, G_PRIORITY_HIGH,
(G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI),
io_invoke, NULL, NULL);
channel_error_callback = g_io_add_watch_full(channel, G_PRIORITY_HIGH,
(G_IO_NVAL),
io_invoke_error, GINT_TO_POINTER(result), NULL);
g_io_channel_unref(channel); /* Apparently this caused crashes for some people.
But irssi does this, so I am going to assume the
crashes were caused by some other stuff. */
gnt_warning("setting up IO (%d)", channel_read_callback);
}
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);
}
void ForkExecParent::setupPipe(GIOChannel *&channel, guint &sourceID, int fd)
{
if (fd == -1) {
// nop
return;
}
channel = g_io_channel_unix_new(fd);
if (!channel) {
// failure
SE_LOG_DEBUG(NULL, NULL, "g_io_channel_unix_new() returned NULL");
close(fd);
return;
}
// Close fd when freeing the channel (done by caller).
g_io_channel_set_close_on_unref(channel, true);
// Don't block in outputReady().
GErrorCXX error;
g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, error);
// We assume that the helper is writing data in the same encoding
// and thus avoid any kind of conversion. Necessary to avoid
// buffering.
error.clear();
g_io_channel_set_encoding(channel, NULL, error);
g_io_channel_set_buffered(channel, true);
sourceID = g_io_add_watch(channel, (GIOCondition)(G_IO_IN|G_IO_ERR|G_IO_HUP), outputReady, this);
}
static gboolean
init_inotify (NMInotifyHelper *self)
{
NMInotifyHelperPrivate *priv = NM_INOTIFY_HELPER_GET_PRIVATE (self);
GIOChannel *channel;
guint source_id;
priv->ifd = inotify_init ();
if (priv->ifd == -1) {
nm_log_warn (LOGD_SETTINGS, "couldn't initialize inotify");
return FALSE;
}
/* Watch the inotify descriptor for file/directory change events */
channel = g_io_channel_unix_new (priv->ifd);
if (!channel) {
nm_log_warn (LOGD_SETTINGS, "couldn't create new GIOChannel");
close (priv->ifd);
priv->ifd = -1;
return FALSE;
}
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_channel_set_encoding (channel, NULL, NULL);
source_id = g_io_add_watch (channel,
G_IO_IN | G_IO_ERR,
(GIOFunc) inotify_event_handler,
(gpointer) self);
g_io_channel_unref (channel);
return TRUE;
}
static guint bluetooth_listen(void)
{
GIOChannel *io;
guint id;
GError *err = NULL;
if (option_channel == -1) {
g_printerr("Bluetooth channel not set\n");
return 0;
}
if (option_packet || option_channel > 31)
io = l2cap_listen(&err);
else
io = rfcomm_listen(&err);
if (io == NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
return 0;
}
g_print("Bluetooth socket created\n");
id = g_io_add_watch(io, G_IO_HUP | G_IO_ERR | G_IO_NVAL,
bluetooth_watch, NULL);
g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
g_io_channel_set_close_on_unref(io, TRUE);
g_io_channel_unref(io);
return id;
}
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;
}
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 obtain_send_channel_cb(GIOChannel *channel, GIOCondition condition,
G_GNUC_UNUSED gpointer gdata)
{
#if HAS_SPAWN_LEAVE_STDIN_OPEN
if (condition & G_IO_FAILURE)
g_io_channel_shutdown(channel, FALSE, NULL);
else
{
g_io_channel_ref(channel);
send_channel = channel;
create_send_source(); /* for the initialization commands */
}
#else
if (!(condition & G_IO_FAILURE))
{
gint stdin_fd = dup(g_io_channel_unix_get_fd(channel));
#ifdef G_OS_UNIX
send_channel = g_io_channel_unix_new(stdin_fd);
g_io_channel_set_flags(send_channel, G_IO_FLAG_NONBLOCK, NULL);
#else
send_channel = g_io_channel_win32_new_fd(stdin_fd);
#endif
g_io_channel_set_encoding(send_channel, NULL, NULL);
g_io_channel_set_buffered(send_channel, FALSE);
create_send_source(); /* for the initialization commands */
}
#endif
return FALSE;
}
/**
* msgpack_conn_new - Set up read/write buffering.
*/
struct msgpack_conn *
msgpack_conn_new(GIOChannel *channel, msgpack_conn_recv_t recv,
msgpack_conn_drop_t drop)
{
struct msgpack_conn *conn;
if (channel == NULL) {
return NULL;
}
conn = g_malloc0(sizeof(*conn));
conn->mc_channel = channel;
conn->mc_recv = recv;
conn->mc_drop = drop;
// TODO: This needs to be done when the socket is first opened.
// Put the conn's channel into nonblocking mode.
g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
// Set the channel encoding to binary.
g_io_channel_set_encoding(channel, NULL, NULL);
// Set up the read listener.
msgpack_unpacker_init(&conn->mc_unpacker, BUFSIZE);
g_io_add_watch(channel, G_IO_IN, msgpack_conn_read, conn);
// Set up the write buffer.
conn->mc_write_buffer = g_string_sized_new(BUFSIZE);
return conn;
}
/*
* Function: add_textview_refresher
*
* Adds a watch in order to display (when available) data from the
* given file descriptor in the given GTK textview.
*/
void add_textview_refresher(GtkTextView * text_view, int fd)
{
GIOChannel *channel = g_io_channel_unix_new(fd);
g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch(channel, G_IO_IN | G_IO_HUP, refresh_textview_from_fd,
text_view);
}
static gboolean attach_fifo(const char *name)
{
GSource *source;
int fd = open (name, O_RDONLY|O_NONBLOCK);
if (fd == -1)
return FALSE;
if (fifo_channel)
g_io_channel_unref(fifo_channel);
fifo_channel = g_io_channel_unix_new(fd);
g_io_channel_set_flags(fifo_channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_channel_set_encoding(fifo_channel, NULL, NULL);
g_io_channel_set_close_on_unref(fifo_channel, TRUE);
source = g_io_create_watch(fifo_channel,
G_IO_IN|G_IO_PRI|G_IO_ERR|G_IO_HUP|G_IO_NVAL);
g_source_set_callback(source, (GSourceFunc)fifo_callback,
(gpointer)fifo_channel,
(GDestroyNotify)fifo_destroy_callback);
g_source_attach(source, main_context);
return TRUE;
}
/**
* paxos_peer_init - Set up peer read/write buffering.
*/
struct paxos_peer *
paxos_peer_init(GIOChannel *channel)
{
struct paxos_peer *peer;
if (channel == NULL) {
return NULL;
}
peer = g_malloc0(sizeof(*peer));
peer->pp_channel = channel;
// TODO: this needs to be done when the socket is first opened
// Put the peer's channel into nonblocking mode.
g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
// Set the channel encoding to binary.
g_io_channel_set_encoding(channel, NULL, NULL);
// Set up the read listener.
msgpack_unpacker_init(&peer->pp_unpacker, PIO_BUFSIZE);
g_io_add_watch(channel, G_IO_IN, paxos_peer_read, peer);
// Set up the write buffer.
peer->pp_write_buffer = g_string_sized_new(PIO_BUFSIZE);
return peer;
}
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 void
watch_for_smartcards (GdmSmartcardExtension *extension)
{
GError *error;
GIOChannel *io_channel;
char *args[] = { GDM_SMARTCARD_WORKER_COMMAND, NULL };
GPid pid;
int stdout_fd;
error = NULL;
if (!g_spawn_async_with_pipes (NULL, args, NULL, 0,
NULL, NULL, &pid, NULL,
&stdout_fd, NULL, &error)) {
g_debug ("could not start smart card manager: %s", error->message);
g_error_free (error);
return;
}
fcntl (stdout_fd, F_SETFD, FD_CLOEXEC);
io_channel = g_io_channel_unix_new (stdout_fd);
g_io_channel_set_flags (io_channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_channel_set_encoding (io_channel, NULL, NULL);
g_io_channel_set_buffered (io_channel, FALSE);
g_io_add_watch (io_channel, G_IO_IN, on_smartcard_event, extension);
g_io_channel_set_close_on_unref (io_channel, TRUE);
g_io_channel_unref (io_channel);
extension->priv->worker_pid = pid;
}
static VALUE
rg_set_flags(VALUE self, VALUE flags)
{
GError* err = NULL;
GIOStatus status = g_io_channel_set_flags(_SELF(self),
NUM2INT(flags), &err);
ioc_error(status, err);
return self;
}
gint
yad_notification_run ()
{
GIOChannel *channel = NULL;
status_icon = gtk_status_icon_new ();
g_signal_connect (status_icon, "size-changed", G_CALLBACK (icon_size_changed_cb), NULL);
if (options.data.dialog_text)
{
if (!options.data.no_markup)
gtk_status_icon_set_tooltip_markup (status_icon, options.data.dialog_text);
else
gtk_status_icon_set_tooltip_text (status_icon, options.data.dialog_text);
}
else
gtk_status_icon_set_tooltip_text (status_icon, _("Yad notification"));
if (options.data.dialog_image)
icon = g_strdup (options.data.dialog_image);
if (options.common_data.command)
action = g_strdup (options.common_data.command);
set_icon ();
g_signal_connect (status_icon, "activate", G_CALLBACK (activate_cb), NULL);
g_signal_connect (status_icon, "popup_menu", G_CALLBACK (popup_menu_cb), NULL);
if (options.notification_data.menu)
parse_menu_str (options.notification_data.menu);
/* quit on middle click (like press Esc) */
if (options.notification_data.middle)
g_signal_connect (status_icon, "button-press-event", G_CALLBACK (middle_quit_cb), NULL);
if (options.common_data.listen)
{
channel = g_io_channel_unix_new (0);
if (channel)
{
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, NULL);
}
}
/* Show icon and wait */
gtk_status_icon_set_visible (status_icon, !options.notification_data.hidden);
if (options.data.timeout > 0)
g_timeout_add_seconds (options.data.timeout, (GSourceFunc) timeout_cb, NULL);
gtk_main ();
return exit_code;
}
static void watchInput(GMainLoop* loop) {
GIOChannel* in = g_io_channel_unix_new(STDIN_FILENO);
GError* error = NULL;
g_io_channel_set_flags(in,G_IO_FLAG_NONBLOCK,&error);
if(error) {
g_error("Can't nonblock %s",error->message);
exit(23);
}
g_io_add_watch(in,G_IO_IN,(void*)on_input,loop);
}
static void
fill_buffer_from_stdin ()
{
GIOChannel *channel;
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, NULL);
}
static void
matedialog_text_fill_entries_from_stdin (GtkTextBuffer *text_buffer)
{
GIOChannel *channel;
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, matedialog_text_handle_stdin, text_buffer);
}
GIOChannel *serial_connect(Configuration *cfg, int *serial_fd)
{
GIOChannel *io;
int fd;
struct termios config;
/* O_RDWR - Opens the port for reading and writing
* O_NOCTTY - The port never becomes the controlling terminal of the process.
* O_NDELAY - Use non-blocking I/O. On some systems this also means the RS232 DCD signal line is ignored.
*/
fd = open(cfg->port, O_RDWR | O_NOCTTY);// | O_NDELAY);
tcgetattr(fd, &config);
if (fd < -1)
{
g_message("Unable to connect to %s: %s(%d)!", cfg->port, strerror(errno), errno);
return NULL;
}
config.c_cflag = get_cflag(cfg);
config.c_iflag = IGNPAR | IGNBRK;
if (cfg->flow == GUART_FLOW_XONXOFF)
{
config.c_iflag |= IXON | IXOFF;
}
config.c_oflag = 0;
config.c_lflag = 0;
config.c_cc[VTIME] = 0;
config.c_cc[VMIN] = 1;
if (tcsetattr(fd, TCSANOW, &config) < 0) {
g_message("Can't change serial settings: %s(%d)", strerror(errno), errno);
close(fd);
return NULL;
}
tcflush(fd, TCOFLUSH);
tcflush(fd, TCIFLUSH);
io = g_io_channel_unix_new(fd);
g_io_channel_set_close_on_unref(io, TRUE);
if (g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL) != G_IO_STATUS_NORMAL) {
g_io_channel_unref(io);
return NULL;
}
*serial_fd = fd;
return io;
}
